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 #define pr_fmt(fmt) "i2c-core: " fmt
32 #include <dt-bindings/i2c/i2c.h>
33 #include <asm/uaccess.h>
34 #include <linux/acpi.h>
35 #include <linux/clk/clk-conf.h>
36 #include <linux/completion.h>
37 #include <linux/delay.h>
38 #include <linux/err.h>
39 #include <linux/errno.h>
40 #include <linux/gpio.h>
41 #include <linux/hardirq.h>
42 #include <linux/i2c.h>
43 #include <linux/idr.h>
44 #include <linux/init.h>
45 #include <linux/irqflags.h>
46 #include <linux/jump_label.h>
47 #include <linux/kernel.h>
48 #include <linux/module.h>
49 #include <linux/mutex.h>
50 #include <linux/of_device.h>
52 #include <linux/of_irq.h>
53 #include <linux/pm_domain.h>
54 #include <linux/pm_runtime.h>
55 #include <linux/pm_wakeirq.h>
56 #include <linux/property.h>
57 #include <linux/rwsem.h>
58 #include <linux/slab.h>
62 #define CREATE_TRACE_POINTS
63 #include <trace/events/i2c.h>
65 #define I2C_ADDR_OFFSET_TEN_BIT 0xa000
66 #define I2C_ADDR_OFFSET_SLAVE 0x1000
68 /* core_lock protects i2c_adapter_idr, and guarantees
69 that device detection, deletion of detected devices, and attach_adapter
70 calls are serialized */
71 static DEFINE_MUTEX(core_lock);
72 static DEFINE_IDR(i2c_adapter_idr);
74 static struct device_type i2c_client_type;
75 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
77 static struct static_key i2c_trace_msg = STATIC_KEY_INIT_FALSE;
78 static bool is_registered;
80 void i2c_transfer_trace_reg(void)
82 static_key_slow_inc(&i2c_trace_msg);
85 void i2c_transfer_trace_unreg(void)
87 static_key_slow_dec(&i2c_trace_msg);
90 #if defined(CONFIG_ACPI)
91 struct i2c_acpi_handler_data {
92 struct acpi_connection_info info;
93 struct i2c_adapter *adapter;
106 struct i2c_acpi_lookup {
107 struct i2c_board_info *info;
108 acpi_handle adapter_handle;
109 acpi_handle device_handle;
112 static int i2c_acpi_find_address(struct acpi_resource *ares, void *data)
114 struct i2c_acpi_lookup *lookup = data;
115 struct i2c_board_info *info = lookup->info;
116 struct acpi_resource_i2c_serialbus *sb;
117 acpi_handle adapter_handle;
120 if (info->addr || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS)
123 sb = &ares->data.i2c_serial_bus;
124 if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C)
128 * Extract the ResourceSource and make sure that the handle matches
129 * with the I2C adapter handle.
131 status = acpi_get_handle(lookup->device_handle,
132 sb->resource_source.string_ptr,
134 if (ACPI_SUCCESS(status) && adapter_handle == lookup->adapter_handle) {
135 info->addr = sb->slave_address;
136 if (sb->access_mode == ACPI_I2C_10BIT_MODE)
137 info->flags |= I2C_CLIENT_TEN;
143 static acpi_status i2c_acpi_add_device(acpi_handle handle, u32 level,
144 void *data, void **return_value)
146 struct i2c_adapter *adapter = data;
147 struct list_head resource_list;
148 struct i2c_acpi_lookup lookup;
149 struct resource_entry *entry;
150 struct i2c_board_info info;
151 struct acpi_device *adev;
154 if (acpi_bus_get_device(handle, &adev))
156 if (acpi_bus_get_status(adev) || !adev->status.present)
159 memset(&info, 0, sizeof(info));
160 info.fwnode = acpi_fwnode_handle(adev);
162 memset(&lookup, 0, sizeof(lookup));
163 lookup.adapter_handle = ACPI_HANDLE(&adapter->dev);
164 lookup.device_handle = handle;
168 * Look up for I2cSerialBus resource with ResourceSource that
169 * matches with this adapter.
171 INIT_LIST_HEAD(&resource_list);
172 ret = acpi_dev_get_resources(adev, &resource_list,
173 i2c_acpi_find_address, &lookup);
174 acpi_dev_free_resource_list(&resource_list);
176 if (ret < 0 || !info.addr)
179 /* Then fill IRQ number if any */
180 ret = acpi_dev_get_resources(adev, &resource_list, NULL, NULL);
184 resource_list_for_each_entry(entry, &resource_list) {
185 if (resource_type(entry->res) == IORESOURCE_IRQ) {
186 info.irq = entry->res->start;
191 acpi_dev_free_resource_list(&resource_list);
193 adev->power.flags.ignore_parent = true;
194 strlcpy(info.type, dev_name(&adev->dev), sizeof(info.type));
195 if (!i2c_new_device(adapter, &info)) {
196 adev->power.flags.ignore_parent = false;
197 dev_err(&adapter->dev,
198 "failed to add I2C device %s from ACPI\n",
199 dev_name(&adev->dev));
205 #define I2C_ACPI_MAX_SCAN_DEPTH 32
208 * i2c_acpi_register_devices - enumerate I2C slave devices behind adapter
209 * @adap: pointer to adapter
211 * Enumerate all I2C slave devices behind this adapter by walking the ACPI
212 * namespace. When a device is found it will be added to the Linux device
213 * model and bound to the corresponding ACPI handle.
215 static void i2c_acpi_register_devices(struct i2c_adapter *adap)
219 if (!has_acpi_companion(&adap->dev))
222 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
223 I2C_ACPI_MAX_SCAN_DEPTH,
224 i2c_acpi_add_device, NULL,
226 if (ACPI_FAILURE(status))
227 dev_warn(&adap->dev, "failed to enumerate I2C slaves\n");
230 #else /* CONFIG_ACPI */
231 static inline void i2c_acpi_register_devices(struct i2c_adapter *adap) { }
232 #endif /* CONFIG_ACPI */
234 #ifdef CONFIG_ACPI_I2C_OPREGION
235 static int acpi_gsb_i2c_read_bytes(struct i2c_client *client,
236 u8 cmd, u8 *data, u8 data_len)
239 struct i2c_msg msgs[2];
243 buffer = kzalloc(data_len, GFP_KERNEL);
247 msgs[0].addr = client->addr;
248 msgs[0].flags = client->flags;
252 msgs[1].addr = client->addr;
253 msgs[1].flags = client->flags | I2C_M_RD;
254 msgs[1].len = data_len;
255 msgs[1].buf = buffer;
257 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
259 dev_err(&client->adapter->dev, "i2c read failed\n");
261 memcpy(data, buffer, data_len);
267 static int acpi_gsb_i2c_write_bytes(struct i2c_client *client,
268 u8 cmd, u8 *data, u8 data_len)
271 struct i2c_msg msgs[1];
275 buffer = kzalloc(data_len + 1, GFP_KERNEL);
280 memcpy(buffer + 1, data, data_len);
282 msgs[0].addr = client->addr;
283 msgs[0].flags = client->flags;
284 msgs[0].len = data_len + 1;
285 msgs[0].buf = buffer;
287 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
289 dev_err(&client->adapter->dev, "i2c write failed\n");
296 i2c_acpi_space_handler(u32 function, acpi_physical_address command,
297 u32 bits, u64 *value64,
298 void *handler_context, void *region_context)
300 struct gsb_buffer *gsb = (struct gsb_buffer *)value64;
301 struct i2c_acpi_handler_data *data = handler_context;
302 struct acpi_connection_info *info = &data->info;
303 struct acpi_resource_i2c_serialbus *sb;
304 struct i2c_adapter *adapter = data->adapter;
305 struct i2c_client *client;
306 struct acpi_resource *ares;
307 u32 accessor_type = function >> 16;
308 u8 action = function & ACPI_IO_MASK;
312 ret = acpi_buffer_to_resource(info->connection, info->length, &ares);
313 if (ACPI_FAILURE(ret))
316 client = kzalloc(sizeof(*client), GFP_KERNEL);
322 if (!value64 || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) {
323 ret = AE_BAD_PARAMETER;
327 sb = &ares->data.i2c_serial_bus;
328 if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C) {
329 ret = AE_BAD_PARAMETER;
333 client->adapter = adapter;
334 client->addr = sb->slave_address;
336 if (sb->access_mode == ACPI_I2C_10BIT_MODE)
337 client->flags |= I2C_CLIENT_TEN;
339 switch (accessor_type) {
340 case ACPI_GSB_ACCESS_ATTRIB_SEND_RCV:
341 if (action == ACPI_READ) {
342 status = i2c_smbus_read_byte(client);
348 status = i2c_smbus_write_byte(client, gsb->bdata);
352 case ACPI_GSB_ACCESS_ATTRIB_BYTE:
353 if (action == ACPI_READ) {
354 status = i2c_smbus_read_byte_data(client, command);
360 status = i2c_smbus_write_byte_data(client, command,
365 case ACPI_GSB_ACCESS_ATTRIB_WORD:
366 if (action == ACPI_READ) {
367 status = i2c_smbus_read_word_data(client, command);
373 status = i2c_smbus_write_word_data(client, command,
378 case ACPI_GSB_ACCESS_ATTRIB_BLOCK:
379 if (action == ACPI_READ) {
380 status = i2c_smbus_read_block_data(client, command,
387 status = i2c_smbus_write_block_data(client, command,
388 gsb->len, gsb->data);
392 case ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE:
393 if (action == ACPI_READ) {
394 status = acpi_gsb_i2c_read_bytes(client, command,
395 gsb->data, info->access_length);
399 status = acpi_gsb_i2c_write_bytes(client, command,
400 gsb->data, info->access_length);
405 dev_warn(&adapter->dev, "protocol 0x%02x not supported for client 0x%02x\n",
406 accessor_type, client->addr);
407 ret = AE_BAD_PARAMETER;
411 gsb->status = status;
420 static int i2c_acpi_install_space_handler(struct i2c_adapter *adapter)
423 struct i2c_acpi_handler_data *data;
426 if (!adapter->dev.parent)
429 handle = ACPI_HANDLE(adapter->dev.parent);
434 data = kzalloc(sizeof(struct i2c_acpi_handler_data),
439 data->adapter = adapter;
440 status = acpi_bus_attach_private_data(handle, (void *)data);
441 if (ACPI_FAILURE(status)) {
446 status = acpi_install_address_space_handler(handle,
447 ACPI_ADR_SPACE_GSBUS,
448 &i2c_acpi_space_handler,
451 if (ACPI_FAILURE(status)) {
452 dev_err(&adapter->dev, "Error installing i2c space handler\n");
453 acpi_bus_detach_private_data(handle);
458 acpi_walk_dep_device_list(handle);
462 static void i2c_acpi_remove_space_handler(struct i2c_adapter *adapter)
465 struct i2c_acpi_handler_data *data;
468 if (!adapter->dev.parent)
471 handle = ACPI_HANDLE(adapter->dev.parent);
476 acpi_remove_address_space_handler(handle,
477 ACPI_ADR_SPACE_GSBUS,
478 &i2c_acpi_space_handler);
480 status = acpi_bus_get_private_data(handle, (void **)&data);
481 if (ACPI_SUCCESS(status))
484 acpi_bus_detach_private_data(handle);
486 #else /* CONFIG_ACPI_I2C_OPREGION */
487 static inline void i2c_acpi_remove_space_handler(struct i2c_adapter *adapter)
490 static inline int i2c_acpi_install_space_handler(struct i2c_adapter *adapter)
492 #endif /* CONFIG_ACPI_I2C_OPREGION */
494 /* ------------------------------------------------------------------------- */
496 static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
497 const struct i2c_client *client)
499 while (id->name[0]) {
500 if (strcmp(client->name, id->name) == 0)
507 static int i2c_device_match(struct device *dev, struct device_driver *drv)
509 struct i2c_client *client = i2c_verify_client(dev);
510 struct i2c_driver *driver;
515 /* Attempt an OF style match */
516 if (of_driver_match_device(dev, drv))
519 /* Then ACPI style match */
520 if (acpi_driver_match_device(dev, drv))
523 driver = to_i2c_driver(drv);
524 /* match on an id table if there is one */
525 if (driver->id_table)
526 return i2c_match_id(driver->id_table, client) != NULL;
531 static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
533 struct i2c_client *client = to_i2c_client(dev);
536 rc = acpi_device_uevent_modalias(dev, env);
540 return add_uevent_var(env, "MODALIAS=%s%s", I2C_MODULE_PREFIX, client->name);
543 /* i2c bus recovery routines */
544 static int get_scl_gpio_value(struct i2c_adapter *adap)
546 return gpio_get_value(adap->bus_recovery_info->scl_gpio);
549 static void set_scl_gpio_value(struct i2c_adapter *adap, int val)
551 gpio_set_value(adap->bus_recovery_info->scl_gpio, val);
554 static int get_sda_gpio_value(struct i2c_adapter *adap)
556 return gpio_get_value(adap->bus_recovery_info->sda_gpio);
559 static int i2c_get_gpios_for_recovery(struct i2c_adapter *adap)
561 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
562 struct device *dev = &adap->dev;
565 ret = gpio_request_one(bri->scl_gpio, GPIOF_OPEN_DRAIN |
566 GPIOF_OUT_INIT_HIGH, "i2c-scl");
568 dev_warn(dev, "Can't get SCL gpio: %d\n", bri->scl_gpio);
573 if (gpio_request_one(bri->sda_gpio, GPIOF_IN, "i2c-sda")) {
574 /* work without SDA polling */
575 dev_warn(dev, "Can't get SDA gpio: %d. Not using SDA polling\n",
584 static void i2c_put_gpios_for_recovery(struct i2c_adapter *adap)
586 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
589 gpio_free(bri->sda_gpio);
591 gpio_free(bri->scl_gpio);
595 * We are generating clock pulses. ndelay() determines durating of clk pulses.
596 * We will generate clock with rate 100 KHz and so duration of both clock levels
597 * is: delay in ns = (10^6 / 100) / 2
599 #define RECOVERY_NDELAY 5000
600 #define RECOVERY_CLK_CNT 9
602 static int i2c_generic_recovery(struct i2c_adapter *adap)
604 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
605 int i = 0, val = 1, ret = 0;
607 if (bri->prepare_recovery)
608 bri->prepare_recovery(adap);
610 bri->set_scl(adap, val);
611 ndelay(RECOVERY_NDELAY);
614 * By this time SCL is high, as we need to give 9 falling-rising edges
616 while (i++ < RECOVERY_CLK_CNT * 2) {
618 /* Break if SDA is high */
619 if (bri->get_sda && bri->get_sda(adap))
621 /* SCL shouldn't be low here */
622 if (!bri->get_scl(adap)) {
624 "SCL is stuck low, exit recovery\n");
631 bri->set_scl(adap, val);
632 ndelay(RECOVERY_NDELAY);
635 if (bri->unprepare_recovery)
636 bri->unprepare_recovery(adap);
641 int i2c_generic_scl_recovery(struct i2c_adapter *adap)
643 return i2c_generic_recovery(adap);
645 EXPORT_SYMBOL_GPL(i2c_generic_scl_recovery);
647 int i2c_generic_gpio_recovery(struct i2c_adapter *adap)
651 ret = i2c_get_gpios_for_recovery(adap);
655 ret = i2c_generic_recovery(adap);
656 i2c_put_gpios_for_recovery(adap);
660 EXPORT_SYMBOL_GPL(i2c_generic_gpio_recovery);
662 int i2c_recover_bus(struct i2c_adapter *adap)
664 if (!adap->bus_recovery_info)
667 dev_dbg(&adap->dev, "Trying i2c bus recovery\n");
668 return adap->bus_recovery_info->recover_bus(adap);
670 EXPORT_SYMBOL_GPL(i2c_recover_bus);
672 static void i2c_init_recovery(struct i2c_adapter *adap)
674 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
680 if (!bri->recover_bus) {
681 err_str = "no recover_bus() found";
685 /* Generic GPIO recovery */
686 if (bri->recover_bus == i2c_generic_gpio_recovery) {
687 if (!gpio_is_valid(bri->scl_gpio)) {
688 err_str = "invalid SCL gpio";
692 if (gpio_is_valid(bri->sda_gpio))
693 bri->get_sda = get_sda_gpio_value;
697 bri->get_scl = get_scl_gpio_value;
698 bri->set_scl = set_scl_gpio_value;
699 } else if (bri->recover_bus == i2c_generic_scl_recovery) {
700 /* Generic SCL recovery */
701 if (!bri->set_scl || !bri->get_scl) {
702 err_str = "no {get|set}_scl() found";
709 dev_err(&adap->dev, "Not using recovery: %s\n", err_str);
710 adap->bus_recovery_info = NULL;
713 static int i2c_device_probe(struct device *dev)
715 struct i2c_client *client = i2c_verify_client(dev);
716 struct i2c_driver *driver;
726 irq = of_irq_get_byname(dev->of_node, "irq");
727 if (irq == -EINVAL || irq == -ENODATA)
728 irq = of_irq_get(dev->of_node, 0);
729 } else if (ACPI_COMPANION(dev)) {
730 irq = acpi_dev_gpio_irq_get(ACPI_COMPANION(dev), 0);
732 if (irq == -EPROBE_DEFER)
740 driver = to_i2c_driver(dev->driver);
741 if (!driver->probe || !driver->id_table)
744 if (client->flags & I2C_CLIENT_WAKE) {
745 int wakeirq = -ENOENT;
748 wakeirq = of_irq_get_byname(dev->of_node, "wakeup");
749 if (wakeirq == -EPROBE_DEFER)
753 device_init_wakeup(&client->dev, true);
755 if (wakeirq > 0 && wakeirq != client->irq)
756 status = dev_pm_set_dedicated_wake_irq(dev, wakeirq);
757 else if (client->irq > 0)
758 status = dev_pm_set_wake_irq(dev, client->irq);
763 dev_warn(&client->dev, "failed to set up wakeup irq");
766 dev_dbg(dev, "probe\n");
768 status = of_clk_set_defaults(dev->of_node, false);
770 goto err_clear_wakeup_irq;
772 status = dev_pm_domain_attach(&client->dev, true);
773 if (status == -EPROBE_DEFER)
774 goto err_clear_wakeup_irq;
776 status = driver->probe(client, i2c_match_id(driver->id_table, client));
778 goto err_detach_pm_domain;
782 err_detach_pm_domain:
783 dev_pm_domain_detach(&client->dev, true);
784 err_clear_wakeup_irq:
785 dev_pm_clear_wake_irq(&client->dev);
786 device_init_wakeup(&client->dev, false);
790 static int i2c_device_remove(struct device *dev)
792 struct i2c_client *client = i2c_verify_client(dev);
793 struct i2c_driver *driver;
796 if (!client || !dev->driver)
799 driver = to_i2c_driver(dev->driver);
800 if (driver->remove) {
801 dev_dbg(dev, "remove\n");
802 status = driver->remove(client);
805 dev_pm_domain_detach(&client->dev, true);
807 dev_pm_clear_wake_irq(&client->dev);
808 device_init_wakeup(&client->dev, false);
813 static void i2c_device_shutdown(struct device *dev)
815 struct i2c_client *client = i2c_verify_client(dev);
816 struct i2c_driver *driver;
818 if (!client || !dev->driver)
820 driver = to_i2c_driver(dev->driver);
821 if (driver->shutdown)
822 driver->shutdown(client);
825 static void i2c_client_dev_release(struct device *dev)
827 kfree(to_i2c_client(dev));
831 show_name(struct device *dev, struct device_attribute *attr, char *buf)
833 return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
834 to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
836 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
839 show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
841 struct i2c_client *client = to_i2c_client(dev);
844 len = acpi_device_modalias(dev, buf, PAGE_SIZE -1);
848 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
850 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
852 static struct attribute *i2c_dev_attrs[] = {
854 /* modalias helps coldplug: modprobe $(cat .../modalias) */
855 &dev_attr_modalias.attr,
858 ATTRIBUTE_GROUPS(i2c_dev);
860 struct bus_type i2c_bus_type = {
862 .match = i2c_device_match,
863 .probe = i2c_device_probe,
864 .remove = i2c_device_remove,
865 .shutdown = i2c_device_shutdown,
867 EXPORT_SYMBOL_GPL(i2c_bus_type);
869 static struct device_type i2c_client_type = {
870 .groups = i2c_dev_groups,
871 .uevent = i2c_device_uevent,
872 .release = i2c_client_dev_release,
877 * i2c_verify_client - return parameter as i2c_client, or NULL
878 * @dev: device, probably from some driver model iterator
880 * When traversing the driver model tree, perhaps using driver model
881 * iterators like @device_for_each_child(), you can't assume very much
882 * about the nodes you find. Use this function to avoid oopses caused
883 * by wrongly treating some non-I2C device as an i2c_client.
885 struct i2c_client *i2c_verify_client(struct device *dev)
887 return (dev->type == &i2c_client_type)
891 EXPORT_SYMBOL(i2c_verify_client);
894 /* Return a unique address which takes the flags of the client into account */
895 static unsigned short i2c_encode_flags_to_addr(struct i2c_client *client)
897 unsigned short addr = client->addr;
899 /* For some client flags, add an arbitrary offset to avoid collisions */
900 if (client->flags & I2C_CLIENT_TEN)
901 addr |= I2C_ADDR_OFFSET_TEN_BIT;
903 if (client->flags & I2C_CLIENT_SLAVE)
904 addr |= I2C_ADDR_OFFSET_SLAVE;
909 /* This is a permissive address validity check, I2C address map constraints
910 * are purposely not enforced, except for the general call address. */
911 static int i2c_check_addr_validity(unsigned addr, unsigned short flags)
913 if (flags & I2C_CLIENT_TEN) {
914 /* 10-bit address, all values are valid */
918 /* 7-bit address, reject the general call address */
919 if (addr == 0x00 || addr > 0x7f)
925 /* And this is a strict address validity check, used when probing. If a
926 * device uses a reserved address, then it shouldn't be probed. 7-bit
927 * addressing is assumed, 10-bit address devices are rare and should be
928 * explicitly enumerated. */
929 static int i2c_check_7bit_addr_validity_strict(unsigned short addr)
932 * Reserved addresses per I2C specification:
933 * 0x00 General call address / START byte
935 * 0x02 Reserved for different bus format
936 * 0x03 Reserved for future purposes
937 * 0x04-0x07 Hs-mode master code
938 * 0x78-0x7b 10-bit slave addressing
939 * 0x7c-0x7f Reserved for future purposes
941 if (addr < 0x08 || addr > 0x77)
946 static int __i2c_check_addr_busy(struct device *dev, void *addrp)
948 struct i2c_client *client = i2c_verify_client(dev);
949 int addr = *(int *)addrp;
951 if (client && i2c_encode_flags_to_addr(client) == addr)
956 /* walk up mux tree */
957 static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
959 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
962 result = device_for_each_child(&adapter->dev, &addr,
963 __i2c_check_addr_busy);
965 if (!result && parent)
966 result = i2c_check_mux_parents(parent, addr);
971 /* recurse down mux tree */
972 static int i2c_check_mux_children(struct device *dev, void *addrp)
976 if (dev->type == &i2c_adapter_type)
977 result = device_for_each_child(dev, addrp,
978 i2c_check_mux_children);
980 result = __i2c_check_addr_busy(dev, addrp);
985 static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
987 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
991 result = i2c_check_mux_parents(parent, addr);
994 result = device_for_each_child(&adapter->dev, &addr,
995 i2c_check_mux_children);
1001 * i2c_adapter_lock_bus - Get exclusive access to an I2C bus segment
1002 * @adapter: Target I2C bus segment
1003 * @flags: I2C_LOCK_ROOT_ADAPTER locks the root i2c adapter, I2C_LOCK_SEGMENT
1004 * locks only this branch in the adapter tree
1006 static void i2c_adapter_lock_bus(struct i2c_adapter *adapter,
1009 rt_mutex_lock(&adapter->bus_lock);
1013 * i2c_adapter_trylock_bus - Try to get exclusive access to an I2C bus segment
1014 * @adapter: Target I2C bus segment
1015 * @flags: I2C_LOCK_ROOT_ADAPTER trylocks the root i2c adapter, I2C_LOCK_SEGMENT
1016 * trylocks only this branch in the adapter tree
1018 static int i2c_adapter_trylock_bus(struct i2c_adapter *adapter,
1021 return rt_mutex_trylock(&adapter->bus_lock);
1025 * i2c_adapter_unlock_bus - Release exclusive access to an I2C bus segment
1026 * @adapter: Target I2C bus segment
1027 * @flags: I2C_LOCK_ROOT_ADAPTER unlocks the root i2c adapter, I2C_LOCK_SEGMENT
1028 * unlocks only this branch in the adapter tree
1030 static void i2c_adapter_unlock_bus(struct i2c_adapter *adapter,
1033 rt_mutex_unlock(&adapter->bus_lock);
1036 static void i2c_dev_set_name(struct i2c_adapter *adap,
1037 struct i2c_client *client)
1039 struct acpi_device *adev = ACPI_COMPANION(&client->dev);
1042 dev_set_name(&client->dev, "i2c-%s", acpi_dev_name(adev));
1046 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
1047 i2c_encode_flags_to_addr(client));
1051 * i2c_new_device - instantiate an i2c device
1052 * @adap: the adapter managing the device
1053 * @info: describes one I2C device; bus_num is ignored
1054 * Context: can sleep
1056 * Create an i2c device. Binding is handled through driver model
1057 * probe()/remove() methods. A driver may be bound to this device when we
1058 * return from this function, or any later moment (e.g. maybe hotplugging will
1059 * load the driver module). This call is not appropriate for use by mainboard
1060 * initialization logic, which usually runs during an arch_initcall() long
1061 * before any i2c_adapter could exist.
1063 * This returns the new i2c client, which may be saved for later use with
1064 * i2c_unregister_device(); or NULL to indicate an error.
1067 i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
1069 struct i2c_client *client;
1072 client = kzalloc(sizeof *client, GFP_KERNEL);
1076 client->adapter = adap;
1078 client->dev.platform_data = info->platform_data;
1081 client->dev.archdata = *info->archdata;
1083 client->flags = info->flags;
1084 client->addr = info->addr;
1085 client->irq = info->irq;
1087 strlcpy(client->name, info->type, sizeof(client->name));
1089 status = i2c_check_addr_validity(client->addr, client->flags);
1091 dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
1092 client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
1093 goto out_err_silent;
1096 /* Check for address business */
1097 status = i2c_check_addr_busy(adap, i2c_encode_flags_to_addr(client));
1101 client->dev.parent = &client->adapter->dev;
1102 client->dev.bus = &i2c_bus_type;
1103 client->dev.type = &i2c_client_type;
1104 client->dev.of_node = info->of_node;
1105 client->dev.fwnode = info->fwnode;
1107 i2c_dev_set_name(adap, client);
1108 status = device_register(&client->dev);
1112 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
1113 client->name, dev_name(&client->dev));
1118 dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
1119 "(%d)\n", client->name, client->addr, status);
1124 EXPORT_SYMBOL_GPL(i2c_new_device);
1128 * i2c_unregister_device - reverse effect of i2c_new_device()
1129 * @client: value returned from i2c_new_device()
1130 * Context: can sleep
1132 void i2c_unregister_device(struct i2c_client *client)
1134 if (client->dev.of_node)
1135 of_node_clear_flag(client->dev.of_node, OF_POPULATED);
1136 device_unregister(&client->dev);
1138 EXPORT_SYMBOL_GPL(i2c_unregister_device);
1141 static const struct i2c_device_id dummy_id[] = {
1146 static int dummy_probe(struct i2c_client *client,
1147 const struct i2c_device_id *id)
1152 static int dummy_remove(struct i2c_client *client)
1157 static struct i2c_driver dummy_driver = {
1158 .driver.name = "dummy",
1159 .probe = dummy_probe,
1160 .remove = dummy_remove,
1161 .id_table = dummy_id,
1165 * i2c_new_dummy - return a new i2c device bound to a dummy driver
1166 * @adapter: the adapter managing the device
1167 * @address: seven bit address to be used
1168 * Context: can sleep
1170 * This returns an I2C client bound to the "dummy" driver, intended for use
1171 * with devices that consume multiple addresses. Examples of such chips
1172 * include various EEPROMS (like 24c04 and 24c08 models).
1174 * These dummy devices have two main uses. First, most I2C and SMBus calls
1175 * except i2c_transfer() need a client handle; the dummy will be that handle.
1176 * And second, this prevents the specified address from being bound to a
1179 * This returns the new i2c client, which should be saved for later use with
1180 * i2c_unregister_device(); or NULL to indicate an error.
1182 struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
1184 struct i2c_board_info info = {
1185 I2C_BOARD_INFO("dummy", address),
1188 return i2c_new_device(adapter, &info);
1190 EXPORT_SYMBOL_GPL(i2c_new_dummy);
1193 * i2c_new_secondary_device - Helper to get the instantiated secondary address
1194 * and create the associated device
1195 * @client: Handle to the primary client
1196 * @name: Handle to specify which secondary address to get
1197 * @default_addr: Used as a fallback if no secondary address was specified
1198 * Context: can sleep
1200 * I2C clients can be composed of multiple I2C slaves bound together in a single
1201 * component. The I2C client driver then binds to the master I2C slave and needs
1202 * to create I2C dummy clients to communicate with all the other slaves.
1204 * This function creates and returns an I2C dummy client whose I2C address is
1205 * retrieved from the platform firmware based on the given slave name. If no
1206 * address is specified by the firmware default_addr is used.
1208 * On DT-based platforms the address is retrieved from the "reg" property entry
1209 * cell whose "reg-names" value matches the slave name.
1211 * This returns the new i2c client, which should be saved for later use with
1212 * i2c_unregister_device(); or NULL to indicate an error.
1214 struct i2c_client *i2c_new_secondary_device(struct i2c_client *client,
1218 struct device_node *np = client->dev.of_node;
1219 u32 addr = default_addr;
1223 i = of_property_match_string(np, "reg-names", name);
1225 of_property_read_u32_index(np, "reg", i, &addr);
1228 dev_dbg(&client->adapter->dev, "Address for %s : 0x%x\n", name, addr);
1229 return i2c_new_dummy(client->adapter, addr);
1231 EXPORT_SYMBOL_GPL(i2c_new_secondary_device);
1233 /* ------------------------------------------------------------------------- */
1235 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
1237 static void i2c_adapter_dev_release(struct device *dev)
1239 struct i2c_adapter *adap = to_i2c_adapter(dev);
1240 complete(&adap->dev_released);
1244 * This function is only needed for mutex_lock_nested, so it is never
1245 * called unless locking correctness checking is enabled. Thus we
1246 * make it inline to avoid a compiler warning. That's what gcc ends up
1249 static inline unsigned int i2c_adapter_depth(struct i2c_adapter *adapter)
1251 unsigned int depth = 0;
1253 while ((adapter = i2c_parent_is_i2c_adapter(adapter)))
1260 * Let users instantiate I2C devices through sysfs. This can be used when
1261 * platform initialization code doesn't contain the proper data for
1262 * whatever reason. Also useful for drivers that do device detection and
1263 * detection fails, either because the device uses an unexpected address,
1264 * or this is a compatible device with different ID register values.
1266 * Parameter checking may look overzealous, but we really don't want
1267 * the user to provide incorrect parameters.
1270 i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
1271 const char *buf, size_t count)
1273 struct i2c_adapter *adap = to_i2c_adapter(dev);
1274 struct i2c_board_info info;
1275 struct i2c_client *client;
1279 memset(&info, 0, sizeof(struct i2c_board_info));
1281 blank = strchr(buf, ' ');
1283 dev_err(dev, "%s: Missing parameters\n", "new_device");
1286 if (blank - buf > I2C_NAME_SIZE - 1) {
1287 dev_err(dev, "%s: Invalid device name\n", "new_device");
1290 memcpy(info.type, buf, blank - buf);
1292 /* Parse remaining parameters, reject extra parameters */
1293 res = sscanf(++blank, "%hi%c", &info.addr, &end);
1295 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
1298 if (res > 1 && end != '\n') {
1299 dev_err(dev, "%s: Extra parameters\n", "new_device");
1303 if ((info.addr & I2C_ADDR_OFFSET_TEN_BIT) == I2C_ADDR_OFFSET_TEN_BIT) {
1304 info.addr &= ~I2C_ADDR_OFFSET_TEN_BIT;
1305 info.flags |= I2C_CLIENT_TEN;
1308 if (info.addr & I2C_ADDR_OFFSET_SLAVE) {
1309 info.addr &= ~I2C_ADDR_OFFSET_SLAVE;
1310 info.flags |= I2C_CLIENT_SLAVE;
1313 client = i2c_new_device(adap, &info);
1317 /* Keep track of the added device */
1318 mutex_lock(&adap->userspace_clients_lock);
1319 list_add_tail(&client->detected, &adap->userspace_clients);
1320 mutex_unlock(&adap->userspace_clients_lock);
1321 dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
1322 info.type, info.addr);
1326 static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
1329 * And of course let the users delete the devices they instantiated, if
1330 * they got it wrong. This interface can only be used to delete devices
1331 * instantiated by i2c_sysfs_new_device above. This guarantees that we
1332 * don't delete devices to which some kernel code still has references.
1334 * Parameter checking may look overzealous, but we really don't want
1335 * the user to delete the wrong device.
1338 i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
1339 const char *buf, size_t count)
1341 struct i2c_adapter *adap = to_i2c_adapter(dev);
1342 struct i2c_client *client, *next;
1343 unsigned short addr;
1347 /* Parse parameters, reject extra parameters */
1348 res = sscanf(buf, "%hi%c", &addr, &end);
1350 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
1353 if (res > 1 && end != '\n') {
1354 dev_err(dev, "%s: Extra parameters\n", "delete_device");
1358 /* Make sure the device was added through sysfs */
1360 mutex_lock_nested(&adap->userspace_clients_lock,
1361 i2c_adapter_depth(adap));
1362 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1364 if (i2c_encode_flags_to_addr(client) == addr) {
1365 dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
1366 "delete_device", client->name, client->addr);
1368 list_del(&client->detected);
1369 i2c_unregister_device(client);
1374 mutex_unlock(&adap->userspace_clients_lock);
1377 dev_err(dev, "%s: Can't find device in list\n",
1381 static DEVICE_ATTR_IGNORE_LOCKDEP(delete_device, S_IWUSR, NULL,
1382 i2c_sysfs_delete_device);
1384 static struct attribute *i2c_adapter_attrs[] = {
1385 &dev_attr_name.attr,
1386 &dev_attr_new_device.attr,
1387 &dev_attr_delete_device.attr,
1390 ATTRIBUTE_GROUPS(i2c_adapter);
1392 struct device_type i2c_adapter_type = {
1393 .groups = i2c_adapter_groups,
1394 .release = i2c_adapter_dev_release,
1396 EXPORT_SYMBOL_GPL(i2c_adapter_type);
1399 * i2c_verify_adapter - return parameter as i2c_adapter or NULL
1400 * @dev: device, probably from some driver model iterator
1402 * When traversing the driver model tree, perhaps using driver model
1403 * iterators like @device_for_each_child(), you can't assume very much
1404 * about the nodes you find. Use this function to avoid oopses caused
1405 * by wrongly treating some non-I2C device as an i2c_adapter.
1407 struct i2c_adapter *i2c_verify_adapter(struct device *dev)
1409 return (dev->type == &i2c_adapter_type)
1410 ? to_i2c_adapter(dev)
1413 EXPORT_SYMBOL(i2c_verify_adapter);
1415 #ifdef CONFIG_I2C_COMPAT
1416 static struct class_compat *i2c_adapter_compat_class;
1419 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
1421 struct i2c_devinfo *devinfo;
1423 down_read(&__i2c_board_lock);
1424 list_for_each_entry(devinfo, &__i2c_board_list, list) {
1425 if (devinfo->busnum == adapter->nr
1426 && !i2c_new_device(adapter,
1427 &devinfo->board_info))
1428 dev_err(&adapter->dev,
1429 "Can't create device at 0x%02x\n",
1430 devinfo->board_info.addr);
1432 up_read(&__i2c_board_lock);
1435 /* OF support code */
1437 #if IS_ENABLED(CONFIG_OF)
1438 static struct i2c_client *of_i2c_register_device(struct i2c_adapter *adap,
1439 struct device_node *node)
1441 struct i2c_client *result;
1442 struct i2c_board_info info = {};
1443 struct dev_archdata dev_ad = {};
1444 const __be32 *addr_be;
1448 dev_dbg(&adap->dev, "of_i2c: register %s\n", node->full_name);
1450 if (of_modalias_node(node, info.type, sizeof(info.type)) < 0) {
1451 dev_err(&adap->dev, "of_i2c: modalias failure on %s\n",
1453 return ERR_PTR(-EINVAL);
1456 addr_be = of_get_property(node, "reg", &len);
1457 if (!addr_be || (len < sizeof(*addr_be))) {
1458 dev_err(&adap->dev, "of_i2c: invalid reg on %s\n",
1460 return ERR_PTR(-EINVAL);
1463 addr = be32_to_cpup(addr_be);
1464 if (addr & I2C_TEN_BIT_ADDRESS) {
1465 addr &= ~I2C_TEN_BIT_ADDRESS;
1466 info.flags |= I2C_CLIENT_TEN;
1469 if (addr & I2C_OWN_SLAVE_ADDRESS) {
1470 addr &= ~I2C_OWN_SLAVE_ADDRESS;
1471 info.flags |= I2C_CLIENT_SLAVE;
1474 if (i2c_check_addr_validity(addr, info.flags)) {
1475 dev_err(&adap->dev, "of_i2c: invalid addr=%x on %s\n",
1476 info.addr, node->full_name);
1477 return ERR_PTR(-EINVAL);
1481 info.of_node = of_node_get(node);
1482 info.archdata = &dev_ad;
1484 if (of_get_property(node, "wakeup-source", NULL))
1485 info.flags |= I2C_CLIENT_WAKE;
1487 result = i2c_new_device(adap, &info);
1488 if (result == NULL) {
1489 dev_err(&adap->dev, "of_i2c: Failure registering %s\n",
1492 return ERR_PTR(-EINVAL);
1497 static void of_i2c_register_devices(struct i2c_adapter *adap)
1499 struct device_node *node;
1501 /* Only register child devices if the adapter has a node pointer set */
1502 if (!adap->dev.of_node)
1505 dev_dbg(&adap->dev, "of_i2c: walking child nodes\n");
1507 for_each_available_child_of_node(adap->dev.of_node, node) {
1508 if (of_node_test_and_set_flag(node, OF_POPULATED))
1510 of_i2c_register_device(adap, node);
1514 static int of_dev_node_match(struct device *dev, void *data)
1516 return dev->of_node == data;
1519 /* must call put_device() when done with returned i2c_client device */
1520 struct i2c_client *of_find_i2c_device_by_node(struct device_node *node)
1523 struct i2c_client *client;
1525 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
1529 client = i2c_verify_client(dev);
1535 EXPORT_SYMBOL(of_find_i2c_device_by_node);
1537 /* must call put_device() when done with returned i2c_adapter device */
1538 struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node)
1541 struct i2c_adapter *adapter;
1543 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
1547 adapter = i2c_verify_adapter(dev);
1553 EXPORT_SYMBOL(of_find_i2c_adapter_by_node);
1555 /* must call i2c_put_adapter() when done with returned i2c_adapter device */
1556 struct i2c_adapter *of_get_i2c_adapter_by_node(struct device_node *node)
1558 struct i2c_adapter *adapter;
1560 adapter = of_find_i2c_adapter_by_node(node);
1564 if (!try_module_get(adapter->owner)) {
1565 put_device(&adapter->dev);
1571 EXPORT_SYMBOL(of_get_i2c_adapter_by_node);
1573 static void of_i2c_register_devices(struct i2c_adapter *adap) { }
1574 #endif /* CONFIG_OF */
1576 static int i2c_do_add_adapter(struct i2c_driver *driver,
1577 struct i2c_adapter *adap)
1579 /* Detect supported devices on that bus, and instantiate them */
1580 i2c_detect(adap, driver);
1582 /* Let legacy drivers scan this bus for matching devices */
1583 if (driver->attach_adapter) {
1584 dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
1585 driver->driver.name);
1586 dev_warn(&adap->dev, "Please use another way to instantiate "
1587 "your i2c_client\n");
1588 /* We ignore the return code; if it fails, too bad */
1589 driver->attach_adapter(adap);
1594 static int __process_new_adapter(struct device_driver *d, void *data)
1596 return i2c_do_add_adapter(to_i2c_driver(d), data);
1599 static int i2c_register_adapter(struct i2c_adapter *adap)
1603 /* Can't register until after driver model init */
1604 if (WARN_ON(!is_registered)) {
1610 if (WARN(!adap->name[0], "i2c adapter has no name"))
1614 pr_err("adapter '%s': no algo supplied!\n", adap->name);
1618 if (!adap->lock_bus) {
1619 adap->lock_bus = i2c_adapter_lock_bus;
1620 adap->trylock_bus = i2c_adapter_trylock_bus;
1621 adap->unlock_bus = i2c_adapter_unlock_bus;
1624 rt_mutex_init(&adap->bus_lock);
1625 rt_mutex_init(&adap->mux_lock);
1626 mutex_init(&adap->userspace_clients_lock);
1627 INIT_LIST_HEAD(&adap->userspace_clients);
1629 /* Set default timeout to 1 second if not already set */
1630 if (adap->timeout == 0)
1633 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
1634 adap->dev.bus = &i2c_bus_type;
1635 adap->dev.type = &i2c_adapter_type;
1636 res = device_register(&adap->dev);
1638 pr_err("adapter '%s': can't register device (%d)\n", adap->name, res);
1642 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
1644 pm_runtime_no_callbacks(&adap->dev);
1645 pm_suspend_ignore_children(&adap->dev, true);
1646 pm_runtime_enable(&adap->dev);
1648 #ifdef CONFIG_I2C_COMPAT
1649 res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
1652 dev_warn(&adap->dev,
1653 "Failed to create compatibility class link\n");
1656 i2c_init_recovery(adap);
1658 /* create pre-declared device nodes */
1659 of_i2c_register_devices(adap);
1660 i2c_acpi_register_devices(adap);
1661 i2c_acpi_install_space_handler(adap);
1663 if (adap->nr < __i2c_first_dynamic_bus_num)
1664 i2c_scan_static_board_info(adap);
1666 /* Notify drivers */
1667 mutex_lock(&core_lock);
1668 bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
1669 mutex_unlock(&core_lock);
1674 mutex_lock(&core_lock);
1675 idr_remove(&i2c_adapter_idr, adap->nr);
1676 mutex_unlock(&core_lock);
1681 * __i2c_add_numbered_adapter - i2c_add_numbered_adapter where nr is never -1
1682 * @adap: the adapter to register (with adap->nr initialized)
1683 * Context: can sleep
1685 * See i2c_add_numbered_adapter() for details.
1687 static int __i2c_add_numbered_adapter(struct i2c_adapter *adap)
1691 mutex_lock(&core_lock);
1692 id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1, GFP_KERNEL);
1693 mutex_unlock(&core_lock);
1694 if (WARN(id < 0, "couldn't get idr"))
1695 return id == -ENOSPC ? -EBUSY : id;
1697 return i2c_register_adapter(adap);
1701 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
1702 * @adapter: the adapter to add
1703 * Context: can sleep
1705 * This routine is used to declare an I2C adapter when its bus number
1706 * doesn't matter or when its bus number is specified by an dt alias.
1707 * Examples of bases when the bus number doesn't matter: I2C adapters
1708 * dynamically added by USB links or PCI plugin cards.
1710 * When this returns zero, a new bus number was allocated and stored
1711 * in adap->nr, and the specified adapter became available for clients.
1712 * Otherwise, a negative errno value is returned.
1714 int i2c_add_adapter(struct i2c_adapter *adapter)
1716 struct device *dev = &adapter->dev;
1720 id = of_alias_get_id(dev->of_node, "i2c");
1723 return __i2c_add_numbered_adapter(adapter);
1727 mutex_lock(&core_lock);
1728 id = idr_alloc(&i2c_adapter_idr, adapter,
1729 __i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
1730 mutex_unlock(&core_lock);
1731 if (WARN(id < 0, "couldn't get idr"))
1736 return i2c_register_adapter(adapter);
1738 EXPORT_SYMBOL(i2c_add_adapter);
1741 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
1742 * @adap: the adapter to register (with adap->nr initialized)
1743 * Context: can sleep
1745 * This routine is used to declare an I2C adapter when its bus number
1746 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
1747 * or otherwise built in to the system's mainboard, and where i2c_board_info
1748 * is used to properly configure I2C devices.
1750 * If the requested bus number is set to -1, then this function will behave
1751 * identically to i2c_add_adapter, and will dynamically assign a bus number.
1753 * If no devices have pre-been declared for this bus, then be sure to
1754 * register the adapter before any dynamically allocated ones. Otherwise
1755 * the required bus ID may not be available.
1757 * When this returns zero, the specified adapter became available for
1758 * clients using the bus number provided in adap->nr. Also, the table
1759 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
1760 * and the appropriate driver model device nodes are created. Otherwise, a
1761 * negative errno value is returned.
1763 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
1765 if (adap->nr == -1) /* -1 means dynamically assign bus id */
1766 return i2c_add_adapter(adap);
1768 return __i2c_add_numbered_adapter(adap);
1770 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
1772 static void i2c_do_del_adapter(struct i2c_driver *driver,
1773 struct i2c_adapter *adapter)
1775 struct i2c_client *client, *_n;
1777 /* Remove the devices we created ourselves as the result of hardware
1778 * probing (using a driver's detect method) */
1779 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
1780 if (client->adapter == adapter) {
1781 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
1782 client->name, client->addr);
1783 list_del(&client->detected);
1784 i2c_unregister_device(client);
1789 static int __unregister_client(struct device *dev, void *dummy)
1791 struct i2c_client *client = i2c_verify_client(dev);
1792 if (client && strcmp(client->name, "dummy"))
1793 i2c_unregister_device(client);
1797 static int __unregister_dummy(struct device *dev, void *dummy)
1799 struct i2c_client *client = i2c_verify_client(dev);
1801 i2c_unregister_device(client);
1805 static int __process_removed_adapter(struct device_driver *d, void *data)
1807 i2c_do_del_adapter(to_i2c_driver(d), data);
1812 * i2c_del_adapter - unregister I2C adapter
1813 * @adap: the adapter being unregistered
1814 * Context: can sleep
1816 * This unregisters an I2C adapter which was previously registered
1817 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
1819 void i2c_del_adapter(struct i2c_adapter *adap)
1821 struct i2c_adapter *found;
1822 struct i2c_client *client, *next;
1824 /* First make sure that this adapter was ever added */
1825 mutex_lock(&core_lock);
1826 found = idr_find(&i2c_adapter_idr, adap->nr);
1827 mutex_unlock(&core_lock);
1828 if (found != adap) {
1829 pr_debug("attempting to delete unregistered adapter [%s]\n", adap->name);
1833 i2c_acpi_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("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("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 dev_err(&adap->dev, "failed to create client for '%s'\n",
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("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");