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 <linux/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 #define I2C_ADDR_7BITS_MAX 0x77
69 #define I2C_ADDR_7BITS_COUNT (I2C_ADDR_7BITS_MAX + 1)
71 /* core_lock protects i2c_adapter_idr, and guarantees
72 that device detection, deletion of detected devices, and attach_adapter
73 calls are serialized */
74 static DEFINE_MUTEX(core_lock);
75 static DEFINE_IDR(i2c_adapter_idr);
77 static struct device_type i2c_client_type;
78 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
80 static struct static_key i2c_trace_msg = STATIC_KEY_INIT_FALSE;
81 static bool is_registered;
83 int i2c_transfer_trace_reg(void)
85 static_key_slow_inc(&i2c_trace_msg);
89 void i2c_transfer_trace_unreg(void)
91 static_key_slow_dec(&i2c_trace_msg);
94 #if defined(CONFIG_ACPI)
95 struct i2c_acpi_handler_data {
96 struct acpi_connection_info info;
97 struct i2c_adapter *adapter;
110 struct i2c_acpi_lookup {
111 struct i2c_board_info *info;
112 acpi_handle adapter_handle;
113 acpi_handle device_handle;
114 acpi_handle search_handle;
119 static int i2c_acpi_fill_info(struct acpi_resource *ares, void *data)
121 struct i2c_acpi_lookup *lookup = data;
122 struct i2c_board_info *info = lookup->info;
123 struct acpi_resource_i2c_serialbus *sb;
126 if (info->addr || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS)
129 sb = &ares->data.i2c_serial_bus;
130 if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C)
133 status = acpi_get_handle(lookup->device_handle,
134 sb->resource_source.string_ptr,
135 &lookup->adapter_handle);
136 if (!ACPI_SUCCESS(status))
139 info->addr = sb->slave_address;
140 lookup->speed = sb->connection_speed;
141 if (sb->access_mode == ACPI_I2C_10BIT_MODE)
142 info->flags |= I2C_CLIENT_TEN;
147 static int i2c_acpi_do_lookup(struct acpi_device *adev,
148 struct i2c_acpi_lookup *lookup)
150 struct i2c_board_info *info = lookup->info;
151 struct list_head resource_list;
154 if (acpi_bus_get_status(adev) || !adev->status.present ||
155 acpi_device_enumerated(adev))
158 memset(info, 0, sizeof(*info));
159 lookup->device_handle = acpi_device_handle(adev);
161 /* Look up for I2cSerialBus resource */
162 INIT_LIST_HEAD(&resource_list);
163 ret = acpi_dev_get_resources(adev, &resource_list,
164 i2c_acpi_fill_info, lookup);
165 acpi_dev_free_resource_list(&resource_list);
167 if (ret < 0 || !info->addr)
173 static int i2c_acpi_get_info(struct acpi_device *adev,
174 struct i2c_board_info *info,
175 struct i2c_adapter *adapter,
176 acpi_handle *adapter_handle)
178 struct list_head resource_list;
179 struct resource_entry *entry;
180 struct i2c_acpi_lookup lookup;
183 memset(&lookup, 0, sizeof(lookup));
186 ret = i2c_acpi_do_lookup(adev, &lookup);
191 /* The adapter must match the one in I2cSerialBus() connector */
192 if (ACPI_HANDLE(&adapter->dev) != lookup.adapter_handle)
195 struct acpi_device *adapter_adev;
197 /* The adapter must be present */
198 if (acpi_bus_get_device(lookup.adapter_handle, &adapter_adev))
200 if (acpi_bus_get_status(adapter_adev) ||
201 !adapter_adev->status.present)
205 info->fwnode = acpi_fwnode_handle(adev);
207 *adapter_handle = lookup.adapter_handle;
209 /* Then fill IRQ number if any */
210 INIT_LIST_HEAD(&resource_list);
211 ret = acpi_dev_get_resources(adev, &resource_list, NULL, NULL);
215 resource_list_for_each_entry(entry, &resource_list) {
216 if (resource_type(entry->res) == IORESOURCE_IRQ) {
217 info->irq = entry->res->start;
222 acpi_dev_free_resource_list(&resource_list);
224 strlcpy(info->type, dev_name(&adev->dev), sizeof(info->type));
229 static void i2c_acpi_register_device(struct i2c_adapter *adapter,
230 struct acpi_device *adev,
231 struct i2c_board_info *info)
233 adev->power.flags.ignore_parent = true;
234 acpi_device_set_enumerated(adev);
236 if (!i2c_new_device(adapter, info)) {
237 adev->power.flags.ignore_parent = false;
238 dev_err(&adapter->dev,
239 "failed to add I2C device %s from ACPI\n",
240 dev_name(&adev->dev));
244 static acpi_status i2c_acpi_add_device(acpi_handle handle, u32 level,
245 void *data, void **return_value)
247 struct i2c_adapter *adapter = data;
248 struct acpi_device *adev;
249 struct i2c_board_info info;
251 if (acpi_bus_get_device(handle, &adev))
254 if (i2c_acpi_get_info(adev, &info, adapter, NULL))
257 i2c_acpi_register_device(adapter, adev, &info);
262 #define I2C_ACPI_MAX_SCAN_DEPTH 32
265 * i2c_acpi_register_devices - enumerate I2C slave devices behind adapter
266 * @adap: pointer to adapter
268 * Enumerate all I2C slave devices behind this adapter by walking the ACPI
269 * namespace. When a device is found it will be added to the Linux device
270 * model and bound to the corresponding ACPI handle.
272 static void i2c_acpi_register_devices(struct i2c_adapter *adap)
276 if (!has_acpi_companion(&adap->dev))
279 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
280 I2C_ACPI_MAX_SCAN_DEPTH,
281 i2c_acpi_add_device, NULL,
283 if (ACPI_FAILURE(status))
284 dev_warn(&adap->dev, "failed to enumerate I2C slaves\n");
287 static acpi_status i2c_acpi_lookup_speed(acpi_handle handle, u32 level,
288 void *data, void **return_value)
290 struct i2c_acpi_lookup *lookup = data;
291 struct acpi_device *adev;
293 if (acpi_bus_get_device(handle, &adev))
296 if (i2c_acpi_do_lookup(adev, lookup))
299 if (lookup->search_handle != lookup->adapter_handle)
302 if (lookup->speed <= lookup->min_speed)
303 lookup->min_speed = lookup->speed;
309 * i2c_acpi_find_bus_speed - find I2C bus speed from ACPI
310 * @dev: The device owning the bus
312 * Find the I2C bus speed by walking the ACPI namespace for all I2C slaves
313 * devices connected to this bus and use the speed of slowest device.
315 * Returns the speed in Hz or zero
317 u32 i2c_acpi_find_bus_speed(struct device *dev)
319 struct i2c_acpi_lookup lookup;
320 struct i2c_board_info dummy;
323 if (!has_acpi_companion(dev))
326 memset(&lookup, 0, sizeof(lookup));
327 lookup.search_handle = ACPI_HANDLE(dev);
328 lookup.min_speed = UINT_MAX;
329 lookup.info = &dummy;
331 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
332 I2C_ACPI_MAX_SCAN_DEPTH,
333 i2c_acpi_lookup_speed, NULL,
336 if (ACPI_FAILURE(status)) {
337 dev_warn(dev, "unable to find I2C bus speed from ACPI\n");
341 return lookup.min_speed != UINT_MAX ? lookup.min_speed : 0;
343 EXPORT_SYMBOL_GPL(i2c_acpi_find_bus_speed);
345 static int i2c_acpi_match_adapter(struct device *dev, void *data)
347 struct i2c_adapter *adapter = i2c_verify_adapter(dev);
352 return ACPI_HANDLE(dev) == (acpi_handle)data;
355 static int i2c_acpi_match_device(struct device *dev, void *data)
357 return ACPI_COMPANION(dev) == data;
360 static struct i2c_adapter *i2c_acpi_find_adapter_by_handle(acpi_handle handle)
364 dev = bus_find_device(&i2c_bus_type, NULL, handle,
365 i2c_acpi_match_adapter);
366 return dev ? i2c_verify_adapter(dev) : NULL;
369 static struct i2c_client *i2c_acpi_find_client_by_adev(struct acpi_device *adev)
373 dev = bus_find_device(&i2c_bus_type, NULL, adev, i2c_acpi_match_device);
374 return dev ? i2c_verify_client(dev) : NULL;
377 static int i2c_acpi_notify(struct notifier_block *nb, unsigned long value,
380 struct acpi_device *adev = arg;
381 struct i2c_board_info info;
382 acpi_handle adapter_handle;
383 struct i2c_adapter *adapter;
384 struct i2c_client *client;
387 case ACPI_RECONFIG_DEVICE_ADD:
388 if (i2c_acpi_get_info(adev, &info, NULL, &adapter_handle))
391 adapter = i2c_acpi_find_adapter_by_handle(adapter_handle);
395 i2c_acpi_register_device(adapter, adev, &info);
397 case ACPI_RECONFIG_DEVICE_REMOVE:
398 if (!acpi_device_enumerated(adev))
401 client = i2c_acpi_find_client_by_adev(adev);
405 i2c_unregister_device(client);
406 put_device(&client->dev);
413 static struct notifier_block i2c_acpi_notifier = {
414 .notifier_call = i2c_acpi_notify,
416 #else /* CONFIG_ACPI */
417 static inline void i2c_acpi_register_devices(struct i2c_adapter *adap) { }
418 extern struct notifier_block i2c_acpi_notifier;
419 #endif /* CONFIG_ACPI */
421 #ifdef CONFIG_ACPI_I2C_OPREGION
422 static int acpi_gsb_i2c_read_bytes(struct i2c_client *client,
423 u8 cmd, u8 *data, u8 data_len)
426 struct i2c_msg msgs[2];
430 buffer = kzalloc(data_len, GFP_KERNEL);
434 msgs[0].addr = client->addr;
435 msgs[0].flags = client->flags;
439 msgs[1].addr = client->addr;
440 msgs[1].flags = client->flags | I2C_M_RD;
441 msgs[1].len = data_len;
442 msgs[1].buf = buffer;
444 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
446 dev_err(&client->adapter->dev, "i2c read failed\n");
448 memcpy(data, buffer, data_len);
454 static int acpi_gsb_i2c_write_bytes(struct i2c_client *client,
455 u8 cmd, u8 *data, u8 data_len)
458 struct i2c_msg msgs[1];
462 buffer = kzalloc(data_len + 1, GFP_KERNEL);
467 memcpy(buffer + 1, data, data_len);
469 msgs[0].addr = client->addr;
470 msgs[0].flags = client->flags;
471 msgs[0].len = data_len + 1;
472 msgs[0].buf = buffer;
474 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
476 dev_err(&client->adapter->dev, "i2c write failed\n");
483 i2c_acpi_space_handler(u32 function, acpi_physical_address command,
484 u32 bits, u64 *value64,
485 void *handler_context, void *region_context)
487 struct gsb_buffer *gsb = (struct gsb_buffer *)value64;
488 struct i2c_acpi_handler_data *data = handler_context;
489 struct acpi_connection_info *info = &data->info;
490 struct acpi_resource_i2c_serialbus *sb;
491 struct i2c_adapter *adapter = data->adapter;
492 struct i2c_client *client;
493 struct acpi_resource *ares;
494 u32 accessor_type = function >> 16;
495 u8 action = function & ACPI_IO_MASK;
499 ret = acpi_buffer_to_resource(info->connection, info->length, &ares);
500 if (ACPI_FAILURE(ret))
503 client = kzalloc(sizeof(*client), GFP_KERNEL);
509 if (!value64 || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) {
510 ret = AE_BAD_PARAMETER;
514 sb = &ares->data.i2c_serial_bus;
515 if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C) {
516 ret = AE_BAD_PARAMETER;
520 client->adapter = adapter;
521 client->addr = sb->slave_address;
523 if (sb->access_mode == ACPI_I2C_10BIT_MODE)
524 client->flags |= I2C_CLIENT_TEN;
526 switch (accessor_type) {
527 case ACPI_GSB_ACCESS_ATTRIB_SEND_RCV:
528 if (action == ACPI_READ) {
529 status = i2c_smbus_read_byte(client);
535 status = i2c_smbus_write_byte(client, gsb->bdata);
539 case ACPI_GSB_ACCESS_ATTRIB_BYTE:
540 if (action == ACPI_READ) {
541 status = i2c_smbus_read_byte_data(client, command);
547 status = i2c_smbus_write_byte_data(client, command,
552 case ACPI_GSB_ACCESS_ATTRIB_WORD:
553 if (action == ACPI_READ) {
554 status = i2c_smbus_read_word_data(client, command);
560 status = i2c_smbus_write_word_data(client, command,
565 case ACPI_GSB_ACCESS_ATTRIB_BLOCK:
566 if (action == ACPI_READ) {
567 status = i2c_smbus_read_block_data(client, command,
574 status = i2c_smbus_write_block_data(client, command,
575 gsb->len, gsb->data);
579 case ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE:
580 if (action == ACPI_READ) {
581 status = acpi_gsb_i2c_read_bytes(client, command,
582 gsb->data, info->access_length);
586 status = acpi_gsb_i2c_write_bytes(client, command,
587 gsb->data, info->access_length);
592 dev_warn(&adapter->dev, "protocol 0x%02x not supported for client 0x%02x\n",
593 accessor_type, client->addr);
594 ret = AE_BAD_PARAMETER;
598 gsb->status = status;
607 static int i2c_acpi_install_space_handler(struct i2c_adapter *adapter)
610 struct i2c_acpi_handler_data *data;
613 if (!adapter->dev.parent)
616 handle = ACPI_HANDLE(adapter->dev.parent);
621 data = kzalloc(sizeof(struct i2c_acpi_handler_data),
626 data->adapter = adapter;
627 status = acpi_bus_attach_private_data(handle, (void *)data);
628 if (ACPI_FAILURE(status)) {
633 status = acpi_install_address_space_handler(handle,
634 ACPI_ADR_SPACE_GSBUS,
635 &i2c_acpi_space_handler,
638 if (ACPI_FAILURE(status)) {
639 dev_err(&adapter->dev, "Error installing i2c space handler\n");
640 acpi_bus_detach_private_data(handle);
645 acpi_walk_dep_device_list(handle);
649 static void i2c_acpi_remove_space_handler(struct i2c_adapter *adapter)
652 struct i2c_acpi_handler_data *data;
655 if (!adapter->dev.parent)
658 handle = ACPI_HANDLE(adapter->dev.parent);
663 acpi_remove_address_space_handler(handle,
664 ACPI_ADR_SPACE_GSBUS,
665 &i2c_acpi_space_handler);
667 status = acpi_bus_get_private_data(handle, (void **)&data);
668 if (ACPI_SUCCESS(status))
671 acpi_bus_detach_private_data(handle);
673 #else /* CONFIG_ACPI_I2C_OPREGION */
674 static inline void i2c_acpi_remove_space_handler(struct i2c_adapter *adapter)
677 static inline int i2c_acpi_install_space_handler(struct i2c_adapter *adapter)
679 #endif /* CONFIG_ACPI_I2C_OPREGION */
681 /* ------------------------------------------------------------------------- */
683 const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
684 const struct i2c_client *client)
689 while (id->name[0]) {
690 if (strcmp(client->name, id->name) == 0)
696 EXPORT_SYMBOL_GPL(i2c_match_id);
698 static int i2c_device_match(struct device *dev, struct device_driver *drv)
700 struct i2c_client *client = i2c_verify_client(dev);
701 struct i2c_driver *driver;
704 /* Attempt an OF style match */
705 if (i2c_of_match_device(drv->of_match_table, client))
708 /* Then ACPI style match */
709 if (acpi_driver_match_device(dev, drv))
712 driver = to_i2c_driver(drv);
714 /* Finally an I2C match */
715 if (i2c_match_id(driver->id_table, client))
721 static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
723 struct i2c_client *client = to_i2c_client(dev);
726 rc = acpi_device_uevent_modalias(dev, env);
730 return add_uevent_var(env, "MODALIAS=%s%s", I2C_MODULE_PREFIX, client->name);
733 /* i2c bus recovery routines */
734 static int get_scl_gpio_value(struct i2c_adapter *adap)
736 return gpio_get_value(adap->bus_recovery_info->scl_gpio);
739 static void set_scl_gpio_value(struct i2c_adapter *adap, int val)
741 gpio_set_value(adap->bus_recovery_info->scl_gpio, val);
744 static int get_sda_gpio_value(struct i2c_adapter *adap)
746 return gpio_get_value(adap->bus_recovery_info->sda_gpio);
749 static int i2c_get_gpios_for_recovery(struct i2c_adapter *adap)
751 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
752 struct device *dev = &adap->dev;
755 ret = gpio_request_one(bri->scl_gpio, GPIOF_OPEN_DRAIN |
756 GPIOF_OUT_INIT_HIGH, "i2c-scl");
758 dev_warn(dev, "Can't get SCL gpio: %d\n", bri->scl_gpio);
763 if (gpio_request_one(bri->sda_gpio, GPIOF_IN, "i2c-sda")) {
764 /* work without SDA polling */
765 dev_warn(dev, "Can't get SDA gpio: %d. Not using SDA polling\n",
774 static void i2c_put_gpios_for_recovery(struct i2c_adapter *adap)
776 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
779 gpio_free(bri->sda_gpio);
781 gpio_free(bri->scl_gpio);
785 * We are generating clock pulses. ndelay() determines durating of clk pulses.
786 * We will generate clock with rate 100 KHz and so duration of both clock levels
787 * is: delay in ns = (10^6 / 100) / 2
789 #define RECOVERY_NDELAY 5000
790 #define RECOVERY_CLK_CNT 9
792 static int i2c_generic_recovery(struct i2c_adapter *adap)
794 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
795 int i = 0, val = 1, ret = 0;
797 if (bri->prepare_recovery)
798 bri->prepare_recovery(adap);
800 bri->set_scl(adap, val);
801 ndelay(RECOVERY_NDELAY);
804 * By this time SCL is high, as we need to give 9 falling-rising edges
806 while (i++ < RECOVERY_CLK_CNT * 2) {
808 /* Break if SDA is high */
809 if (bri->get_sda && bri->get_sda(adap))
811 /* SCL shouldn't be low here */
812 if (!bri->get_scl(adap)) {
814 "SCL is stuck low, exit recovery\n");
821 bri->set_scl(adap, val);
822 ndelay(RECOVERY_NDELAY);
825 if (bri->unprepare_recovery)
826 bri->unprepare_recovery(adap);
831 int i2c_generic_scl_recovery(struct i2c_adapter *adap)
833 return i2c_generic_recovery(adap);
835 EXPORT_SYMBOL_GPL(i2c_generic_scl_recovery);
837 int i2c_generic_gpio_recovery(struct i2c_adapter *adap)
841 ret = i2c_get_gpios_for_recovery(adap);
845 ret = i2c_generic_recovery(adap);
846 i2c_put_gpios_for_recovery(adap);
850 EXPORT_SYMBOL_GPL(i2c_generic_gpio_recovery);
852 int i2c_recover_bus(struct i2c_adapter *adap)
854 if (!adap->bus_recovery_info)
857 dev_dbg(&adap->dev, "Trying i2c bus recovery\n");
858 return adap->bus_recovery_info->recover_bus(adap);
860 EXPORT_SYMBOL_GPL(i2c_recover_bus);
862 static void i2c_init_recovery(struct i2c_adapter *adap)
864 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
870 if (!bri->recover_bus) {
871 err_str = "no recover_bus() found";
875 /* Generic GPIO recovery */
876 if (bri->recover_bus == i2c_generic_gpio_recovery) {
877 if (!gpio_is_valid(bri->scl_gpio)) {
878 err_str = "invalid SCL gpio";
882 if (gpio_is_valid(bri->sda_gpio))
883 bri->get_sda = get_sda_gpio_value;
887 bri->get_scl = get_scl_gpio_value;
888 bri->set_scl = set_scl_gpio_value;
889 } else if (bri->recover_bus == i2c_generic_scl_recovery) {
890 /* Generic SCL recovery */
891 if (!bri->set_scl || !bri->get_scl) {
892 err_str = "no {get|set}_scl() found";
899 dev_err(&adap->dev, "Not using recovery: %s\n", err_str);
900 adap->bus_recovery_info = NULL;
903 static int i2c_smbus_host_notify_to_irq(const struct i2c_client *client)
905 struct i2c_adapter *adap = client->adapter;
908 if (!adap->host_notify_domain)
911 if (client->flags & I2C_CLIENT_TEN)
914 irq = irq_find_mapping(adap->host_notify_domain, client->addr);
916 irq = irq_create_mapping(adap->host_notify_domain,
919 return irq > 0 ? irq : -ENXIO;
922 static int i2c_device_probe(struct device *dev)
924 struct i2c_client *client = i2c_verify_client(dev);
925 struct i2c_driver *driver;
935 irq = of_irq_get_byname(dev->of_node, "irq");
936 if (irq == -EINVAL || irq == -ENODATA)
937 irq = of_irq_get(dev->of_node, 0);
938 } else if (ACPI_COMPANION(dev)) {
939 irq = acpi_dev_gpio_irq_get(ACPI_COMPANION(dev), 0);
941 if (irq == -EPROBE_DEFER)
944 * ACPI and OF did not find any useful IRQ, try to see
945 * if Host Notify can be used.
948 dev_dbg(dev, "Using Host Notify IRQ\n");
949 irq = i2c_smbus_host_notify_to_irq(client);
957 driver = to_i2c_driver(dev->driver);
960 * An I2C ID table is not mandatory, if and only if, a suitable Device
961 * Tree match table entry is supplied for the probing device.
963 if (!driver->id_table &&
964 !i2c_of_match_device(dev->driver->of_match_table, client))
967 if (client->flags & I2C_CLIENT_WAKE) {
968 int wakeirq = -ENOENT;
971 wakeirq = of_irq_get_byname(dev->of_node, "wakeup");
972 if (wakeirq == -EPROBE_DEFER)
976 device_init_wakeup(&client->dev, true);
978 if (wakeirq > 0 && wakeirq != client->irq)
979 status = dev_pm_set_dedicated_wake_irq(dev, wakeirq);
980 else if (client->irq > 0)
981 status = dev_pm_set_wake_irq(dev, client->irq);
986 dev_warn(&client->dev, "failed to set up wakeup irq\n");
989 dev_dbg(dev, "probe\n");
991 status = of_clk_set_defaults(dev->of_node, false);
993 goto err_clear_wakeup_irq;
995 status = dev_pm_domain_attach(&client->dev, true);
996 if (status == -EPROBE_DEFER)
997 goto err_clear_wakeup_irq;
1000 * When there are no more users of probe(),
1001 * rename probe_new to probe.
1003 if (driver->probe_new)
1004 status = driver->probe_new(client);
1005 else if (driver->probe)
1006 status = driver->probe(client,
1007 i2c_match_id(driver->id_table, client));
1012 goto err_detach_pm_domain;
1016 err_detach_pm_domain:
1017 dev_pm_domain_detach(&client->dev, true);
1018 err_clear_wakeup_irq:
1019 dev_pm_clear_wake_irq(&client->dev);
1020 device_init_wakeup(&client->dev, false);
1024 static int i2c_device_remove(struct device *dev)
1026 struct i2c_client *client = i2c_verify_client(dev);
1027 struct i2c_driver *driver;
1030 if (!client || !dev->driver)
1033 driver = to_i2c_driver(dev->driver);
1034 if (driver->remove) {
1035 dev_dbg(dev, "remove\n");
1036 status = driver->remove(client);
1039 dev_pm_domain_detach(&client->dev, true);
1041 dev_pm_clear_wake_irq(&client->dev);
1042 device_init_wakeup(&client->dev, false);
1047 static void i2c_device_shutdown(struct device *dev)
1049 struct i2c_client *client = i2c_verify_client(dev);
1050 struct i2c_driver *driver;
1052 if (!client || !dev->driver)
1054 driver = to_i2c_driver(dev->driver);
1055 if (driver->shutdown)
1056 driver->shutdown(client);
1059 static void i2c_client_dev_release(struct device *dev)
1061 kfree(to_i2c_client(dev));
1065 show_name(struct device *dev, struct device_attribute *attr, char *buf)
1067 return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
1068 to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
1070 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
1073 show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
1075 struct i2c_client *client = to_i2c_client(dev);
1078 len = acpi_device_modalias(dev, buf, PAGE_SIZE -1);
1082 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
1084 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
1086 static struct attribute *i2c_dev_attrs[] = {
1087 &dev_attr_name.attr,
1088 /* modalias helps coldplug: modprobe $(cat .../modalias) */
1089 &dev_attr_modalias.attr,
1092 ATTRIBUTE_GROUPS(i2c_dev);
1094 struct bus_type i2c_bus_type = {
1096 .match = i2c_device_match,
1097 .probe = i2c_device_probe,
1098 .remove = i2c_device_remove,
1099 .shutdown = i2c_device_shutdown,
1101 EXPORT_SYMBOL_GPL(i2c_bus_type);
1103 static struct device_type i2c_client_type = {
1104 .groups = i2c_dev_groups,
1105 .uevent = i2c_device_uevent,
1106 .release = i2c_client_dev_release,
1111 * i2c_verify_client - return parameter as i2c_client, or NULL
1112 * @dev: device, probably from some driver model iterator
1114 * When traversing the driver model tree, perhaps using driver model
1115 * iterators like @device_for_each_child(), you can't assume very much
1116 * about the nodes you find. Use this function to avoid oopses caused
1117 * by wrongly treating some non-I2C device as an i2c_client.
1119 struct i2c_client *i2c_verify_client(struct device *dev)
1121 return (dev->type == &i2c_client_type)
1122 ? to_i2c_client(dev)
1125 EXPORT_SYMBOL(i2c_verify_client);
1128 /* Return a unique address which takes the flags of the client into account */
1129 static unsigned short i2c_encode_flags_to_addr(struct i2c_client *client)
1131 unsigned short addr = client->addr;
1133 /* For some client flags, add an arbitrary offset to avoid collisions */
1134 if (client->flags & I2C_CLIENT_TEN)
1135 addr |= I2C_ADDR_OFFSET_TEN_BIT;
1137 if (client->flags & I2C_CLIENT_SLAVE)
1138 addr |= I2C_ADDR_OFFSET_SLAVE;
1143 /* This is a permissive address validity check, I2C address map constraints
1144 * are purposely not enforced, except for the general call address. */
1145 static int i2c_check_addr_validity(unsigned addr, unsigned short flags)
1147 if (flags & I2C_CLIENT_TEN) {
1148 /* 10-bit address, all values are valid */
1152 /* 7-bit address, reject the general call address */
1153 if (addr == 0x00 || addr > 0x7f)
1159 /* And this is a strict address validity check, used when probing. If a
1160 * device uses a reserved address, then it shouldn't be probed. 7-bit
1161 * addressing is assumed, 10-bit address devices are rare and should be
1162 * explicitly enumerated. */
1163 static int i2c_check_7bit_addr_validity_strict(unsigned short addr)
1166 * Reserved addresses per I2C specification:
1167 * 0x00 General call address / START byte
1169 * 0x02 Reserved for different bus format
1170 * 0x03 Reserved for future purposes
1171 * 0x04-0x07 Hs-mode master code
1172 * 0x78-0x7b 10-bit slave addressing
1173 * 0x7c-0x7f Reserved for future purposes
1175 if (addr < 0x08 || addr > 0x77)
1180 static int __i2c_check_addr_busy(struct device *dev, void *addrp)
1182 struct i2c_client *client = i2c_verify_client(dev);
1183 int addr = *(int *)addrp;
1185 if (client && i2c_encode_flags_to_addr(client) == addr)
1190 /* walk up mux tree */
1191 static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
1193 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
1196 result = device_for_each_child(&adapter->dev, &addr,
1197 __i2c_check_addr_busy);
1199 if (!result && parent)
1200 result = i2c_check_mux_parents(parent, addr);
1205 /* recurse down mux tree */
1206 static int i2c_check_mux_children(struct device *dev, void *addrp)
1210 if (dev->type == &i2c_adapter_type)
1211 result = device_for_each_child(dev, addrp,
1212 i2c_check_mux_children);
1214 result = __i2c_check_addr_busy(dev, addrp);
1219 static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
1221 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
1225 result = i2c_check_mux_parents(parent, addr);
1228 result = device_for_each_child(&adapter->dev, &addr,
1229 i2c_check_mux_children);
1235 * i2c_adapter_lock_bus - Get exclusive access to an I2C bus segment
1236 * @adapter: Target I2C bus segment
1237 * @flags: I2C_LOCK_ROOT_ADAPTER locks the root i2c adapter, I2C_LOCK_SEGMENT
1238 * locks only this branch in the adapter tree
1240 static void i2c_adapter_lock_bus(struct i2c_adapter *adapter,
1243 rt_mutex_lock(&adapter->bus_lock);
1247 * i2c_adapter_trylock_bus - Try to get exclusive access to an I2C bus segment
1248 * @adapter: Target I2C bus segment
1249 * @flags: I2C_LOCK_ROOT_ADAPTER trylocks the root i2c adapter, I2C_LOCK_SEGMENT
1250 * trylocks only this branch in the adapter tree
1252 static int i2c_adapter_trylock_bus(struct i2c_adapter *adapter,
1255 return rt_mutex_trylock(&adapter->bus_lock);
1259 * i2c_adapter_unlock_bus - Release exclusive access to an I2C bus segment
1260 * @adapter: Target I2C bus segment
1261 * @flags: I2C_LOCK_ROOT_ADAPTER unlocks the root i2c adapter, I2C_LOCK_SEGMENT
1262 * unlocks only this branch in the adapter tree
1264 static void i2c_adapter_unlock_bus(struct i2c_adapter *adapter,
1267 rt_mutex_unlock(&adapter->bus_lock);
1270 static void i2c_dev_set_name(struct i2c_adapter *adap,
1271 struct i2c_client *client)
1273 struct acpi_device *adev = ACPI_COMPANION(&client->dev);
1276 dev_set_name(&client->dev, "i2c-%s", acpi_dev_name(adev));
1280 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
1281 i2c_encode_flags_to_addr(client));
1285 * i2c_new_device - instantiate an i2c device
1286 * @adap: the adapter managing the device
1287 * @info: describes one I2C device; bus_num is ignored
1288 * Context: can sleep
1290 * Create an i2c device. Binding is handled through driver model
1291 * probe()/remove() methods. A driver may be bound to this device when we
1292 * return from this function, or any later moment (e.g. maybe hotplugging will
1293 * load the driver module). This call is not appropriate for use by mainboard
1294 * initialization logic, which usually runs during an arch_initcall() long
1295 * before any i2c_adapter could exist.
1297 * This returns the new i2c client, which may be saved for later use with
1298 * i2c_unregister_device(); or NULL to indicate an error.
1301 i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
1303 struct i2c_client *client;
1306 client = kzalloc(sizeof *client, GFP_KERNEL);
1310 client->adapter = adap;
1312 client->dev.platform_data = info->platform_data;
1315 client->dev.archdata = *info->archdata;
1317 client->flags = info->flags;
1318 client->addr = info->addr;
1319 client->irq = info->irq;
1321 strlcpy(client->name, info->type, sizeof(client->name));
1323 status = i2c_check_addr_validity(client->addr, client->flags);
1325 dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
1326 client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
1327 goto out_err_silent;
1330 /* Check for address business */
1331 status = i2c_check_addr_busy(adap, i2c_encode_flags_to_addr(client));
1335 client->dev.parent = &client->adapter->dev;
1336 client->dev.bus = &i2c_bus_type;
1337 client->dev.type = &i2c_client_type;
1338 client->dev.of_node = info->of_node;
1339 client->dev.fwnode = info->fwnode;
1341 i2c_dev_set_name(adap, client);
1342 status = device_register(&client->dev);
1346 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
1347 client->name, dev_name(&client->dev));
1353 "Failed to register i2c client %s at 0x%02x (%d)\n",
1354 client->name, client->addr, status);
1359 EXPORT_SYMBOL_GPL(i2c_new_device);
1363 * i2c_unregister_device - reverse effect of i2c_new_device()
1364 * @client: value returned from i2c_new_device()
1365 * Context: can sleep
1367 void i2c_unregister_device(struct i2c_client *client)
1369 if (client->dev.of_node)
1370 of_node_clear_flag(client->dev.of_node, OF_POPULATED);
1371 if (ACPI_COMPANION(&client->dev))
1372 acpi_device_clear_enumerated(ACPI_COMPANION(&client->dev));
1373 device_unregister(&client->dev);
1375 EXPORT_SYMBOL_GPL(i2c_unregister_device);
1378 static const struct i2c_device_id dummy_id[] = {
1383 static int dummy_probe(struct i2c_client *client,
1384 const struct i2c_device_id *id)
1389 static int dummy_remove(struct i2c_client *client)
1394 static struct i2c_driver dummy_driver = {
1395 .driver.name = "dummy",
1396 .probe = dummy_probe,
1397 .remove = dummy_remove,
1398 .id_table = dummy_id,
1402 * i2c_new_dummy - return a new i2c device bound to a dummy driver
1403 * @adapter: the adapter managing the device
1404 * @address: seven bit address to be used
1405 * Context: can sleep
1407 * This returns an I2C client bound to the "dummy" driver, intended for use
1408 * with devices that consume multiple addresses. Examples of such chips
1409 * include various EEPROMS (like 24c04 and 24c08 models).
1411 * These dummy devices have two main uses. First, most I2C and SMBus calls
1412 * except i2c_transfer() need a client handle; the dummy will be that handle.
1413 * And second, this prevents the specified address from being bound to a
1416 * This returns the new i2c client, which should be saved for later use with
1417 * i2c_unregister_device(); or NULL to indicate an error.
1419 struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
1421 struct i2c_board_info info = {
1422 I2C_BOARD_INFO("dummy", address),
1425 return i2c_new_device(adapter, &info);
1427 EXPORT_SYMBOL_GPL(i2c_new_dummy);
1430 * i2c_new_secondary_device - Helper to get the instantiated secondary address
1431 * and create the associated device
1432 * @client: Handle to the primary client
1433 * @name: Handle to specify which secondary address to get
1434 * @default_addr: Used as a fallback if no secondary address was specified
1435 * Context: can sleep
1437 * I2C clients can be composed of multiple I2C slaves bound together in a single
1438 * component. The I2C client driver then binds to the master I2C slave and needs
1439 * to create I2C dummy clients to communicate with all the other slaves.
1441 * This function creates and returns an I2C dummy client whose I2C address is
1442 * retrieved from the platform firmware based on the given slave name. If no
1443 * address is specified by the firmware default_addr is used.
1445 * On DT-based platforms the address is retrieved from the "reg" property entry
1446 * cell whose "reg-names" value matches the slave name.
1448 * This returns the new i2c client, which should be saved for later use with
1449 * i2c_unregister_device(); or NULL to indicate an error.
1451 struct i2c_client *i2c_new_secondary_device(struct i2c_client *client,
1455 struct device_node *np = client->dev.of_node;
1456 u32 addr = default_addr;
1460 i = of_property_match_string(np, "reg-names", name);
1462 of_property_read_u32_index(np, "reg", i, &addr);
1465 dev_dbg(&client->adapter->dev, "Address for %s : 0x%x\n", name, addr);
1466 return i2c_new_dummy(client->adapter, addr);
1468 EXPORT_SYMBOL_GPL(i2c_new_secondary_device);
1470 /* ------------------------------------------------------------------------- */
1472 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
1474 static void i2c_adapter_dev_release(struct device *dev)
1476 struct i2c_adapter *adap = to_i2c_adapter(dev);
1477 complete(&adap->dev_released);
1480 unsigned int i2c_adapter_depth(struct i2c_adapter *adapter)
1482 unsigned int depth = 0;
1484 while ((adapter = i2c_parent_is_i2c_adapter(adapter)))
1487 WARN_ONCE(depth >= MAX_LOCKDEP_SUBCLASSES,
1488 "adapter depth exceeds lockdep subclass limit\n");
1492 EXPORT_SYMBOL_GPL(i2c_adapter_depth);
1495 * Let users instantiate I2C devices through sysfs. This can be used when
1496 * platform initialization code doesn't contain the proper data for
1497 * whatever reason. Also useful for drivers that do device detection and
1498 * detection fails, either because the device uses an unexpected address,
1499 * or this is a compatible device with different ID register values.
1501 * Parameter checking may look overzealous, but we really don't want
1502 * the user to provide incorrect parameters.
1505 i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
1506 const char *buf, size_t count)
1508 struct i2c_adapter *adap = to_i2c_adapter(dev);
1509 struct i2c_board_info info;
1510 struct i2c_client *client;
1514 memset(&info, 0, sizeof(struct i2c_board_info));
1516 blank = strchr(buf, ' ');
1518 dev_err(dev, "%s: Missing parameters\n", "new_device");
1521 if (blank - buf > I2C_NAME_SIZE - 1) {
1522 dev_err(dev, "%s: Invalid device name\n", "new_device");
1525 memcpy(info.type, buf, blank - buf);
1527 /* Parse remaining parameters, reject extra parameters */
1528 res = sscanf(++blank, "%hi%c", &info.addr, &end);
1530 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
1533 if (res > 1 && end != '\n') {
1534 dev_err(dev, "%s: Extra parameters\n", "new_device");
1538 if ((info.addr & I2C_ADDR_OFFSET_TEN_BIT) == I2C_ADDR_OFFSET_TEN_BIT) {
1539 info.addr &= ~I2C_ADDR_OFFSET_TEN_BIT;
1540 info.flags |= I2C_CLIENT_TEN;
1543 if (info.addr & I2C_ADDR_OFFSET_SLAVE) {
1544 info.addr &= ~I2C_ADDR_OFFSET_SLAVE;
1545 info.flags |= I2C_CLIENT_SLAVE;
1548 client = i2c_new_device(adap, &info);
1552 /* Keep track of the added device */
1553 mutex_lock(&adap->userspace_clients_lock);
1554 list_add_tail(&client->detected, &adap->userspace_clients);
1555 mutex_unlock(&adap->userspace_clients_lock);
1556 dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
1557 info.type, info.addr);
1561 static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
1564 * And of course let the users delete the devices they instantiated, if
1565 * they got it wrong. This interface can only be used to delete devices
1566 * instantiated by i2c_sysfs_new_device above. This guarantees that we
1567 * don't delete devices to which some kernel code still has references.
1569 * Parameter checking may look overzealous, but we really don't want
1570 * the user to delete the wrong device.
1573 i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
1574 const char *buf, size_t count)
1576 struct i2c_adapter *adap = to_i2c_adapter(dev);
1577 struct i2c_client *client, *next;
1578 unsigned short addr;
1582 /* Parse parameters, reject extra parameters */
1583 res = sscanf(buf, "%hi%c", &addr, &end);
1585 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
1588 if (res > 1 && end != '\n') {
1589 dev_err(dev, "%s: Extra parameters\n", "delete_device");
1593 /* Make sure the device was added through sysfs */
1595 mutex_lock_nested(&adap->userspace_clients_lock,
1596 i2c_adapter_depth(adap));
1597 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1599 if (i2c_encode_flags_to_addr(client) == addr) {
1600 dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
1601 "delete_device", client->name, client->addr);
1603 list_del(&client->detected);
1604 i2c_unregister_device(client);
1609 mutex_unlock(&adap->userspace_clients_lock);
1612 dev_err(dev, "%s: Can't find device in list\n",
1616 static DEVICE_ATTR_IGNORE_LOCKDEP(delete_device, S_IWUSR, NULL,
1617 i2c_sysfs_delete_device);
1619 static struct attribute *i2c_adapter_attrs[] = {
1620 &dev_attr_name.attr,
1621 &dev_attr_new_device.attr,
1622 &dev_attr_delete_device.attr,
1625 ATTRIBUTE_GROUPS(i2c_adapter);
1627 struct device_type i2c_adapter_type = {
1628 .groups = i2c_adapter_groups,
1629 .release = i2c_adapter_dev_release,
1631 EXPORT_SYMBOL_GPL(i2c_adapter_type);
1634 * i2c_verify_adapter - return parameter as i2c_adapter or NULL
1635 * @dev: device, probably from some driver model iterator
1637 * When traversing the driver model tree, perhaps using driver model
1638 * iterators like @device_for_each_child(), you can't assume very much
1639 * about the nodes you find. Use this function to avoid oopses caused
1640 * by wrongly treating some non-I2C device as an i2c_adapter.
1642 struct i2c_adapter *i2c_verify_adapter(struct device *dev)
1644 return (dev->type == &i2c_adapter_type)
1645 ? to_i2c_adapter(dev)
1648 EXPORT_SYMBOL(i2c_verify_adapter);
1650 #ifdef CONFIG_I2C_COMPAT
1651 static struct class_compat *i2c_adapter_compat_class;
1654 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
1656 struct i2c_devinfo *devinfo;
1658 down_read(&__i2c_board_lock);
1659 list_for_each_entry(devinfo, &__i2c_board_list, list) {
1660 if (devinfo->busnum == adapter->nr
1661 && !i2c_new_device(adapter,
1662 &devinfo->board_info))
1663 dev_err(&adapter->dev,
1664 "Can't create device at 0x%02x\n",
1665 devinfo->board_info.addr);
1667 up_read(&__i2c_board_lock);
1670 /* OF support code */
1672 #if IS_ENABLED(CONFIG_OF)
1673 static struct i2c_client *of_i2c_register_device(struct i2c_adapter *adap,
1674 struct device_node *node)
1676 struct i2c_client *result;
1677 struct i2c_board_info info = {};
1678 struct dev_archdata dev_ad = {};
1679 const __be32 *addr_be;
1683 dev_dbg(&adap->dev, "of_i2c: register %s\n", node->full_name);
1685 if (of_modalias_node(node, info.type, sizeof(info.type)) < 0) {
1686 dev_err(&adap->dev, "of_i2c: modalias failure on %s\n",
1688 return ERR_PTR(-EINVAL);
1691 addr_be = of_get_property(node, "reg", &len);
1692 if (!addr_be || (len < sizeof(*addr_be))) {
1693 dev_err(&adap->dev, "of_i2c: invalid reg on %s\n",
1695 return ERR_PTR(-EINVAL);
1698 addr = be32_to_cpup(addr_be);
1699 if (addr & I2C_TEN_BIT_ADDRESS) {
1700 addr &= ~I2C_TEN_BIT_ADDRESS;
1701 info.flags |= I2C_CLIENT_TEN;
1704 if (addr & I2C_OWN_SLAVE_ADDRESS) {
1705 addr &= ~I2C_OWN_SLAVE_ADDRESS;
1706 info.flags |= I2C_CLIENT_SLAVE;
1709 if (i2c_check_addr_validity(addr, info.flags)) {
1710 dev_err(&adap->dev, "of_i2c: invalid addr=%x on %s\n",
1711 info.addr, node->full_name);
1712 return ERR_PTR(-EINVAL);
1716 info.of_node = of_node_get(node);
1717 info.archdata = &dev_ad;
1719 if (of_get_property(node, "wakeup-source", NULL))
1720 info.flags |= I2C_CLIENT_WAKE;
1722 result = i2c_new_device(adap, &info);
1723 if (result == NULL) {
1724 dev_err(&adap->dev, "of_i2c: Failure registering %s\n",
1727 return ERR_PTR(-EINVAL);
1732 static void of_i2c_register_devices(struct i2c_adapter *adap)
1734 struct device_node *bus, *node;
1735 struct i2c_client *client;
1737 /* Only register child devices if the adapter has a node pointer set */
1738 if (!adap->dev.of_node)
1741 dev_dbg(&adap->dev, "of_i2c: walking child nodes\n");
1743 bus = of_get_child_by_name(adap->dev.of_node, "i2c-bus");
1745 bus = of_node_get(adap->dev.of_node);
1747 for_each_available_child_of_node(bus, node) {
1748 if (of_node_test_and_set_flag(node, OF_POPULATED))
1751 client = of_i2c_register_device(adap, node);
1752 if (IS_ERR(client)) {
1753 dev_warn(&adap->dev,
1754 "Failed to create I2C device for %s\n",
1756 of_node_clear_flag(node, OF_POPULATED);
1763 static int of_dev_node_match(struct device *dev, void *data)
1765 return dev->of_node == data;
1768 /* must call put_device() when done with returned i2c_client device */
1769 struct i2c_client *of_find_i2c_device_by_node(struct device_node *node)
1772 struct i2c_client *client;
1774 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
1778 client = i2c_verify_client(dev);
1784 EXPORT_SYMBOL(of_find_i2c_device_by_node);
1786 /* must call put_device() when done with returned i2c_adapter device */
1787 struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node)
1790 struct i2c_adapter *adapter;
1792 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
1796 adapter = i2c_verify_adapter(dev);
1802 EXPORT_SYMBOL(of_find_i2c_adapter_by_node);
1804 /* must call i2c_put_adapter() when done with returned i2c_adapter device */
1805 struct i2c_adapter *of_get_i2c_adapter_by_node(struct device_node *node)
1807 struct i2c_adapter *adapter;
1809 adapter = of_find_i2c_adapter_by_node(node);
1813 if (!try_module_get(adapter->owner)) {
1814 put_device(&adapter->dev);
1820 EXPORT_SYMBOL(of_get_i2c_adapter_by_node);
1822 static const struct of_device_id*
1823 i2c_of_match_device_sysfs(const struct of_device_id *matches,
1824 struct i2c_client *client)
1828 for (; matches->compatible[0]; matches++) {
1830 * Adding devices through the i2c sysfs interface provides us
1831 * a string to match which may be compatible with the device
1832 * tree compatible strings, however with no actual of_node the
1833 * of_match_device() will not match
1835 if (sysfs_streq(client->name, matches->compatible))
1838 name = strchr(matches->compatible, ',');
1840 name = matches->compatible;
1844 if (sysfs_streq(client->name, name))
1851 const struct of_device_id
1852 *i2c_of_match_device(const struct of_device_id *matches,
1853 struct i2c_client *client)
1855 const struct of_device_id *match;
1857 if (!(client && matches))
1860 match = of_match_device(matches, &client->dev);
1864 return i2c_of_match_device_sysfs(matches, client);
1866 EXPORT_SYMBOL_GPL(i2c_of_match_device);
1868 static void of_i2c_register_devices(struct i2c_adapter *adap) { }
1869 #endif /* CONFIG_OF */
1871 static int i2c_do_add_adapter(struct i2c_driver *driver,
1872 struct i2c_adapter *adap)
1874 /* Detect supported devices on that bus, and instantiate them */
1875 i2c_detect(adap, driver);
1877 /* Let legacy drivers scan this bus for matching devices */
1878 if (driver->attach_adapter) {
1879 dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
1880 driver->driver.name);
1881 dev_warn(&adap->dev,
1882 "Please use another way to instantiate your i2c_client\n");
1883 /* We ignore the return code; if it fails, too bad */
1884 driver->attach_adapter(adap);
1889 static int __process_new_adapter(struct device_driver *d, void *data)
1891 return i2c_do_add_adapter(to_i2c_driver(d), data);
1894 static const struct i2c_lock_operations i2c_adapter_lock_ops = {
1895 .lock_bus = i2c_adapter_lock_bus,
1896 .trylock_bus = i2c_adapter_trylock_bus,
1897 .unlock_bus = i2c_adapter_unlock_bus,
1900 static void i2c_host_notify_irq_teardown(struct i2c_adapter *adap)
1902 struct irq_domain *domain = adap->host_notify_domain;
1903 irq_hw_number_t hwirq;
1908 for (hwirq = 0 ; hwirq < I2C_ADDR_7BITS_COUNT ; hwirq++)
1909 irq_dispose_mapping(irq_find_mapping(domain, hwirq));
1911 irq_domain_remove(domain);
1912 adap->host_notify_domain = NULL;
1915 static int i2c_host_notify_irq_map(struct irq_domain *h,
1917 irq_hw_number_t hw_irq_num)
1919 irq_set_chip_and_handler(virq, &dummy_irq_chip, handle_simple_irq);
1924 static const struct irq_domain_ops i2c_host_notify_irq_ops = {
1925 .map = i2c_host_notify_irq_map,
1928 static int i2c_setup_host_notify_irq_domain(struct i2c_adapter *adap)
1930 struct irq_domain *domain;
1932 if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_HOST_NOTIFY))
1935 domain = irq_domain_create_linear(adap->dev.fwnode,
1936 I2C_ADDR_7BITS_COUNT,
1937 &i2c_host_notify_irq_ops, adap);
1941 adap->host_notify_domain = domain;
1947 * i2c_handle_smbus_host_notify - Forward a Host Notify event to the correct
1949 * @adap: the adapter
1950 * @addr: the I2C address of the notifying device
1951 * Context: can't sleep
1953 * Helper function to be called from an I2C bus driver's interrupt
1954 * handler. It will schedule the Host Notify IRQ.
1956 int i2c_handle_smbus_host_notify(struct i2c_adapter *adap, unsigned short addr)
1963 irq = irq_find_mapping(adap->host_notify_domain, addr);
1967 generic_handle_irq(irq);
1971 EXPORT_SYMBOL_GPL(i2c_handle_smbus_host_notify);
1973 static int i2c_register_adapter(struct i2c_adapter *adap)
1977 /* Can't register until after driver model init */
1978 if (WARN_ON(!is_registered)) {
1984 if (WARN(!adap->name[0], "i2c adapter has no name"))
1988 pr_err("adapter '%s': no algo supplied!\n", adap->name);
1992 if (!adap->lock_ops)
1993 adap->lock_ops = &i2c_adapter_lock_ops;
1995 rt_mutex_init(&adap->bus_lock);
1996 rt_mutex_init(&adap->mux_lock);
1997 mutex_init(&adap->userspace_clients_lock);
1998 INIT_LIST_HEAD(&adap->userspace_clients);
2000 /* Set default timeout to 1 second if not already set */
2001 if (adap->timeout == 0)
2004 /* register soft irqs for Host Notify */
2005 res = i2c_setup_host_notify_irq_domain(adap);
2007 pr_err("adapter '%s': can't create Host Notify IRQs (%d)\n",
2012 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
2013 adap->dev.bus = &i2c_bus_type;
2014 adap->dev.type = &i2c_adapter_type;
2015 res = device_register(&adap->dev);
2017 pr_err("adapter '%s': can't register device (%d)\n", adap->name, res);
2021 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
2023 pm_runtime_no_callbacks(&adap->dev);
2024 pm_suspend_ignore_children(&adap->dev, true);
2025 pm_runtime_enable(&adap->dev);
2027 #ifdef CONFIG_I2C_COMPAT
2028 res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
2031 dev_warn(&adap->dev,
2032 "Failed to create compatibility class link\n");
2035 i2c_init_recovery(adap);
2037 /* create pre-declared device nodes */
2038 of_i2c_register_devices(adap);
2039 i2c_acpi_register_devices(adap);
2040 i2c_acpi_install_space_handler(adap);
2042 if (adap->nr < __i2c_first_dynamic_bus_num)
2043 i2c_scan_static_board_info(adap);
2045 /* Notify drivers */
2046 mutex_lock(&core_lock);
2047 bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
2048 mutex_unlock(&core_lock);
2053 mutex_lock(&core_lock);
2054 idr_remove(&i2c_adapter_idr, adap->nr);
2055 mutex_unlock(&core_lock);
2060 * __i2c_add_numbered_adapter - i2c_add_numbered_adapter where nr is never -1
2061 * @adap: the adapter to register (with adap->nr initialized)
2062 * Context: can sleep
2064 * See i2c_add_numbered_adapter() for details.
2066 static int __i2c_add_numbered_adapter(struct i2c_adapter *adap)
2070 mutex_lock(&core_lock);
2071 id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1, GFP_KERNEL);
2072 mutex_unlock(&core_lock);
2073 if (WARN(id < 0, "couldn't get idr"))
2074 return id == -ENOSPC ? -EBUSY : id;
2076 return i2c_register_adapter(adap);
2080 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
2081 * @adapter: the adapter to add
2082 * Context: can sleep
2084 * This routine is used to declare an I2C adapter when its bus number
2085 * doesn't matter or when its bus number is specified by an dt alias.
2086 * Examples of bases when the bus number doesn't matter: I2C adapters
2087 * dynamically added by USB links or PCI plugin cards.
2089 * When this returns zero, a new bus number was allocated and stored
2090 * in adap->nr, and the specified adapter became available for clients.
2091 * Otherwise, a negative errno value is returned.
2093 int i2c_add_adapter(struct i2c_adapter *adapter)
2095 struct device *dev = &adapter->dev;
2099 id = of_alias_get_id(dev->of_node, "i2c");
2102 return __i2c_add_numbered_adapter(adapter);
2106 mutex_lock(&core_lock);
2107 id = idr_alloc(&i2c_adapter_idr, adapter,
2108 __i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
2109 mutex_unlock(&core_lock);
2110 if (WARN(id < 0, "couldn't get idr"))
2115 return i2c_register_adapter(adapter);
2117 EXPORT_SYMBOL(i2c_add_adapter);
2120 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
2121 * @adap: the adapter to register (with adap->nr initialized)
2122 * Context: can sleep
2124 * This routine is used to declare an I2C adapter when its bus number
2125 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
2126 * or otherwise built in to the system's mainboard, and where i2c_board_info
2127 * is used to properly configure I2C devices.
2129 * If the requested bus number is set to -1, then this function will behave
2130 * identically to i2c_add_adapter, and will dynamically assign a bus number.
2132 * If no devices have pre-been declared for this bus, then be sure to
2133 * register the adapter before any dynamically allocated ones. Otherwise
2134 * the required bus ID may not be available.
2136 * When this returns zero, the specified adapter became available for
2137 * clients using the bus number provided in adap->nr. Also, the table
2138 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
2139 * and the appropriate driver model device nodes are created. Otherwise, a
2140 * negative errno value is returned.
2142 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
2144 if (adap->nr == -1) /* -1 means dynamically assign bus id */
2145 return i2c_add_adapter(adap);
2147 return __i2c_add_numbered_adapter(adap);
2149 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
2151 static void i2c_do_del_adapter(struct i2c_driver *driver,
2152 struct i2c_adapter *adapter)
2154 struct i2c_client *client, *_n;
2156 /* Remove the devices we created ourselves as the result of hardware
2157 * probing (using a driver's detect method) */
2158 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
2159 if (client->adapter == adapter) {
2160 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
2161 client->name, client->addr);
2162 list_del(&client->detected);
2163 i2c_unregister_device(client);
2168 static int __unregister_client(struct device *dev, void *dummy)
2170 struct i2c_client *client = i2c_verify_client(dev);
2171 if (client && strcmp(client->name, "dummy"))
2172 i2c_unregister_device(client);
2176 static int __unregister_dummy(struct device *dev, void *dummy)
2178 struct i2c_client *client = i2c_verify_client(dev);
2180 i2c_unregister_device(client);
2184 static int __process_removed_adapter(struct device_driver *d, void *data)
2186 i2c_do_del_adapter(to_i2c_driver(d), data);
2191 * i2c_del_adapter - unregister I2C adapter
2192 * @adap: the adapter being unregistered
2193 * Context: can sleep
2195 * This unregisters an I2C adapter which was previously registered
2196 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
2198 void i2c_del_adapter(struct i2c_adapter *adap)
2200 struct i2c_adapter *found;
2201 struct i2c_client *client, *next;
2203 /* First make sure that this adapter was ever added */
2204 mutex_lock(&core_lock);
2205 found = idr_find(&i2c_adapter_idr, adap->nr);
2206 mutex_unlock(&core_lock);
2207 if (found != adap) {
2208 pr_debug("attempting to delete unregistered adapter [%s]\n", adap->name);
2212 i2c_acpi_remove_space_handler(adap);
2213 /* Tell drivers about this removal */
2214 mutex_lock(&core_lock);
2215 bus_for_each_drv(&i2c_bus_type, NULL, adap,
2216 __process_removed_adapter);
2217 mutex_unlock(&core_lock);
2219 /* Remove devices instantiated from sysfs */
2220 mutex_lock_nested(&adap->userspace_clients_lock,
2221 i2c_adapter_depth(adap));
2222 list_for_each_entry_safe(client, next, &adap->userspace_clients,
2224 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
2226 list_del(&client->detected);
2227 i2c_unregister_device(client);
2229 mutex_unlock(&adap->userspace_clients_lock);
2231 /* Detach any active clients. This can't fail, thus we do not
2232 * check the returned value. This is a two-pass process, because
2233 * we can't remove the dummy devices during the first pass: they
2234 * could have been instantiated by real devices wishing to clean
2235 * them up properly, so we give them a chance to do that first. */
2236 device_for_each_child(&adap->dev, NULL, __unregister_client);
2237 device_for_each_child(&adap->dev, NULL, __unregister_dummy);
2239 #ifdef CONFIG_I2C_COMPAT
2240 class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
2244 /* device name is gone after device_unregister */
2245 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
2247 pm_runtime_disable(&adap->dev);
2249 i2c_host_notify_irq_teardown(adap);
2251 /* wait until all references to the device are gone
2253 * FIXME: This is old code and should ideally be replaced by an
2254 * alternative which results in decoupling the lifetime of the struct
2255 * device from the i2c_adapter, like spi or netdev do. Any solution
2256 * should be thoroughly tested with DEBUG_KOBJECT_RELEASE enabled!
2258 init_completion(&adap->dev_released);
2259 device_unregister(&adap->dev);
2260 wait_for_completion(&adap->dev_released);
2263 mutex_lock(&core_lock);
2264 idr_remove(&i2c_adapter_idr, adap->nr);
2265 mutex_unlock(&core_lock);
2267 /* Clear the device structure in case this adapter is ever going to be
2269 memset(&adap->dev, 0, sizeof(adap->dev));
2271 EXPORT_SYMBOL(i2c_del_adapter);
2274 * i2c_parse_fw_timings - get I2C related timing parameters from firmware
2275 * @dev: The device to scan for I2C timing properties
2276 * @t: the i2c_timings struct to be filled with values
2277 * @use_defaults: bool to use sane defaults derived from the I2C specification
2278 * when properties are not found, otherwise use 0
2280 * Scan the device for the generic I2C properties describing timing parameters
2281 * for the signal and fill the given struct with the results. If a property was
2282 * not found and use_defaults was true, then maximum timings are assumed which
2283 * are derived from the I2C specification. If use_defaults is not used, the
2284 * results will be 0, so drivers can apply their own defaults later. The latter
2285 * is mainly intended for avoiding regressions of existing drivers which want
2286 * to switch to this function. New drivers almost always should use the defaults.
2289 void i2c_parse_fw_timings(struct device *dev, struct i2c_timings *t, bool use_defaults)
2293 memset(t, 0, sizeof(*t));
2295 ret = device_property_read_u32(dev, "clock-frequency", &t->bus_freq_hz);
2296 if (ret && use_defaults)
2297 t->bus_freq_hz = 100000;
2299 ret = device_property_read_u32(dev, "i2c-scl-rising-time-ns", &t->scl_rise_ns);
2300 if (ret && use_defaults) {
2301 if (t->bus_freq_hz <= 100000)
2302 t->scl_rise_ns = 1000;
2303 else if (t->bus_freq_hz <= 400000)
2304 t->scl_rise_ns = 300;
2306 t->scl_rise_ns = 120;
2309 ret = device_property_read_u32(dev, "i2c-scl-falling-time-ns", &t->scl_fall_ns);
2310 if (ret && use_defaults) {
2311 if (t->bus_freq_hz <= 400000)
2312 t->scl_fall_ns = 300;
2314 t->scl_fall_ns = 120;
2317 device_property_read_u32(dev, "i2c-scl-internal-delay-ns", &t->scl_int_delay_ns);
2319 ret = device_property_read_u32(dev, "i2c-sda-falling-time-ns", &t->sda_fall_ns);
2320 if (ret && use_defaults)
2321 t->sda_fall_ns = t->scl_fall_ns;
2323 EXPORT_SYMBOL_GPL(i2c_parse_fw_timings);
2325 /* ------------------------------------------------------------------------- */
2327 int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
2331 mutex_lock(&core_lock);
2332 res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
2333 mutex_unlock(&core_lock);
2337 EXPORT_SYMBOL_GPL(i2c_for_each_dev);
2339 static int __process_new_driver(struct device *dev, void *data)
2341 if (dev->type != &i2c_adapter_type)
2343 return i2c_do_add_adapter(data, to_i2c_adapter(dev));
2347 * An i2c_driver is used with one or more i2c_client (device) nodes to access
2348 * i2c slave chips, on a bus instance associated with some i2c_adapter.
2351 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
2355 /* Can't register until after driver model init */
2356 if (WARN_ON(!is_registered))
2359 /* add the driver to the list of i2c drivers in the driver core */
2360 driver->driver.owner = owner;
2361 driver->driver.bus = &i2c_bus_type;
2362 INIT_LIST_HEAD(&driver->clients);
2364 /* When registration returns, the driver core
2365 * will have called probe() for all matching-but-unbound devices.
2367 res = driver_register(&driver->driver);
2371 pr_debug("driver [%s] registered\n", driver->driver.name);
2373 /* Walk the adapters that are already present */
2374 i2c_for_each_dev(driver, __process_new_driver);
2378 EXPORT_SYMBOL(i2c_register_driver);
2380 static int __process_removed_driver(struct device *dev, void *data)
2382 if (dev->type == &i2c_adapter_type)
2383 i2c_do_del_adapter(data, to_i2c_adapter(dev));
2388 * i2c_del_driver - unregister I2C driver
2389 * @driver: the driver being unregistered
2390 * Context: can sleep
2392 void i2c_del_driver(struct i2c_driver *driver)
2394 i2c_for_each_dev(driver, __process_removed_driver);
2396 driver_unregister(&driver->driver);
2397 pr_debug("driver [%s] unregistered\n", driver->driver.name);
2399 EXPORT_SYMBOL(i2c_del_driver);
2401 /* ------------------------------------------------------------------------- */
2404 * i2c_use_client - increments the reference count of the i2c client structure
2405 * @client: the client being referenced
2407 * Each live reference to a client should be refcounted. The driver model does
2408 * that automatically as part of driver binding, so that most drivers don't
2409 * need to do this explicitly: they hold a reference until they're unbound
2412 * A pointer to the client with the incremented reference counter is returned.
2414 struct i2c_client *i2c_use_client(struct i2c_client *client)
2416 if (client && get_device(&client->dev))
2420 EXPORT_SYMBOL(i2c_use_client);
2423 * i2c_release_client - release a use of the i2c client structure
2424 * @client: the client being no longer referenced
2426 * Must be called when a user of a client is finished with it.
2428 void i2c_release_client(struct i2c_client *client)
2431 put_device(&client->dev);
2433 EXPORT_SYMBOL(i2c_release_client);
2435 struct i2c_cmd_arg {
2440 static int i2c_cmd(struct device *dev, void *_arg)
2442 struct i2c_client *client = i2c_verify_client(dev);
2443 struct i2c_cmd_arg *arg = _arg;
2444 struct i2c_driver *driver;
2446 if (!client || !client->dev.driver)
2449 driver = to_i2c_driver(client->dev.driver);
2450 if (driver->command)
2451 driver->command(client, arg->cmd, arg->arg);
2455 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
2457 struct i2c_cmd_arg cmd_arg;
2461 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
2463 EXPORT_SYMBOL(i2c_clients_command);
2465 #if IS_ENABLED(CONFIG_OF_DYNAMIC)
2466 static int of_i2c_notify(struct notifier_block *nb, unsigned long action,
2469 struct of_reconfig_data *rd = arg;
2470 struct i2c_adapter *adap;
2471 struct i2c_client *client;
2473 switch (of_reconfig_get_state_change(action, rd)) {
2474 case OF_RECONFIG_CHANGE_ADD:
2475 adap = of_find_i2c_adapter_by_node(rd->dn->parent);
2477 return NOTIFY_OK; /* not for us */
2479 if (of_node_test_and_set_flag(rd->dn, OF_POPULATED)) {
2480 put_device(&adap->dev);
2484 client = of_i2c_register_device(adap, rd->dn);
2485 put_device(&adap->dev);
2487 if (IS_ERR(client)) {
2488 dev_err(&adap->dev, "failed to create client for '%s'\n",
2490 of_node_clear_flag(rd->dn, OF_POPULATED);
2491 return notifier_from_errno(PTR_ERR(client));
2494 case OF_RECONFIG_CHANGE_REMOVE:
2495 /* already depopulated? */
2496 if (!of_node_check_flag(rd->dn, OF_POPULATED))
2499 /* find our device by node */
2500 client = of_find_i2c_device_by_node(rd->dn);
2502 return NOTIFY_OK; /* no? not meant for us */
2504 /* unregister takes one ref away */
2505 i2c_unregister_device(client);
2507 /* and put the reference of the find */
2508 put_device(&client->dev);
2514 static struct notifier_block i2c_of_notifier = {
2515 .notifier_call = of_i2c_notify,
2518 extern struct notifier_block i2c_of_notifier;
2519 #endif /* CONFIG_OF_DYNAMIC */
2521 static int __init i2c_init(void)
2525 retval = of_alias_get_highest_id("i2c");
2527 down_write(&__i2c_board_lock);
2528 if (retval >= __i2c_first_dynamic_bus_num)
2529 __i2c_first_dynamic_bus_num = retval + 1;
2530 up_write(&__i2c_board_lock);
2532 retval = bus_register(&i2c_bus_type);
2536 is_registered = true;
2538 #ifdef CONFIG_I2C_COMPAT
2539 i2c_adapter_compat_class = class_compat_register("i2c-adapter");
2540 if (!i2c_adapter_compat_class) {
2545 retval = i2c_add_driver(&dummy_driver);
2549 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2550 WARN_ON(of_reconfig_notifier_register(&i2c_of_notifier));
2551 if (IS_ENABLED(CONFIG_ACPI))
2552 WARN_ON(acpi_reconfig_notifier_register(&i2c_acpi_notifier));
2557 #ifdef CONFIG_I2C_COMPAT
2558 class_compat_unregister(i2c_adapter_compat_class);
2561 is_registered = false;
2562 bus_unregister(&i2c_bus_type);
2566 static void __exit i2c_exit(void)
2568 if (IS_ENABLED(CONFIG_ACPI))
2569 WARN_ON(acpi_reconfig_notifier_unregister(&i2c_acpi_notifier));
2570 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2571 WARN_ON(of_reconfig_notifier_unregister(&i2c_of_notifier));
2572 i2c_del_driver(&dummy_driver);
2573 #ifdef CONFIG_I2C_COMPAT
2574 class_compat_unregister(i2c_adapter_compat_class);
2576 bus_unregister(&i2c_bus_type);
2577 tracepoint_synchronize_unregister();
2580 /* We must initialize early, because some subsystems register i2c drivers
2581 * in subsys_initcall() code, but are linked (and initialized) before i2c.
2583 postcore_initcall(i2c_init);
2584 module_exit(i2c_exit);
2586 /* ----------------------------------------------------
2587 * the functional interface to the i2c busses.
2588 * ----------------------------------------------------
2591 /* Check if val is exceeding the quirk IFF quirk is non 0 */
2592 #define i2c_quirk_exceeded(val, quirk) ((quirk) && ((val) > (quirk)))
2594 static int i2c_quirk_error(struct i2c_adapter *adap, struct i2c_msg *msg, char *err_msg)
2596 dev_err_ratelimited(&adap->dev, "adapter quirk: %s (addr 0x%04x, size %u, %s)\n",
2597 err_msg, msg->addr, msg->len,
2598 msg->flags & I2C_M_RD ? "read" : "write");
2602 static int i2c_check_for_quirks(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2604 const struct i2c_adapter_quirks *q = adap->quirks;
2605 int max_num = q->max_num_msgs, i;
2606 bool do_len_check = true;
2608 if (q->flags & I2C_AQ_COMB) {
2611 /* special checks for combined messages */
2613 if (q->flags & I2C_AQ_COMB_WRITE_FIRST && msgs[0].flags & I2C_M_RD)
2614 return i2c_quirk_error(adap, &msgs[0], "1st comb msg must be write");
2616 if (q->flags & I2C_AQ_COMB_READ_SECOND && !(msgs[1].flags & I2C_M_RD))
2617 return i2c_quirk_error(adap, &msgs[1], "2nd comb msg must be read");
2619 if (q->flags & I2C_AQ_COMB_SAME_ADDR && msgs[0].addr != msgs[1].addr)
2620 return i2c_quirk_error(adap, &msgs[0], "comb msg only to same addr");
2622 if (i2c_quirk_exceeded(msgs[0].len, q->max_comb_1st_msg_len))
2623 return i2c_quirk_error(adap, &msgs[0], "msg too long");
2625 if (i2c_quirk_exceeded(msgs[1].len, q->max_comb_2nd_msg_len))
2626 return i2c_quirk_error(adap, &msgs[1], "msg too long");
2628 do_len_check = false;
2632 if (i2c_quirk_exceeded(num, max_num))
2633 return i2c_quirk_error(adap, &msgs[0], "too many messages");
2635 for (i = 0; i < num; i++) {
2636 u16 len = msgs[i].len;
2638 if (msgs[i].flags & I2C_M_RD) {
2639 if (do_len_check && i2c_quirk_exceeded(len, q->max_read_len))
2640 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2642 if (do_len_check && i2c_quirk_exceeded(len, q->max_write_len))
2643 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2651 * __i2c_transfer - unlocked flavor of i2c_transfer
2652 * @adap: Handle to I2C bus
2653 * @msgs: One or more messages to execute before STOP is issued to
2654 * terminate the operation; each message begins with a START.
2655 * @num: Number of messages to be executed.
2657 * Returns negative errno, else the number of messages executed.
2659 * Adapter lock must be held when calling this function. No debug logging
2660 * takes place. adap->algo->master_xfer existence isn't checked.
2662 int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2664 unsigned long orig_jiffies;
2667 if (adap->quirks && i2c_check_for_quirks(adap, msgs, num))
2670 /* i2c_trace_msg gets enabled when tracepoint i2c_transfer gets
2671 * enabled. This is an efficient way of keeping the for-loop from
2672 * being executed when not needed.
2674 if (static_key_false(&i2c_trace_msg)) {
2676 for (i = 0; i < num; i++)
2677 if (msgs[i].flags & I2C_M_RD)
2678 trace_i2c_read(adap, &msgs[i], i);
2680 trace_i2c_write(adap, &msgs[i], i);
2683 /* Retry automatically on arbitration loss */
2684 orig_jiffies = jiffies;
2685 for (ret = 0, try = 0; try <= adap->retries; try++) {
2686 ret = adap->algo->master_xfer(adap, msgs, num);
2689 if (time_after(jiffies, orig_jiffies + adap->timeout))
2693 if (static_key_false(&i2c_trace_msg)) {
2695 for (i = 0; i < ret; i++)
2696 if (msgs[i].flags & I2C_M_RD)
2697 trace_i2c_reply(adap, &msgs[i], i);
2698 trace_i2c_result(adap, i, ret);
2703 EXPORT_SYMBOL(__i2c_transfer);
2706 * i2c_transfer - execute a single or combined I2C message
2707 * @adap: Handle to I2C bus
2708 * @msgs: One or more messages to execute before STOP is issued to
2709 * terminate the operation; each message begins with a START.
2710 * @num: Number of messages to be executed.
2712 * Returns negative errno, else the number of messages executed.
2714 * Note that there is no requirement that each message be sent to
2715 * the same slave address, although that is the most common model.
2717 int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2721 /* REVISIT the fault reporting model here is weak:
2723 * - When we get an error after receiving N bytes from a slave,
2724 * there is no way to report "N".
2726 * - When we get a NAK after transmitting N bytes to a slave,
2727 * there is no way to report "N" ... or to let the master
2728 * continue executing the rest of this combined message, if
2729 * that's the appropriate response.
2731 * - When for example "num" is two and we successfully complete
2732 * the first message but get an error part way through the
2733 * second, it's unclear whether that should be reported as
2734 * one (discarding status on the second message) or errno
2735 * (discarding status on the first one).
2738 if (adap->algo->master_xfer) {
2740 for (ret = 0; ret < num; ret++) {
2742 "master_xfer[%d] %c, addr=0x%02x, len=%d%s\n",
2743 ret, (msgs[ret].flags & I2C_M_RD) ? 'R' : 'W',
2744 msgs[ret].addr, msgs[ret].len,
2745 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
2749 if (in_atomic() || irqs_disabled()) {
2750 ret = i2c_trylock_bus(adap, I2C_LOCK_SEGMENT);
2752 /* I2C activity is ongoing. */
2755 i2c_lock_bus(adap, I2C_LOCK_SEGMENT);
2758 ret = __i2c_transfer(adap, msgs, num);
2759 i2c_unlock_bus(adap, I2C_LOCK_SEGMENT);
2763 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
2767 EXPORT_SYMBOL(i2c_transfer);
2770 * i2c_master_send - issue a single I2C message in master transmit mode
2771 * @client: Handle to slave device
2772 * @buf: Data that will be written to the slave
2773 * @count: How many bytes to write, must be less than 64k since msg.len is u16
2775 * Returns negative errno, or else the number of bytes written.
2777 int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
2780 struct i2c_adapter *adap = client->adapter;
2783 msg.addr = client->addr;
2784 msg.flags = client->flags & I2C_M_TEN;
2786 msg.buf = (char *)buf;
2788 ret = i2c_transfer(adap, &msg, 1);
2791 * If everything went ok (i.e. 1 msg transmitted), return #bytes
2792 * transmitted, else error code.
2794 return (ret == 1) ? count : ret;
2796 EXPORT_SYMBOL(i2c_master_send);
2799 * i2c_master_recv - issue a single I2C message in master receive mode
2800 * @client: Handle to slave device
2801 * @buf: Where to store data read from slave
2802 * @count: How many bytes to read, must be less than 64k since msg.len is u16
2804 * Returns negative errno, or else the number of bytes read.
2806 int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
2808 struct i2c_adapter *adap = client->adapter;
2812 msg.addr = client->addr;
2813 msg.flags = client->flags & I2C_M_TEN;
2814 msg.flags |= I2C_M_RD;
2818 ret = i2c_transfer(adap, &msg, 1);
2821 * If everything went ok (i.e. 1 msg received), return #bytes received,
2824 return (ret == 1) ? count : ret;
2826 EXPORT_SYMBOL(i2c_master_recv);
2828 /* ----------------------------------------------------
2829 * the i2c address scanning function
2830 * Will not work for 10-bit addresses!
2831 * ----------------------------------------------------
2835 * Legacy default probe function, mostly relevant for SMBus. The default
2836 * probe method is a quick write, but it is known to corrupt the 24RF08
2837 * EEPROMs due to a state machine bug, and could also irreversibly
2838 * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
2839 * we use a short byte read instead. Also, some bus drivers don't implement
2840 * quick write, so we fallback to a byte read in that case too.
2841 * On x86, there is another special case for FSC hardware monitoring chips,
2842 * which want regular byte reads (address 0x73.) Fortunately, these are the
2843 * only known chips using this I2C address on PC hardware.
2844 * Returns 1 if probe succeeded, 0 if not.
2846 static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
2849 union i2c_smbus_data dummy;
2852 if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
2853 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
2854 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2855 I2C_SMBUS_BYTE_DATA, &dummy);
2858 if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
2859 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
2860 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
2861 I2C_SMBUS_QUICK, NULL);
2862 else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
2863 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2864 I2C_SMBUS_BYTE, &dummy);
2866 dev_warn(&adap->dev, "No suitable probing method supported for address 0x%02X\n",
2874 static int i2c_detect_address(struct i2c_client *temp_client,
2875 struct i2c_driver *driver)
2877 struct i2c_board_info info;
2878 struct i2c_adapter *adapter = temp_client->adapter;
2879 int addr = temp_client->addr;
2882 /* Make sure the address is valid */
2883 err = i2c_check_7bit_addr_validity_strict(addr);
2885 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
2890 /* Skip if already in use (7 bit, no need to encode flags) */
2891 if (i2c_check_addr_busy(adapter, addr))
2894 /* Make sure there is something at this address */
2895 if (!i2c_default_probe(adapter, addr))
2898 /* Finally call the custom detection function */
2899 memset(&info, 0, sizeof(struct i2c_board_info));
2901 err = driver->detect(temp_client, &info);
2903 /* -ENODEV is returned if the detection fails. We catch it
2904 here as this isn't an error. */
2905 return err == -ENODEV ? 0 : err;
2908 /* Consistency check */
2909 if (info.type[0] == '\0') {
2910 dev_err(&adapter->dev,
2911 "%s detection function provided no name for 0x%x\n",
2912 driver->driver.name, addr);
2914 struct i2c_client *client;
2916 /* Detection succeeded, instantiate the device */
2917 if (adapter->class & I2C_CLASS_DEPRECATED)
2918 dev_warn(&adapter->dev,
2919 "This adapter will soon drop class based instantiation of devices. "
2920 "Please make sure client 0x%02x gets instantiated by other means. "
2921 "Check 'Documentation/i2c/instantiating-devices' for details.\n",
2924 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
2925 info.type, info.addr);
2926 client = i2c_new_device(adapter, &info);
2928 list_add_tail(&client->detected, &driver->clients);
2930 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
2931 info.type, info.addr);
2936 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
2938 const unsigned short *address_list;
2939 struct i2c_client *temp_client;
2941 int adap_id = i2c_adapter_id(adapter);
2943 address_list = driver->address_list;
2944 if (!driver->detect || !address_list)
2947 /* Warn that the adapter lost class based instantiation */
2948 if (adapter->class == I2C_CLASS_DEPRECATED) {
2949 dev_dbg(&adapter->dev,
2950 "This adapter dropped support for I2C classes and won't auto-detect %s devices anymore. "
2951 "If you need it, check 'Documentation/i2c/instantiating-devices' for alternatives.\n",
2952 driver->driver.name);
2956 /* Stop here if the classes do not match */
2957 if (!(adapter->class & driver->class))
2960 /* Set up a temporary client to help detect callback */
2961 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
2964 temp_client->adapter = adapter;
2966 for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
2967 dev_dbg(&adapter->dev,
2968 "found normal entry for adapter %d, addr 0x%02x\n",
2969 adap_id, address_list[i]);
2970 temp_client->addr = address_list[i];
2971 err = i2c_detect_address(temp_client, driver);
2980 int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
2982 return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2983 I2C_SMBUS_QUICK, NULL) >= 0;
2985 EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
2988 i2c_new_probed_device(struct i2c_adapter *adap,
2989 struct i2c_board_info *info,
2990 unsigned short const *addr_list,
2991 int (*probe)(struct i2c_adapter *, unsigned short addr))
2996 probe = i2c_default_probe;
2998 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
2999 /* Check address validity */
3000 if (i2c_check_7bit_addr_validity_strict(addr_list[i]) < 0) {
3001 dev_warn(&adap->dev, "Invalid 7-bit address 0x%02x\n",
3006 /* Check address availability (7 bit, no need to encode flags) */
3007 if (i2c_check_addr_busy(adap, addr_list[i])) {
3009 "Address 0x%02x already in use, not probing\n",
3014 /* Test address responsiveness */
3015 if (probe(adap, addr_list[i]))
3019 if (addr_list[i] == I2C_CLIENT_END) {
3020 dev_dbg(&adap->dev, "Probing failed, no device found\n");
3024 info->addr = addr_list[i];
3025 return i2c_new_device(adap, info);
3027 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
3029 struct i2c_adapter *i2c_get_adapter(int nr)
3031 struct i2c_adapter *adapter;
3033 mutex_lock(&core_lock);
3034 adapter = idr_find(&i2c_adapter_idr, nr);
3038 if (try_module_get(adapter->owner))
3039 get_device(&adapter->dev);
3044 mutex_unlock(&core_lock);
3047 EXPORT_SYMBOL(i2c_get_adapter);
3049 void i2c_put_adapter(struct i2c_adapter *adap)
3054 put_device(&adap->dev);
3055 module_put(adap->owner);
3057 EXPORT_SYMBOL(i2c_put_adapter);
3059 /* The SMBus parts */
3061 #define POLY (0x1070U << 3)
3062 static u8 crc8(u16 data)
3066 for (i = 0; i < 8; i++) {
3071 return (u8)(data >> 8);
3074 /* Incremental CRC8 over count bytes in the array pointed to by p */
3075 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
3079 for (i = 0; i < count; i++)
3080 crc = crc8((crc ^ p[i]) << 8);
3084 /* Assume a 7-bit address, which is reasonable for SMBus */
3085 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
3087 /* The address will be sent first */
3088 u8 addr = i2c_8bit_addr_from_msg(msg);
3089 pec = i2c_smbus_pec(pec, &addr, 1);
3091 /* The data buffer follows */
3092 return i2c_smbus_pec(pec, msg->buf, msg->len);
3095 /* Used for write only transactions */
3096 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
3098 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
3102 /* Return <0 on CRC error
3103 If there was a write before this read (most cases) we need to take the
3104 partial CRC from the write part into account.
3105 Note that this function does modify the message (we need to decrease the
3106 message length to hide the CRC byte from the caller). */
3107 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
3109 u8 rpec = msg->buf[--msg->len];
3110 cpec = i2c_smbus_msg_pec(cpec, msg);
3113 pr_debug("Bad PEC 0x%02x vs. 0x%02x\n",
3121 * i2c_smbus_read_byte - SMBus "receive byte" protocol
3122 * @client: Handle to slave device
3124 * This executes the SMBus "receive byte" protocol, returning negative errno
3125 * else the byte received from the device.
3127 s32 i2c_smbus_read_byte(const struct i2c_client *client)
3129 union i2c_smbus_data data;
3132 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3134 I2C_SMBUS_BYTE, &data);
3135 return (status < 0) ? status : data.byte;
3137 EXPORT_SYMBOL(i2c_smbus_read_byte);
3140 * i2c_smbus_write_byte - SMBus "send byte" protocol
3141 * @client: Handle to slave device
3142 * @value: Byte to be sent
3144 * This executes the SMBus "send byte" protocol, returning negative errno
3145 * else zero on success.
3147 s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
3149 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3150 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
3152 EXPORT_SYMBOL(i2c_smbus_write_byte);
3155 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
3156 * @client: Handle to slave device
3157 * @command: Byte interpreted by slave
3159 * This executes the SMBus "read byte" protocol, returning negative errno
3160 * else a data byte received from the device.
3162 s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
3164 union i2c_smbus_data data;
3167 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3168 I2C_SMBUS_READ, command,
3169 I2C_SMBUS_BYTE_DATA, &data);
3170 return (status < 0) ? status : data.byte;
3172 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
3175 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
3176 * @client: Handle to slave device
3177 * @command: Byte interpreted by slave
3178 * @value: Byte being written
3180 * This executes the SMBus "write byte" protocol, returning negative errno
3181 * else zero on success.
3183 s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
3186 union i2c_smbus_data data;
3188 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3189 I2C_SMBUS_WRITE, command,
3190 I2C_SMBUS_BYTE_DATA, &data);
3192 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
3195 * i2c_smbus_read_word_data - SMBus "read word" protocol
3196 * @client: Handle to slave device
3197 * @command: Byte interpreted by slave
3199 * This executes the SMBus "read word" protocol, returning negative errno
3200 * else a 16-bit unsigned "word" received from the device.
3202 s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
3204 union i2c_smbus_data data;
3207 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3208 I2C_SMBUS_READ, command,
3209 I2C_SMBUS_WORD_DATA, &data);
3210 return (status < 0) ? status : data.word;
3212 EXPORT_SYMBOL(i2c_smbus_read_word_data);
3215 * i2c_smbus_write_word_data - SMBus "write word" protocol
3216 * @client: Handle to slave device
3217 * @command: Byte interpreted by slave
3218 * @value: 16-bit "word" being written
3220 * This executes the SMBus "write word" protocol, returning negative errno
3221 * else zero on success.
3223 s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
3226 union i2c_smbus_data data;
3228 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3229 I2C_SMBUS_WRITE, command,
3230 I2C_SMBUS_WORD_DATA, &data);
3232 EXPORT_SYMBOL(i2c_smbus_write_word_data);
3235 * i2c_smbus_read_block_data - SMBus "block read" protocol
3236 * @client: Handle to slave device
3237 * @command: Byte interpreted by slave
3238 * @values: Byte array into which data will be read; big enough to hold
3239 * the data returned by the slave. SMBus allows at most 32 bytes.
3241 * This executes the SMBus "block read" protocol, returning negative errno
3242 * else the number of data bytes in the slave's response.
3244 * Note that using this function requires that the client's adapter support
3245 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
3246 * support this; its emulation through I2C messaging relies on a specific
3247 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
3249 s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
3252 union i2c_smbus_data data;
3255 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3256 I2C_SMBUS_READ, command,
3257 I2C_SMBUS_BLOCK_DATA, &data);
3261 memcpy(values, &data.block[1], data.block[0]);
3262 return data.block[0];
3264 EXPORT_SYMBOL(i2c_smbus_read_block_data);
3267 * i2c_smbus_write_block_data - SMBus "block write" protocol
3268 * @client: Handle to slave device
3269 * @command: Byte interpreted by slave
3270 * @length: Size of data block; SMBus allows at most 32 bytes
3271 * @values: Byte array which will be written.
3273 * This executes the SMBus "block write" protocol, returning negative errno
3274 * else zero on success.
3276 s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
3277 u8 length, const u8 *values)
3279 union i2c_smbus_data data;
3281 if (length > I2C_SMBUS_BLOCK_MAX)
3282 length = I2C_SMBUS_BLOCK_MAX;
3283 data.block[0] = length;
3284 memcpy(&data.block[1], values, length);
3285 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3286 I2C_SMBUS_WRITE, command,
3287 I2C_SMBUS_BLOCK_DATA, &data);
3289 EXPORT_SYMBOL(i2c_smbus_write_block_data);
3291 /* Returns the number of read bytes */
3292 s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
3293 u8 length, u8 *values)
3295 union i2c_smbus_data data;
3298 if (length > I2C_SMBUS_BLOCK_MAX)
3299 length = I2C_SMBUS_BLOCK_MAX;
3300 data.block[0] = length;
3301 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3302 I2C_SMBUS_READ, command,
3303 I2C_SMBUS_I2C_BLOCK_DATA, &data);
3307 memcpy(values, &data.block[1], data.block[0]);
3308 return data.block[0];
3310 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
3312 s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
3313 u8 length, const u8 *values)
3315 union i2c_smbus_data data;
3317 if (length > I2C_SMBUS_BLOCK_MAX)
3318 length = I2C_SMBUS_BLOCK_MAX;
3319 data.block[0] = length;
3320 memcpy(data.block + 1, values, length);
3321 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3322 I2C_SMBUS_WRITE, command,
3323 I2C_SMBUS_I2C_BLOCK_DATA, &data);
3325 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
3327 /* Simulate a SMBus command using the i2c protocol
3328 No checking of parameters is done! */
3329 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
3330 unsigned short flags,
3331 char read_write, u8 command, int size,
3332 union i2c_smbus_data *data)
3334 /* So we need to generate a series of msgs. In the case of writing, we
3335 need to use only one message; when reading, we need two. We initialize
3336 most things with sane defaults, to keep the code below somewhat
3338 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
3339 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
3340 int num = read_write == I2C_SMBUS_READ ? 2 : 1;
3344 struct i2c_msg msg[2] = {
3352 .flags = flags | I2C_M_RD,
3358 msgbuf0[0] = command;
3360 case I2C_SMBUS_QUICK:
3362 /* Special case: The read/write field is used as data */
3363 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
3367 case I2C_SMBUS_BYTE:
3368 if (read_write == I2C_SMBUS_READ) {
3369 /* Special case: only a read! */
3370 msg[0].flags = I2C_M_RD | flags;
3374 case I2C_SMBUS_BYTE_DATA:
3375 if (read_write == I2C_SMBUS_READ)
3379 msgbuf0[1] = data->byte;
3382 case I2C_SMBUS_WORD_DATA:
3383 if (read_write == I2C_SMBUS_READ)
3387 msgbuf0[1] = data->word & 0xff;
3388 msgbuf0[2] = data->word >> 8;
3391 case I2C_SMBUS_PROC_CALL:
3392 num = 2; /* Special case */
3393 read_write = I2C_SMBUS_READ;
3396 msgbuf0[1] = data->word & 0xff;
3397 msgbuf0[2] = data->word >> 8;
3399 case I2C_SMBUS_BLOCK_DATA:
3400 if (read_write == I2C_SMBUS_READ) {
3401 msg[1].flags |= I2C_M_RECV_LEN;
3402 msg[1].len = 1; /* block length will be added by
3403 the underlying bus driver */
3405 msg[0].len = data->block[0] + 2;
3406 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
3407 dev_err(&adapter->dev,
3408 "Invalid block write size %d\n",
3412 for (i = 1; i < msg[0].len; i++)
3413 msgbuf0[i] = data->block[i-1];
3416 case I2C_SMBUS_BLOCK_PROC_CALL:
3417 num = 2; /* Another special case */
3418 read_write = I2C_SMBUS_READ;
3419 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
3420 dev_err(&adapter->dev,
3421 "Invalid block write size %d\n",
3425 msg[0].len = data->block[0] + 2;
3426 for (i = 1; i < msg[0].len; i++)
3427 msgbuf0[i] = data->block[i-1];
3428 msg[1].flags |= I2C_M_RECV_LEN;
3429 msg[1].len = 1; /* block length will be added by
3430 the underlying bus driver */
3432 case I2C_SMBUS_I2C_BLOCK_DATA:
3433 if (read_write == I2C_SMBUS_READ) {
3434 msg[1].len = data->block[0];
3436 msg[0].len = data->block[0] + 1;
3437 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
3438 dev_err(&adapter->dev,
3439 "Invalid block write size %d\n",
3443 for (i = 1; i <= data->block[0]; i++)
3444 msgbuf0[i] = data->block[i];
3448 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
3452 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
3453 && size != I2C_SMBUS_I2C_BLOCK_DATA);
3455 /* Compute PEC if first message is a write */
3456 if (!(msg[0].flags & I2C_M_RD)) {
3457 if (num == 1) /* Write only */
3458 i2c_smbus_add_pec(&msg[0]);
3459 else /* Write followed by read */
3460 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
3462 /* Ask for PEC if last message is a read */
3463 if (msg[num-1].flags & I2C_M_RD)
3467 status = i2c_transfer(adapter, msg, num);
3471 /* Check PEC if last message is a read */
3472 if (i && (msg[num-1].flags & I2C_M_RD)) {
3473 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
3478 if (read_write == I2C_SMBUS_READ)
3480 case I2C_SMBUS_BYTE:
3481 data->byte = msgbuf0[0];
3483 case I2C_SMBUS_BYTE_DATA:
3484 data->byte = msgbuf1[0];
3486 case I2C_SMBUS_WORD_DATA:
3487 case I2C_SMBUS_PROC_CALL:
3488 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
3490 case I2C_SMBUS_I2C_BLOCK_DATA:
3491 for (i = 0; i < data->block[0]; i++)
3492 data->block[i+1] = msgbuf1[i];
3494 case I2C_SMBUS_BLOCK_DATA:
3495 case I2C_SMBUS_BLOCK_PROC_CALL:
3496 for (i = 0; i < msgbuf1[0] + 1; i++)
3497 data->block[i] = msgbuf1[i];
3504 * i2c_smbus_xfer - execute SMBus protocol operations
3505 * @adapter: Handle to I2C bus
3506 * @addr: Address of SMBus slave on that bus
3507 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
3508 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
3509 * @command: Byte interpreted by slave, for protocols which use such bytes
3510 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
3511 * @data: Data to be read or written
3513 * This executes an SMBus protocol operation, and returns a negative
3514 * errno code else zero on success.
3516 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
3517 char read_write, u8 command, int protocol,
3518 union i2c_smbus_data *data)
3520 unsigned long orig_jiffies;
3524 /* If enabled, the following two tracepoints are conditional on
3525 * read_write and protocol.
3527 trace_smbus_write(adapter, addr, flags, read_write,
3528 command, protocol, data);
3529 trace_smbus_read(adapter, addr, flags, read_write,
3532 flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
3534 if (adapter->algo->smbus_xfer) {
3535 i2c_lock_bus(adapter, I2C_LOCK_SEGMENT);
3537 /* Retry automatically on arbitration loss */
3538 orig_jiffies = jiffies;
3539 for (res = 0, try = 0; try <= adapter->retries; try++) {
3540 res = adapter->algo->smbus_xfer(adapter, addr, flags,
3541 read_write, command,
3545 if (time_after(jiffies,
3546 orig_jiffies + adapter->timeout))
3549 i2c_unlock_bus(adapter, I2C_LOCK_SEGMENT);
3551 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
3554 * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
3555 * implement native support for the SMBus operation.
3559 res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
3560 command, protocol, data);
3563 /* If enabled, the reply tracepoint is conditional on read_write. */
3564 trace_smbus_reply(adapter, addr, flags, read_write,
3565 command, protocol, data);
3566 trace_smbus_result(adapter, addr, flags, read_write,
3567 command, protocol, res);
3571 EXPORT_SYMBOL(i2c_smbus_xfer);
3574 * i2c_smbus_read_i2c_block_data_or_emulated - read block or emulate
3575 * @client: Handle to slave device
3576 * @command: Byte interpreted by slave
3577 * @length: Size of data block; SMBus allows at most I2C_SMBUS_BLOCK_MAX bytes
3578 * @values: Byte array into which data will be read; big enough to hold
3579 * the data returned by the slave. SMBus allows at most
3580 * I2C_SMBUS_BLOCK_MAX bytes.
3582 * This executes the SMBus "block read" protocol if supported by the adapter.
3583 * If block read is not supported, it emulates it using either word or byte
3584 * read protocols depending on availability.
3586 * The addresses of the I2C slave device that are accessed with this function
3587 * must be mapped to a linear region, so that a block read will have the same
3588 * effect as a byte read. Before using this function you must double-check
3589 * if the I2C slave does support exchanging a block transfer with a byte
3592 s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
3593 u8 command, u8 length, u8 *values)
3598 if (length > I2C_SMBUS_BLOCK_MAX)
3599 length = I2C_SMBUS_BLOCK_MAX;
3601 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK))
3602 return i2c_smbus_read_i2c_block_data(client, command, length, values);
3604 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA))
3607 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_WORD_DATA)) {
3608 while ((i + 2) <= length) {
3609 status = i2c_smbus_read_word_data(client, command + i);
3612 values[i] = status & 0xff;
3613 values[i + 1] = status >> 8;
3618 while (i < length) {
3619 status = i2c_smbus_read_byte_data(client, command + i);
3628 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data_or_emulated);
3630 #if IS_ENABLED(CONFIG_I2C_SLAVE)
3631 int i2c_slave_register(struct i2c_client *client, i2c_slave_cb_t slave_cb)
3635 if (!client || !slave_cb) {
3636 WARN(1, "insufficent data\n");
3640 if (!(client->flags & I2C_CLIENT_SLAVE))
3641 dev_warn(&client->dev, "%s: client slave flag not set. You might see address collisions\n",
3644 if (!(client->flags & I2C_CLIENT_TEN)) {
3645 /* Enforce stricter address checking */
3646 ret = i2c_check_7bit_addr_validity_strict(client->addr);
3648 dev_err(&client->dev, "%s: invalid address\n", __func__);
3653 if (!client->adapter->algo->reg_slave) {
3654 dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
3658 client->slave_cb = slave_cb;
3660 i2c_lock_adapter(client->adapter);
3661 ret = client->adapter->algo->reg_slave(client);
3662 i2c_unlock_adapter(client->adapter);
3665 client->slave_cb = NULL;
3666 dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
3671 EXPORT_SYMBOL_GPL(i2c_slave_register);
3673 int i2c_slave_unregister(struct i2c_client *client)
3677 if (!client->adapter->algo->unreg_slave) {
3678 dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
3682 i2c_lock_adapter(client->adapter);
3683 ret = client->adapter->algo->unreg_slave(client);
3684 i2c_unlock_adapter(client->adapter);
3687 client->slave_cb = NULL;
3689 dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
3693 EXPORT_SYMBOL_GPL(i2c_slave_unregister);
3696 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
3697 MODULE_DESCRIPTION("I2C-Bus main module");
3698 MODULE_LICENSE("GPL");