1 /* i2c-core.c - a device driver for the iic-bus interface */
2 /* ------------------------------------------------------------------------- */
3 /* Copyright (C) 1995-99 Simon G. Vogl
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details. */
14 /* ------------------------------------------------------------------------- */
16 /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi>.
17 All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl>
18 SMBus 2.0 support by Mark Studebaker <mdsxyz123@yahoo.com> and
19 Jean Delvare <jdelvare@suse.de>
20 Mux support by Rodolfo Giometti <giometti@enneenne.com> and
21 Michael Lawnick <michael.lawnick.ext@nsn.com>
22 OF support is copyright (c) 2008 Jochen Friedrich <jochen@scram.de>
23 (based on a previous patch from Jon Smirl <jonsmirl@gmail.com>) and
24 (c) 2013 Wolfram Sang <wsa@the-dreams.de>
25 I2C ACPI code Copyright (C) 2014 Intel Corp
26 Author: Lan Tianyu <tianyu.lan@intel.com>
27 I2C slave support (c) 2014 by Wolfram Sang <wsa@sang-engineering.com>
30 #define pr_fmt(fmt) "i2c-core: " fmt
32 #include <dt-bindings/i2c/i2c.h>
33 #include <asm/uaccess.h>
34 #include <linux/acpi.h>
35 #include <linux/clk/clk-conf.h>
36 #include <linux/completion.h>
37 #include <linux/delay.h>
38 #include <linux/err.h>
39 #include <linux/errno.h>
40 #include <linux/gpio.h>
41 #include <linux/hardirq.h>
42 #include <linux/i2c.h>
43 #include <linux/idr.h>
44 #include <linux/init.h>
45 #include <linux/interrupt.h>
46 #include <linux/irqflags.h>
47 #include <linux/jump_label.h>
48 #include <linux/kernel.h>
49 #include <linux/module.h>
50 #include <linux/mutex.h>
51 #include <linux/of_device.h>
53 #include <linux/of_irq.h>
54 #include <linux/pm_domain.h>
55 #include <linux/pm_runtime.h>
56 #include <linux/pm_wakeirq.h>
57 #include <linux/property.h>
58 #include <linux/rwsem.h>
59 #include <linux/slab.h>
63 #define CREATE_TRACE_POINTS
64 #include <trace/events/i2c.h>
66 #define I2C_ADDR_OFFSET_TEN_BIT 0xa000
67 #define I2C_ADDR_OFFSET_SLAVE 0x1000
69 /* core_lock protects i2c_adapter_idr, and guarantees
70 that device detection, deletion of detected devices, and attach_adapter
71 calls are serialized */
72 static DEFINE_MUTEX(core_lock);
73 static DEFINE_IDR(i2c_adapter_idr);
75 static struct device_type i2c_client_type;
76 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
78 static struct static_key i2c_trace_msg = STATIC_KEY_INIT_FALSE;
79 static bool is_registered;
81 void i2c_transfer_trace_reg(void)
83 static_key_slow_inc(&i2c_trace_msg);
86 void i2c_transfer_trace_unreg(void)
88 static_key_slow_dec(&i2c_trace_msg);
91 #if defined(CONFIG_ACPI)
92 struct i2c_acpi_handler_data {
93 struct acpi_connection_info info;
94 struct i2c_adapter *adapter;
107 struct i2c_acpi_lookup {
108 struct i2c_board_info *info;
109 acpi_handle adapter_handle;
110 acpi_handle device_handle;
111 acpi_handle search_handle;
116 static int i2c_acpi_fill_info(struct acpi_resource *ares, void *data)
118 struct i2c_acpi_lookup *lookup = data;
119 struct i2c_board_info *info = lookup->info;
120 struct acpi_resource_i2c_serialbus *sb;
123 if (info->addr || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS)
126 sb = &ares->data.i2c_serial_bus;
127 if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C)
130 status = acpi_get_handle(lookup->device_handle,
131 sb->resource_source.string_ptr,
132 &lookup->adapter_handle);
133 if (!ACPI_SUCCESS(status))
136 info->addr = sb->slave_address;
137 lookup->speed = sb->connection_speed;
138 if (sb->access_mode == ACPI_I2C_10BIT_MODE)
139 info->flags |= I2C_CLIENT_TEN;
144 static int i2c_acpi_do_lookup(struct acpi_device *adev,
145 struct i2c_acpi_lookup *lookup)
147 struct i2c_board_info *info = lookup->info;
148 struct list_head resource_list;
151 if (acpi_bus_get_status(adev) || !adev->status.present ||
152 acpi_device_enumerated(adev))
155 memset(info, 0, sizeof(*info));
156 lookup->device_handle = acpi_device_handle(adev);
158 /* Look up for I2cSerialBus resource */
159 INIT_LIST_HEAD(&resource_list);
160 ret = acpi_dev_get_resources(adev, &resource_list,
161 i2c_acpi_fill_info, lookup);
162 acpi_dev_free_resource_list(&resource_list);
164 if (ret < 0 || !info->addr)
170 static int i2c_acpi_get_info(struct acpi_device *adev,
171 struct i2c_board_info *info,
172 struct i2c_adapter *adapter,
173 acpi_handle *adapter_handle)
175 struct list_head resource_list;
176 struct resource_entry *entry;
177 struct i2c_acpi_lookup lookup;
180 memset(&lookup, 0, sizeof(lookup));
183 ret = i2c_acpi_do_lookup(adev, &lookup);
188 /* The adapter must match the one in I2cSerialBus() connector */
189 if (ACPI_HANDLE(&adapter->dev) != lookup.adapter_handle)
192 struct acpi_device *adapter_adev;
194 /* The adapter must be present */
195 if (acpi_bus_get_device(lookup.adapter_handle, &adapter_adev))
197 if (acpi_bus_get_status(adapter_adev) ||
198 !adapter_adev->status.present)
202 info->fwnode = acpi_fwnode_handle(adev);
204 *adapter_handle = lookup.adapter_handle;
206 /* Then fill IRQ number if any */
207 INIT_LIST_HEAD(&resource_list);
208 ret = acpi_dev_get_resources(adev, &resource_list, NULL, NULL);
212 resource_list_for_each_entry(entry, &resource_list) {
213 if (resource_type(entry->res) == IORESOURCE_IRQ) {
214 info->irq = entry->res->start;
219 acpi_dev_free_resource_list(&resource_list);
221 strlcpy(info->type, dev_name(&adev->dev), sizeof(info->type));
226 static void i2c_acpi_register_device(struct i2c_adapter *adapter,
227 struct acpi_device *adev,
228 struct i2c_board_info *info)
230 adev->power.flags.ignore_parent = true;
231 acpi_device_set_enumerated(adev);
233 if (!i2c_new_device(adapter, info)) {
234 adev->power.flags.ignore_parent = false;
235 dev_err(&adapter->dev,
236 "failed to add I2C device %s from ACPI\n",
237 dev_name(&adev->dev));
241 static acpi_status i2c_acpi_add_device(acpi_handle handle, u32 level,
242 void *data, void **return_value)
244 struct i2c_adapter *adapter = data;
245 struct acpi_device *adev;
246 struct i2c_board_info info;
248 if (acpi_bus_get_device(handle, &adev))
251 if (i2c_acpi_get_info(adev, &info, adapter, NULL))
254 i2c_acpi_register_device(adapter, adev, &info);
259 #define I2C_ACPI_MAX_SCAN_DEPTH 32
262 * i2c_acpi_register_devices - enumerate I2C slave devices behind adapter
263 * @adap: pointer to adapter
265 * Enumerate all I2C slave devices behind this adapter by walking the ACPI
266 * namespace. When a device is found it will be added to the Linux device
267 * model and bound to the corresponding ACPI handle.
269 static void i2c_acpi_register_devices(struct i2c_adapter *adap)
273 if (!has_acpi_companion(&adap->dev))
276 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
277 I2C_ACPI_MAX_SCAN_DEPTH,
278 i2c_acpi_add_device, NULL,
280 if (ACPI_FAILURE(status))
281 dev_warn(&adap->dev, "failed to enumerate I2C slaves\n");
284 static acpi_status i2c_acpi_lookup_speed(acpi_handle handle, u32 level,
285 void *data, void **return_value)
287 struct i2c_acpi_lookup *lookup = data;
288 struct acpi_device *adev;
290 if (acpi_bus_get_device(handle, &adev))
293 if (i2c_acpi_do_lookup(adev, lookup))
296 if (lookup->search_handle != lookup->adapter_handle)
299 if (lookup->speed <= lookup->min_speed)
300 lookup->min_speed = lookup->speed;
306 * i2c_acpi_find_bus_speed - find I2C bus speed from ACPI
307 * @dev: The device owning the bus
309 * Find the I2C bus speed by walking the ACPI namespace for all I2C slaves
310 * devices connected to this bus and use the speed of slowest device.
312 * Returns the speed in Hz or zero
314 u32 i2c_acpi_find_bus_speed(struct device *dev)
316 struct i2c_acpi_lookup lookup;
317 struct i2c_board_info dummy;
320 if (!has_acpi_companion(dev))
323 memset(&lookup, 0, sizeof(lookup));
324 lookup.search_handle = ACPI_HANDLE(dev);
325 lookup.min_speed = UINT_MAX;
326 lookup.info = &dummy;
328 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
329 I2C_ACPI_MAX_SCAN_DEPTH,
330 i2c_acpi_lookup_speed, NULL,
333 if (ACPI_FAILURE(status)) {
334 dev_warn(dev, "unable to find I2C bus speed from ACPI\n");
338 return lookup.min_speed != UINT_MAX ? lookup.min_speed : 0;
340 EXPORT_SYMBOL_GPL(i2c_acpi_find_bus_speed);
342 static int i2c_acpi_match_adapter(struct device *dev, void *data)
344 struct i2c_adapter *adapter = i2c_verify_adapter(dev);
349 return ACPI_HANDLE(dev) == (acpi_handle)data;
352 static int i2c_acpi_match_device(struct device *dev, void *data)
354 return ACPI_COMPANION(dev) == data;
357 static struct i2c_adapter *i2c_acpi_find_adapter_by_handle(acpi_handle handle)
361 dev = bus_find_device(&i2c_bus_type, NULL, handle,
362 i2c_acpi_match_adapter);
363 return dev ? i2c_verify_adapter(dev) : NULL;
366 static struct i2c_client *i2c_acpi_find_client_by_adev(struct acpi_device *adev)
370 dev = bus_find_device(&i2c_bus_type, NULL, adev, i2c_acpi_match_device);
371 return dev ? i2c_verify_client(dev) : NULL;
374 static int i2c_acpi_notify(struct notifier_block *nb, unsigned long value,
377 struct acpi_device *adev = arg;
378 struct i2c_board_info info;
379 acpi_handle adapter_handle;
380 struct i2c_adapter *adapter;
381 struct i2c_client *client;
384 case ACPI_RECONFIG_DEVICE_ADD:
385 if (i2c_acpi_get_info(adev, &info, NULL, &adapter_handle))
388 adapter = i2c_acpi_find_adapter_by_handle(adapter_handle);
392 i2c_acpi_register_device(adapter, adev, &info);
394 case ACPI_RECONFIG_DEVICE_REMOVE:
395 if (!acpi_device_enumerated(adev))
398 client = i2c_acpi_find_client_by_adev(adev);
402 i2c_unregister_device(client);
403 put_device(&client->dev);
410 static struct notifier_block i2c_acpi_notifier = {
411 .notifier_call = i2c_acpi_notify,
413 #else /* CONFIG_ACPI */
414 static inline void i2c_acpi_register_devices(struct i2c_adapter *adap) { }
415 extern struct notifier_block i2c_acpi_notifier;
416 #endif /* CONFIG_ACPI */
418 #ifdef CONFIG_ACPI_I2C_OPREGION
419 static int acpi_gsb_i2c_read_bytes(struct i2c_client *client,
420 u8 cmd, u8 *data, u8 data_len)
423 struct i2c_msg msgs[2];
427 buffer = kzalloc(data_len, GFP_KERNEL);
431 msgs[0].addr = client->addr;
432 msgs[0].flags = client->flags;
436 msgs[1].addr = client->addr;
437 msgs[1].flags = client->flags | I2C_M_RD;
438 msgs[1].len = data_len;
439 msgs[1].buf = buffer;
441 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
443 dev_err(&client->adapter->dev, "i2c read failed\n");
445 memcpy(data, buffer, data_len);
451 static int acpi_gsb_i2c_write_bytes(struct i2c_client *client,
452 u8 cmd, u8 *data, u8 data_len)
455 struct i2c_msg msgs[1];
459 buffer = kzalloc(data_len + 1, GFP_KERNEL);
464 memcpy(buffer + 1, data, data_len);
466 msgs[0].addr = client->addr;
467 msgs[0].flags = client->flags;
468 msgs[0].len = data_len + 1;
469 msgs[0].buf = buffer;
471 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
473 dev_err(&client->adapter->dev, "i2c write failed\n");
480 i2c_acpi_space_handler(u32 function, acpi_physical_address command,
481 u32 bits, u64 *value64,
482 void *handler_context, void *region_context)
484 struct gsb_buffer *gsb = (struct gsb_buffer *)value64;
485 struct i2c_acpi_handler_data *data = handler_context;
486 struct acpi_connection_info *info = &data->info;
487 struct acpi_resource_i2c_serialbus *sb;
488 struct i2c_adapter *adapter = data->adapter;
489 struct i2c_client *client;
490 struct acpi_resource *ares;
491 u32 accessor_type = function >> 16;
492 u8 action = function & ACPI_IO_MASK;
496 ret = acpi_buffer_to_resource(info->connection, info->length, &ares);
497 if (ACPI_FAILURE(ret))
500 client = kzalloc(sizeof(*client), GFP_KERNEL);
506 if (!value64 || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) {
507 ret = AE_BAD_PARAMETER;
511 sb = &ares->data.i2c_serial_bus;
512 if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C) {
513 ret = AE_BAD_PARAMETER;
517 client->adapter = adapter;
518 client->addr = sb->slave_address;
520 if (sb->access_mode == ACPI_I2C_10BIT_MODE)
521 client->flags |= I2C_CLIENT_TEN;
523 switch (accessor_type) {
524 case ACPI_GSB_ACCESS_ATTRIB_SEND_RCV:
525 if (action == ACPI_READ) {
526 status = i2c_smbus_read_byte(client);
532 status = i2c_smbus_write_byte(client, gsb->bdata);
536 case ACPI_GSB_ACCESS_ATTRIB_BYTE:
537 if (action == ACPI_READ) {
538 status = i2c_smbus_read_byte_data(client, command);
544 status = i2c_smbus_write_byte_data(client, command,
549 case ACPI_GSB_ACCESS_ATTRIB_WORD:
550 if (action == ACPI_READ) {
551 status = i2c_smbus_read_word_data(client, command);
557 status = i2c_smbus_write_word_data(client, command,
562 case ACPI_GSB_ACCESS_ATTRIB_BLOCK:
563 if (action == ACPI_READ) {
564 status = i2c_smbus_read_block_data(client, command,
571 status = i2c_smbus_write_block_data(client, command,
572 gsb->len, gsb->data);
576 case ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE:
577 if (action == ACPI_READ) {
578 status = acpi_gsb_i2c_read_bytes(client, command,
579 gsb->data, info->access_length);
583 status = acpi_gsb_i2c_write_bytes(client, command,
584 gsb->data, info->access_length);
589 dev_warn(&adapter->dev, "protocol 0x%02x not supported for client 0x%02x\n",
590 accessor_type, client->addr);
591 ret = AE_BAD_PARAMETER;
595 gsb->status = status;
604 static int i2c_acpi_install_space_handler(struct i2c_adapter *adapter)
607 struct i2c_acpi_handler_data *data;
610 if (!adapter->dev.parent)
613 handle = ACPI_HANDLE(adapter->dev.parent);
618 data = kzalloc(sizeof(struct i2c_acpi_handler_data),
623 data->adapter = adapter;
624 status = acpi_bus_attach_private_data(handle, (void *)data);
625 if (ACPI_FAILURE(status)) {
630 status = acpi_install_address_space_handler(handle,
631 ACPI_ADR_SPACE_GSBUS,
632 &i2c_acpi_space_handler,
635 if (ACPI_FAILURE(status)) {
636 dev_err(&adapter->dev, "Error installing i2c space handler\n");
637 acpi_bus_detach_private_data(handle);
642 acpi_walk_dep_device_list(handle);
646 static void i2c_acpi_remove_space_handler(struct i2c_adapter *adapter)
649 struct i2c_acpi_handler_data *data;
652 if (!adapter->dev.parent)
655 handle = ACPI_HANDLE(adapter->dev.parent);
660 acpi_remove_address_space_handler(handle,
661 ACPI_ADR_SPACE_GSBUS,
662 &i2c_acpi_space_handler);
664 status = acpi_bus_get_private_data(handle, (void **)&data);
665 if (ACPI_SUCCESS(status))
668 acpi_bus_detach_private_data(handle);
670 #else /* CONFIG_ACPI_I2C_OPREGION */
671 static inline void i2c_acpi_remove_space_handler(struct i2c_adapter *adapter)
674 static inline int i2c_acpi_install_space_handler(struct i2c_adapter *adapter)
676 #endif /* CONFIG_ACPI_I2C_OPREGION */
678 /* ------------------------------------------------------------------------- */
680 static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
681 const struct i2c_client *client)
683 while (id->name[0]) {
684 if (strcmp(client->name, id->name) == 0)
691 static int i2c_device_match(struct device *dev, struct device_driver *drv)
693 struct i2c_client *client = i2c_verify_client(dev);
694 struct i2c_driver *driver;
699 /* Attempt an OF style match */
700 if (of_driver_match_device(dev, drv))
703 /* Then ACPI style match */
704 if (acpi_driver_match_device(dev, drv))
707 driver = to_i2c_driver(drv);
708 /* match on an id table if there is one */
709 if (driver->id_table)
710 return i2c_match_id(driver->id_table, client) != NULL;
715 static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
717 struct i2c_client *client = to_i2c_client(dev);
720 rc = acpi_device_uevent_modalias(dev, env);
724 return add_uevent_var(env, "MODALIAS=%s%s", I2C_MODULE_PREFIX, client->name);
727 /* i2c bus recovery routines */
728 static int get_scl_gpio_value(struct i2c_adapter *adap)
730 return gpio_get_value(adap->bus_recovery_info->scl_gpio);
733 static void set_scl_gpio_value(struct i2c_adapter *adap, int val)
735 gpio_set_value(adap->bus_recovery_info->scl_gpio, val);
738 static int get_sda_gpio_value(struct i2c_adapter *adap)
740 return gpio_get_value(adap->bus_recovery_info->sda_gpio);
743 static int i2c_get_gpios_for_recovery(struct i2c_adapter *adap)
745 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
746 struct device *dev = &adap->dev;
749 ret = gpio_request_one(bri->scl_gpio, GPIOF_OPEN_DRAIN |
750 GPIOF_OUT_INIT_HIGH, "i2c-scl");
752 dev_warn(dev, "Can't get SCL gpio: %d\n", bri->scl_gpio);
757 if (gpio_request_one(bri->sda_gpio, GPIOF_IN, "i2c-sda")) {
758 /* work without SDA polling */
759 dev_warn(dev, "Can't get SDA gpio: %d. Not using SDA polling\n",
768 static void i2c_put_gpios_for_recovery(struct i2c_adapter *adap)
770 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
773 gpio_free(bri->sda_gpio);
775 gpio_free(bri->scl_gpio);
779 * We are generating clock pulses. ndelay() determines durating of clk pulses.
780 * We will generate clock with rate 100 KHz and so duration of both clock levels
781 * is: delay in ns = (10^6 / 100) / 2
783 #define RECOVERY_NDELAY 5000
784 #define RECOVERY_CLK_CNT 9
786 static int i2c_generic_recovery(struct i2c_adapter *adap)
788 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
789 int i = 0, val = 1, ret = 0;
791 if (bri->prepare_recovery)
792 bri->prepare_recovery(adap);
794 bri->set_scl(adap, val);
795 ndelay(RECOVERY_NDELAY);
798 * By this time SCL is high, as we need to give 9 falling-rising edges
800 while (i++ < RECOVERY_CLK_CNT * 2) {
802 /* Break if SDA is high */
803 if (bri->get_sda && bri->get_sda(adap))
805 /* SCL shouldn't be low here */
806 if (!bri->get_scl(adap)) {
808 "SCL is stuck low, exit recovery\n");
815 bri->set_scl(adap, val);
816 ndelay(RECOVERY_NDELAY);
819 if (bri->unprepare_recovery)
820 bri->unprepare_recovery(adap);
825 int i2c_generic_scl_recovery(struct i2c_adapter *adap)
827 return i2c_generic_recovery(adap);
829 EXPORT_SYMBOL_GPL(i2c_generic_scl_recovery);
831 int i2c_generic_gpio_recovery(struct i2c_adapter *adap)
835 ret = i2c_get_gpios_for_recovery(adap);
839 ret = i2c_generic_recovery(adap);
840 i2c_put_gpios_for_recovery(adap);
844 EXPORT_SYMBOL_GPL(i2c_generic_gpio_recovery);
846 int i2c_recover_bus(struct i2c_adapter *adap)
848 if (!adap->bus_recovery_info)
851 dev_dbg(&adap->dev, "Trying i2c bus recovery\n");
852 return adap->bus_recovery_info->recover_bus(adap);
854 EXPORT_SYMBOL_GPL(i2c_recover_bus);
856 static void i2c_init_recovery(struct i2c_adapter *adap)
858 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
864 if (!bri->recover_bus) {
865 err_str = "no recover_bus() found";
869 /* Generic GPIO recovery */
870 if (bri->recover_bus == i2c_generic_gpio_recovery) {
871 if (!gpio_is_valid(bri->scl_gpio)) {
872 err_str = "invalid SCL gpio";
876 if (gpio_is_valid(bri->sda_gpio))
877 bri->get_sda = get_sda_gpio_value;
881 bri->get_scl = get_scl_gpio_value;
882 bri->set_scl = set_scl_gpio_value;
883 } else if (bri->recover_bus == i2c_generic_scl_recovery) {
884 /* Generic SCL recovery */
885 if (!bri->set_scl || !bri->get_scl) {
886 err_str = "no {get|set}_scl() found";
893 dev_err(&adap->dev, "Not using recovery: %s\n", err_str);
894 adap->bus_recovery_info = NULL;
897 static int i2c_device_probe(struct device *dev)
899 struct i2c_client *client = i2c_verify_client(dev);
900 struct i2c_driver *driver;
910 irq = of_irq_get_byname(dev->of_node, "irq");
911 if (irq == -EINVAL || irq == -ENODATA)
912 irq = of_irq_get(dev->of_node, 0);
913 } else if (ACPI_COMPANION(dev)) {
914 irq = acpi_dev_gpio_irq_get(ACPI_COMPANION(dev), 0);
916 if (irq == -EPROBE_DEFER)
924 driver = to_i2c_driver(dev->driver);
925 if (!driver->probe || !driver->id_table)
928 if (client->flags & I2C_CLIENT_WAKE) {
929 int wakeirq = -ENOENT;
932 wakeirq = of_irq_get_byname(dev->of_node, "wakeup");
933 if (wakeirq == -EPROBE_DEFER)
937 device_init_wakeup(&client->dev, true);
939 if (wakeirq > 0 && wakeirq != client->irq)
940 status = dev_pm_set_dedicated_wake_irq(dev, wakeirq);
941 else if (client->irq > 0)
942 status = dev_pm_set_wake_irq(dev, client->irq);
947 dev_warn(&client->dev, "failed to set up wakeup irq\n");
950 dev_dbg(dev, "probe\n");
952 status = of_clk_set_defaults(dev->of_node, false);
954 goto err_clear_wakeup_irq;
956 status = dev_pm_domain_attach(&client->dev, true);
957 if (status == -EPROBE_DEFER)
958 goto err_clear_wakeup_irq;
960 status = driver->probe(client, i2c_match_id(driver->id_table, client));
962 goto err_detach_pm_domain;
966 err_detach_pm_domain:
967 dev_pm_domain_detach(&client->dev, true);
968 err_clear_wakeup_irq:
969 dev_pm_clear_wake_irq(&client->dev);
970 device_init_wakeup(&client->dev, false);
974 static int i2c_device_remove(struct device *dev)
976 struct i2c_client *client = i2c_verify_client(dev);
977 struct i2c_driver *driver;
980 if (!client || !dev->driver)
983 driver = to_i2c_driver(dev->driver);
984 if (driver->remove) {
985 dev_dbg(dev, "remove\n");
986 status = driver->remove(client);
989 dev_pm_domain_detach(&client->dev, true);
991 dev_pm_clear_wake_irq(&client->dev);
992 device_init_wakeup(&client->dev, false);
997 static void i2c_device_shutdown(struct device *dev)
999 struct i2c_client *client = i2c_verify_client(dev);
1000 struct i2c_driver *driver;
1002 if (!client || !dev->driver)
1004 driver = to_i2c_driver(dev->driver);
1005 if (driver->shutdown)
1006 driver->shutdown(client);
1007 else if (client->irq > 0)
1008 disable_irq(client->irq);
1011 static void i2c_client_dev_release(struct device *dev)
1013 kfree(to_i2c_client(dev));
1017 show_name(struct device *dev, struct device_attribute *attr, char *buf)
1019 return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
1020 to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
1022 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
1025 show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
1027 struct i2c_client *client = to_i2c_client(dev);
1030 len = acpi_device_modalias(dev, buf, PAGE_SIZE -1);
1034 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
1036 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
1038 static struct attribute *i2c_dev_attrs[] = {
1039 &dev_attr_name.attr,
1040 /* modalias helps coldplug: modprobe $(cat .../modalias) */
1041 &dev_attr_modalias.attr,
1044 ATTRIBUTE_GROUPS(i2c_dev);
1046 struct bus_type i2c_bus_type = {
1048 .match = i2c_device_match,
1049 .probe = i2c_device_probe,
1050 .remove = i2c_device_remove,
1051 .shutdown = i2c_device_shutdown,
1053 EXPORT_SYMBOL_GPL(i2c_bus_type);
1055 static struct device_type i2c_client_type = {
1056 .groups = i2c_dev_groups,
1057 .uevent = i2c_device_uevent,
1058 .release = i2c_client_dev_release,
1063 * i2c_verify_client - return parameter as i2c_client, or NULL
1064 * @dev: device, probably from some driver model iterator
1066 * When traversing the driver model tree, perhaps using driver model
1067 * iterators like @device_for_each_child(), you can't assume very much
1068 * about the nodes you find. Use this function to avoid oopses caused
1069 * by wrongly treating some non-I2C device as an i2c_client.
1071 struct i2c_client *i2c_verify_client(struct device *dev)
1073 return (dev->type == &i2c_client_type)
1074 ? to_i2c_client(dev)
1077 EXPORT_SYMBOL(i2c_verify_client);
1080 /* Return a unique address which takes the flags of the client into account */
1081 static unsigned short i2c_encode_flags_to_addr(struct i2c_client *client)
1083 unsigned short addr = client->addr;
1085 /* For some client flags, add an arbitrary offset to avoid collisions */
1086 if (client->flags & I2C_CLIENT_TEN)
1087 addr |= I2C_ADDR_OFFSET_TEN_BIT;
1089 if (client->flags & I2C_CLIENT_SLAVE)
1090 addr |= I2C_ADDR_OFFSET_SLAVE;
1095 /* This is a permissive address validity check, I2C address map constraints
1096 * are purposely not enforced, except for the general call address. */
1097 static int i2c_check_addr_validity(unsigned addr, unsigned short flags)
1099 if (flags & I2C_CLIENT_TEN) {
1100 /* 10-bit address, all values are valid */
1104 /* 7-bit address, reject the general call address */
1105 if (addr == 0x00 || addr > 0x7f)
1111 /* And this is a strict address validity check, used when probing. If a
1112 * device uses a reserved address, then it shouldn't be probed. 7-bit
1113 * addressing is assumed, 10-bit address devices are rare and should be
1114 * explicitly enumerated. */
1115 static int i2c_check_7bit_addr_validity_strict(unsigned short addr)
1118 * Reserved addresses per I2C specification:
1119 * 0x00 General call address / START byte
1121 * 0x02 Reserved for different bus format
1122 * 0x03 Reserved for future purposes
1123 * 0x04-0x07 Hs-mode master code
1124 * 0x78-0x7b 10-bit slave addressing
1125 * 0x7c-0x7f Reserved for future purposes
1127 if (addr < 0x08 || addr > 0x77)
1132 static int __i2c_check_addr_busy(struct device *dev, void *addrp)
1134 struct i2c_client *client = i2c_verify_client(dev);
1135 int addr = *(int *)addrp;
1137 if (client && i2c_encode_flags_to_addr(client) == addr)
1142 /* walk up mux tree */
1143 static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
1145 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
1148 result = device_for_each_child(&adapter->dev, &addr,
1149 __i2c_check_addr_busy);
1151 if (!result && parent)
1152 result = i2c_check_mux_parents(parent, addr);
1157 /* recurse down mux tree */
1158 static int i2c_check_mux_children(struct device *dev, void *addrp)
1162 if (dev->type == &i2c_adapter_type)
1163 result = device_for_each_child(dev, addrp,
1164 i2c_check_mux_children);
1166 result = __i2c_check_addr_busy(dev, addrp);
1171 static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
1173 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
1177 result = i2c_check_mux_parents(parent, addr);
1180 result = device_for_each_child(&adapter->dev, &addr,
1181 i2c_check_mux_children);
1187 * i2c_adapter_lock_bus - Get exclusive access to an I2C bus segment
1188 * @adapter: Target I2C bus segment
1189 * @flags: I2C_LOCK_ROOT_ADAPTER locks the root i2c adapter, I2C_LOCK_SEGMENT
1190 * locks only this branch in the adapter tree
1192 static void i2c_adapter_lock_bus(struct i2c_adapter *adapter,
1195 rt_mutex_lock(&adapter->bus_lock);
1199 * i2c_adapter_trylock_bus - Try to get exclusive access to an I2C bus segment
1200 * @adapter: Target I2C bus segment
1201 * @flags: I2C_LOCK_ROOT_ADAPTER trylocks the root i2c adapter, I2C_LOCK_SEGMENT
1202 * trylocks only this branch in the adapter tree
1204 static int i2c_adapter_trylock_bus(struct i2c_adapter *adapter,
1207 return rt_mutex_trylock(&adapter->bus_lock);
1211 * i2c_adapter_unlock_bus - Release exclusive access to an I2C bus segment
1212 * @adapter: Target I2C bus segment
1213 * @flags: I2C_LOCK_ROOT_ADAPTER unlocks the root i2c adapter, I2C_LOCK_SEGMENT
1214 * unlocks only this branch in the adapter tree
1216 static void i2c_adapter_unlock_bus(struct i2c_adapter *adapter,
1219 rt_mutex_unlock(&adapter->bus_lock);
1222 static void i2c_dev_set_name(struct i2c_adapter *adap,
1223 struct i2c_client *client)
1225 struct acpi_device *adev = ACPI_COMPANION(&client->dev);
1228 dev_set_name(&client->dev, "i2c-%s", acpi_dev_name(adev));
1232 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
1233 i2c_encode_flags_to_addr(client));
1237 * i2c_new_device - instantiate an i2c device
1238 * @adap: the adapter managing the device
1239 * @info: describes one I2C device; bus_num is ignored
1240 * Context: can sleep
1242 * Create an i2c device. Binding is handled through driver model
1243 * probe()/remove() methods. A driver may be bound to this device when we
1244 * return from this function, or any later moment (e.g. maybe hotplugging will
1245 * load the driver module). This call is not appropriate for use by mainboard
1246 * initialization logic, which usually runs during an arch_initcall() long
1247 * before any i2c_adapter could exist.
1249 * This returns the new i2c client, which may be saved for later use with
1250 * i2c_unregister_device(); or NULL to indicate an error.
1253 i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
1255 struct i2c_client *client;
1258 client = kzalloc(sizeof *client, GFP_KERNEL);
1262 client->adapter = adap;
1264 client->dev.platform_data = info->platform_data;
1267 client->dev.archdata = *info->archdata;
1269 client->flags = info->flags;
1270 client->addr = info->addr;
1271 client->irq = info->irq;
1273 strlcpy(client->name, info->type, sizeof(client->name));
1275 status = i2c_check_addr_validity(client->addr, client->flags);
1277 dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
1278 client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
1279 goto out_err_silent;
1282 /* Check for address business */
1283 status = i2c_check_addr_busy(adap, i2c_encode_flags_to_addr(client));
1287 client->dev.parent = &client->adapter->dev;
1288 client->dev.bus = &i2c_bus_type;
1289 client->dev.type = &i2c_client_type;
1290 client->dev.of_node = info->of_node;
1291 client->dev.fwnode = info->fwnode;
1293 i2c_dev_set_name(adap, client);
1294 status = device_register(&client->dev);
1298 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
1299 client->name, dev_name(&client->dev));
1305 "Failed to register i2c client %s at 0x%02x (%d)\n",
1306 client->name, client->addr, status);
1311 EXPORT_SYMBOL_GPL(i2c_new_device);
1315 * i2c_unregister_device - reverse effect of i2c_new_device()
1316 * @client: value returned from i2c_new_device()
1317 * Context: can sleep
1319 void i2c_unregister_device(struct i2c_client *client)
1321 if (client->dev.of_node)
1322 of_node_clear_flag(client->dev.of_node, OF_POPULATED);
1323 if (ACPI_COMPANION(&client->dev))
1324 acpi_device_clear_enumerated(ACPI_COMPANION(&client->dev));
1325 device_unregister(&client->dev);
1327 EXPORT_SYMBOL_GPL(i2c_unregister_device);
1330 static const struct i2c_device_id dummy_id[] = {
1335 static int dummy_probe(struct i2c_client *client,
1336 const struct i2c_device_id *id)
1341 static int dummy_remove(struct i2c_client *client)
1346 static struct i2c_driver dummy_driver = {
1347 .driver.name = "dummy",
1348 .probe = dummy_probe,
1349 .remove = dummy_remove,
1350 .id_table = dummy_id,
1354 * i2c_new_dummy - return a new i2c device bound to a dummy driver
1355 * @adapter: the adapter managing the device
1356 * @address: seven bit address to be used
1357 * Context: can sleep
1359 * This returns an I2C client bound to the "dummy" driver, intended for use
1360 * with devices that consume multiple addresses. Examples of such chips
1361 * include various EEPROMS (like 24c04 and 24c08 models).
1363 * These dummy devices have two main uses. First, most I2C and SMBus calls
1364 * except i2c_transfer() need a client handle; the dummy will be that handle.
1365 * And second, this prevents the specified address from being bound to a
1368 * This returns the new i2c client, which should be saved for later use with
1369 * i2c_unregister_device(); or NULL to indicate an error.
1371 struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
1373 struct i2c_board_info info = {
1374 I2C_BOARD_INFO("dummy", address),
1377 return i2c_new_device(adapter, &info);
1379 EXPORT_SYMBOL_GPL(i2c_new_dummy);
1382 * i2c_new_secondary_device - Helper to get the instantiated secondary address
1383 * and create the associated device
1384 * @client: Handle to the primary client
1385 * @name: Handle to specify which secondary address to get
1386 * @default_addr: Used as a fallback if no secondary address was specified
1387 * Context: can sleep
1389 * I2C clients can be composed of multiple I2C slaves bound together in a single
1390 * component. The I2C client driver then binds to the master I2C slave and needs
1391 * to create I2C dummy clients to communicate with all the other slaves.
1393 * This function creates and returns an I2C dummy client whose I2C address is
1394 * retrieved from the platform firmware based on the given slave name. If no
1395 * address is specified by the firmware default_addr is used.
1397 * On DT-based platforms the address is retrieved from the "reg" property entry
1398 * cell whose "reg-names" value matches the slave name.
1400 * This returns the new i2c client, which should be saved for later use with
1401 * i2c_unregister_device(); or NULL to indicate an error.
1403 struct i2c_client *i2c_new_secondary_device(struct i2c_client *client,
1407 struct device_node *np = client->dev.of_node;
1408 u32 addr = default_addr;
1412 i = of_property_match_string(np, "reg-names", name);
1414 of_property_read_u32_index(np, "reg", i, &addr);
1417 dev_dbg(&client->adapter->dev, "Address for %s : 0x%x\n", name, addr);
1418 return i2c_new_dummy(client->adapter, addr);
1420 EXPORT_SYMBOL_GPL(i2c_new_secondary_device);
1422 /* ------------------------------------------------------------------------- */
1424 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
1426 static void i2c_adapter_dev_release(struct device *dev)
1428 struct i2c_adapter *adap = to_i2c_adapter(dev);
1429 complete(&adap->dev_released);
1432 unsigned int i2c_adapter_depth(struct i2c_adapter *adapter)
1434 unsigned int depth = 0;
1436 while ((adapter = i2c_parent_is_i2c_adapter(adapter)))
1439 WARN_ONCE(depth >= MAX_LOCKDEP_SUBCLASSES,
1440 "adapter depth exceeds lockdep subclass limit\n");
1444 EXPORT_SYMBOL_GPL(i2c_adapter_depth);
1447 * Let users instantiate I2C devices through sysfs. This can be used when
1448 * platform initialization code doesn't contain the proper data for
1449 * whatever reason. Also useful for drivers that do device detection and
1450 * detection fails, either because the device uses an unexpected address,
1451 * or this is a compatible device with different ID register values.
1453 * Parameter checking may look overzealous, but we really don't want
1454 * the user to provide incorrect parameters.
1457 i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
1458 const char *buf, size_t count)
1460 struct i2c_adapter *adap = to_i2c_adapter(dev);
1461 struct i2c_board_info info;
1462 struct i2c_client *client;
1466 memset(&info, 0, sizeof(struct i2c_board_info));
1468 blank = strchr(buf, ' ');
1470 dev_err(dev, "%s: Missing parameters\n", "new_device");
1473 if (blank - buf > I2C_NAME_SIZE - 1) {
1474 dev_err(dev, "%s: Invalid device name\n", "new_device");
1477 memcpy(info.type, buf, blank - buf);
1479 /* Parse remaining parameters, reject extra parameters */
1480 res = sscanf(++blank, "%hi%c", &info.addr, &end);
1482 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
1485 if (res > 1 && end != '\n') {
1486 dev_err(dev, "%s: Extra parameters\n", "new_device");
1490 if ((info.addr & I2C_ADDR_OFFSET_TEN_BIT) == I2C_ADDR_OFFSET_TEN_BIT) {
1491 info.addr &= ~I2C_ADDR_OFFSET_TEN_BIT;
1492 info.flags |= I2C_CLIENT_TEN;
1495 if (info.addr & I2C_ADDR_OFFSET_SLAVE) {
1496 info.addr &= ~I2C_ADDR_OFFSET_SLAVE;
1497 info.flags |= I2C_CLIENT_SLAVE;
1500 client = i2c_new_device(adap, &info);
1504 /* Keep track of the added device */
1505 mutex_lock(&adap->userspace_clients_lock);
1506 list_add_tail(&client->detected, &adap->userspace_clients);
1507 mutex_unlock(&adap->userspace_clients_lock);
1508 dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
1509 info.type, info.addr);
1513 static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
1516 * And of course let the users delete the devices they instantiated, if
1517 * they got it wrong. This interface can only be used to delete devices
1518 * instantiated by i2c_sysfs_new_device above. This guarantees that we
1519 * don't delete devices to which some kernel code still has references.
1521 * Parameter checking may look overzealous, but we really don't want
1522 * the user to delete the wrong device.
1525 i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
1526 const char *buf, size_t count)
1528 struct i2c_adapter *adap = to_i2c_adapter(dev);
1529 struct i2c_client *client, *next;
1530 unsigned short addr;
1534 /* Parse parameters, reject extra parameters */
1535 res = sscanf(buf, "%hi%c", &addr, &end);
1537 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
1540 if (res > 1 && end != '\n') {
1541 dev_err(dev, "%s: Extra parameters\n", "delete_device");
1545 /* Make sure the device was added through sysfs */
1547 mutex_lock_nested(&adap->userspace_clients_lock,
1548 i2c_adapter_depth(adap));
1549 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1551 if (i2c_encode_flags_to_addr(client) == addr) {
1552 dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
1553 "delete_device", client->name, client->addr);
1555 list_del(&client->detected);
1556 i2c_unregister_device(client);
1561 mutex_unlock(&adap->userspace_clients_lock);
1564 dev_err(dev, "%s: Can't find device in list\n",
1568 static DEVICE_ATTR_IGNORE_LOCKDEP(delete_device, S_IWUSR, NULL,
1569 i2c_sysfs_delete_device);
1571 static struct attribute *i2c_adapter_attrs[] = {
1572 &dev_attr_name.attr,
1573 &dev_attr_new_device.attr,
1574 &dev_attr_delete_device.attr,
1577 ATTRIBUTE_GROUPS(i2c_adapter);
1579 struct device_type i2c_adapter_type = {
1580 .groups = i2c_adapter_groups,
1581 .release = i2c_adapter_dev_release,
1583 EXPORT_SYMBOL_GPL(i2c_adapter_type);
1586 * i2c_verify_adapter - return parameter as i2c_adapter or NULL
1587 * @dev: device, probably from some driver model iterator
1589 * When traversing the driver model tree, perhaps using driver model
1590 * iterators like @device_for_each_child(), you can't assume very much
1591 * about the nodes you find. Use this function to avoid oopses caused
1592 * by wrongly treating some non-I2C device as an i2c_adapter.
1594 struct i2c_adapter *i2c_verify_adapter(struct device *dev)
1596 return (dev->type == &i2c_adapter_type)
1597 ? to_i2c_adapter(dev)
1600 EXPORT_SYMBOL(i2c_verify_adapter);
1602 #ifdef CONFIG_I2C_COMPAT
1603 static struct class_compat *i2c_adapter_compat_class;
1606 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
1608 struct i2c_devinfo *devinfo;
1610 down_read(&__i2c_board_lock);
1611 list_for_each_entry(devinfo, &__i2c_board_list, list) {
1612 if (devinfo->busnum == adapter->nr
1613 && !i2c_new_device(adapter,
1614 &devinfo->board_info))
1615 dev_err(&adapter->dev,
1616 "Can't create device at 0x%02x\n",
1617 devinfo->board_info.addr);
1619 up_read(&__i2c_board_lock);
1622 /* OF support code */
1624 #if IS_ENABLED(CONFIG_OF)
1625 static struct i2c_client *of_i2c_register_device(struct i2c_adapter *adap,
1626 struct device_node *node)
1628 struct i2c_client *result;
1629 struct i2c_board_info info = {};
1630 struct dev_archdata dev_ad = {};
1631 const __be32 *addr_be;
1635 dev_dbg(&adap->dev, "of_i2c: register %s\n", node->full_name);
1637 if (of_modalias_node(node, info.type, sizeof(info.type)) < 0) {
1638 dev_err(&adap->dev, "of_i2c: modalias failure on %s\n",
1640 return ERR_PTR(-EINVAL);
1643 addr_be = of_get_property(node, "reg", &len);
1644 if (!addr_be || (len < sizeof(*addr_be))) {
1645 dev_err(&adap->dev, "of_i2c: invalid reg on %s\n",
1647 return ERR_PTR(-EINVAL);
1650 addr = be32_to_cpup(addr_be);
1651 if (addr & I2C_TEN_BIT_ADDRESS) {
1652 addr &= ~I2C_TEN_BIT_ADDRESS;
1653 info.flags |= I2C_CLIENT_TEN;
1656 if (addr & I2C_OWN_SLAVE_ADDRESS) {
1657 addr &= ~I2C_OWN_SLAVE_ADDRESS;
1658 info.flags |= I2C_CLIENT_SLAVE;
1661 if (i2c_check_addr_validity(addr, info.flags)) {
1662 dev_err(&adap->dev, "of_i2c: invalid addr=%x on %s\n",
1663 addr, node->full_name);
1664 return ERR_PTR(-EINVAL);
1668 info.of_node = of_node_get(node);
1669 info.archdata = &dev_ad;
1671 if (of_get_property(node, "wakeup-source", NULL))
1672 info.flags |= I2C_CLIENT_WAKE;
1674 result = i2c_new_device(adap, &info);
1675 if (result == NULL) {
1676 dev_err(&adap->dev, "of_i2c: Failure registering %s\n",
1679 return ERR_PTR(-EINVAL);
1684 static void of_i2c_register_devices(struct i2c_adapter *adap)
1686 struct device_node *bus, *node;
1687 struct i2c_client *client;
1689 /* Only register child devices if the adapter has a node pointer set */
1690 if (!adap->dev.of_node)
1693 dev_dbg(&adap->dev, "of_i2c: walking child nodes\n");
1695 bus = of_get_child_by_name(adap->dev.of_node, "i2c-bus");
1697 bus = of_node_get(adap->dev.of_node);
1699 for_each_available_child_of_node(bus, node) {
1700 if (of_node_test_and_set_flag(node, OF_POPULATED))
1703 client = of_i2c_register_device(adap, node);
1704 if (IS_ERR(client)) {
1705 dev_warn(&adap->dev,
1706 "Failed to create I2C device for %s\n",
1708 of_node_clear_flag(node, OF_POPULATED);
1715 static int of_dev_node_match(struct device *dev, void *data)
1717 return dev->of_node == data;
1720 /* must call put_device() when done with returned i2c_client device */
1721 struct i2c_client *of_find_i2c_device_by_node(struct device_node *node)
1724 struct i2c_client *client;
1726 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
1730 client = i2c_verify_client(dev);
1736 EXPORT_SYMBOL(of_find_i2c_device_by_node);
1738 /* must call put_device() when done with returned i2c_adapter device */
1739 struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node)
1742 struct i2c_adapter *adapter;
1744 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
1748 adapter = i2c_verify_adapter(dev);
1754 EXPORT_SYMBOL(of_find_i2c_adapter_by_node);
1756 /* must call i2c_put_adapter() when done with returned i2c_adapter device */
1757 struct i2c_adapter *of_get_i2c_adapter_by_node(struct device_node *node)
1759 struct i2c_adapter *adapter;
1761 adapter = of_find_i2c_adapter_by_node(node);
1765 if (!try_module_get(adapter->owner)) {
1766 put_device(&adapter->dev);
1772 EXPORT_SYMBOL(of_get_i2c_adapter_by_node);
1774 static void of_i2c_register_devices(struct i2c_adapter *adap) { }
1775 #endif /* CONFIG_OF */
1777 static int i2c_do_add_adapter(struct i2c_driver *driver,
1778 struct i2c_adapter *adap)
1780 /* Detect supported devices on that bus, and instantiate them */
1781 i2c_detect(adap, driver);
1783 /* Let legacy drivers scan this bus for matching devices */
1784 if (driver->attach_adapter) {
1785 dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
1786 driver->driver.name);
1787 dev_warn(&adap->dev,
1788 "Please use another way to instantiate your i2c_client\n");
1789 /* We ignore the return code; if it fails, too bad */
1790 driver->attach_adapter(adap);
1795 static int __process_new_adapter(struct device_driver *d, void *data)
1797 return i2c_do_add_adapter(to_i2c_driver(d), data);
1800 static const struct i2c_lock_operations i2c_adapter_lock_ops = {
1801 .lock_bus = i2c_adapter_lock_bus,
1802 .trylock_bus = i2c_adapter_trylock_bus,
1803 .unlock_bus = i2c_adapter_unlock_bus,
1806 static int i2c_register_adapter(struct i2c_adapter *adap)
1810 /* Can't register until after driver model init */
1811 if (WARN_ON(!is_registered)) {
1817 if (WARN(!adap->name[0], "i2c adapter has no name"))
1821 pr_err("adapter '%s': no algo supplied!\n", adap->name);
1825 if (!adap->lock_ops)
1826 adap->lock_ops = &i2c_adapter_lock_ops;
1828 rt_mutex_init(&adap->bus_lock);
1829 rt_mutex_init(&adap->mux_lock);
1830 mutex_init(&adap->userspace_clients_lock);
1831 INIT_LIST_HEAD(&adap->userspace_clients);
1833 /* Set default timeout to 1 second if not already set */
1834 if (adap->timeout == 0)
1837 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
1838 adap->dev.bus = &i2c_bus_type;
1839 adap->dev.type = &i2c_adapter_type;
1840 res = device_register(&adap->dev);
1842 pr_err("adapter '%s': can't register device (%d)\n", adap->name, res);
1846 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
1848 pm_runtime_no_callbacks(&adap->dev);
1849 pm_suspend_ignore_children(&adap->dev, true);
1850 pm_runtime_enable(&adap->dev);
1852 #ifdef CONFIG_I2C_COMPAT
1853 res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
1856 dev_warn(&adap->dev,
1857 "Failed to create compatibility class link\n");
1860 i2c_init_recovery(adap);
1862 /* create pre-declared device nodes */
1863 of_i2c_register_devices(adap);
1864 i2c_acpi_install_space_handler(adap);
1865 i2c_acpi_register_devices(adap);
1867 if (adap->nr < __i2c_first_dynamic_bus_num)
1868 i2c_scan_static_board_info(adap);
1870 /* Notify drivers */
1871 mutex_lock(&core_lock);
1872 bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
1873 mutex_unlock(&core_lock);
1878 mutex_lock(&core_lock);
1879 idr_remove(&i2c_adapter_idr, adap->nr);
1880 mutex_unlock(&core_lock);
1885 * __i2c_add_numbered_adapter - i2c_add_numbered_adapter where nr is never -1
1886 * @adap: the adapter to register (with adap->nr initialized)
1887 * Context: can sleep
1889 * See i2c_add_numbered_adapter() for details.
1891 static int __i2c_add_numbered_adapter(struct i2c_adapter *adap)
1895 mutex_lock(&core_lock);
1896 id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1, GFP_KERNEL);
1897 mutex_unlock(&core_lock);
1898 if (WARN(id < 0, "couldn't get idr"))
1899 return id == -ENOSPC ? -EBUSY : id;
1901 return i2c_register_adapter(adap);
1905 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
1906 * @adapter: the adapter to add
1907 * Context: can sleep
1909 * This routine is used to declare an I2C adapter when its bus number
1910 * doesn't matter or when its bus number is specified by an dt alias.
1911 * Examples of bases when the bus number doesn't matter: I2C adapters
1912 * dynamically added by USB links or PCI plugin cards.
1914 * When this returns zero, a new bus number was allocated and stored
1915 * in adap->nr, and the specified adapter became available for clients.
1916 * Otherwise, a negative errno value is returned.
1918 int i2c_add_adapter(struct i2c_adapter *adapter)
1920 struct device *dev = &adapter->dev;
1924 id = of_alias_get_id(dev->of_node, "i2c");
1927 return __i2c_add_numbered_adapter(adapter);
1931 mutex_lock(&core_lock);
1932 id = idr_alloc(&i2c_adapter_idr, adapter,
1933 __i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
1934 mutex_unlock(&core_lock);
1935 if (WARN(id < 0, "couldn't get idr"))
1940 return i2c_register_adapter(adapter);
1942 EXPORT_SYMBOL(i2c_add_adapter);
1945 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
1946 * @adap: the adapter to register (with adap->nr initialized)
1947 * Context: can sleep
1949 * This routine is used to declare an I2C adapter when its bus number
1950 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
1951 * or otherwise built in to the system's mainboard, and where i2c_board_info
1952 * is used to properly configure I2C devices.
1954 * If the requested bus number is set to -1, then this function will behave
1955 * identically to i2c_add_adapter, and will dynamically assign a bus number.
1957 * If no devices have pre-been declared for this bus, then be sure to
1958 * register the adapter before any dynamically allocated ones. Otherwise
1959 * the required bus ID may not be available.
1961 * When this returns zero, the specified adapter became available for
1962 * clients using the bus number provided in adap->nr. Also, the table
1963 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
1964 * and the appropriate driver model device nodes are created. Otherwise, a
1965 * negative errno value is returned.
1967 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
1969 if (adap->nr == -1) /* -1 means dynamically assign bus id */
1970 return i2c_add_adapter(adap);
1972 return __i2c_add_numbered_adapter(adap);
1974 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
1976 static void i2c_do_del_adapter(struct i2c_driver *driver,
1977 struct i2c_adapter *adapter)
1979 struct i2c_client *client, *_n;
1981 /* Remove the devices we created ourselves as the result of hardware
1982 * probing (using a driver's detect method) */
1983 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
1984 if (client->adapter == adapter) {
1985 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
1986 client->name, client->addr);
1987 list_del(&client->detected);
1988 i2c_unregister_device(client);
1993 static int __unregister_client(struct device *dev, void *dummy)
1995 struct i2c_client *client = i2c_verify_client(dev);
1996 if (client && strcmp(client->name, "dummy"))
1997 i2c_unregister_device(client);
2001 static int __unregister_dummy(struct device *dev, void *dummy)
2003 struct i2c_client *client = i2c_verify_client(dev);
2005 i2c_unregister_device(client);
2009 static int __process_removed_adapter(struct device_driver *d, void *data)
2011 i2c_do_del_adapter(to_i2c_driver(d), data);
2016 * i2c_del_adapter - unregister I2C adapter
2017 * @adap: the adapter being unregistered
2018 * Context: can sleep
2020 * This unregisters an I2C adapter which was previously registered
2021 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
2023 void i2c_del_adapter(struct i2c_adapter *adap)
2025 struct i2c_adapter *found;
2026 struct i2c_client *client, *next;
2028 /* First make sure that this adapter was ever added */
2029 mutex_lock(&core_lock);
2030 found = idr_find(&i2c_adapter_idr, adap->nr);
2031 mutex_unlock(&core_lock);
2032 if (found != adap) {
2033 pr_debug("attempting to delete unregistered adapter [%s]\n", adap->name);
2037 i2c_acpi_remove_space_handler(adap);
2038 /* Tell drivers about this removal */
2039 mutex_lock(&core_lock);
2040 bus_for_each_drv(&i2c_bus_type, NULL, adap,
2041 __process_removed_adapter);
2042 mutex_unlock(&core_lock);
2044 /* Remove devices instantiated from sysfs */
2045 mutex_lock_nested(&adap->userspace_clients_lock,
2046 i2c_adapter_depth(adap));
2047 list_for_each_entry_safe(client, next, &adap->userspace_clients,
2049 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
2051 list_del(&client->detected);
2052 i2c_unregister_device(client);
2054 mutex_unlock(&adap->userspace_clients_lock);
2056 /* Detach any active clients. This can't fail, thus we do not
2057 * check the returned value. This is a two-pass process, because
2058 * we can't remove the dummy devices during the first pass: they
2059 * could have been instantiated by real devices wishing to clean
2060 * them up properly, so we give them a chance to do that first. */
2061 device_for_each_child(&adap->dev, NULL, __unregister_client);
2062 device_for_each_child(&adap->dev, NULL, __unregister_dummy);
2064 #ifdef CONFIG_I2C_COMPAT
2065 class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
2069 /* device name is gone after device_unregister */
2070 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
2072 pm_runtime_disable(&adap->dev);
2074 /* wait until all references to the device are gone
2076 * FIXME: This is old code and should ideally be replaced by an
2077 * alternative which results in decoupling the lifetime of the struct
2078 * device from the i2c_adapter, like spi or netdev do. Any solution
2079 * should be thoroughly tested with DEBUG_KOBJECT_RELEASE enabled!
2081 init_completion(&adap->dev_released);
2082 device_unregister(&adap->dev);
2083 wait_for_completion(&adap->dev_released);
2086 mutex_lock(&core_lock);
2087 idr_remove(&i2c_adapter_idr, adap->nr);
2088 mutex_unlock(&core_lock);
2090 /* Clear the device structure in case this adapter is ever going to be
2092 memset(&adap->dev, 0, sizeof(adap->dev));
2094 EXPORT_SYMBOL(i2c_del_adapter);
2097 * i2c_parse_fw_timings - get I2C related timing parameters from firmware
2098 * @dev: The device to scan for I2C timing properties
2099 * @t: the i2c_timings struct to be filled with values
2100 * @use_defaults: bool to use sane defaults derived from the I2C specification
2101 * when properties are not found, otherwise use 0
2103 * Scan the device for the generic I2C properties describing timing parameters
2104 * for the signal and fill the given struct with the results. If a property was
2105 * not found and use_defaults was true, then maximum timings are assumed which
2106 * are derived from the I2C specification. If use_defaults is not used, the
2107 * results will be 0, so drivers can apply their own defaults later. The latter
2108 * is mainly intended for avoiding regressions of existing drivers which want
2109 * to switch to this function. New drivers almost always should use the defaults.
2112 void i2c_parse_fw_timings(struct device *dev, struct i2c_timings *t, bool use_defaults)
2116 memset(t, 0, sizeof(*t));
2118 ret = device_property_read_u32(dev, "clock-frequency", &t->bus_freq_hz);
2119 if (ret && use_defaults)
2120 t->bus_freq_hz = 100000;
2122 ret = device_property_read_u32(dev, "i2c-scl-rising-time-ns", &t->scl_rise_ns);
2123 if (ret && use_defaults) {
2124 if (t->bus_freq_hz <= 100000)
2125 t->scl_rise_ns = 1000;
2126 else if (t->bus_freq_hz <= 400000)
2127 t->scl_rise_ns = 300;
2129 t->scl_rise_ns = 120;
2132 ret = device_property_read_u32(dev, "i2c-scl-falling-time-ns", &t->scl_fall_ns);
2133 if (ret && use_defaults) {
2134 if (t->bus_freq_hz <= 400000)
2135 t->scl_fall_ns = 300;
2137 t->scl_fall_ns = 120;
2140 device_property_read_u32(dev, "i2c-scl-internal-delay-ns", &t->scl_int_delay_ns);
2142 ret = device_property_read_u32(dev, "i2c-sda-falling-time-ns", &t->sda_fall_ns);
2143 if (ret && use_defaults)
2144 t->sda_fall_ns = t->scl_fall_ns;
2146 EXPORT_SYMBOL_GPL(i2c_parse_fw_timings);
2148 /* ------------------------------------------------------------------------- */
2150 int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
2154 mutex_lock(&core_lock);
2155 res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
2156 mutex_unlock(&core_lock);
2160 EXPORT_SYMBOL_GPL(i2c_for_each_dev);
2162 static int __process_new_driver(struct device *dev, void *data)
2164 if (dev->type != &i2c_adapter_type)
2166 return i2c_do_add_adapter(data, to_i2c_adapter(dev));
2170 * An i2c_driver is used with one or more i2c_client (device) nodes to access
2171 * i2c slave chips, on a bus instance associated with some i2c_adapter.
2174 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
2178 /* Can't register until after driver model init */
2179 if (WARN_ON(!is_registered))
2182 /* add the driver to the list of i2c drivers in the driver core */
2183 driver->driver.owner = owner;
2184 driver->driver.bus = &i2c_bus_type;
2185 INIT_LIST_HEAD(&driver->clients);
2187 /* When registration returns, the driver core
2188 * will have called probe() for all matching-but-unbound devices.
2190 res = driver_register(&driver->driver);
2194 pr_debug("driver [%s] registered\n", driver->driver.name);
2196 /* Walk the adapters that are already present */
2197 i2c_for_each_dev(driver, __process_new_driver);
2201 EXPORT_SYMBOL(i2c_register_driver);
2203 static int __process_removed_driver(struct device *dev, void *data)
2205 if (dev->type == &i2c_adapter_type)
2206 i2c_do_del_adapter(data, to_i2c_adapter(dev));
2211 * i2c_del_driver - unregister I2C driver
2212 * @driver: the driver being unregistered
2213 * Context: can sleep
2215 void i2c_del_driver(struct i2c_driver *driver)
2217 i2c_for_each_dev(driver, __process_removed_driver);
2219 driver_unregister(&driver->driver);
2220 pr_debug("driver [%s] unregistered\n", driver->driver.name);
2222 EXPORT_SYMBOL(i2c_del_driver);
2224 /* ------------------------------------------------------------------------- */
2227 * i2c_use_client - increments the reference count of the i2c client structure
2228 * @client: the client being referenced
2230 * Each live reference to a client should be refcounted. The driver model does
2231 * that automatically as part of driver binding, so that most drivers don't
2232 * need to do this explicitly: they hold a reference until they're unbound
2235 * A pointer to the client with the incremented reference counter is returned.
2237 struct i2c_client *i2c_use_client(struct i2c_client *client)
2239 if (client && get_device(&client->dev))
2243 EXPORT_SYMBOL(i2c_use_client);
2246 * i2c_release_client - release a use of the i2c client structure
2247 * @client: the client being no longer referenced
2249 * Must be called when a user of a client is finished with it.
2251 void i2c_release_client(struct i2c_client *client)
2254 put_device(&client->dev);
2256 EXPORT_SYMBOL(i2c_release_client);
2258 struct i2c_cmd_arg {
2263 static int i2c_cmd(struct device *dev, void *_arg)
2265 struct i2c_client *client = i2c_verify_client(dev);
2266 struct i2c_cmd_arg *arg = _arg;
2267 struct i2c_driver *driver;
2269 if (!client || !client->dev.driver)
2272 driver = to_i2c_driver(client->dev.driver);
2273 if (driver->command)
2274 driver->command(client, arg->cmd, arg->arg);
2278 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
2280 struct i2c_cmd_arg cmd_arg;
2284 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
2286 EXPORT_SYMBOL(i2c_clients_command);
2288 #if IS_ENABLED(CONFIG_OF_DYNAMIC)
2289 static int of_i2c_notify(struct notifier_block *nb, unsigned long action,
2292 struct of_reconfig_data *rd = arg;
2293 struct i2c_adapter *adap;
2294 struct i2c_client *client;
2296 switch (of_reconfig_get_state_change(action, rd)) {
2297 case OF_RECONFIG_CHANGE_ADD:
2298 adap = of_find_i2c_adapter_by_node(rd->dn->parent);
2300 return NOTIFY_OK; /* not for us */
2302 if (of_node_test_and_set_flag(rd->dn, OF_POPULATED)) {
2303 put_device(&adap->dev);
2307 client = of_i2c_register_device(adap, rd->dn);
2308 put_device(&adap->dev);
2310 if (IS_ERR(client)) {
2311 dev_err(&adap->dev, "failed to create client for '%s'\n",
2313 of_node_clear_flag(rd->dn, OF_POPULATED);
2314 return notifier_from_errno(PTR_ERR(client));
2317 case OF_RECONFIG_CHANGE_REMOVE:
2318 /* already depopulated? */
2319 if (!of_node_check_flag(rd->dn, OF_POPULATED))
2322 /* find our device by node */
2323 client = of_find_i2c_device_by_node(rd->dn);
2325 return NOTIFY_OK; /* no? not meant for us */
2327 /* unregister takes one ref away */
2328 i2c_unregister_device(client);
2330 /* and put the reference of the find */
2331 put_device(&client->dev);
2337 static struct notifier_block i2c_of_notifier = {
2338 .notifier_call = of_i2c_notify,
2341 extern struct notifier_block i2c_of_notifier;
2342 #endif /* CONFIG_OF_DYNAMIC */
2344 static int __init i2c_init(void)
2348 retval = of_alias_get_highest_id("i2c");
2350 down_write(&__i2c_board_lock);
2351 if (retval >= __i2c_first_dynamic_bus_num)
2352 __i2c_first_dynamic_bus_num = retval + 1;
2353 up_write(&__i2c_board_lock);
2355 retval = bus_register(&i2c_bus_type);
2359 is_registered = true;
2361 #ifdef CONFIG_I2C_COMPAT
2362 i2c_adapter_compat_class = class_compat_register("i2c-adapter");
2363 if (!i2c_adapter_compat_class) {
2368 retval = i2c_add_driver(&dummy_driver);
2372 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2373 WARN_ON(of_reconfig_notifier_register(&i2c_of_notifier));
2374 if (IS_ENABLED(CONFIG_ACPI))
2375 WARN_ON(acpi_reconfig_notifier_register(&i2c_acpi_notifier));
2380 #ifdef CONFIG_I2C_COMPAT
2381 class_compat_unregister(i2c_adapter_compat_class);
2384 is_registered = false;
2385 bus_unregister(&i2c_bus_type);
2389 static void __exit i2c_exit(void)
2391 if (IS_ENABLED(CONFIG_ACPI))
2392 WARN_ON(acpi_reconfig_notifier_unregister(&i2c_acpi_notifier));
2393 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2394 WARN_ON(of_reconfig_notifier_unregister(&i2c_of_notifier));
2395 i2c_del_driver(&dummy_driver);
2396 #ifdef CONFIG_I2C_COMPAT
2397 class_compat_unregister(i2c_adapter_compat_class);
2399 bus_unregister(&i2c_bus_type);
2400 tracepoint_synchronize_unregister();
2403 /* We must initialize early, because some subsystems register i2c drivers
2404 * in subsys_initcall() code, but are linked (and initialized) before i2c.
2406 postcore_initcall(i2c_init);
2407 module_exit(i2c_exit);
2409 /* ----------------------------------------------------
2410 * the functional interface to the i2c busses.
2411 * ----------------------------------------------------
2414 /* Check if val is exceeding the quirk IFF quirk is non 0 */
2415 #define i2c_quirk_exceeded(val, quirk) ((quirk) && ((val) > (quirk)))
2417 static int i2c_quirk_error(struct i2c_adapter *adap, struct i2c_msg *msg, char *err_msg)
2419 dev_err_ratelimited(&adap->dev, "adapter quirk: %s (addr 0x%04x, size %u, %s)\n",
2420 err_msg, msg->addr, msg->len,
2421 msg->flags & I2C_M_RD ? "read" : "write");
2425 static int i2c_check_for_quirks(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2427 const struct i2c_adapter_quirks *q = adap->quirks;
2428 int max_num = q->max_num_msgs, i;
2429 bool do_len_check = true;
2431 if (q->flags & I2C_AQ_COMB) {
2434 /* special checks for combined messages */
2436 if (q->flags & I2C_AQ_COMB_WRITE_FIRST && msgs[0].flags & I2C_M_RD)
2437 return i2c_quirk_error(adap, &msgs[0], "1st comb msg must be write");
2439 if (q->flags & I2C_AQ_COMB_READ_SECOND && !(msgs[1].flags & I2C_M_RD))
2440 return i2c_quirk_error(adap, &msgs[1], "2nd comb msg must be read");
2442 if (q->flags & I2C_AQ_COMB_SAME_ADDR && msgs[0].addr != msgs[1].addr)
2443 return i2c_quirk_error(adap, &msgs[0], "comb msg only to same addr");
2445 if (i2c_quirk_exceeded(msgs[0].len, q->max_comb_1st_msg_len))
2446 return i2c_quirk_error(adap, &msgs[0], "msg too long");
2448 if (i2c_quirk_exceeded(msgs[1].len, q->max_comb_2nd_msg_len))
2449 return i2c_quirk_error(adap, &msgs[1], "msg too long");
2451 do_len_check = false;
2455 if (i2c_quirk_exceeded(num, max_num))
2456 return i2c_quirk_error(adap, &msgs[0], "too many messages");
2458 for (i = 0; i < num; i++) {
2459 u16 len = msgs[i].len;
2461 if (msgs[i].flags & I2C_M_RD) {
2462 if (do_len_check && i2c_quirk_exceeded(len, q->max_read_len))
2463 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2465 if (do_len_check && i2c_quirk_exceeded(len, q->max_write_len))
2466 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2474 * __i2c_transfer - unlocked flavor of i2c_transfer
2475 * @adap: Handle to I2C bus
2476 * @msgs: One or more messages to execute before STOP is issued to
2477 * terminate the operation; each message begins with a START.
2478 * @num: Number of messages to be executed.
2480 * Returns negative errno, else the number of messages executed.
2482 * Adapter lock must be held when calling this function. No debug logging
2483 * takes place. adap->algo->master_xfer existence isn't checked.
2485 int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2487 unsigned long orig_jiffies;
2490 if (adap->quirks && i2c_check_for_quirks(adap, msgs, num))
2493 /* i2c_trace_msg gets enabled when tracepoint i2c_transfer gets
2494 * enabled. This is an efficient way of keeping the for-loop from
2495 * being executed when not needed.
2497 if (static_key_false(&i2c_trace_msg)) {
2499 for (i = 0; i < num; i++)
2500 if (msgs[i].flags & I2C_M_RD)
2501 trace_i2c_read(adap, &msgs[i], i);
2503 trace_i2c_write(adap, &msgs[i], i);
2506 /* Retry automatically on arbitration loss */
2507 orig_jiffies = jiffies;
2508 for (ret = 0, try = 0; try <= adap->retries; try++) {
2509 ret = adap->algo->master_xfer(adap, msgs, num);
2512 if (time_after(jiffies, orig_jiffies + adap->timeout))
2516 if (static_key_false(&i2c_trace_msg)) {
2518 for (i = 0; i < ret; i++)
2519 if (msgs[i].flags & I2C_M_RD)
2520 trace_i2c_reply(adap, &msgs[i], i);
2521 trace_i2c_result(adap, i, ret);
2526 EXPORT_SYMBOL(__i2c_transfer);
2529 * i2c_transfer - execute a single or combined I2C message
2530 * @adap: Handle to I2C bus
2531 * @msgs: One or more messages to execute before STOP is issued to
2532 * terminate the operation; each message begins with a START.
2533 * @num: Number of messages to be executed.
2535 * Returns negative errno, else the number of messages executed.
2537 * Note that there is no requirement that each message be sent to
2538 * the same slave address, although that is the most common model.
2540 int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2544 /* REVISIT the fault reporting model here is weak:
2546 * - When we get an error after receiving N bytes from a slave,
2547 * there is no way to report "N".
2549 * - When we get a NAK after transmitting N bytes to a slave,
2550 * there is no way to report "N" ... or to let the master
2551 * continue executing the rest of this combined message, if
2552 * that's the appropriate response.
2554 * - When for example "num" is two and we successfully complete
2555 * the first message but get an error part way through the
2556 * second, it's unclear whether that should be reported as
2557 * one (discarding status on the second message) or errno
2558 * (discarding status on the first one).
2561 if (adap->algo->master_xfer) {
2563 for (ret = 0; ret < num; ret++) {
2565 "master_xfer[%d] %c, addr=0x%02x, len=%d%s\n",
2566 ret, (msgs[ret].flags & I2C_M_RD) ? 'R' : 'W',
2567 msgs[ret].addr, msgs[ret].len,
2568 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
2572 if (in_atomic() || irqs_disabled()) {
2573 ret = i2c_trylock_bus(adap, I2C_LOCK_SEGMENT);
2575 /* I2C activity is ongoing. */
2578 i2c_lock_bus(adap, I2C_LOCK_SEGMENT);
2581 ret = __i2c_transfer(adap, msgs, num);
2582 i2c_unlock_bus(adap, I2C_LOCK_SEGMENT);
2586 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
2590 EXPORT_SYMBOL(i2c_transfer);
2593 * i2c_master_send - issue a single I2C message in master transmit mode
2594 * @client: Handle to slave device
2595 * @buf: Data that will be written to the slave
2596 * @count: How many bytes to write, must be less than 64k since msg.len is u16
2598 * Returns negative errno, or else the number of bytes written.
2600 int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
2603 struct i2c_adapter *adap = client->adapter;
2606 msg.addr = client->addr;
2607 msg.flags = client->flags & I2C_M_TEN;
2609 msg.buf = (char *)buf;
2611 ret = i2c_transfer(adap, &msg, 1);
2614 * If everything went ok (i.e. 1 msg transmitted), return #bytes
2615 * transmitted, else error code.
2617 return (ret == 1) ? count : ret;
2619 EXPORT_SYMBOL(i2c_master_send);
2622 * i2c_master_recv - issue a single I2C message in master receive mode
2623 * @client: Handle to slave device
2624 * @buf: Where to store data read from slave
2625 * @count: How many bytes to read, must be less than 64k since msg.len is u16
2627 * Returns negative errno, or else the number of bytes read.
2629 int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
2631 struct i2c_adapter *adap = client->adapter;
2635 msg.addr = client->addr;
2636 msg.flags = client->flags & I2C_M_TEN;
2637 msg.flags |= I2C_M_RD;
2641 ret = i2c_transfer(adap, &msg, 1);
2644 * If everything went ok (i.e. 1 msg received), return #bytes received,
2647 return (ret == 1) ? count : ret;
2649 EXPORT_SYMBOL(i2c_master_recv);
2651 /* ----------------------------------------------------
2652 * the i2c address scanning function
2653 * Will not work for 10-bit addresses!
2654 * ----------------------------------------------------
2658 * Legacy default probe function, mostly relevant for SMBus. The default
2659 * probe method is a quick write, but it is known to corrupt the 24RF08
2660 * EEPROMs due to a state machine bug, and could also irreversibly
2661 * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
2662 * we use a short byte read instead. Also, some bus drivers don't implement
2663 * quick write, so we fallback to a byte read in that case too.
2664 * On x86, there is another special case for FSC hardware monitoring chips,
2665 * which want regular byte reads (address 0x73.) Fortunately, these are the
2666 * only known chips using this I2C address on PC hardware.
2667 * Returns 1 if probe succeeded, 0 if not.
2669 static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
2672 union i2c_smbus_data dummy;
2675 if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
2676 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
2677 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2678 I2C_SMBUS_BYTE_DATA, &dummy);
2681 if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
2682 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
2683 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
2684 I2C_SMBUS_QUICK, NULL);
2685 else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
2686 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2687 I2C_SMBUS_BYTE, &dummy);
2689 dev_warn(&adap->dev, "No suitable probing method supported for address 0x%02X\n",
2697 static int i2c_detect_address(struct i2c_client *temp_client,
2698 struct i2c_driver *driver)
2700 struct i2c_board_info info;
2701 struct i2c_adapter *adapter = temp_client->adapter;
2702 int addr = temp_client->addr;
2705 /* Make sure the address is valid */
2706 err = i2c_check_7bit_addr_validity_strict(addr);
2708 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
2713 /* Skip if already in use (7 bit, no need to encode flags) */
2714 if (i2c_check_addr_busy(adapter, addr))
2717 /* Make sure there is something at this address */
2718 if (!i2c_default_probe(adapter, addr))
2721 /* Finally call the custom detection function */
2722 memset(&info, 0, sizeof(struct i2c_board_info));
2724 err = driver->detect(temp_client, &info);
2726 /* -ENODEV is returned if the detection fails. We catch it
2727 here as this isn't an error. */
2728 return err == -ENODEV ? 0 : err;
2731 /* Consistency check */
2732 if (info.type[0] == '\0') {
2733 dev_err(&adapter->dev,
2734 "%s detection function provided no name for 0x%x\n",
2735 driver->driver.name, addr);
2737 struct i2c_client *client;
2739 /* Detection succeeded, instantiate the device */
2740 if (adapter->class & I2C_CLASS_DEPRECATED)
2741 dev_warn(&adapter->dev,
2742 "This adapter will soon drop class based instantiation of devices. "
2743 "Please make sure client 0x%02x gets instantiated by other means. "
2744 "Check 'Documentation/i2c/instantiating-devices' for details.\n",
2747 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
2748 info.type, info.addr);
2749 client = i2c_new_device(adapter, &info);
2751 list_add_tail(&client->detected, &driver->clients);
2753 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
2754 info.type, info.addr);
2759 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
2761 const unsigned short *address_list;
2762 struct i2c_client *temp_client;
2764 int adap_id = i2c_adapter_id(adapter);
2766 address_list = driver->address_list;
2767 if (!driver->detect || !address_list)
2770 /* Warn that the adapter lost class based instantiation */
2771 if (adapter->class == I2C_CLASS_DEPRECATED) {
2772 dev_dbg(&adapter->dev,
2773 "This adapter dropped support for I2C classes and won't auto-detect %s devices anymore. "
2774 "If you need it, check 'Documentation/i2c/instantiating-devices' for alternatives.\n",
2775 driver->driver.name);
2779 /* Stop here if the classes do not match */
2780 if (!(adapter->class & driver->class))
2783 /* Set up a temporary client to help detect callback */
2784 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
2787 temp_client->adapter = adapter;
2789 for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
2790 dev_dbg(&adapter->dev,
2791 "found normal entry for adapter %d, addr 0x%02x\n",
2792 adap_id, address_list[i]);
2793 temp_client->addr = address_list[i];
2794 err = i2c_detect_address(temp_client, driver);
2803 int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
2805 return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2806 I2C_SMBUS_QUICK, NULL) >= 0;
2808 EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
2811 i2c_new_probed_device(struct i2c_adapter *adap,
2812 struct i2c_board_info *info,
2813 unsigned short const *addr_list,
2814 int (*probe)(struct i2c_adapter *, unsigned short addr))
2819 probe = i2c_default_probe;
2821 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
2822 /* Check address validity */
2823 if (i2c_check_7bit_addr_validity_strict(addr_list[i]) < 0) {
2824 dev_warn(&adap->dev, "Invalid 7-bit address 0x%02x\n",
2829 /* Check address availability (7 bit, no need to encode flags) */
2830 if (i2c_check_addr_busy(adap, addr_list[i])) {
2832 "Address 0x%02x already in use, not probing\n",
2837 /* Test address responsiveness */
2838 if (probe(adap, addr_list[i]))
2842 if (addr_list[i] == I2C_CLIENT_END) {
2843 dev_dbg(&adap->dev, "Probing failed, no device found\n");
2847 info->addr = addr_list[i];
2848 return i2c_new_device(adap, info);
2850 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
2852 struct i2c_adapter *i2c_get_adapter(int nr)
2854 struct i2c_adapter *adapter;
2856 mutex_lock(&core_lock);
2857 adapter = idr_find(&i2c_adapter_idr, nr);
2861 if (try_module_get(adapter->owner))
2862 get_device(&adapter->dev);
2867 mutex_unlock(&core_lock);
2870 EXPORT_SYMBOL(i2c_get_adapter);
2872 void i2c_put_adapter(struct i2c_adapter *adap)
2877 put_device(&adap->dev);
2878 module_put(adap->owner);
2880 EXPORT_SYMBOL(i2c_put_adapter);
2882 /* The SMBus parts */
2884 #define POLY (0x1070U << 3)
2885 static u8 crc8(u16 data)
2889 for (i = 0; i < 8; i++) {
2894 return (u8)(data >> 8);
2897 /* Incremental CRC8 over count bytes in the array pointed to by p */
2898 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
2902 for (i = 0; i < count; i++)
2903 crc = crc8((crc ^ p[i]) << 8);
2907 /* Assume a 7-bit address, which is reasonable for SMBus */
2908 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
2910 /* The address will be sent first */
2911 u8 addr = i2c_8bit_addr_from_msg(msg);
2912 pec = i2c_smbus_pec(pec, &addr, 1);
2914 /* The data buffer follows */
2915 return i2c_smbus_pec(pec, msg->buf, msg->len);
2918 /* Used for write only transactions */
2919 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
2921 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
2925 /* Return <0 on CRC error
2926 If there was a write before this read (most cases) we need to take the
2927 partial CRC from the write part into account.
2928 Note that this function does modify the message (we need to decrease the
2929 message length to hide the CRC byte from the caller). */
2930 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
2932 u8 rpec = msg->buf[--msg->len];
2933 cpec = i2c_smbus_msg_pec(cpec, msg);
2936 pr_debug("Bad PEC 0x%02x vs. 0x%02x\n",
2944 * i2c_smbus_read_byte - SMBus "receive byte" protocol
2945 * @client: Handle to slave device
2947 * This executes the SMBus "receive byte" protocol, returning negative errno
2948 * else the byte received from the device.
2950 s32 i2c_smbus_read_byte(const struct i2c_client *client)
2952 union i2c_smbus_data data;
2955 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2957 I2C_SMBUS_BYTE, &data);
2958 return (status < 0) ? status : data.byte;
2960 EXPORT_SYMBOL(i2c_smbus_read_byte);
2963 * i2c_smbus_write_byte - SMBus "send byte" protocol
2964 * @client: Handle to slave device
2965 * @value: Byte to be sent
2967 * This executes the SMBus "send byte" protocol, returning negative errno
2968 * else zero on success.
2970 s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
2972 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2973 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
2975 EXPORT_SYMBOL(i2c_smbus_write_byte);
2978 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
2979 * @client: Handle to slave device
2980 * @command: Byte interpreted by slave
2982 * This executes the SMBus "read byte" protocol, returning negative errno
2983 * else a data byte received from the device.
2985 s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
2987 union i2c_smbus_data data;
2990 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2991 I2C_SMBUS_READ, command,
2992 I2C_SMBUS_BYTE_DATA, &data);
2993 return (status < 0) ? status : data.byte;
2995 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
2998 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
2999 * @client: Handle to slave device
3000 * @command: Byte interpreted by slave
3001 * @value: Byte being written
3003 * This executes the SMBus "write byte" protocol, returning negative errno
3004 * else zero on success.
3006 s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
3009 union i2c_smbus_data data;
3011 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3012 I2C_SMBUS_WRITE, command,
3013 I2C_SMBUS_BYTE_DATA, &data);
3015 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
3018 * i2c_smbus_read_word_data - SMBus "read word" protocol
3019 * @client: Handle to slave device
3020 * @command: Byte interpreted by slave
3022 * This executes the SMBus "read word" protocol, returning negative errno
3023 * else a 16-bit unsigned "word" received from the device.
3025 s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
3027 union i2c_smbus_data data;
3030 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3031 I2C_SMBUS_READ, command,
3032 I2C_SMBUS_WORD_DATA, &data);
3033 return (status < 0) ? status : data.word;
3035 EXPORT_SYMBOL(i2c_smbus_read_word_data);
3038 * i2c_smbus_write_word_data - SMBus "write word" protocol
3039 * @client: Handle to slave device
3040 * @command: Byte interpreted by slave
3041 * @value: 16-bit "word" being written
3043 * This executes the SMBus "write word" protocol, returning negative errno
3044 * else zero on success.
3046 s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
3049 union i2c_smbus_data data;
3051 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3052 I2C_SMBUS_WRITE, command,
3053 I2C_SMBUS_WORD_DATA, &data);
3055 EXPORT_SYMBOL(i2c_smbus_write_word_data);
3058 * i2c_smbus_read_block_data - SMBus "block read" protocol
3059 * @client: Handle to slave device
3060 * @command: Byte interpreted by slave
3061 * @values: Byte array into which data will be read; big enough to hold
3062 * the data returned by the slave. SMBus allows at most 32 bytes.
3064 * This executes the SMBus "block read" protocol, returning negative errno
3065 * else the number of data bytes in the slave's response.
3067 * Note that using this function requires that the client's adapter support
3068 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
3069 * support this; its emulation through I2C messaging relies on a specific
3070 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
3072 s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
3075 union i2c_smbus_data data;
3078 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3079 I2C_SMBUS_READ, command,
3080 I2C_SMBUS_BLOCK_DATA, &data);
3084 memcpy(values, &data.block[1], data.block[0]);
3085 return data.block[0];
3087 EXPORT_SYMBOL(i2c_smbus_read_block_data);
3090 * i2c_smbus_write_block_data - SMBus "block write" protocol
3091 * @client: Handle to slave device
3092 * @command: Byte interpreted by slave
3093 * @length: Size of data block; SMBus allows at most 32 bytes
3094 * @values: Byte array which will be written.
3096 * This executes the SMBus "block write" protocol, returning negative errno
3097 * else zero on success.
3099 s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
3100 u8 length, const u8 *values)
3102 union i2c_smbus_data data;
3104 if (length > I2C_SMBUS_BLOCK_MAX)
3105 length = I2C_SMBUS_BLOCK_MAX;
3106 data.block[0] = length;
3107 memcpy(&data.block[1], values, length);
3108 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3109 I2C_SMBUS_WRITE, command,
3110 I2C_SMBUS_BLOCK_DATA, &data);
3112 EXPORT_SYMBOL(i2c_smbus_write_block_data);
3114 /* Returns the number of read bytes */
3115 s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
3116 u8 length, u8 *values)
3118 union i2c_smbus_data data;
3121 if (length > I2C_SMBUS_BLOCK_MAX)
3122 length = I2C_SMBUS_BLOCK_MAX;
3123 data.block[0] = length;
3124 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3125 I2C_SMBUS_READ, command,
3126 I2C_SMBUS_I2C_BLOCK_DATA, &data);
3130 memcpy(values, &data.block[1], data.block[0]);
3131 return data.block[0];
3133 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
3135 s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
3136 u8 length, const u8 *values)
3138 union i2c_smbus_data data;
3140 if (length > I2C_SMBUS_BLOCK_MAX)
3141 length = I2C_SMBUS_BLOCK_MAX;
3142 data.block[0] = length;
3143 memcpy(data.block + 1, values, length);
3144 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3145 I2C_SMBUS_WRITE, command,
3146 I2C_SMBUS_I2C_BLOCK_DATA, &data);
3148 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
3150 /* Simulate a SMBus command using the i2c protocol
3151 No checking of parameters is done! */
3152 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
3153 unsigned short flags,
3154 char read_write, u8 command, int size,
3155 union i2c_smbus_data *data)
3157 /* So we need to generate a series of msgs. In the case of writing, we
3158 need to use only one message; when reading, we need two. We initialize
3159 most things with sane defaults, to keep the code below somewhat
3161 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
3162 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
3163 int num = read_write == I2C_SMBUS_READ ? 2 : 1;
3167 struct i2c_msg msg[2] = {
3175 .flags = flags | I2C_M_RD,
3181 msgbuf0[0] = command;
3183 case I2C_SMBUS_QUICK:
3185 /* Special case: The read/write field is used as data */
3186 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
3190 case I2C_SMBUS_BYTE:
3191 if (read_write == I2C_SMBUS_READ) {
3192 /* Special case: only a read! */
3193 msg[0].flags = I2C_M_RD | flags;
3197 case I2C_SMBUS_BYTE_DATA:
3198 if (read_write == I2C_SMBUS_READ)
3202 msgbuf0[1] = data->byte;
3205 case I2C_SMBUS_WORD_DATA:
3206 if (read_write == I2C_SMBUS_READ)
3210 msgbuf0[1] = data->word & 0xff;
3211 msgbuf0[2] = data->word >> 8;
3214 case I2C_SMBUS_PROC_CALL:
3215 num = 2; /* Special case */
3216 read_write = I2C_SMBUS_READ;
3219 msgbuf0[1] = data->word & 0xff;
3220 msgbuf0[2] = data->word >> 8;
3222 case I2C_SMBUS_BLOCK_DATA:
3223 if (read_write == I2C_SMBUS_READ) {
3224 msg[1].flags |= I2C_M_RECV_LEN;
3225 msg[1].len = 1; /* block length will be added by
3226 the underlying bus driver */
3228 msg[0].len = data->block[0] + 2;
3229 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
3230 dev_err(&adapter->dev,
3231 "Invalid block write size %d\n",
3235 for (i = 1; i < msg[0].len; i++)
3236 msgbuf0[i] = data->block[i-1];
3239 case I2C_SMBUS_BLOCK_PROC_CALL:
3240 num = 2; /* Another special case */
3241 read_write = I2C_SMBUS_READ;
3242 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
3243 dev_err(&adapter->dev,
3244 "Invalid block write size %d\n",
3248 msg[0].len = data->block[0] + 2;
3249 for (i = 1; i < msg[0].len; i++)
3250 msgbuf0[i] = data->block[i-1];
3251 msg[1].flags |= I2C_M_RECV_LEN;
3252 msg[1].len = 1; /* block length will be added by
3253 the underlying bus driver */
3255 case I2C_SMBUS_I2C_BLOCK_DATA:
3256 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
3257 dev_err(&adapter->dev, "Invalid block %s size %d\n",
3258 read_write == I2C_SMBUS_READ ? "read" : "write",
3262 if (read_write == I2C_SMBUS_READ) {
3263 msg[1].len = data->block[0];
3265 msg[0].len = data->block[0] + 1;
3266 for (i = 1; i <= data->block[0]; i++)
3267 msgbuf0[i] = data->block[i];
3271 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
3275 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
3276 && size != I2C_SMBUS_I2C_BLOCK_DATA);
3278 /* Compute PEC if first message is a write */
3279 if (!(msg[0].flags & I2C_M_RD)) {
3280 if (num == 1) /* Write only */
3281 i2c_smbus_add_pec(&msg[0]);
3282 else /* Write followed by read */
3283 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
3285 /* Ask for PEC if last message is a read */
3286 if (msg[num-1].flags & I2C_M_RD)
3290 status = i2c_transfer(adapter, msg, num);
3294 /* Check PEC if last message is a read */
3295 if (i && (msg[num-1].flags & I2C_M_RD)) {
3296 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
3301 if (read_write == I2C_SMBUS_READ)
3303 case I2C_SMBUS_BYTE:
3304 data->byte = msgbuf0[0];
3306 case I2C_SMBUS_BYTE_DATA:
3307 data->byte = msgbuf1[0];
3309 case I2C_SMBUS_WORD_DATA:
3310 case I2C_SMBUS_PROC_CALL:
3311 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
3313 case I2C_SMBUS_I2C_BLOCK_DATA:
3314 for (i = 0; i < data->block[0]; i++)
3315 data->block[i+1] = msgbuf1[i];
3317 case I2C_SMBUS_BLOCK_DATA:
3318 case I2C_SMBUS_BLOCK_PROC_CALL:
3319 for (i = 0; i < msgbuf1[0] + 1; i++)
3320 data->block[i] = msgbuf1[i];
3327 * i2c_smbus_xfer - execute SMBus protocol operations
3328 * @adapter: Handle to I2C bus
3329 * @addr: Address of SMBus slave on that bus
3330 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
3331 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
3332 * @command: Byte interpreted by slave, for protocols which use such bytes
3333 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
3334 * @data: Data to be read or written
3336 * This executes an SMBus protocol operation, and returns a negative
3337 * errno code else zero on success.
3339 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
3340 char read_write, u8 command, int protocol,
3341 union i2c_smbus_data *data)
3343 unsigned long orig_jiffies;
3347 /* If enabled, the following two tracepoints are conditional on
3348 * read_write and protocol.
3350 trace_smbus_write(adapter, addr, flags, read_write,
3351 command, protocol, data);
3352 trace_smbus_read(adapter, addr, flags, read_write,
3355 flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
3357 if (adapter->algo->smbus_xfer) {
3358 i2c_lock_bus(adapter, I2C_LOCK_SEGMENT);
3360 /* Retry automatically on arbitration loss */
3361 orig_jiffies = jiffies;
3362 for (res = 0, try = 0; try <= adapter->retries; try++) {
3363 res = adapter->algo->smbus_xfer(adapter, addr, flags,
3364 read_write, command,
3368 if (time_after(jiffies,
3369 orig_jiffies + adapter->timeout))
3372 i2c_unlock_bus(adapter, I2C_LOCK_SEGMENT);
3374 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
3377 * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
3378 * implement native support for the SMBus operation.
3382 res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
3383 command, protocol, data);
3386 /* If enabled, the reply tracepoint is conditional on read_write. */
3387 trace_smbus_reply(adapter, addr, flags, read_write,
3388 command, protocol, data);
3389 trace_smbus_result(adapter, addr, flags, read_write,
3390 command, protocol, res);
3394 EXPORT_SYMBOL(i2c_smbus_xfer);
3397 * i2c_smbus_read_i2c_block_data_or_emulated - read block or emulate
3398 * @client: Handle to slave device
3399 * @command: Byte interpreted by slave
3400 * @length: Size of data block; SMBus allows at most I2C_SMBUS_BLOCK_MAX bytes
3401 * @values: Byte array into which data will be read; big enough to hold
3402 * the data returned by the slave. SMBus allows at most
3403 * I2C_SMBUS_BLOCK_MAX bytes.
3405 * This executes the SMBus "block read" protocol if supported by the adapter.
3406 * If block read is not supported, it emulates it using either word or byte
3407 * read protocols depending on availability.
3409 * The addresses of the I2C slave device that are accessed with this function
3410 * must be mapped to a linear region, so that a block read will have the same
3411 * effect as a byte read. Before using this function you must double-check
3412 * if the I2C slave does support exchanging a block transfer with a byte
3415 s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
3416 u8 command, u8 length, u8 *values)
3421 if (length > I2C_SMBUS_BLOCK_MAX)
3422 length = I2C_SMBUS_BLOCK_MAX;
3424 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK))
3425 return i2c_smbus_read_i2c_block_data(client, command, length, values);
3427 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA))
3430 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_WORD_DATA)) {
3431 while ((i + 2) <= length) {
3432 status = i2c_smbus_read_word_data(client, command + i);
3435 values[i] = status & 0xff;
3436 values[i + 1] = status >> 8;
3441 while (i < length) {
3442 status = i2c_smbus_read_byte_data(client, command + i);
3451 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data_or_emulated);
3453 #if IS_ENABLED(CONFIG_I2C_SLAVE)
3454 int i2c_slave_register(struct i2c_client *client, i2c_slave_cb_t slave_cb)
3458 if (!client || !slave_cb) {
3459 WARN(1, "insufficent data\n");
3463 if (!(client->flags & I2C_CLIENT_SLAVE))
3464 dev_warn(&client->dev, "%s: client slave flag not set. You might see address collisions\n",
3467 if (!(client->flags & I2C_CLIENT_TEN)) {
3468 /* Enforce stricter address checking */
3469 ret = i2c_check_7bit_addr_validity_strict(client->addr);
3471 dev_err(&client->dev, "%s: invalid address\n", __func__);
3476 if (!client->adapter->algo->reg_slave) {
3477 dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
3481 client->slave_cb = slave_cb;
3483 i2c_lock_adapter(client->adapter);
3484 ret = client->adapter->algo->reg_slave(client);
3485 i2c_unlock_adapter(client->adapter);
3488 client->slave_cb = NULL;
3489 dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
3494 EXPORT_SYMBOL_GPL(i2c_slave_register);
3496 int i2c_slave_unregister(struct i2c_client *client)
3500 if (!client->adapter->algo->unreg_slave) {
3501 dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
3505 i2c_lock_adapter(client->adapter);
3506 ret = client->adapter->algo->unreg_slave(client);
3507 i2c_unlock_adapter(client->adapter);
3510 client->slave_cb = NULL;
3512 dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
3516 EXPORT_SYMBOL_GPL(i2c_slave_unregister);
3519 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
3520 MODULE_DESCRIPTION("I2C-Bus main module");
3521 MODULE_LICENSE("GPL");