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;
529 /* uevent helps with hotplug: modprobe -q $(MODALIAS) */
530 static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
532 struct i2c_client *client = to_i2c_client(dev);
535 rc = acpi_device_uevent_modalias(dev, env);
539 if (add_uevent_var(env, "MODALIAS=%s%s",
540 I2C_MODULE_PREFIX, client->name))
542 dev_dbg(dev, "uevent\n");
546 /* i2c bus recovery routines */
547 static int get_scl_gpio_value(struct i2c_adapter *adap)
549 return gpio_get_value(adap->bus_recovery_info->scl_gpio);
552 static void set_scl_gpio_value(struct i2c_adapter *adap, int val)
554 gpio_set_value(adap->bus_recovery_info->scl_gpio, val);
557 static int get_sda_gpio_value(struct i2c_adapter *adap)
559 return gpio_get_value(adap->bus_recovery_info->sda_gpio);
562 static int i2c_get_gpios_for_recovery(struct i2c_adapter *adap)
564 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
565 struct device *dev = &adap->dev;
568 ret = gpio_request_one(bri->scl_gpio, GPIOF_OPEN_DRAIN |
569 GPIOF_OUT_INIT_HIGH, "i2c-scl");
571 dev_warn(dev, "Can't get SCL gpio: %d\n", bri->scl_gpio);
576 if (gpio_request_one(bri->sda_gpio, GPIOF_IN, "i2c-sda")) {
577 /* work without SDA polling */
578 dev_warn(dev, "Can't get SDA gpio: %d. Not using SDA polling\n",
587 static void i2c_put_gpios_for_recovery(struct i2c_adapter *adap)
589 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
592 gpio_free(bri->sda_gpio);
594 gpio_free(bri->scl_gpio);
598 * We are generating clock pulses. ndelay() determines durating of clk pulses.
599 * We will generate clock with rate 100 KHz and so duration of both clock levels
600 * is: delay in ns = (10^6 / 100) / 2
602 #define RECOVERY_NDELAY 5000
603 #define RECOVERY_CLK_CNT 9
605 static int i2c_generic_recovery(struct i2c_adapter *adap)
607 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
608 int i = 0, val = 1, ret = 0;
610 if (bri->prepare_recovery)
611 bri->prepare_recovery(adap);
613 bri->set_scl(adap, val);
614 ndelay(RECOVERY_NDELAY);
617 * By this time SCL is high, as we need to give 9 falling-rising edges
619 while (i++ < RECOVERY_CLK_CNT * 2) {
621 /* Break if SDA is high */
622 if (bri->get_sda && bri->get_sda(adap))
624 /* SCL shouldn't be low here */
625 if (!bri->get_scl(adap)) {
627 "SCL is stuck low, exit recovery\n");
634 bri->set_scl(adap, val);
635 ndelay(RECOVERY_NDELAY);
638 if (bri->unprepare_recovery)
639 bri->unprepare_recovery(adap);
644 int i2c_generic_scl_recovery(struct i2c_adapter *adap)
646 return i2c_generic_recovery(adap);
648 EXPORT_SYMBOL_GPL(i2c_generic_scl_recovery);
650 int i2c_generic_gpio_recovery(struct i2c_adapter *adap)
654 ret = i2c_get_gpios_for_recovery(adap);
658 ret = i2c_generic_recovery(adap);
659 i2c_put_gpios_for_recovery(adap);
663 EXPORT_SYMBOL_GPL(i2c_generic_gpio_recovery);
665 int i2c_recover_bus(struct i2c_adapter *adap)
667 if (!adap->bus_recovery_info)
670 dev_dbg(&adap->dev, "Trying i2c bus recovery\n");
671 return adap->bus_recovery_info->recover_bus(adap);
673 EXPORT_SYMBOL_GPL(i2c_recover_bus);
675 static int i2c_device_probe(struct device *dev)
677 struct i2c_client *client = i2c_verify_client(dev);
678 struct i2c_driver *driver;
688 irq = of_irq_get_byname(dev->of_node, "irq");
689 if (irq == -EINVAL || irq == -ENODATA)
690 irq = of_irq_get(dev->of_node, 0);
691 } else if (ACPI_COMPANION(dev)) {
692 irq = acpi_dev_gpio_irq_get(ACPI_COMPANION(dev), 0);
694 if (irq == -EPROBE_DEFER)
702 driver = to_i2c_driver(dev->driver);
703 if (!driver->probe || !driver->id_table)
706 if (client->flags & I2C_CLIENT_WAKE) {
707 int wakeirq = -ENOENT;
710 wakeirq = of_irq_get_byname(dev->of_node, "wakeup");
711 if (wakeirq == -EPROBE_DEFER)
715 device_init_wakeup(&client->dev, true);
717 if (wakeirq > 0 && wakeirq != client->irq)
718 status = dev_pm_set_dedicated_wake_irq(dev, wakeirq);
719 else if (client->irq > 0)
720 status = dev_pm_set_wake_irq(dev, client->irq);
725 dev_warn(&client->dev, "failed to set up wakeup irq");
728 dev_dbg(dev, "probe\n");
730 status = of_clk_set_defaults(dev->of_node, false);
732 goto err_clear_wakeup_irq;
734 status = dev_pm_domain_attach(&client->dev, true);
735 if (status == -EPROBE_DEFER)
736 goto err_clear_wakeup_irq;
738 status = driver->probe(client, i2c_match_id(driver->id_table, client));
740 goto err_detach_pm_domain;
744 err_detach_pm_domain:
745 dev_pm_domain_detach(&client->dev, true);
746 err_clear_wakeup_irq:
747 dev_pm_clear_wake_irq(&client->dev);
748 device_init_wakeup(&client->dev, false);
752 static int i2c_device_remove(struct device *dev)
754 struct i2c_client *client = i2c_verify_client(dev);
755 struct i2c_driver *driver;
758 if (!client || !dev->driver)
761 driver = to_i2c_driver(dev->driver);
762 if (driver->remove) {
763 dev_dbg(dev, "remove\n");
764 status = driver->remove(client);
767 dev_pm_domain_detach(&client->dev, true);
769 dev_pm_clear_wake_irq(&client->dev);
770 device_init_wakeup(&client->dev, false);
775 static void i2c_device_shutdown(struct device *dev)
777 struct i2c_client *client = i2c_verify_client(dev);
778 struct i2c_driver *driver;
780 if (!client || !dev->driver)
782 driver = to_i2c_driver(dev->driver);
783 if (driver->shutdown)
784 driver->shutdown(client);
787 static void i2c_client_dev_release(struct device *dev)
789 kfree(to_i2c_client(dev));
793 show_name(struct device *dev, struct device_attribute *attr, char *buf)
795 return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
796 to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
798 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
801 show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
803 struct i2c_client *client = to_i2c_client(dev);
806 len = acpi_device_modalias(dev, buf, PAGE_SIZE -1);
810 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
812 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
814 static struct attribute *i2c_dev_attrs[] = {
816 /* modalias helps coldplug: modprobe $(cat .../modalias) */
817 &dev_attr_modalias.attr,
820 ATTRIBUTE_GROUPS(i2c_dev);
822 struct bus_type i2c_bus_type = {
824 .match = i2c_device_match,
825 .probe = i2c_device_probe,
826 .remove = i2c_device_remove,
827 .shutdown = i2c_device_shutdown,
829 EXPORT_SYMBOL_GPL(i2c_bus_type);
831 static struct device_type i2c_client_type = {
832 .groups = i2c_dev_groups,
833 .uevent = i2c_device_uevent,
834 .release = i2c_client_dev_release,
839 * i2c_verify_client - return parameter as i2c_client, or NULL
840 * @dev: device, probably from some driver model iterator
842 * When traversing the driver model tree, perhaps using driver model
843 * iterators like @device_for_each_child(), you can't assume very much
844 * about the nodes you find. Use this function to avoid oopses caused
845 * by wrongly treating some non-I2C device as an i2c_client.
847 struct i2c_client *i2c_verify_client(struct device *dev)
849 return (dev->type == &i2c_client_type)
853 EXPORT_SYMBOL(i2c_verify_client);
856 /* Return a unique address which takes the flags of the client into account */
857 static unsigned short i2c_encode_flags_to_addr(struct i2c_client *client)
859 unsigned short addr = client->addr;
861 /* For some client flags, add an arbitrary offset to avoid collisions */
862 if (client->flags & I2C_CLIENT_TEN)
863 addr |= I2C_ADDR_OFFSET_TEN_BIT;
865 if (client->flags & I2C_CLIENT_SLAVE)
866 addr |= I2C_ADDR_OFFSET_SLAVE;
871 /* This is a permissive address validity check, I2C address map constraints
872 * are purposely not enforced, except for the general call address. */
873 static int i2c_check_addr_validity(unsigned addr, unsigned short flags)
875 if (flags & I2C_CLIENT_TEN) {
876 /* 10-bit address, all values are valid */
880 /* 7-bit address, reject the general call address */
881 if (addr == 0x00 || addr > 0x7f)
887 /* And this is a strict address validity check, used when probing. If a
888 * device uses a reserved address, then it shouldn't be probed. 7-bit
889 * addressing is assumed, 10-bit address devices are rare and should be
890 * explicitly enumerated. */
891 static int i2c_check_7bit_addr_validity_strict(unsigned short addr)
894 * Reserved addresses per I2C specification:
895 * 0x00 General call address / START byte
897 * 0x02 Reserved for different bus format
898 * 0x03 Reserved for future purposes
899 * 0x04-0x07 Hs-mode master code
900 * 0x78-0x7b 10-bit slave addressing
901 * 0x7c-0x7f Reserved for future purposes
903 if (addr < 0x08 || addr > 0x77)
908 static int __i2c_check_addr_busy(struct device *dev, void *addrp)
910 struct i2c_client *client = i2c_verify_client(dev);
911 int addr = *(int *)addrp;
913 if (client && i2c_encode_flags_to_addr(client) == addr)
918 /* walk up mux tree */
919 static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
921 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
924 result = device_for_each_child(&adapter->dev, &addr,
925 __i2c_check_addr_busy);
927 if (!result && parent)
928 result = i2c_check_mux_parents(parent, addr);
933 /* recurse down mux tree */
934 static int i2c_check_mux_children(struct device *dev, void *addrp)
938 if (dev->type == &i2c_adapter_type)
939 result = device_for_each_child(dev, addrp,
940 i2c_check_mux_children);
942 result = __i2c_check_addr_busy(dev, addrp);
947 static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
949 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
953 result = i2c_check_mux_parents(parent, addr);
956 result = device_for_each_child(&adapter->dev, &addr,
957 i2c_check_mux_children);
963 * i2c_lock_adapter - Get exclusive access to an I2C bus segment
964 * @adapter: Target I2C bus segment
966 void i2c_lock_adapter(struct i2c_adapter *adapter)
968 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
971 i2c_lock_adapter(parent);
973 rt_mutex_lock(&adapter->bus_lock);
975 EXPORT_SYMBOL_GPL(i2c_lock_adapter);
978 * i2c_trylock_adapter - Try to get exclusive access to an I2C bus segment
979 * @adapter: Target I2C bus segment
981 static int i2c_trylock_adapter(struct i2c_adapter *adapter)
983 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
986 return i2c_trylock_adapter(parent);
988 return rt_mutex_trylock(&adapter->bus_lock);
992 * i2c_unlock_adapter - Release exclusive access to an I2C bus segment
993 * @adapter: Target I2C bus segment
995 void i2c_unlock_adapter(struct i2c_adapter *adapter)
997 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
1000 i2c_unlock_adapter(parent);
1002 rt_mutex_unlock(&adapter->bus_lock);
1004 EXPORT_SYMBOL_GPL(i2c_unlock_adapter);
1006 static void i2c_dev_set_name(struct i2c_adapter *adap,
1007 struct i2c_client *client)
1009 struct acpi_device *adev = ACPI_COMPANION(&client->dev);
1012 dev_set_name(&client->dev, "i2c-%s", acpi_dev_name(adev));
1016 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
1017 i2c_encode_flags_to_addr(client));
1021 * i2c_new_device - instantiate an i2c device
1022 * @adap: the adapter managing the device
1023 * @info: describes one I2C device; bus_num is ignored
1024 * Context: can sleep
1026 * Create an i2c device. Binding is handled through driver model
1027 * probe()/remove() methods. A driver may be bound to this device when we
1028 * return from this function, or any later moment (e.g. maybe hotplugging will
1029 * load the driver module). This call is not appropriate for use by mainboard
1030 * initialization logic, which usually runs during an arch_initcall() long
1031 * before any i2c_adapter could exist.
1033 * This returns the new i2c client, which may be saved for later use with
1034 * i2c_unregister_device(); or NULL to indicate an error.
1037 i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
1039 struct i2c_client *client;
1042 client = kzalloc(sizeof *client, GFP_KERNEL);
1046 client->adapter = adap;
1048 client->dev.platform_data = info->platform_data;
1051 client->dev.archdata = *info->archdata;
1053 client->flags = info->flags;
1054 client->addr = info->addr;
1055 client->irq = info->irq;
1057 strlcpy(client->name, info->type, sizeof(client->name));
1059 status = i2c_check_addr_validity(client->addr, client->flags);
1061 dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
1062 client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
1063 goto out_err_silent;
1066 /* Check for address business */
1067 status = i2c_check_addr_busy(adap, i2c_encode_flags_to_addr(client));
1071 client->dev.parent = &client->adapter->dev;
1072 client->dev.bus = &i2c_bus_type;
1073 client->dev.type = &i2c_client_type;
1074 client->dev.of_node = info->of_node;
1075 client->dev.fwnode = info->fwnode;
1077 i2c_dev_set_name(adap, client);
1078 status = device_register(&client->dev);
1082 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
1083 client->name, dev_name(&client->dev));
1088 dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
1089 "(%d)\n", client->name, client->addr, status);
1094 EXPORT_SYMBOL_GPL(i2c_new_device);
1098 * i2c_unregister_device - reverse effect of i2c_new_device()
1099 * @client: value returned from i2c_new_device()
1100 * Context: can sleep
1102 void i2c_unregister_device(struct i2c_client *client)
1104 if (client->dev.of_node)
1105 of_node_clear_flag(client->dev.of_node, OF_POPULATED);
1106 device_unregister(&client->dev);
1108 EXPORT_SYMBOL_GPL(i2c_unregister_device);
1111 static const struct i2c_device_id dummy_id[] = {
1116 static int dummy_probe(struct i2c_client *client,
1117 const struct i2c_device_id *id)
1122 static int dummy_remove(struct i2c_client *client)
1127 static struct i2c_driver dummy_driver = {
1128 .driver.name = "dummy",
1129 .probe = dummy_probe,
1130 .remove = dummy_remove,
1131 .id_table = dummy_id,
1135 * i2c_new_dummy - return a new i2c device bound to a dummy driver
1136 * @adapter: the adapter managing the device
1137 * @address: seven bit address to be used
1138 * Context: can sleep
1140 * This returns an I2C client bound to the "dummy" driver, intended for use
1141 * with devices that consume multiple addresses. Examples of such chips
1142 * include various EEPROMS (like 24c04 and 24c08 models).
1144 * These dummy devices have two main uses. First, most I2C and SMBus calls
1145 * except i2c_transfer() need a client handle; the dummy will be that handle.
1146 * And second, this prevents the specified address from being bound to a
1149 * This returns the new i2c client, which should be saved for later use with
1150 * i2c_unregister_device(); or NULL to indicate an error.
1152 struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
1154 struct i2c_board_info info = {
1155 I2C_BOARD_INFO("dummy", address),
1158 return i2c_new_device(adapter, &info);
1160 EXPORT_SYMBOL_GPL(i2c_new_dummy);
1162 /* ------------------------------------------------------------------------- */
1164 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
1166 static void i2c_adapter_dev_release(struct device *dev)
1168 struct i2c_adapter *adap = to_i2c_adapter(dev);
1169 complete(&adap->dev_released);
1173 * This function is only needed for mutex_lock_nested, so it is never
1174 * called unless locking correctness checking is enabled. Thus we
1175 * make it inline to avoid a compiler warning. That's what gcc ends up
1178 static inline unsigned int i2c_adapter_depth(struct i2c_adapter *adapter)
1180 unsigned int depth = 0;
1182 while ((adapter = i2c_parent_is_i2c_adapter(adapter)))
1189 * Let users instantiate I2C devices through sysfs. This can be used when
1190 * platform initialization code doesn't contain the proper data for
1191 * whatever reason. Also useful for drivers that do device detection and
1192 * detection fails, either because the device uses an unexpected address,
1193 * or this is a compatible device with different ID register values.
1195 * Parameter checking may look overzealous, but we really don't want
1196 * the user to provide incorrect parameters.
1199 i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
1200 const char *buf, size_t count)
1202 struct i2c_adapter *adap = to_i2c_adapter(dev);
1203 struct i2c_board_info info;
1204 struct i2c_client *client;
1208 memset(&info, 0, sizeof(struct i2c_board_info));
1210 blank = strchr(buf, ' ');
1212 dev_err(dev, "%s: Missing parameters\n", "new_device");
1215 if (blank - buf > I2C_NAME_SIZE - 1) {
1216 dev_err(dev, "%s: Invalid device name\n", "new_device");
1219 memcpy(info.type, buf, blank - buf);
1221 /* Parse remaining parameters, reject extra parameters */
1222 res = sscanf(++blank, "%hi%c", &info.addr, &end);
1224 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
1227 if (res > 1 && end != '\n') {
1228 dev_err(dev, "%s: Extra parameters\n", "new_device");
1232 if ((info.addr & I2C_ADDR_OFFSET_TEN_BIT) == I2C_ADDR_OFFSET_TEN_BIT) {
1233 info.addr &= ~I2C_ADDR_OFFSET_TEN_BIT;
1234 info.flags |= I2C_CLIENT_TEN;
1237 if (info.addr & I2C_ADDR_OFFSET_SLAVE) {
1238 info.addr &= ~I2C_ADDR_OFFSET_SLAVE;
1239 info.flags |= I2C_CLIENT_SLAVE;
1242 client = i2c_new_device(adap, &info);
1246 /* Keep track of the added device */
1247 mutex_lock(&adap->userspace_clients_lock);
1248 list_add_tail(&client->detected, &adap->userspace_clients);
1249 mutex_unlock(&adap->userspace_clients_lock);
1250 dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
1251 info.type, info.addr);
1255 static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
1258 * And of course let the users delete the devices they instantiated, if
1259 * they got it wrong. This interface can only be used to delete devices
1260 * instantiated by i2c_sysfs_new_device above. This guarantees that we
1261 * don't delete devices to which some kernel code still has references.
1263 * Parameter checking may look overzealous, but we really don't want
1264 * the user to delete the wrong device.
1267 i2c_sysfs_delete_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_client *client, *next;
1272 unsigned short addr;
1276 /* Parse parameters, reject extra parameters */
1277 res = sscanf(buf, "%hi%c", &addr, &end);
1279 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
1282 if (res > 1 && end != '\n') {
1283 dev_err(dev, "%s: Extra parameters\n", "delete_device");
1287 /* Make sure the device was added through sysfs */
1289 mutex_lock_nested(&adap->userspace_clients_lock,
1290 i2c_adapter_depth(adap));
1291 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1293 if (i2c_encode_flags_to_addr(client) == addr) {
1294 dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
1295 "delete_device", client->name, client->addr);
1297 list_del(&client->detected);
1298 i2c_unregister_device(client);
1303 mutex_unlock(&adap->userspace_clients_lock);
1306 dev_err(dev, "%s: Can't find device in list\n",
1310 static DEVICE_ATTR_IGNORE_LOCKDEP(delete_device, S_IWUSR, NULL,
1311 i2c_sysfs_delete_device);
1313 static struct attribute *i2c_adapter_attrs[] = {
1314 &dev_attr_name.attr,
1315 &dev_attr_new_device.attr,
1316 &dev_attr_delete_device.attr,
1319 ATTRIBUTE_GROUPS(i2c_adapter);
1321 struct device_type i2c_adapter_type = {
1322 .groups = i2c_adapter_groups,
1323 .release = i2c_adapter_dev_release,
1325 EXPORT_SYMBOL_GPL(i2c_adapter_type);
1328 * i2c_verify_adapter - return parameter as i2c_adapter or NULL
1329 * @dev: device, probably from some driver model iterator
1331 * When traversing the driver model tree, perhaps using driver model
1332 * iterators like @device_for_each_child(), you can't assume very much
1333 * about the nodes you find. Use this function to avoid oopses caused
1334 * by wrongly treating some non-I2C device as an i2c_adapter.
1336 struct i2c_adapter *i2c_verify_adapter(struct device *dev)
1338 return (dev->type == &i2c_adapter_type)
1339 ? to_i2c_adapter(dev)
1342 EXPORT_SYMBOL(i2c_verify_adapter);
1344 #ifdef CONFIG_I2C_COMPAT
1345 static struct class_compat *i2c_adapter_compat_class;
1348 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
1350 struct i2c_devinfo *devinfo;
1352 down_read(&__i2c_board_lock);
1353 list_for_each_entry(devinfo, &__i2c_board_list, list) {
1354 if (devinfo->busnum == adapter->nr
1355 && !i2c_new_device(adapter,
1356 &devinfo->board_info))
1357 dev_err(&adapter->dev,
1358 "Can't create device at 0x%02x\n",
1359 devinfo->board_info.addr);
1361 up_read(&__i2c_board_lock);
1364 /* OF support code */
1366 #if IS_ENABLED(CONFIG_OF)
1367 static struct i2c_client *of_i2c_register_device(struct i2c_adapter *adap,
1368 struct device_node *node)
1370 struct i2c_client *result;
1371 struct i2c_board_info info = {};
1372 struct dev_archdata dev_ad = {};
1373 const __be32 *addr_be;
1377 dev_dbg(&adap->dev, "of_i2c: register %s\n", node->full_name);
1379 if (of_modalias_node(node, info.type, sizeof(info.type)) < 0) {
1380 dev_err(&adap->dev, "of_i2c: modalias failure on %s\n",
1382 return ERR_PTR(-EINVAL);
1385 addr_be = of_get_property(node, "reg", &len);
1386 if (!addr_be || (len < sizeof(*addr_be))) {
1387 dev_err(&adap->dev, "of_i2c: invalid reg on %s\n",
1389 return ERR_PTR(-EINVAL);
1392 addr = be32_to_cpup(addr_be);
1393 if (addr & I2C_TEN_BIT_ADDRESS) {
1394 addr &= ~I2C_TEN_BIT_ADDRESS;
1395 info.flags |= I2C_CLIENT_TEN;
1398 if (addr & I2C_OWN_SLAVE_ADDRESS) {
1399 addr &= ~I2C_OWN_SLAVE_ADDRESS;
1400 info.flags |= I2C_CLIENT_SLAVE;
1403 if (i2c_check_addr_validity(addr, info.flags)) {
1404 dev_err(&adap->dev, "of_i2c: invalid addr=%x on %s\n",
1405 info.addr, node->full_name);
1406 return ERR_PTR(-EINVAL);
1410 info.of_node = of_node_get(node);
1411 info.archdata = &dev_ad;
1413 if (of_get_property(node, "wakeup-source", NULL))
1414 info.flags |= I2C_CLIENT_WAKE;
1416 result = i2c_new_device(adap, &info);
1417 if (result == NULL) {
1418 dev_err(&adap->dev, "of_i2c: Failure registering %s\n",
1421 return ERR_PTR(-EINVAL);
1426 static void of_i2c_register_devices(struct i2c_adapter *adap)
1428 struct device_node *node;
1430 /* Only register child devices if the adapter has a node pointer set */
1431 if (!adap->dev.of_node)
1434 dev_dbg(&adap->dev, "of_i2c: walking child nodes\n");
1436 for_each_available_child_of_node(adap->dev.of_node, node) {
1437 if (of_node_test_and_set_flag(node, OF_POPULATED))
1439 of_i2c_register_device(adap, node);
1443 static int of_dev_node_match(struct device *dev, void *data)
1445 return dev->of_node == data;
1448 /* must call put_device() when done with returned i2c_client device */
1449 struct i2c_client *of_find_i2c_device_by_node(struct device_node *node)
1452 struct i2c_client *client;
1454 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
1458 client = i2c_verify_client(dev);
1464 EXPORT_SYMBOL(of_find_i2c_device_by_node);
1466 /* must call put_device() when done with returned i2c_adapter device */
1467 struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node)
1470 struct i2c_adapter *adapter;
1472 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
1476 adapter = i2c_verify_adapter(dev);
1482 EXPORT_SYMBOL(of_find_i2c_adapter_by_node);
1484 /* must call i2c_put_adapter() when done with returned i2c_adapter device */
1485 struct i2c_adapter *of_get_i2c_adapter_by_node(struct device_node *node)
1487 struct i2c_adapter *adapter;
1489 adapter = of_find_i2c_adapter_by_node(node);
1493 if (!try_module_get(adapter->owner)) {
1494 put_device(&adapter->dev);
1500 EXPORT_SYMBOL(of_get_i2c_adapter_by_node);
1502 static void of_i2c_register_devices(struct i2c_adapter *adap) { }
1503 #endif /* CONFIG_OF */
1505 static int i2c_do_add_adapter(struct i2c_driver *driver,
1506 struct i2c_adapter *adap)
1508 /* Detect supported devices on that bus, and instantiate them */
1509 i2c_detect(adap, driver);
1511 /* Let legacy drivers scan this bus for matching devices */
1512 if (driver->attach_adapter) {
1513 dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
1514 driver->driver.name);
1515 dev_warn(&adap->dev, "Please use another way to instantiate "
1516 "your i2c_client\n");
1517 /* We ignore the return code; if it fails, too bad */
1518 driver->attach_adapter(adap);
1523 static int __process_new_adapter(struct device_driver *d, void *data)
1525 return i2c_do_add_adapter(to_i2c_driver(d), data);
1528 static int i2c_register_adapter(struct i2c_adapter *adap)
1532 /* Can't register until after driver model init */
1533 if (WARN_ON(!is_registered)) {
1539 if (unlikely(adap->name[0] == '\0')) {
1540 pr_err("i2c-core: Attempt to register an adapter with "
1544 if (unlikely(!adap->algo)) {
1545 pr_err("i2c-core: Attempt to register adapter '%s' with "
1546 "no algo!\n", adap->name);
1550 rt_mutex_init(&adap->bus_lock);
1551 mutex_init(&adap->userspace_clients_lock);
1552 INIT_LIST_HEAD(&adap->userspace_clients);
1554 /* Set default timeout to 1 second if not already set */
1555 if (adap->timeout == 0)
1558 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
1559 adap->dev.bus = &i2c_bus_type;
1560 adap->dev.type = &i2c_adapter_type;
1561 res = device_register(&adap->dev);
1565 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
1567 pm_runtime_no_callbacks(&adap->dev);
1568 pm_runtime_enable(&adap->dev);
1570 #ifdef CONFIG_I2C_COMPAT
1571 res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
1574 dev_warn(&adap->dev,
1575 "Failed to create compatibility class link\n");
1578 /* bus recovery specific initialization */
1579 if (adap->bus_recovery_info) {
1580 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
1582 if (!bri->recover_bus) {
1583 dev_err(&adap->dev, "No recover_bus() found, not using recovery\n");
1584 adap->bus_recovery_info = NULL;
1588 /* Generic GPIO recovery */
1589 if (bri->recover_bus == i2c_generic_gpio_recovery) {
1590 if (!gpio_is_valid(bri->scl_gpio)) {
1591 dev_err(&adap->dev, "Invalid SCL gpio, not using recovery\n");
1592 adap->bus_recovery_info = NULL;
1596 if (gpio_is_valid(bri->sda_gpio))
1597 bri->get_sda = get_sda_gpio_value;
1599 bri->get_sda = NULL;
1601 bri->get_scl = get_scl_gpio_value;
1602 bri->set_scl = set_scl_gpio_value;
1603 } else if (!bri->set_scl || !bri->get_scl) {
1604 /* Generic SCL recovery */
1605 dev_err(&adap->dev, "No {get|set}_gpio() found, not using recovery\n");
1606 adap->bus_recovery_info = NULL;
1611 /* create pre-declared device nodes */
1612 of_i2c_register_devices(adap);
1613 acpi_i2c_register_devices(adap);
1614 acpi_i2c_install_space_handler(adap);
1616 if (adap->nr < __i2c_first_dynamic_bus_num)
1617 i2c_scan_static_board_info(adap);
1619 /* Notify drivers */
1620 mutex_lock(&core_lock);
1621 bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
1622 mutex_unlock(&core_lock);
1627 mutex_lock(&core_lock);
1628 idr_remove(&i2c_adapter_idr, adap->nr);
1629 mutex_unlock(&core_lock);
1634 * __i2c_add_numbered_adapter - i2c_add_numbered_adapter where nr is never -1
1635 * @adap: the adapter to register (with adap->nr initialized)
1636 * Context: can sleep
1638 * See i2c_add_numbered_adapter() for details.
1640 static int __i2c_add_numbered_adapter(struct i2c_adapter *adap)
1644 mutex_lock(&core_lock);
1645 id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1,
1647 mutex_unlock(&core_lock);
1649 return id == -ENOSPC ? -EBUSY : id;
1651 return i2c_register_adapter(adap);
1655 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
1656 * @adapter: the adapter to add
1657 * Context: can sleep
1659 * This routine is used to declare an I2C adapter when its bus number
1660 * doesn't matter or when its bus number is specified by an dt alias.
1661 * Examples of bases when the bus number doesn't matter: I2C adapters
1662 * dynamically added by USB links or PCI plugin cards.
1664 * When this returns zero, a new bus number was allocated and stored
1665 * in adap->nr, and the specified adapter became available for clients.
1666 * Otherwise, a negative errno value is returned.
1668 int i2c_add_adapter(struct i2c_adapter *adapter)
1670 struct device *dev = &adapter->dev;
1674 id = of_alias_get_id(dev->of_node, "i2c");
1677 return __i2c_add_numbered_adapter(adapter);
1681 mutex_lock(&core_lock);
1682 id = idr_alloc(&i2c_adapter_idr, adapter,
1683 __i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
1684 mutex_unlock(&core_lock);
1690 return i2c_register_adapter(adapter);
1692 EXPORT_SYMBOL(i2c_add_adapter);
1695 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
1696 * @adap: the adapter to register (with adap->nr initialized)
1697 * Context: can sleep
1699 * This routine is used to declare an I2C adapter when its bus number
1700 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
1701 * or otherwise built in to the system's mainboard, and where i2c_board_info
1702 * is used to properly configure I2C devices.
1704 * If the requested bus number is set to -1, then this function will behave
1705 * identically to i2c_add_adapter, and will dynamically assign a bus number.
1707 * If no devices have pre-been declared for this bus, then be sure to
1708 * register the adapter before any dynamically allocated ones. Otherwise
1709 * the required bus ID may not be available.
1711 * When this returns zero, the specified adapter became available for
1712 * clients using the bus number provided in adap->nr. Also, the table
1713 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
1714 * and the appropriate driver model device nodes are created. Otherwise, a
1715 * negative errno value is returned.
1717 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
1719 if (adap->nr == -1) /* -1 means dynamically assign bus id */
1720 return i2c_add_adapter(adap);
1722 return __i2c_add_numbered_adapter(adap);
1724 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
1726 static void i2c_do_del_adapter(struct i2c_driver *driver,
1727 struct i2c_adapter *adapter)
1729 struct i2c_client *client, *_n;
1731 /* Remove the devices we created ourselves as the result of hardware
1732 * probing (using a driver's detect method) */
1733 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
1734 if (client->adapter == adapter) {
1735 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
1736 client->name, client->addr);
1737 list_del(&client->detected);
1738 i2c_unregister_device(client);
1743 static int __unregister_client(struct device *dev, void *dummy)
1745 struct i2c_client *client = i2c_verify_client(dev);
1746 if (client && strcmp(client->name, "dummy"))
1747 i2c_unregister_device(client);
1751 static int __unregister_dummy(struct device *dev, void *dummy)
1753 struct i2c_client *client = i2c_verify_client(dev);
1755 i2c_unregister_device(client);
1759 static int __process_removed_adapter(struct device_driver *d, void *data)
1761 i2c_do_del_adapter(to_i2c_driver(d), data);
1766 * i2c_del_adapter - unregister I2C adapter
1767 * @adap: the adapter being unregistered
1768 * Context: can sleep
1770 * This unregisters an I2C adapter which was previously registered
1771 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
1773 void i2c_del_adapter(struct i2c_adapter *adap)
1775 struct i2c_adapter *found;
1776 struct i2c_client *client, *next;
1778 /* First make sure that this adapter was ever added */
1779 mutex_lock(&core_lock);
1780 found = idr_find(&i2c_adapter_idr, adap->nr);
1781 mutex_unlock(&core_lock);
1782 if (found != adap) {
1783 pr_debug("i2c-core: attempting to delete unregistered "
1784 "adapter [%s]\n", adap->name);
1788 acpi_i2c_remove_space_handler(adap);
1789 /* Tell drivers about this removal */
1790 mutex_lock(&core_lock);
1791 bus_for_each_drv(&i2c_bus_type, NULL, adap,
1792 __process_removed_adapter);
1793 mutex_unlock(&core_lock);
1795 /* Remove devices instantiated from sysfs */
1796 mutex_lock_nested(&adap->userspace_clients_lock,
1797 i2c_adapter_depth(adap));
1798 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1800 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
1802 list_del(&client->detected);
1803 i2c_unregister_device(client);
1805 mutex_unlock(&adap->userspace_clients_lock);
1807 /* Detach any active clients. This can't fail, thus we do not
1808 * check the returned value. This is a two-pass process, because
1809 * we can't remove the dummy devices during the first pass: they
1810 * could have been instantiated by real devices wishing to clean
1811 * them up properly, so we give them a chance to do that first. */
1812 device_for_each_child(&adap->dev, NULL, __unregister_client);
1813 device_for_each_child(&adap->dev, NULL, __unregister_dummy);
1815 #ifdef CONFIG_I2C_COMPAT
1816 class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
1820 /* device name is gone after device_unregister */
1821 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
1823 pm_runtime_disable(&adap->dev);
1825 /* wait until all references to the device are gone
1827 * FIXME: This is old code and should ideally be replaced by an
1828 * alternative which results in decoupling the lifetime of the struct
1829 * device from the i2c_adapter, like spi or netdev do. Any solution
1830 * should be thoroughly tested with DEBUG_KOBJECT_RELEASE enabled!
1832 init_completion(&adap->dev_released);
1833 device_unregister(&adap->dev);
1834 wait_for_completion(&adap->dev_released);
1837 mutex_lock(&core_lock);
1838 idr_remove(&i2c_adapter_idr, adap->nr);
1839 mutex_unlock(&core_lock);
1841 /* Clear the device structure in case this adapter is ever going to be
1843 memset(&adap->dev, 0, sizeof(adap->dev));
1845 EXPORT_SYMBOL(i2c_del_adapter);
1848 * i2c_parse_fw_timings - get I2C related timing parameters from firmware
1849 * @dev: The device to scan for I2C timing properties
1850 * @t: the i2c_timings struct to be filled with values
1851 * @use_defaults: bool to use sane defaults derived from the I2C specification
1852 * when properties are not found, otherwise use 0
1854 * Scan the device for the generic I2C properties describing timing parameters
1855 * for the signal and fill the given struct with the results. If a property was
1856 * not found and use_defaults was true, then maximum timings are assumed which
1857 * are derived from the I2C specification. If use_defaults is not used, the
1858 * results will be 0, so drivers can apply their own defaults later. The latter
1859 * is mainly intended for avoiding regressions of existing drivers which want
1860 * to switch to this function. New drivers almost always should use the defaults.
1863 void i2c_parse_fw_timings(struct device *dev, struct i2c_timings *t, bool use_defaults)
1867 memset(t, 0, sizeof(*t));
1869 ret = device_property_read_u32(dev, "clock-frequency", &t->bus_freq_hz);
1870 if (ret && use_defaults)
1871 t->bus_freq_hz = 100000;
1873 ret = device_property_read_u32(dev, "i2c-scl-rising-time-ns", &t->scl_rise_ns);
1874 if (ret && use_defaults) {
1875 if (t->bus_freq_hz <= 100000)
1876 t->scl_rise_ns = 1000;
1877 else if (t->bus_freq_hz <= 400000)
1878 t->scl_rise_ns = 300;
1880 t->scl_rise_ns = 120;
1883 ret = device_property_read_u32(dev, "i2c-scl-falling-time-ns", &t->scl_fall_ns);
1884 if (ret && use_defaults) {
1885 if (t->bus_freq_hz <= 400000)
1886 t->scl_fall_ns = 300;
1888 t->scl_fall_ns = 120;
1891 device_property_read_u32(dev, "i2c-scl-internal-delay-ns", &t->scl_int_delay_ns);
1893 ret = device_property_read_u32(dev, "i2c-sda-falling-time-ns", &t->sda_fall_ns);
1894 if (ret && use_defaults)
1895 t->sda_fall_ns = t->scl_fall_ns;
1897 EXPORT_SYMBOL_GPL(i2c_parse_fw_timings);
1899 /* ------------------------------------------------------------------------- */
1901 int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
1905 mutex_lock(&core_lock);
1906 res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
1907 mutex_unlock(&core_lock);
1911 EXPORT_SYMBOL_GPL(i2c_for_each_dev);
1913 static int __process_new_driver(struct device *dev, void *data)
1915 if (dev->type != &i2c_adapter_type)
1917 return i2c_do_add_adapter(data, to_i2c_adapter(dev));
1921 * An i2c_driver is used with one or more i2c_client (device) nodes to access
1922 * i2c slave chips, on a bus instance associated with some i2c_adapter.
1925 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
1929 /* Can't register until after driver model init */
1930 if (WARN_ON(!is_registered))
1933 /* add the driver to the list of i2c drivers in the driver core */
1934 driver->driver.owner = owner;
1935 driver->driver.bus = &i2c_bus_type;
1937 /* When registration returns, the driver core
1938 * will have called probe() for all matching-but-unbound devices.
1940 res = driver_register(&driver->driver);
1944 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
1946 INIT_LIST_HEAD(&driver->clients);
1947 /* Walk the adapters that are already present */
1948 i2c_for_each_dev(driver, __process_new_driver);
1952 EXPORT_SYMBOL(i2c_register_driver);
1954 static int __process_removed_driver(struct device *dev, void *data)
1956 if (dev->type == &i2c_adapter_type)
1957 i2c_do_del_adapter(data, to_i2c_adapter(dev));
1962 * i2c_del_driver - unregister I2C driver
1963 * @driver: the driver being unregistered
1964 * Context: can sleep
1966 void i2c_del_driver(struct i2c_driver *driver)
1968 i2c_for_each_dev(driver, __process_removed_driver);
1970 driver_unregister(&driver->driver);
1971 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
1973 EXPORT_SYMBOL(i2c_del_driver);
1975 /* ------------------------------------------------------------------------- */
1978 * i2c_use_client - increments the reference count of the i2c client structure
1979 * @client: the client being referenced
1981 * Each live reference to a client should be refcounted. The driver model does
1982 * that automatically as part of driver binding, so that most drivers don't
1983 * need to do this explicitly: they hold a reference until they're unbound
1986 * A pointer to the client with the incremented reference counter is returned.
1988 struct i2c_client *i2c_use_client(struct i2c_client *client)
1990 if (client && get_device(&client->dev))
1994 EXPORT_SYMBOL(i2c_use_client);
1997 * i2c_release_client - release a use of the i2c client structure
1998 * @client: the client being no longer referenced
2000 * Must be called when a user of a client is finished with it.
2002 void i2c_release_client(struct i2c_client *client)
2005 put_device(&client->dev);
2007 EXPORT_SYMBOL(i2c_release_client);
2009 struct i2c_cmd_arg {
2014 static int i2c_cmd(struct device *dev, void *_arg)
2016 struct i2c_client *client = i2c_verify_client(dev);
2017 struct i2c_cmd_arg *arg = _arg;
2018 struct i2c_driver *driver;
2020 if (!client || !client->dev.driver)
2023 driver = to_i2c_driver(client->dev.driver);
2024 if (driver->command)
2025 driver->command(client, arg->cmd, arg->arg);
2029 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
2031 struct i2c_cmd_arg cmd_arg;
2035 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
2037 EXPORT_SYMBOL(i2c_clients_command);
2039 #if IS_ENABLED(CONFIG_OF_DYNAMIC)
2040 static int of_i2c_notify(struct notifier_block *nb, unsigned long action,
2043 struct of_reconfig_data *rd = arg;
2044 struct i2c_adapter *adap;
2045 struct i2c_client *client;
2047 switch (of_reconfig_get_state_change(action, rd)) {
2048 case OF_RECONFIG_CHANGE_ADD:
2049 adap = of_find_i2c_adapter_by_node(rd->dn->parent);
2051 return NOTIFY_OK; /* not for us */
2053 if (of_node_test_and_set_flag(rd->dn, OF_POPULATED)) {
2054 put_device(&adap->dev);
2058 client = of_i2c_register_device(adap, rd->dn);
2059 put_device(&adap->dev);
2061 if (IS_ERR(client)) {
2062 pr_err("%s: failed to create for '%s'\n",
2063 __func__, rd->dn->full_name);
2064 return notifier_from_errno(PTR_ERR(client));
2067 case OF_RECONFIG_CHANGE_REMOVE:
2068 /* already depopulated? */
2069 if (!of_node_check_flag(rd->dn, OF_POPULATED))
2072 /* find our device by node */
2073 client = of_find_i2c_device_by_node(rd->dn);
2075 return NOTIFY_OK; /* no? not meant for us */
2077 /* unregister takes one ref away */
2078 i2c_unregister_device(client);
2080 /* and put the reference of the find */
2081 put_device(&client->dev);
2087 static struct notifier_block i2c_of_notifier = {
2088 .notifier_call = of_i2c_notify,
2091 extern struct notifier_block i2c_of_notifier;
2092 #endif /* CONFIG_OF_DYNAMIC */
2094 static int __init i2c_init(void)
2098 retval = of_alias_get_highest_id("i2c");
2100 down_write(&__i2c_board_lock);
2101 if (retval >= __i2c_first_dynamic_bus_num)
2102 __i2c_first_dynamic_bus_num = retval + 1;
2103 up_write(&__i2c_board_lock);
2105 retval = bus_register(&i2c_bus_type);
2109 is_registered = true;
2111 #ifdef CONFIG_I2C_COMPAT
2112 i2c_adapter_compat_class = class_compat_register("i2c-adapter");
2113 if (!i2c_adapter_compat_class) {
2118 retval = i2c_add_driver(&dummy_driver);
2122 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2123 WARN_ON(of_reconfig_notifier_register(&i2c_of_notifier));
2128 #ifdef CONFIG_I2C_COMPAT
2129 class_compat_unregister(i2c_adapter_compat_class);
2132 is_registered = false;
2133 bus_unregister(&i2c_bus_type);
2137 static void __exit i2c_exit(void)
2139 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2140 WARN_ON(of_reconfig_notifier_unregister(&i2c_of_notifier));
2141 i2c_del_driver(&dummy_driver);
2142 #ifdef CONFIG_I2C_COMPAT
2143 class_compat_unregister(i2c_adapter_compat_class);
2145 bus_unregister(&i2c_bus_type);
2146 tracepoint_synchronize_unregister();
2149 /* We must initialize early, because some subsystems register i2c drivers
2150 * in subsys_initcall() code, but are linked (and initialized) before i2c.
2152 postcore_initcall(i2c_init);
2153 module_exit(i2c_exit);
2155 /* ----------------------------------------------------
2156 * the functional interface to the i2c busses.
2157 * ----------------------------------------------------
2160 /* Check if val is exceeding the quirk IFF quirk is non 0 */
2161 #define i2c_quirk_exceeded(val, quirk) ((quirk) && ((val) > (quirk)))
2163 static int i2c_quirk_error(struct i2c_adapter *adap, struct i2c_msg *msg, char *err_msg)
2165 dev_err_ratelimited(&adap->dev, "adapter quirk: %s (addr 0x%04x, size %u, %s)\n",
2166 err_msg, msg->addr, msg->len,
2167 msg->flags & I2C_M_RD ? "read" : "write");
2171 static int i2c_check_for_quirks(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2173 const struct i2c_adapter_quirks *q = adap->quirks;
2174 int max_num = q->max_num_msgs, i;
2175 bool do_len_check = true;
2177 if (q->flags & I2C_AQ_COMB) {
2180 /* special checks for combined messages */
2182 if (q->flags & I2C_AQ_COMB_WRITE_FIRST && msgs[0].flags & I2C_M_RD)
2183 return i2c_quirk_error(adap, &msgs[0], "1st comb msg must be write");
2185 if (q->flags & I2C_AQ_COMB_READ_SECOND && !(msgs[1].flags & I2C_M_RD))
2186 return i2c_quirk_error(adap, &msgs[1], "2nd comb msg must be read");
2188 if (q->flags & I2C_AQ_COMB_SAME_ADDR && msgs[0].addr != msgs[1].addr)
2189 return i2c_quirk_error(adap, &msgs[0], "comb msg only to same addr");
2191 if (i2c_quirk_exceeded(msgs[0].len, q->max_comb_1st_msg_len))
2192 return i2c_quirk_error(adap, &msgs[0], "msg too long");
2194 if (i2c_quirk_exceeded(msgs[1].len, q->max_comb_2nd_msg_len))
2195 return i2c_quirk_error(adap, &msgs[1], "msg too long");
2197 do_len_check = false;
2201 if (i2c_quirk_exceeded(num, max_num))
2202 return i2c_quirk_error(adap, &msgs[0], "too many messages");
2204 for (i = 0; i < num; i++) {
2205 u16 len = msgs[i].len;
2207 if (msgs[i].flags & I2C_M_RD) {
2208 if (do_len_check && i2c_quirk_exceeded(len, q->max_read_len))
2209 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2211 if (do_len_check && i2c_quirk_exceeded(len, q->max_write_len))
2212 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2220 * __i2c_transfer - unlocked flavor of i2c_transfer
2221 * @adap: Handle to I2C bus
2222 * @msgs: One or more messages to execute before STOP is issued to
2223 * terminate the operation; each message begins with a START.
2224 * @num: Number of messages to be executed.
2226 * Returns negative errno, else the number of messages executed.
2228 * Adapter lock must be held when calling this function. No debug logging
2229 * takes place. adap->algo->master_xfer existence isn't checked.
2231 int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2233 unsigned long orig_jiffies;
2236 if (adap->quirks && i2c_check_for_quirks(adap, msgs, num))
2239 /* i2c_trace_msg gets enabled when tracepoint i2c_transfer gets
2240 * enabled. This is an efficient way of keeping the for-loop from
2241 * being executed when not needed.
2243 if (static_key_false(&i2c_trace_msg)) {
2245 for (i = 0; i < num; i++)
2246 if (msgs[i].flags & I2C_M_RD)
2247 trace_i2c_read(adap, &msgs[i], i);
2249 trace_i2c_write(adap, &msgs[i], i);
2252 /* Retry automatically on arbitration loss */
2253 orig_jiffies = jiffies;
2254 for (ret = 0, try = 0; try <= adap->retries; try++) {
2255 ret = adap->algo->master_xfer(adap, msgs, num);
2258 if (time_after(jiffies, orig_jiffies + adap->timeout))
2262 if (static_key_false(&i2c_trace_msg)) {
2264 for (i = 0; i < ret; i++)
2265 if (msgs[i].flags & I2C_M_RD)
2266 trace_i2c_reply(adap, &msgs[i], i);
2267 trace_i2c_result(adap, i, ret);
2272 EXPORT_SYMBOL(__i2c_transfer);
2275 * i2c_transfer - execute a single or combined I2C message
2276 * @adap: Handle to I2C bus
2277 * @msgs: One or more messages to execute before STOP is issued to
2278 * terminate the operation; each message begins with a START.
2279 * @num: Number of messages to be executed.
2281 * Returns negative errno, else the number of messages executed.
2283 * Note that there is no requirement that each message be sent to
2284 * the same slave address, although that is the most common model.
2286 int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2290 /* REVISIT the fault reporting model here is weak:
2292 * - When we get an error after receiving N bytes from a slave,
2293 * there is no way to report "N".
2295 * - When we get a NAK after transmitting N bytes to a slave,
2296 * there is no way to report "N" ... or to let the master
2297 * continue executing the rest of this combined message, if
2298 * that's the appropriate response.
2300 * - When for example "num" is two and we successfully complete
2301 * the first message but get an error part way through the
2302 * second, it's unclear whether that should be reported as
2303 * one (discarding status on the second message) or errno
2304 * (discarding status on the first one).
2307 if (adap->algo->master_xfer) {
2309 for (ret = 0; ret < num; ret++) {
2310 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
2311 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
2312 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
2313 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
2317 if (in_atomic() || irqs_disabled()) {
2318 ret = i2c_trylock_adapter(adap);
2320 /* I2C activity is ongoing. */
2323 i2c_lock_adapter(adap);
2326 ret = __i2c_transfer(adap, msgs, num);
2327 i2c_unlock_adapter(adap);
2331 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
2335 EXPORT_SYMBOL(i2c_transfer);
2338 * i2c_master_send - issue a single I2C message in master transmit mode
2339 * @client: Handle to slave device
2340 * @buf: Data that will be written to the slave
2341 * @count: How many bytes to write, must be less than 64k since msg.len is u16
2343 * Returns negative errno, or else the number of bytes written.
2345 int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
2348 struct i2c_adapter *adap = client->adapter;
2351 msg.addr = client->addr;
2352 msg.flags = client->flags & I2C_M_TEN;
2354 msg.buf = (char *)buf;
2356 ret = i2c_transfer(adap, &msg, 1);
2359 * If everything went ok (i.e. 1 msg transmitted), return #bytes
2360 * transmitted, else error code.
2362 return (ret == 1) ? count : ret;
2364 EXPORT_SYMBOL(i2c_master_send);
2367 * i2c_master_recv - issue a single I2C message in master receive mode
2368 * @client: Handle to slave device
2369 * @buf: Where to store data read from slave
2370 * @count: How many bytes to read, must be less than 64k since msg.len is u16
2372 * Returns negative errno, or else the number of bytes read.
2374 int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
2376 struct i2c_adapter *adap = client->adapter;
2380 msg.addr = client->addr;
2381 msg.flags = client->flags & I2C_M_TEN;
2382 msg.flags |= I2C_M_RD;
2386 ret = i2c_transfer(adap, &msg, 1);
2389 * If everything went ok (i.e. 1 msg received), return #bytes received,
2392 return (ret == 1) ? count : ret;
2394 EXPORT_SYMBOL(i2c_master_recv);
2396 /* ----------------------------------------------------
2397 * the i2c address scanning function
2398 * Will not work for 10-bit addresses!
2399 * ----------------------------------------------------
2403 * Legacy default probe function, mostly relevant for SMBus. The default
2404 * probe method is a quick write, but it is known to corrupt the 24RF08
2405 * EEPROMs due to a state machine bug, and could also irreversibly
2406 * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
2407 * we use a short byte read instead. Also, some bus drivers don't implement
2408 * quick write, so we fallback to a byte read in that case too.
2409 * On x86, there is another special case for FSC hardware monitoring chips,
2410 * which want regular byte reads (address 0x73.) Fortunately, these are the
2411 * only known chips using this I2C address on PC hardware.
2412 * Returns 1 if probe succeeded, 0 if not.
2414 static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
2417 union i2c_smbus_data dummy;
2420 if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
2421 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
2422 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2423 I2C_SMBUS_BYTE_DATA, &dummy);
2426 if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
2427 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
2428 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
2429 I2C_SMBUS_QUICK, NULL);
2430 else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
2431 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2432 I2C_SMBUS_BYTE, &dummy);
2434 dev_warn(&adap->dev, "No suitable probing method supported for address 0x%02X\n",
2442 static int i2c_detect_address(struct i2c_client *temp_client,
2443 struct i2c_driver *driver)
2445 struct i2c_board_info info;
2446 struct i2c_adapter *adapter = temp_client->adapter;
2447 int addr = temp_client->addr;
2450 /* Make sure the address is valid */
2451 err = i2c_check_7bit_addr_validity_strict(addr);
2453 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
2458 /* Skip if already in use (7 bit, no need to encode flags) */
2459 if (i2c_check_addr_busy(adapter, addr))
2462 /* Make sure there is something at this address */
2463 if (!i2c_default_probe(adapter, addr))
2466 /* Finally call the custom detection function */
2467 memset(&info, 0, sizeof(struct i2c_board_info));
2469 err = driver->detect(temp_client, &info);
2471 /* -ENODEV is returned if the detection fails. We catch it
2472 here as this isn't an error. */
2473 return err == -ENODEV ? 0 : err;
2476 /* Consistency check */
2477 if (info.type[0] == '\0') {
2478 dev_err(&adapter->dev, "%s detection function provided "
2479 "no name for 0x%x\n", driver->driver.name,
2482 struct i2c_client *client;
2484 /* Detection succeeded, instantiate the device */
2485 if (adapter->class & I2C_CLASS_DEPRECATED)
2486 dev_warn(&adapter->dev,
2487 "This adapter will soon drop class based instantiation of devices. "
2488 "Please make sure client 0x%02x gets instantiated by other means. "
2489 "Check 'Documentation/i2c/instantiating-devices' for details.\n",
2492 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
2493 info.type, info.addr);
2494 client = i2c_new_device(adapter, &info);
2496 list_add_tail(&client->detected, &driver->clients);
2498 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
2499 info.type, info.addr);
2504 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
2506 const unsigned short *address_list;
2507 struct i2c_client *temp_client;
2509 int adap_id = i2c_adapter_id(adapter);
2511 address_list = driver->address_list;
2512 if (!driver->detect || !address_list)
2515 /* Warn that the adapter lost class based instantiation */
2516 if (adapter->class == I2C_CLASS_DEPRECATED) {
2517 dev_dbg(&adapter->dev,
2518 "This adapter dropped support for I2C classes and "
2519 "won't auto-detect %s devices anymore. If you need it, check "
2520 "'Documentation/i2c/instantiating-devices' for alternatives.\n",
2521 driver->driver.name);
2525 /* Stop here if the classes do not match */
2526 if (!(adapter->class & driver->class))
2529 /* Set up a temporary client to help detect callback */
2530 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
2533 temp_client->adapter = adapter;
2535 for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
2536 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
2537 "addr 0x%02x\n", adap_id, address_list[i]);
2538 temp_client->addr = address_list[i];
2539 err = i2c_detect_address(temp_client, driver);
2548 int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
2550 return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2551 I2C_SMBUS_QUICK, NULL) >= 0;
2553 EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
2556 i2c_new_probed_device(struct i2c_adapter *adap,
2557 struct i2c_board_info *info,
2558 unsigned short const *addr_list,
2559 int (*probe)(struct i2c_adapter *, unsigned short addr))
2564 probe = i2c_default_probe;
2566 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
2567 /* Check address validity */
2568 if (i2c_check_7bit_addr_validity_strict(addr_list[i]) < 0) {
2569 dev_warn(&adap->dev, "Invalid 7-bit address "
2570 "0x%02x\n", addr_list[i]);
2574 /* Check address availability (7 bit, no need to encode flags) */
2575 if (i2c_check_addr_busy(adap, addr_list[i])) {
2576 dev_dbg(&adap->dev, "Address 0x%02x already in "
2577 "use, not probing\n", addr_list[i]);
2581 /* Test address responsiveness */
2582 if (probe(adap, addr_list[i]))
2586 if (addr_list[i] == I2C_CLIENT_END) {
2587 dev_dbg(&adap->dev, "Probing failed, no device found\n");
2591 info->addr = addr_list[i];
2592 return i2c_new_device(adap, info);
2594 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
2596 struct i2c_adapter *i2c_get_adapter(int nr)
2598 struct i2c_adapter *adapter;
2600 mutex_lock(&core_lock);
2601 adapter = idr_find(&i2c_adapter_idr, nr);
2605 if (try_module_get(adapter->owner))
2606 get_device(&adapter->dev);
2611 mutex_unlock(&core_lock);
2614 EXPORT_SYMBOL(i2c_get_adapter);
2616 void i2c_put_adapter(struct i2c_adapter *adap)
2621 put_device(&adap->dev);
2622 module_put(adap->owner);
2624 EXPORT_SYMBOL(i2c_put_adapter);
2626 /* The SMBus parts */
2628 #define POLY (0x1070U << 3)
2629 static u8 crc8(u16 data)
2633 for (i = 0; i < 8; i++) {
2638 return (u8)(data >> 8);
2641 /* Incremental CRC8 over count bytes in the array pointed to by p */
2642 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
2646 for (i = 0; i < count; i++)
2647 crc = crc8((crc ^ p[i]) << 8);
2651 /* Assume a 7-bit address, which is reasonable for SMBus */
2652 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
2654 /* The address will be sent first */
2655 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
2656 pec = i2c_smbus_pec(pec, &addr, 1);
2658 /* The data buffer follows */
2659 return i2c_smbus_pec(pec, msg->buf, msg->len);
2662 /* Used for write only transactions */
2663 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
2665 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
2669 /* Return <0 on CRC error
2670 If there was a write before this read (most cases) we need to take the
2671 partial CRC from the write part into account.
2672 Note that this function does modify the message (we need to decrease the
2673 message length to hide the CRC byte from the caller). */
2674 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
2676 u8 rpec = msg->buf[--msg->len];
2677 cpec = i2c_smbus_msg_pec(cpec, msg);
2680 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
2688 * i2c_smbus_read_byte - SMBus "receive byte" protocol
2689 * @client: Handle to slave device
2691 * This executes the SMBus "receive byte" protocol, returning negative errno
2692 * else the byte received from the device.
2694 s32 i2c_smbus_read_byte(const struct i2c_client *client)
2696 union i2c_smbus_data data;
2699 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2701 I2C_SMBUS_BYTE, &data);
2702 return (status < 0) ? status : data.byte;
2704 EXPORT_SYMBOL(i2c_smbus_read_byte);
2707 * i2c_smbus_write_byte - SMBus "send byte" protocol
2708 * @client: Handle to slave device
2709 * @value: Byte to be sent
2711 * This executes the SMBus "send byte" protocol, returning negative errno
2712 * else zero on success.
2714 s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
2716 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2717 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
2719 EXPORT_SYMBOL(i2c_smbus_write_byte);
2722 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
2723 * @client: Handle to slave device
2724 * @command: Byte interpreted by slave
2726 * This executes the SMBus "read byte" protocol, returning negative errno
2727 * else a data byte received from the device.
2729 s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
2731 union i2c_smbus_data data;
2734 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2735 I2C_SMBUS_READ, command,
2736 I2C_SMBUS_BYTE_DATA, &data);
2737 return (status < 0) ? status : data.byte;
2739 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
2742 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
2743 * @client: Handle to slave device
2744 * @command: Byte interpreted by slave
2745 * @value: Byte being written
2747 * This executes the SMBus "write byte" protocol, returning negative errno
2748 * else zero on success.
2750 s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
2753 union i2c_smbus_data data;
2755 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2756 I2C_SMBUS_WRITE, command,
2757 I2C_SMBUS_BYTE_DATA, &data);
2759 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
2762 * i2c_smbus_read_word_data - SMBus "read word" protocol
2763 * @client: Handle to slave device
2764 * @command: Byte interpreted by slave
2766 * This executes the SMBus "read word" protocol, returning negative errno
2767 * else a 16-bit unsigned "word" received from the device.
2769 s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
2771 union i2c_smbus_data data;
2774 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2775 I2C_SMBUS_READ, command,
2776 I2C_SMBUS_WORD_DATA, &data);
2777 return (status < 0) ? status : data.word;
2779 EXPORT_SYMBOL(i2c_smbus_read_word_data);
2782 * i2c_smbus_write_word_data - SMBus "write word" protocol
2783 * @client: Handle to slave device
2784 * @command: Byte interpreted by slave
2785 * @value: 16-bit "word" being written
2787 * This executes the SMBus "write word" protocol, returning negative errno
2788 * else zero on success.
2790 s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
2793 union i2c_smbus_data data;
2795 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2796 I2C_SMBUS_WRITE, command,
2797 I2C_SMBUS_WORD_DATA, &data);
2799 EXPORT_SYMBOL(i2c_smbus_write_word_data);
2802 * i2c_smbus_read_block_data - SMBus "block read" protocol
2803 * @client: Handle to slave device
2804 * @command: Byte interpreted by slave
2805 * @values: Byte array into which data will be read; big enough to hold
2806 * the data returned by the slave. SMBus allows at most 32 bytes.
2808 * This executes the SMBus "block read" protocol, returning negative errno
2809 * else the number of data bytes in the slave's response.
2811 * Note that using this function requires that the client's adapter support
2812 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
2813 * support this; its emulation through I2C messaging relies on a specific
2814 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
2816 s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
2819 union i2c_smbus_data data;
2822 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2823 I2C_SMBUS_READ, command,
2824 I2C_SMBUS_BLOCK_DATA, &data);
2828 memcpy(values, &data.block[1], data.block[0]);
2829 return data.block[0];
2831 EXPORT_SYMBOL(i2c_smbus_read_block_data);
2834 * i2c_smbus_write_block_data - SMBus "block write" protocol
2835 * @client: Handle to slave device
2836 * @command: Byte interpreted by slave
2837 * @length: Size of data block; SMBus allows at most 32 bytes
2838 * @values: Byte array which will be written.
2840 * This executes the SMBus "block write" protocol, returning negative errno
2841 * else zero on success.
2843 s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
2844 u8 length, const u8 *values)
2846 union i2c_smbus_data data;
2848 if (length > I2C_SMBUS_BLOCK_MAX)
2849 length = I2C_SMBUS_BLOCK_MAX;
2850 data.block[0] = length;
2851 memcpy(&data.block[1], values, length);
2852 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2853 I2C_SMBUS_WRITE, command,
2854 I2C_SMBUS_BLOCK_DATA, &data);
2856 EXPORT_SYMBOL(i2c_smbus_write_block_data);
2858 /* Returns the number of read bytes */
2859 s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
2860 u8 length, u8 *values)
2862 union i2c_smbus_data data;
2865 if (length > I2C_SMBUS_BLOCK_MAX)
2866 length = I2C_SMBUS_BLOCK_MAX;
2867 data.block[0] = length;
2868 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2869 I2C_SMBUS_READ, command,
2870 I2C_SMBUS_I2C_BLOCK_DATA, &data);
2874 memcpy(values, &data.block[1], data.block[0]);
2875 return data.block[0];
2877 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
2879 s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
2880 u8 length, const u8 *values)
2882 union i2c_smbus_data data;
2884 if (length > I2C_SMBUS_BLOCK_MAX)
2885 length = I2C_SMBUS_BLOCK_MAX;
2886 data.block[0] = length;
2887 memcpy(data.block + 1, values, length);
2888 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2889 I2C_SMBUS_WRITE, command,
2890 I2C_SMBUS_I2C_BLOCK_DATA, &data);
2892 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
2894 /* Simulate a SMBus command using the i2c protocol
2895 No checking of parameters is done! */
2896 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
2897 unsigned short flags,
2898 char read_write, u8 command, int size,
2899 union i2c_smbus_data *data)
2901 /* So we need to generate a series of msgs. In the case of writing, we
2902 need to use only one message; when reading, we need two. We initialize
2903 most things with sane defaults, to keep the code below somewhat
2905 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
2906 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
2907 int num = read_write == I2C_SMBUS_READ ? 2 : 1;
2911 struct i2c_msg msg[2] = {
2919 .flags = flags | I2C_M_RD,
2925 msgbuf0[0] = command;
2927 case I2C_SMBUS_QUICK:
2929 /* Special case: The read/write field is used as data */
2930 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
2934 case I2C_SMBUS_BYTE:
2935 if (read_write == I2C_SMBUS_READ) {
2936 /* Special case: only a read! */
2937 msg[0].flags = I2C_M_RD | flags;
2941 case I2C_SMBUS_BYTE_DATA:
2942 if (read_write == I2C_SMBUS_READ)
2946 msgbuf0[1] = data->byte;
2949 case I2C_SMBUS_WORD_DATA:
2950 if (read_write == I2C_SMBUS_READ)
2954 msgbuf0[1] = data->word & 0xff;
2955 msgbuf0[2] = data->word >> 8;
2958 case I2C_SMBUS_PROC_CALL:
2959 num = 2; /* Special case */
2960 read_write = I2C_SMBUS_READ;
2963 msgbuf0[1] = data->word & 0xff;
2964 msgbuf0[2] = data->word >> 8;
2966 case I2C_SMBUS_BLOCK_DATA:
2967 if (read_write == I2C_SMBUS_READ) {
2968 msg[1].flags |= I2C_M_RECV_LEN;
2969 msg[1].len = 1; /* block length will be added by
2970 the underlying bus driver */
2972 msg[0].len = data->block[0] + 2;
2973 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
2974 dev_err(&adapter->dev,
2975 "Invalid block write size %d\n",
2979 for (i = 1; i < msg[0].len; i++)
2980 msgbuf0[i] = data->block[i-1];
2983 case I2C_SMBUS_BLOCK_PROC_CALL:
2984 num = 2; /* Another special case */
2985 read_write = I2C_SMBUS_READ;
2986 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
2987 dev_err(&adapter->dev,
2988 "Invalid block write size %d\n",
2992 msg[0].len = data->block[0] + 2;
2993 for (i = 1; i < msg[0].len; i++)
2994 msgbuf0[i] = data->block[i-1];
2995 msg[1].flags |= I2C_M_RECV_LEN;
2996 msg[1].len = 1; /* block length will be added by
2997 the underlying bus driver */
2999 case I2C_SMBUS_I2C_BLOCK_DATA:
3000 if (read_write == I2C_SMBUS_READ) {
3001 msg[1].len = data->block[0];
3003 msg[0].len = data->block[0] + 1;
3004 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
3005 dev_err(&adapter->dev,
3006 "Invalid block write size %d\n",
3010 for (i = 1; i <= data->block[0]; i++)
3011 msgbuf0[i] = data->block[i];
3015 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
3019 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
3020 && size != I2C_SMBUS_I2C_BLOCK_DATA);
3022 /* Compute PEC if first message is a write */
3023 if (!(msg[0].flags & I2C_M_RD)) {
3024 if (num == 1) /* Write only */
3025 i2c_smbus_add_pec(&msg[0]);
3026 else /* Write followed by read */
3027 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
3029 /* Ask for PEC if last message is a read */
3030 if (msg[num-1].flags & I2C_M_RD)
3034 status = i2c_transfer(adapter, msg, num);
3038 /* Check PEC if last message is a read */
3039 if (i && (msg[num-1].flags & I2C_M_RD)) {
3040 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
3045 if (read_write == I2C_SMBUS_READ)
3047 case I2C_SMBUS_BYTE:
3048 data->byte = msgbuf0[0];
3050 case I2C_SMBUS_BYTE_DATA:
3051 data->byte = msgbuf1[0];
3053 case I2C_SMBUS_WORD_DATA:
3054 case I2C_SMBUS_PROC_CALL:
3055 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
3057 case I2C_SMBUS_I2C_BLOCK_DATA:
3058 for (i = 0; i < data->block[0]; i++)
3059 data->block[i+1] = msgbuf1[i];
3061 case I2C_SMBUS_BLOCK_DATA:
3062 case I2C_SMBUS_BLOCK_PROC_CALL:
3063 for (i = 0; i < msgbuf1[0] + 1; i++)
3064 data->block[i] = msgbuf1[i];
3071 * i2c_smbus_xfer - execute SMBus protocol operations
3072 * @adapter: Handle to I2C bus
3073 * @addr: Address of SMBus slave on that bus
3074 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
3075 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
3076 * @command: Byte interpreted by slave, for protocols which use such bytes
3077 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
3078 * @data: Data to be read or written
3080 * This executes an SMBus protocol operation, and returns a negative
3081 * errno code else zero on success.
3083 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
3084 char read_write, u8 command, int protocol,
3085 union i2c_smbus_data *data)
3087 unsigned long orig_jiffies;
3091 /* If enabled, the following two tracepoints are conditional on
3092 * read_write and protocol.
3094 trace_smbus_write(adapter, addr, flags, read_write,
3095 command, protocol, data);
3096 trace_smbus_read(adapter, addr, flags, read_write,
3099 flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
3101 if (adapter->algo->smbus_xfer) {
3102 i2c_lock_adapter(adapter);
3104 /* Retry automatically on arbitration loss */
3105 orig_jiffies = jiffies;
3106 for (res = 0, try = 0; try <= adapter->retries; try++) {
3107 res = adapter->algo->smbus_xfer(adapter, addr, flags,
3108 read_write, command,
3112 if (time_after(jiffies,
3113 orig_jiffies + adapter->timeout))
3116 i2c_unlock_adapter(adapter);
3118 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
3121 * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
3122 * implement native support for the SMBus operation.
3126 res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
3127 command, protocol, data);
3130 /* If enabled, the reply tracepoint is conditional on read_write. */
3131 trace_smbus_reply(adapter, addr, flags, read_write,
3132 command, protocol, data);
3133 trace_smbus_result(adapter, addr, flags, read_write,
3134 command, protocol, res);
3138 EXPORT_SYMBOL(i2c_smbus_xfer);
3141 * i2c_smbus_read_i2c_block_data_or_emulated - read block or emulate
3142 * @client: Handle to slave device
3143 * @command: Byte interpreted by slave
3144 * @length: Size of data block; SMBus allows at most I2C_SMBUS_BLOCK_MAX bytes
3145 * @values: Byte array into which data will be read; big enough to hold
3146 * the data returned by the slave. SMBus allows at most
3147 * I2C_SMBUS_BLOCK_MAX bytes.
3149 * This executes the SMBus "block read" protocol if supported by the adapter.
3150 * If block read is not supported, it emulates it using either word or byte
3151 * read protocols depending on availability.
3153 * The addresses of the I2C slave device that are accessed with this function
3154 * must be mapped to a linear region, so that a block read will have the same
3155 * effect as a byte read. Before using this function you must double-check
3156 * if the I2C slave does support exchanging a block transfer with a byte
3159 s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
3160 u8 command, u8 length, u8 *values)
3165 if (length > I2C_SMBUS_BLOCK_MAX)
3166 length = I2C_SMBUS_BLOCK_MAX;
3168 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK))
3169 return i2c_smbus_read_i2c_block_data(client, command, length, values);
3171 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA))
3174 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_WORD_DATA)) {
3175 while ((i + 2) <= length) {
3176 status = i2c_smbus_read_word_data(client, command + i);
3179 values[i] = status & 0xff;
3180 values[i + 1] = status >> 8;
3185 while (i < length) {
3186 status = i2c_smbus_read_byte_data(client, command + i);
3195 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data_or_emulated);
3197 #if IS_ENABLED(CONFIG_I2C_SLAVE)
3198 int i2c_slave_register(struct i2c_client *client, i2c_slave_cb_t slave_cb)
3202 if (!client || !slave_cb) {
3203 WARN(1, "insufficent data\n");
3207 if (!(client->flags & I2C_CLIENT_SLAVE))
3208 dev_warn(&client->dev, "%s: client slave flag not set. You might see address collisions\n",
3211 if (!(client->flags & I2C_CLIENT_TEN)) {
3212 /* Enforce stricter address checking */
3213 ret = i2c_check_7bit_addr_validity_strict(client->addr);
3215 dev_err(&client->dev, "%s: invalid address\n", __func__);
3220 if (!client->adapter->algo->reg_slave) {
3221 dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
3225 client->slave_cb = slave_cb;
3227 i2c_lock_adapter(client->adapter);
3228 ret = client->adapter->algo->reg_slave(client);
3229 i2c_unlock_adapter(client->adapter);
3232 client->slave_cb = NULL;
3233 dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
3238 EXPORT_SYMBOL_GPL(i2c_slave_register);
3240 int i2c_slave_unregister(struct i2c_client *client)
3244 if (!client->adapter->algo->unreg_slave) {
3245 dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
3249 i2c_lock_adapter(client->adapter);
3250 ret = client->adapter->algo->unreg_slave(client);
3251 i2c_unlock_adapter(client->adapter);
3254 client->slave_cb = NULL;
3256 dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
3260 EXPORT_SYMBOL_GPL(i2c_slave_unregister);
3263 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
3264 MODULE_DESCRIPTION("I2C-Bus main module");
3265 MODULE_LICENSE("GPL");