1 /* i2c-core.c - a device driver for the iic-bus interface */
2 /* ------------------------------------------------------------------------- */
3 /* Copyright (C) 1995-99 Simon G. Vogl
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details. */
14 /* ------------------------------------------------------------------------- */
16 /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi>.
17 All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl>
18 SMBus 2.0 support by Mark Studebaker <mdsxyz123@yahoo.com> and
19 Jean Delvare <jdelvare@suse.de>
20 Mux support by Rodolfo Giometti <giometti@enneenne.com> and
21 Michael Lawnick <michael.lawnick.ext@nsn.com>
22 OF support is copyright (c) 2008 Jochen Friedrich <jochen@scram.de>
23 (based on a previous patch from Jon Smirl <jonsmirl@gmail.com>) and
24 (c) 2013 Wolfram Sang <wsa@the-dreams.de>
25 I2C ACPI code Copyright (C) 2014 Intel Corp
26 Author: Lan Tianyu <tianyu.lan@intel.com>
27 I2C slave support (c) 2014 by Wolfram Sang <wsa@sang-engineering.com>
30 #define pr_fmt(fmt) "i2c-core: " fmt
32 #include <dt-bindings/i2c/i2c.h>
33 #include <asm/uaccess.h>
34 #include <linux/acpi.h>
35 #include <linux/clk/clk-conf.h>
36 #include <linux/completion.h>
37 #include <linux/delay.h>
38 #include <linux/err.h>
39 #include <linux/errno.h>
40 #include <linux/gpio.h>
41 #include <linux/hardirq.h>
42 #include <linux/i2c.h>
43 #include <linux/idr.h>
44 #include <linux/init.h>
45 #include <linux/irqflags.h>
46 #include <linux/jump_label.h>
47 #include <linux/kernel.h>
48 #include <linux/module.h>
49 #include <linux/mutex.h>
50 #include <linux/of_device.h>
52 #include <linux/of_irq.h>
53 #include <linux/pm_domain.h>
54 #include <linux/pm_runtime.h>
55 #include <linux/pm_wakeirq.h>
56 #include <linux/property.h>
57 #include <linux/rwsem.h>
58 #include <linux/slab.h>
62 #define CREATE_TRACE_POINTS
63 #include <trace/events/i2c.h>
65 #define I2C_ADDR_OFFSET_TEN_BIT 0xa000
66 #define I2C_ADDR_OFFSET_SLAVE 0x1000
68 /* core_lock protects i2c_adapter_idr, and guarantees
69 that device detection, deletion of detected devices, and attach_adapter
70 calls are serialized */
71 static DEFINE_MUTEX(core_lock);
72 static DEFINE_IDR(i2c_adapter_idr);
74 static struct device_type i2c_client_type;
75 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
77 static struct static_key i2c_trace_msg = STATIC_KEY_INIT_FALSE;
78 static bool is_registered;
80 void i2c_transfer_trace_reg(void)
82 static_key_slow_inc(&i2c_trace_msg);
85 void i2c_transfer_trace_unreg(void)
87 static_key_slow_dec(&i2c_trace_msg);
90 #if defined(CONFIG_ACPI)
91 struct i2c_acpi_handler_data {
92 struct acpi_connection_info info;
93 struct i2c_adapter *adapter;
106 struct i2c_acpi_lookup {
107 struct i2c_board_info *info;
108 acpi_handle adapter_handle;
109 acpi_handle device_handle;
110 acpi_handle search_handle;
115 static int i2c_acpi_fill_info(struct acpi_resource *ares, void *data)
117 struct i2c_acpi_lookup *lookup = data;
118 struct i2c_board_info *info = lookup->info;
119 struct acpi_resource_i2c_serialbus *sb;
122 if (info->addr || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS)
125 sb = &ares->data.i2c_serial_bus;
126 if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C)
129 status = acpi_get_handle(lookup->device_handle,
130 sb->resource_source.string_ptr,
131 &lookup->adapter_handle);
132 if (!ACPI_SUCCESS(status))
135 info->addr = sb->slave_address;
136 lookup->speed = sb->connection_speed;
137 if (sb->access_mode == ACPI_I2C_10BIT_MODE)
138 info->flags |= I2C_CLIENT_TEN;
143 static int i2c_acpi_do_lookup(struct acpi_device *adev,
144 struct i2c_acpi_lookup *lookup)
146 struct i2c_board_info *info = lookup->info;
147 struct list_head resource_list;
150 if (acpi_bus_get_status(adev) || !adev->status.present ||
151 acpi_device_enumerated(adev))
154 memset(info, 0, sizeof(*info));
155 lookup->device_handle = acpi_device_handle(adev);
157 /* Look up for I2cSerialBus resource */
158 INIT_LIST_HEAD(&resource_list);
159 ret = acpi_dev_get_resources(adev, &resource_list,
160 i2c_acpi_fill_info, lookup);
161 acpi_dev_free_resource_list(&resource_list);
163 if (ret < 0 || !info->addr)
169 static int i2c_acpi_get_info(struct acpi_device *adev,
170 struct i2c_board_info *info,
171 acpi_handle *adapter_handle)
173 struct list_head resource_list;
174 struct resource_entry *entry;
175 struct i2c_acpi_lookup lookup;
178 memset(&lookup, 0, sizeof(lookup));
181 ret = i2c_acpi_do_lookup(adev, &lookup);
185 info->fwnode = acpi_fwnode_handle(adev);
186 *adapter_handle = lookup.adapter_handle;
188 /* Then fill IRQ number if any */
189 INIT_LIST_HEAD(&resource_list);
190 ret = acpi_dev_get_resources(adev, &resource_list, NULL, NULL);
194 resource_list_for_each_entry(entry, &resource_list) {
195 if (resource_type(entry->res) == IORESOURCE_IRQ) {
196 info->irq = entry->res->start;
201 acpi_dev_free_resource_list(&resource_list);
203 strlcpy(info->type, dev_name(&adev->dev), sizeof(info->type));
208 static void i2c_acpi_register_device(struct i2c_adapter *adapter,
209 struct acpi_device *adev,
210 struct i2c_board_info *info)
212 adev->power.flags.ignore_parent = true;
213 acpi_device_set_enumerated(adev);
215 if (!i2c_new_device(adapter, info)) {
216 adev->power.flags.ignore_parent = false;
217 dev_err(&adapter->dev,
218 "failed to add I2C device %s from ACPI\n",
219 dev_name(&adev->dev));
223 static acpi_status i2c_acpi_add_device(acpi_handle handle, u32 level,
224 void *data, void **return_value)
226 struct i2c_adapter *adapter = data;
227 struct acpi_device *adev;
228 acpi_handle adapter_handle;
229 struct i2c_board_info info;
231 if (acpi_bus_get_device(handle, &adev))
234 if (i2c_acpi_get_info(adev, &info, &adapter_handle))
237 if (adapter_handle != ACPI_HANDLE(&adapter->dev))
240 i2c_acpi_register_device(adapter, adev, &info);
245 #define I2C_ACPI_MAX_SCAN_DEPTH 32
248 * i2c_acpi_register_devices - enumerate I2C slave devices behind adapter
249 * @adap: pointer to adapter
251 * Enumerate all I2C slave devices behind this adapter by walking the ACPI
252 * namespace. When a device is found it will be added to the Linux device
253 * model and bound to the corresponding ACPI handle.
255 static void i2c_acpi_register_devices(struct i2c_adapter *adap)
259 if (!has_acpi_companion(&adap->dev))
262 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
263 I2C_ACPI_MAX_SCAN_DEPTH,
264 i2c_acpi_add_device, NULL,
266 if (ACPI_FAILURE(status))
267 dev_warn(&adap->dev, "failed to enumerate I2C slaves\n");
270 static acpi_status i2c_acpi_lookup_speed(acpi_handle handle, u32 level,
271 void *data, void **return_value)
273 struct i2c_acpi_lookup *lookup = data;
274 struct acpi_device *adev;
276 if (acpi_bus_get_device(handle, &adev))
279 if (i2c_acpi_do_lookup(adev, lookup))
282 if (lookup->search_handle != lookup->adapter_handle)
285 if (lookup->speed <= lookup->min_speed)
286 lookup->min_speed = lookup->speed;
292 * i2c_acpi_find_bus_speed - find I2C bus speed from ACPI
293 * @dev: The device owning the bus
295 * Find the I2C bus speed by walking the ACPI namespace for all I2C slaves
296 * devices connected to this bus and use the speed of slowest device.
298 * Returns the speed in Hz or zero
300 u32 i2c_acpi_find_bus_speed(struct device *dev)
302 struct i2c_acpi_lookup lookup;
303 struct i2c_board_info dummy;
306 if (!has_acpi_companion(dev))
309 memset(&lookup, 0, sizeof(lookup));
310 lookup.search_handle = ACPI_HANDLE(dev);
311 lookup.min_speed = UINT_MAX;
312 lookup.info = &dummy;
314 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
315 I2C_ACPI_MAX_SCAN_DEPTH,
316 i2c_acpi_lookup_speed, NULL,
319 if (ACPI_FAILURE(status)) {
320 dev_warn(dev, "unable to find I2C bus speed from ACPI\n");
324 return lookup.min_speed != UINT_MAX ? lookup.min_speed : 0;
326 EXPORT_SYMBOL_GPL(i2c_acpi_find_bus_speed);
328 static int i2c_acpi_match_adapter(struct device *dev, void *data)
330 struct i2c_adapter *adapter = i2c_verify_adapter(dev);
335 return ACPI_HANDLE(dev) == (acpi_handle)data;
338 static int i2c_acpi_match_device(struct device *dev, void *data)
340 return ACPI_COMPANION(dev) == data;
343 static struct i2c_adapter *i2c_acpi_find_adapter_by_handle(acpi_handle handle)
347 dev = bus_find_device(&i2c_bus_type, NULL, handle,
348 i2c_acpi_match_adapter);
349 return dev ? i2c_verify_adapter(dev) : NULL;
352 static struct i2c_client *i2c_acpi_find_client_by_adev(struct acpi_device *adev)
356 dev = bus_find_device(&i2c_bus_type, NULL, adev, i2c_acpi_match_device);
357 return dev ? i2c_verify_client(dev) : NULL;
360 static int i2c_acpi_notify(struct notifier_block *nb, unsigned long value,
363 struct acpi_device *adev = arg;
364 struct i2c_board_info info;
365 acpi_handle adapter_handle;
366 struct i2c_adapter *adapter;
367 struct i2c_client *client;
370 case ACPI_RECONFIG_DEVICE_ADD:
371 if (i2c_acpi_get_info(adev, &info, &adapter_handle))
374 adapter = i2c_acpi_find_adapter_by_handle(adapter_handle);
378 i2c_acpi_register_device(adapter, adev, &info);
380 case ACPI_RECONFIG_DEVICE_REMOVE:
381 if (!acpi_device_enumerated(adev))
384 client = i2c_acpi_find_client_by_adev(adev);
388 i2c_unregister_device(client);
389 put_device(&client->dev);
396 static struct notifier_block i2c_acpi_notifier = {
397 .notifier_call = i2c_acpi_notify,
399 #else /* CONFIG_ACPI */
400 static inline void i2c_acpi_register_devices(struct i2c_adapter *adap) { }
401 extern struct notifier_block i2c_acpi_notifier;
402 #endif /* CONFIG_ACPI */
404 #ifdef CONFIG_ACPI_I2C_OPREGION
405 static int acpi_gsb_i2c_read_bytes(struct i2c_client *client,
406 u8 cmd, u8 *data, u8 data_len)
409 struct i2c_msg msgs[2];
413 buffer = kzalloc(data_len, GFP_KERNEL);
417 msgs[0].addr = client->addr;
418 msgs[0].flags = client->flags;
422 msgs[1].addr = client->addr;
423 msgs[1].flags = client->flags | I2C_M_RD;
424 msgs[1].len = data_len;
425 msgs[1].buf = buffer;
427 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
429 dev_err(&client->adapter->dev, "i2c read failed\n");
431 memcpy(data, buffer, data_len);
437 static int acpi_gsb_i2c_write_bytes(struct i2c_client *client,
438 u8 cmd, u8 *data, u8 data_len)
441 struct i2c_msg msgs[1];
445 buffer = kzalloc(data_len + 1, GFP_KERNEL);
450 memcpy(buffer + 1, data, data_len);
452 msgs[0].addr = client->addr;
453 msgs[0].flags = client->flags;
454 msgs[0].len = data_len + 1;
455 msgs[0].buf = buffer;
457 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
459 dev_err(&client->adapter->dev, "i2c write failed\n");
466 i2c_acpi_space_handler(u32 function, acpi_physical_address command,
467 u32 bits, u64 *value64,
468 void *handler_context, void *region_context)
470 struct gsb_buffer *gsb = (struct gsb_buffer *)value64;
471 struct i2c_acpi_handler_data *data = handler_context;
472 struct acpi_connection_info *info = &data->info;
473 struct acpi_resource_i2c_serialbus *sb;
474 struct i2c_adapter *adapter = data->adapter;
475 struct i2c_client *client;
476 struct acpi_resource *ares;
477 u32 accessor_type = function >> 16;
478 u8 action = function & ACPI_IO_MASK;
482 ret = acpi_buffer_to_resource(info->connection, info->length, &ares);
483 if (ACPI_FAILURE(ret))
486 client = kzalloc(sizeof(*client), GFP_KERNEL);
492 if (!value64 || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) {
493 ret = AE_BAD_PARAMETER;
497 sb = &ares->data.i2c_serial_bus;
498 if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C) {
499 ret = AE_BAD_PARAMETER;
503 client->adapter = adapter;
504 client->addr = sb->slave_address;
506 if (sb->access_mode == ACPI_I2C_10BIT_MODE)
507 client->flags |= I2C_CLIENT_TEN;
509 switch (accessor_type) {
510 case ACPI_GSB_ACCESS_ATTRIB_SEND_RCV:
511 if (action == ACPI_READ) {
512 status = i2c_smbus_read_byte(client);
518 status = i2c_smbus_write_byte(client, gsb->bdata);
522 case ACPI_GSB_ACCESS_ATTRIB_BYTE:
523 if (action == ACPI_READ) {
524 status = i2c_smbus_read_byte_data(client, command);
530 status = i2c_smbus_write_byte_data(client, command,
535 case ACPI_GSB_ACCESS_ATTRIB_WORD:
536 if (action == ACPI_READ) {
537 status = i2c_smbus_read_word_data(client, command);
543 status = i2c_smbus_write_word_data(client, command,
548 case ACPI_GSB_ACCESS_ATTRIB_BLOCK:
549 if (action == ACPI_READ) {
550 status = i2c_smbus_read_block_data(client, command,
557 status = i2c_smbus_write_block_data(client, command,
558 gsb->len, gsb->data);
562 case ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE:
563 if (action == ACPI_READ) {
564 status = acpi_gsb_i2c_read_bytes(client, command,
565 gsb->data, info->access_length);
569 status = acpi_gsb_i2c_write_bytes(client, command,
570 gsb->data, info->access_length);
575 dev_warn(&adapter->dev, "protocol 0x%02x not supported for client 0x%02x\n",
576 accessor_type, client->addr);
577 ret = AE_BAD_PARAMETER;
581 gsb->status = status;
590 static int i2c_acpi_install_space_handler(struct i2c_adapter *adapter)
593 struct i2c_acpi_handler_data *data;
596 if (!adapter->dev.parent)
599 handle = ACPI_HANDLE(adapter->dev.parent);
604 data = kzalloc(sizeof(struct i2c_acpi_handler_data),
609 data->adapter = adapter;
610 status = acpi_bus_attach_private_data(handle, (void *)data);
611 if (ACPI_FAILURE(status)) {
616 status = acpi_install_address_space_handler(handle,
617 ACPI_ADR_SPACE_GSBUS,
618 &i2c_acpi_space_handler,
621 if (ACPI_FAILURE(status)) {
622 dev_err(&adapter->dev, "Error installing i2c space handler\n");
623 acpi_bus_detach_private_data(handle);
628 acpi_walk_dep_device_list(handle);
632 static void i2c_acpi_remove_space_handler(struct i2c_adapter *adapter)
635 struct i2c_acpi_handler_data *data;
638 if (!adapter->dev.parent)
641 handle = ACPI_HANDLE(adapter->dev.parent);
646 acpi_remove_address_space_handler(handle,
647 ACPI_ADR_SPACE_GSBUS,
648 &i2c_acpi_space_handler);
650 status = acpi_bus_get_private_data(handle, (void **)&data);
651 if (ACPI_SUCCESS(status))
654 acpi_bus_detach_private_data(handle);
656 #else /* CONFIG_ACPI_I2C_OPREGION */
657 static inline void i2c_acpi_remove_space_handler(struct i2c_adapter *adapter)
660 static inline int i2c_acpi_install_space_handler(struct i2c_adapter *adapter)
662 #endif /* CONFIG_ACPI_I2C_OPREGION */
664 /* ------------------------------------------------------------------------- */
666 static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
667 const struct i2c_client *client)
669 while (id->name[0]) {
670 if (strcmp(client->name, id->name) == 0)
677 static int i2c_device_match(struct device *dev, struct device_driver *drv)
679 struct i2c_client *client = i2c_verify_client(dev);
680 struct i2c_driver *driver;
685 /* Attempt an OF style match */
686 if (of_driver_match_device(dev, drv))
689 /* Then ACPI style match */
690 if (acpi_driver_match_device(dev, drv))
693 driver = to_i2c_driver(drv);
694 /* match on an id table if there is one */
695 if (driver->id_table)
696 return i2c_match_id(driver->id_table, client) != NULL;
701 static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
703 struct i2c_client *client = to_i2c_client(dev);
706 rc = acpi_device_uevent_modalias(dev, env);
710 return add_uevent_var(env, "MODALIAS=%s%s", I2C_MODULE_PREFIX, client->name);
713 /* i2c bus recovery routines */
714 static int get_scl_gpio_value(struct i2c_adapter *adap)
716 return gpio_get_value(adap->bus_recovery_info->scl_gpio);
719 static void set_scl_gpio_value(struct i2c_adapter *adap, int val)
721 gpio_set_value(adap->bus_recovery_info->scl_gpio, val);
724 static int get_sda_gpio_value(struct i2c_adapter *adap)
726 return gpio_get_value(adap->bus_recovery_info->sda_gpio);
729 static int i2c_get_gpios_for_recovery(struct i2c_adapter *adap)
731 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
732 struct device *dev = &adap->dev;
735 ret = gpio_request_one(bri->scl_gpio, GPIOF_OPEN_DRAIN |
736 GPIOF_OUT_INIT_HIGH, "i2c-scl");
738 dev_warn(dev, "Can't get SCL gpio: %d\n", bri->scl_gpio);
743 if (gpio_request_one(bri->sda_gpio, GPIOF_IN, "i2c-sda")) {
744 /* work without SDA polling */
745 dev_warn(dev, "Can't get SDA gpio: %d. Not using SDA polling\n",
754 static void i2c_put_gpios_for_recovery(struct i2c_adapter *adap)
756 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
759 gpio_free(bri->sda_gpio);
761 gpio_free(bri->scl_gpio);
765 * We are generating clock pulses. ndelay() determines durating of clk pulses.
766 * We will generate clock with rate 100 KHz and so duration of both clock levels
767 * is: delay in ns = (10^6 / 100) / 2
769 #define RECOVERY_NDELAY 5000
770 #define RECOVERY_CLK_CNT 9
772 static int i2c_generic_recovery(struct i2c_adapter *adap)
774 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
775 int i = 0, val = 1, ret = 0;
777 if (bri->prepare_recovery)
778 bri->prepare_recovery(adap);
780 bri->set_scl(adap, val);
781 ndelay(RECOVERY_NDELAY);
784 * By this time SCL is high, as we need to give 9 falling-rising edges
786 while (i++ < RECOVERY_CLK_CNT * 2) {
788 /* Break if SDA is high */
789 if (bri->get_sda && bri->get_sda(adap))
791 /* SCL shouldn't be low here */
792 if (!bri->get_scl(adap)) {
794 "SCL is stuck low, exit recovery\n");
801 bri->set_scl(adap, val);
802 ndelay(RECOVERY_NDELAY);
805 if (bri->unprepare_recovery)
806 bri->unprepare_recovery(adap);
811 int i2c_generic_scl_recovery(struct i2c_adapter *adap)
813 return i2c_generic_recovery(adap);
815 EXPORT_SYMBOL_GPL(i2c_generic_scl_recovery);
817 int i2c_generic_gpio_recovery(struct i2c_adapter *adap)
821 ret = i2c_get_gpios_for_recovery(adap);
825 ret = i2c_generic_recovery(adap);
826 i2c_put_gpios_for_recovery(adap);
830 EXPORT_SYMBOL_GPL(i2c_generic_gpio_recovery);
832 int i2c_recover_bus(struct i2c_adapter *adap)
834 if (!adap->bus_recovery_info)
837 dev_dbg(&adap->dev, "Trying i2c bus recovery\n");
838 return adap->bus_recovery_info->recover_bus(adap);
840 EXPORT_SYMBOL_GPL(i2c_recover_bus);
842 static void i2c_init_recovery(struct i2c_adapter *adap)
844 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
850 if (!bri->recover_bus) {
851 err_str = "no recover_bus() found";
855 /* Generic GPIO recovery */
856 if (bri->recover_bus == i2c_generic_gpio_recovery) {
857 if (!gpio_is_valid(bri->scl_gpio)) {
858 err_str = "invalid SCL gpio";
862 if (gpio_is_valid(bri->sda_gpio))
863 bri->get_sda = get_sda_gpio_value;
867 bri->get_scl = get_scl_gpio_value;
868 bri->set_scl = set_scl_gpio_value;
869 } else if (bri->recover_bus == i2c_generic_scl_recovery) {
870 /* Generic SCL recovery */
871 if (!bri->set_scl || !bri->get_scl) {
872 err_str = "no {get|set}_scl() found";
879 dev_err(&adap->dev, "Not using recovery: %s\n", err_str);
880 adap->bus_recovery_info = NULL;
883 static int i2c_device_probe(struct device *dev)
885 struct i2c_client *client = i2c_verify_client(dev);
886 struct i2c_driver *driver;
896 irq = of_irq_get_byname(dev->of_node, "irq");
897 if (irq == -EINVAL || irq == -ENODATA)
898 irq = of_irq_get(dev->of_node, 0);
899 } else if (ACPI_COMPANION(dev)) {
900 irq = acpi_dev_gpio_irq_get(ACPI_COMPANION(dev), 0);
902 if (irq == -EPROBE_DEFER)
910 driver = to_i2c_driver(dev->driver);
911 if (!driver->probe || !driver->id_table)
914 if (client->flags & I2C_CLIENT_WAKE) {
915 int wakeirq = -ENOENT;
918 wakeirq = of_irq_get_byname(dev->of_node, "wakeup");
919 if (wakeirq == -EPROBE_DEFER)
923 device_init_wakeup(&client->dev, true);
925 if (wakeirq > 0 && wakeirq != client->irq)
926 status = dev_pm_set_dedicated_wake_irq(dev, wakeirq);
927 else if (client->irq > 0)
928 status = dev_pm_set_wake_irq(dev, client->irq);
933 dev_warn(&client->dev, "failed to set up wakeup irq");
936 dev_dbg(dev, "probe\n");
938 status = of_clk_set_defaults(dev->of_node, false);
940 goto err_clear_wakeup_irq;
942 status = dev_pm_domain_attach(&client->dev, true);
943 if (status == -EPROBE_DEFER)
944 goto err_clear_wakeup_irq;
946 status = driver->probe(client, i2c_match_id(driver->id_table, client));
948 goto err_detach_pm_domain;
952 err_detach_pm_domain:
953 dev_pm_domain_detach(&client->dev, true);
954 err_clear_wakeup_irq:
955 dev_pm_clear_wake_irq(&client->dev);
956 device_init_wakeup(&client->dev, false);
960 static int i2c_device_remove(struct device *dev)
962 struct i2c_client *client = i2c_verify_client(dev);
963 struct i2c_driver *driver;
966 if (!client || !dev->driver)
969 driver = to_i2c_driver(dev->driver);
970 if (driver->remove) {
971 dev_dbg(dev, "remove\n");
972 status = driver->remove(client);
975 dev_pm_domain_detach(&client->dev, true);
977 dev_pm_clear_wake_irq(&client->dev);
978 device_init_wakeup(&client->dev, false);
983 static void i2c_device_shutdown(struct device *dev)
985 struct i2c_client *client = i2c_verify_client(dev);
986 struct i2c_driver *driver;
988 if (!client || !dev->driver)
990 driver = to_i2c_driver(dev->driver);
991 if (driver->shutdown)
992 driver->shutdown(client);
995 static void i2c_client_dev_release(struct device *dev)
997 kfree(to_i2c_client(dev));
1001 show_name(struct device *dev, struct device_attribute *attr, char *buf)
1003 return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
1004 to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
1006 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
1009 show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
1011 struct i2c_client *client = to_i2c_client(dev);
1014 len = acpi_device_modalias(dev, buf, PAGE_SIZE -1);
1018 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
1020 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
1022 static struct attribute *i2c_dev_attrs[] = {
1023 &dev_attr_name.attr,
1024 /* modalias helps coldplug: modprobe $(cat .../modalias) */
1025 &dev_attr_modalias.attr,
1028 ATTRIBUTE_GROUPS(i2c_dev);
1030 struct bus_type i2c_bus_type = {
1032 .match = i2c_device_match,
1033 .probe = i2c_device_probe,
1034 .remove = i2c_device_remove,
1035 .shutdown = i2c_device_shutdown,
1037 EXPORT_SYMBOL_GPL(i2c_bus_type);
1039 static struct device_type i2c_client_type = {
1040 .groups = i2c_dev_groups,
1041 .uevent = i2c_device_uevent,
1042 .release = i2c_client_dev_release,
1047 * i2c_verify_client - return parameter as i2c_client, or NULL
1048 * @dev: device, probably from some driver model iterator
1050 * When traversing the driver model tree, perhaps using driver model
1051 * iterators like @device_for_each_child(), you can't assume very much
1052 * about the nodes you find. Use this function to avoid oopses caused
1053 * by wrongly treating some non-I2C device as an i2c_client.
1055 struct i2c_client *i2c_verify_client(struct device *dev)
1057 return (dev->type == &i2c_client_type)
1058 ? to_i2c_client(dev)
1061 EXPORT_SYMBOL(i2c_verify_client);
1064 /* Return a unique address which takes the flags of the client into account */
1065 static unsigned short i2c_encode_flags_to_addr(struct i2c_client *client)
1067 unsigned short addr = client->addr;
1069 /* For some client flags, add an arbitrary offset to avoid collisions */
1070 if (client->flags & I2C_CLIENT_TEN)
1071 addr |= I2C_ADDR_OFFSET_TEN_BIT;
1073 if (client->flags & I2C_CLIENT_SLAVE)
1074 addr |= I2C_ADDR_OFFSET_SLAVE;
1079 /* This is a permissive address validity check, I2C address map constraints
1080 * are purposely not enforced, except for the general call address. */
1081 static int i2c_check_addr_validity(unsigned addr, unsigned short flags)
1083 if (flags & I2C_CLIENT_TEN) {
1084 /* 10-bit address, all values are valid */
1088 /* 7-bit address, reject the general call address */
1089 if (addr == 0x00 || addr > 0x7f)
1095 /* And this is a strict address validity check, used when probing. If a
1096 * device uses a reserved address, then it shouldn't be probed. 7-bit
1097 * addressing is assumed, 10-bit address devices are rare and should be
1098 * explicitly enumerated. */
1099 static int i2c_check_7bit_addr_validity_strict(unsigned short addr)
1102 * Reserved addresses per I2C specification:
1103 * 0x00 General call address / START byte
1105 * 0x02 Reserved for different bus format
1106 * 0x03 Reserved for future purposes
1107 * 0x04-0x07 Hs-mode master code
1108 * 0x78-0x7b 10-bit slave addressing
1109 * 0x7c-0x7f Reserved for future purposes
1111 if (addr < 0x08 || addr > 0x77)
1116 static int __i2c_check_addr_busy(struct device *dev, void *addrp)
1118 struct i2c_client *client = i2c_verify_client(dev);
1119 int addr = *(int *)addrp;
1121 if (client && i2c_encode_flags_to_addr(client) == addr)
1126 /* walk up mux tree */
1127 static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
1129 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
1132 result = device_for_each_child(&adapter->dev, &addr,
1133 __i2c_check_addr_busy);
1135 if (!result && parent)
1136 result = i2c_check_mux_parents(parent, addr);
1141 /* recurse down mux tree */
1142 static int i2c_check_mux_children(struct device *dev, void *addrp)
1146 if (dev->type == &i2c_adapter_type)
1147 result = device_for_each_child(dev, addrp,
1148 i2c_check_mux_children);
1150 result = __i2c_check_addr_busy(dev, addrp);
1155 static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
1157 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
1161 result = i2c_check_mux_parents(parent, addr);
1164 result = device_for_each_child(&adapter->dev, &addr,
1165 i2c_check_mux_children);
1171 * i2c_adapter_lock_bus - Get exclusive access to an I2C bus segment
1172 * @adapter: Target I2C bus segment
1173 * @flags: I2C_LOCK_ROOT_ADAPTER locks the root i2c adapter, I2C_LOCK_SEGMENT
1174 * locks only this branch in the adapter tree
1176 static void i2c_adapter_lock_bus(struct i2c_adapter *adapter,
1179 rt_mutex_lock(&adapter->bus_lock);
1183 * i2c_adapter_trylock_bus - Try to get exclusive access to an I2C bus segment
1184 * @adapter: Target I2C bus segment
1185 * @flags: I2C_LOCK_ROOT_ADAPTER trylocks the root i2c adapter, I2C_LOCK_SEGMENT
1186 * trylocks only this branch in the adapter tree
1188 static int i2c_adapter_trylock_bus(struct i2c_adapter *adapter,
1191 return rt_mutex_trylock(&adapter->bus_lock);
1195 * i2c_adapter_unlock_bus - Release exclusive access to an I2C bus segment
1196 * @adapter: Target I2C bus segment
1197 * @flags: I2C_LOCK_ROOT_ADAPTER unlocks the root i2c adapter, I2C_LOCK_SEGMENT
1198 * unlocks only this branch in the adapter tree
1200 static void i2c_adapter_unlock_bus(struct i2c_adapter *adapter,
1203 rt_mutex_unlock(&adapter->bus_lock);
1206 static void i2c_dev_set_name(struct i2c_adapter *adap,
1207 struct i2c_client *client)
1209 struct acpi_device *adev = ACPI_COMPANION(&client->dev);
1212 dev_set_name(&client->dev, "i2c-%s", acpi_dev_name(adev));
1216 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
1217 i2c_encode_flags_to_addr(client));
1221 * i2c_new_device - instantiate an i2c device
1222 * @adap: the adapter managing the device
1223 * @info: describes one I2C device; bus_num is ignored
1224 * Context: can sleep
1226 * Create an i2c device. Binding is handled through driver model
1227 * probe()/remove() methods. A driver may be bound to this device when we
1228 * return from this function, or any later moment (e.g. maybe hotplugging will
1229 * load the driver module). This call is not appropriate for use by mainboard
1230 * initialization logic, which usually runs during an arch_initcall() long
1231 * before any i2c_adapter could exist.
1233 * This returns the new i2c client, which may be saved for later use with
1234 * i2c_unregister_device(); or NULL to indicate an error.
1237 i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
1239 struct i2c_client *client;
1242 client = kzalloc(sizeof *client, GFP_KERNEL);
1246 client->adapter = adap;
1248 client->dev.platform_data = info->platform_data;
1251 client->dev.archdata = *info->archdata;
1253 client->flags = info->flags;
1254 client->addr = info->addr;
1255 client->irq = info->irq;
1257 strlcpy(client->name, info->type, sizeof(client->name));
1259 status = i2c_check_addr_validity(client->addr, client->flags);
1261 dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
1262 client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
1263 goto out_err_silent;
1266 /* Check for address business */
1267 status = i2c_check_addr_busy(adap, i2c_encode_flags_to_addr(client));
1271 client->dev.parent = &client->adapter->dev;
1272 client->dev.bus = &i2c_bus_type;
1273 client->dev.type = &i2c_client_type;
1274 client->dev.of_node = info->of_node;
1275 client->dev.fwnode = info->fwnode;
1277 i2c_dev_set_name(adap, client);
1278 status = device_register(&client->dev);
1282 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
1283 client->name, dev_name(&client->dev));
1288 dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
1289 "(%d)\n", client->name, client->addr, status);
1294 EXPORT_SYMBOL_GPL(i2c_new_device);
1298 * i2c_unregister_device - reverse effect of i2c_new_device()
1299 * @client: value returned from i2c_new_device()
1300 * Context: can sleep
1302 void i2c_unregister_device(struct i2c_client *client)
1304 if (client->dev.of_node)
1305 of_node_clear_flag(client->dev.of_node, OF_POPULATED);
1306 if (ACPI_COMPANION(&client->dev))
1307 acpi_device_clear_enumerated(ACPI_COMPANION(&client->dev));
1308 device_unregister(&client->dev);
1310 EXPORT_SYMBOL_GPL(i2c_unregister_device);
1313 static const struct i2c_device_id dummy_id[] = {
1318 static int dummy_probe(struct i2c_client *client,
1319 const struct i2c_device_id *id)
1324 static int dummy_remove(struct i2c_client *client)
1329 static struct i2c_driver dummy_driver = {
1330 .driver.name = "dummy",
1331 .probe = dummy_probe,
1332 .remove = dummy_remove,
1333 .id_table = dummy_id,
1337 * i2c_new_dummy - return a new i2c device bound to a dummy driver
1338 * @adapter: the adapter managing the device
1339 * @address: seven bit address to be used
1340 * Context: can sleep
1342 * This returns an I2C client bound to the "dummy" driver, intended for use
1343 * with devices that consume multiple addresses. Examples of such chips
1344 * include various EEPROMS (like 24c04 and 24c08 models).
1346 * These dummy devices have two main uses. First, most I2C and SMBus calls
1347 * except i2c_transfer() need a client handle; the dummy will be that handle.
1348 * And second, this prevents the specified address from being bound to a
1351 * This returns the new i2c client, which should be saved for later use with
1352 * i2c_unregister_device(); or NULL to indicate an error.
1354 struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
1356 struct i2c_board_info info = {
1357 I2C_BOARD_INFO("dummy", address),
1360 return i2c_new_device(adapter, &info);
1362 EXPORT_SYMBOL_GPL(i2c_new_dummy);
1365 * i2c_new_secondary_device - Helper to get the instantiated secondary address
1366 * and create the associated device
1367 * @client: Handle to the primary client
1368 * @name: Handle to specify which secondary address to get
1369 * @default_addr: Used as a fallback if no secondary address was specified
1370 * Context: can sleep
1372 * I2C clients can be composed of multiple I2C slaves bound together in a single
1373 * component. The I2C client driver then binds to the master I2C slave and needs
1374 * to create I2C dummy clients to communicate with all the other slaves.
1376 * This function creates and returns an I2C dummy client whose I2C address is
1377 * retrieved from the platform firmware based on the given slave name. If no
1378 * address is specified by the firmware default_addr is used.
1380 * On DT-based platforms the address is retrieved from the "reg" property entry
1381 * cell whose "reg-names" value matches the slave name.
1383 * This returns the new i2c client, which should be saved for later use with
1384 * i2c_unregister_device(); or NULL to indicate an error.
1386 struct i2c_client *i2c_new_secondary_device(struct i2c_client *client,
1390 struct device_node *np = client->dev.of_node;
1391 u32 addr = default_addr;
1395 i = of_property_match_string(np, "reg-names", name);
1397 of_property_read_u32_index(np, "reg", i, &addr);
1400 dev_dbg(&client->adapter->dev, "Address for %s : 0x%x\n", name, addr);
1401 return i2c_new_dummy(client->adapter, addr);
1403 EXPORT_SYMBOL_GPL(i2c_new_secondary_device);
1405 /* ------------------------------------------------------------------------- */
1407 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
1409 static void i2c_adapter_dev_release(struct device *dev)
1411 struct i2c_adapter *adap = to_i2c_adapter(dev);
1412 complete(&adap->dev_released);
1416 * This function is only needed for mutex_lock_nested, so it is never
1417 * called unless locking correctness checking is enabled. Thus we
1418 * make it inline to avoid a compiler warning. That's what gcc ends up
1421 static inline unsigned int i2c_adapter_depth(struct i2c_adapter *adapter)
1423 unsigned int depth = 0;
1425 while ((adapter = i2c_parent_is_i2c_adapter(adapter)))
1432 * Let users instantiate I2C devices through sysfs. This can be used when
1433 * platform initialization code doesn't contain the proper data for
1434 * whatever reason. Also useful for drivers that do device detection and
1435 * detection fails, either because the device uses an unexpected address,
1436 * or this is a compatible device with different ID register values.
1438 * Parameter checking may look overzealous, but we really don't want
1439 * the user to provide incorrect parameters.
1442 i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
1443 const char *buf, size_t count)
1445 struct i2c_adapter *adap = to_i2c_adapter(dev);
1446 struct i2c_board_info info;
1447 struct i2c_client *client;
1451 memset(&info, 0, sizeof(struct i2c_board_info));
1453 blank = strchr(buf, ' ');
1455 dev_err(dev, "%s: Missing parameters\n", "new_device");
1458 if (blank - buf > I2C_NAME_SIZE - 1) {
1459 dev_err(dev, "%s: Invalid device name\n", "new_device");
1462 memcpy(info.type, buf, blank - buf);
1464 /* Parse remaining parameters, reject extra parameters */
1465 res = sscanf(++blank, "%hi%c", &info.addr, &end);
1467 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
1470 if (res > 1 && end != '\n') {
1471 dev_err(dev, "%s: Extra parameters\n", "new_device");
1475 if ((info.addr & I2C_ADDR_OFFSET_TEN_BIT) == I2C_ADDR_OFFSET_TEN_BIT) {
1476 info.addr &= ~I2C_ADDR_OFFSET_TEN_BIT;
1477 info.flags |= I2C_CLIENT_TEN;
1480 if (info.addr & I2C_ADDR_OFFSET_SLAVE) {
1481 info.addr &= ~I2C_ADDR_OFFSET_SLAVE;
1482 info.flags |= I2C_CLIENT_SLAVE;
1485 client = i2c_new_device(adap, &info);
1489 /* Keep track of the added device */
1490 mutex_lock(&adap->userspace_clients_lock);
1491 list_add_tail(&client->detected, &adap->userspace_clients);
1492 mutex_unlock(&adap->userspace_clients_lock);
1493 dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
1494 info.type, info.addr);
1498 static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
1501 * And of course let the users delete the devices they instantiated, if
1502 * they got it wrong. This interface can only be used to delete devices
1503 * instantiated by i2c_sysfs_new_device above. This guarantees that we
1504 * don't delete devices to which some kernel code still has references.
1506 * Parameter checking may look overzealous, but we really don't want
1507 * the user to delete the wrong device.
1510 i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
1511 const char *buf, size_t count)
1513 struct i2c_adapter *adap = to_i2c_adapter(dev);
1514 struct i2c_client *client, *next;
1515 unsigned short addr;
1519 /* Parse parameters, reject extra parameters */
1520 res = sscanf(buf, "%hi%c", &addr, &end);
1522 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
1525 if (res > 1 && end != '\n') {
1526 dev_err(dev, "%s: Extra parameters\n", "delete_device");
1530 /* Make sure the device was added through sysfs */
1532 mutex_lock_nested(&adap->userspace_clients_lock,
1533 i2c_adapter_depth(adap));
1534 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1536 if (i2c_encode_flags_to_addr(client) == addr) {
1537 dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
1538 "delete_device", client->name, client->addr);
1540 list_del(&client->detected);
1541 i2c_unregister_device(client);
1546 mutex_unlock(&adap->userspace_clients_lock);
1549 dev_err(dev, "%s: Can't find device in list\n",
1553 static DEVICE_ATTR_IGNORE_LOCKDEP(delete_device, S_IWUSR, NULL,
1554 i2c_sysfs_delete_device);
1556 static struct attribute *i2c_adapter_attrs[] = {
1557 &dev_attr_name.attr,
1558 &dev_attr_new_device.attr,
1559 &dev_attr_delete_device.attr,
1562 ATTRIBUTE_GROUPS(i2c_adapter);
1564 struct device_type i2c_adapter_type = {
1565 .groups = i2c_adapter_groups,
1566 .release = i2c_adapter_dev_release,
1568 EXPORT_SYMBOL_GPL(i2c_adapter_type);
1571 * i2c_verify_adapter - return parameter as i2c_adapter or NULL
1572 * @dev: device, probably from some driver model iterator
1574 * When traversing the driver model tree, perhaps using driver model
1575 * iterators like @device_for_each_child(), you can't assume very much
1576 * about the nodes you find. Use this function to avoid oopses caused
1577 * by wrongly treating some non-I2C device as an i2c_adapter.
1579 struct i2c_adapter *i2c_verify_adapter(struct device *dev)
1581 return (dev->type == &i2c_adapter_type)
1582 ? to_i2c_adapter(dev)
1585 EXPORT_SYMBOL(i2c_verify_adapter);
1587 #ifdef CONFIG_I2C_COMPAT
1588 static struct class_compat *i2c_adapter_compat_class;
1591 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
1593 struct i2c_devinfo *devinfo;
1595 down_read(&__i2c_board_lock);
1596 list_for_each_entry(devinfo, &__i2c_board_list, list) {
1597 if (devinfo->busnum == adapter->nr
1598 && !i2c_new_device(adapter,
1599 &devinfo->board_info))
1600 dev_err(&adapter->dev,
1601 "Can't create device at 0x%02x\n",
1602 devinfo->board_info.addr);
1604 up_read(&__i2c_board_lock);
1607 /* OF support code */
1609 #if IS_ENABLED(CONFIG_OF)
1610 static struct i2c_client *of_i2c_register_device(struct i2c_adapter *adap,
1611 struct device_node *node)
1613 struct i2c_client *result;
1614 struct i2c_board_info info = {};
1615 struct dev_archdata dev_ad = {};
1616 const __be32 *addr_be;
1620 dev_dbg(&adap->dev, "of_i2c: register %s\n", node->full_name);
1622 if (of_modalias_node(node, info.type, sizeof(info.type)) < 0) {
1623 dev_err(&adap->dev, "of_i2c: modalias failure on %s\n",
1625 return ERR_PTR(-EINVAL);
1628 addr_be = of_get_property(node, "reg", &len);
1629 if (!addr_be || (len < sizeof(*addr_be))) {
1630 dev_err(&adap->dev, "of_i2c: invalid reg on %s\n",
1632 return ERR_PTR(-EINVAL);
1635 addr = be32_to_cpup(addr_be);
1636 if (addr & I2C_TEN_BIT_ADDRESS) {
1637 addr &= ~I2C_TEN_BIT_ADDRESS;
1638 info.flags |= I2C_CLIENT_TEN;
1641 if (addr & I2C_OWN_SLAVE_ADDRESS) {
1642 addr &= ~I2C_OWN_SLAVE_ADDRESS;
1643 info.flags |= I2C_CLIENT_SLAVE;
1646 if (i2c_check_addr_validity(addr, info.flags)) {
1647 dev_err(&adap->dev, "of_i2c: invalid addr=%x on %s\n",
1648 info.addr, node->full_name);
1649 return ERR_PTR(-EINVAL);
1653 info.of_node = of_node_get(node);
1654 info.archdata = &dev_ad;
1656 if (of_get_property(node, "wakeup-source", NULL))
1657 info.flags |= I2C_CLIENT_WAKE;
1659 result = i2c_new_device(adap, &info);
1660 if (result == NULL) {
1661 dev_err(&adap->dev, "of_i2c: Failure registering %s\n",
1664 return ERR_PTR(-EINVAL);
1669 static void of_i2c_register_devices(struct i2c_adapter *adap)
1671 struct device_node *node;
1673 /* Only register child devices if the adapter has a node pointer set */
1674 if (!adap->dev.of_node)
1677 dev_dbg(&adap->dev, "of_i2c: walking child nodes\n");
1679 for_each_available_child_of_node(adap->dev.of_node, node) {
1680 if (of_node_test_and_set_flag(node, OF_POPULATED))
1682 of_i2c_register_device(adap, node);
1686 static int of_dev_node_match(struct device *dev, void *data)
1688 return dev->of_node == data;
1691 /* must call put_device() when done with returned i2c_client device */
1692 struct i2c_client *of_find_i2c_device_by_node(struct device_node *node)
1695 struct i2c_client *client;
1697 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
1701 client = i2c_verify_client(dev);
1707 EXPORT_SYMBOL(of_find_i2c_device_by_node);
1709 /* must call put_device() when done with returned i2c_adapter device */
1710 struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node)
1713 struct i2c_adapter *adapter;
1715 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
1719 adapter = i2c_verify_adapter(dev);
1725 EXPORT_SYMBOL(of_find_i2c_adapter_by_node);
1727 /* must call i2c_put_adapter() when done with returned i2c_adapter device */
1728 struct i2c_adapter *of_get_i2c_adapter_by_node(struct device_node *node)
1730 struct i2c_adapter *adapter;
1732 adapter = of_find_i2c_adapter_by_node(node);
1736 if (!try_module_get(adapter->owner)) {
1737 put_device(&adapter->dev);
1743 EXPORT_SYMBOL(of_get_i2c_adapter_by_node);
1745 static void of_i2c_register_devices(struct i2c_adapter *adap) { }
1746 #endif /* CONFIG_OF */
1748 static int i2c_do_add_adapter(struct i2c_driver *driver,
1749 struct i2c_adapter *adap)
1751 /* Detect supported devices on that bus, and instantiate them */
1752 i2c_detect(adap, driver);
1754 /* Let legacy drivers scan this bus for matching devices */
1755 if (driver->attach_adapter) {
1756 dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
1757 driver->driver.name);
1758 dev_warn(&adap->dev, "Please use another way to instantiate "
1759 "your i2c_client\n");
1760 /* We ignore the return code; if it fails, too bad */
1761 driver->attach_adapter(adap);
1766 static int __process_new_adapter(struct device_driver *d, void *data)
1768 return i2c_do_add_adapter(to_i2c_driver(d), data);
1771 static const struct i2c_lock_operations i2c_adapter_lock_ops = {
1772 .lock_bus = i2c_adapter_lock_bus,
1773 .trylock_bus = i2c_adapter_trylock_bus,
1774 .unlock_bus = i2c_adapter_unlock_bus,
1777 static int i2c_register_adapter(struct i2c_adapter *adap)
1781 /* Can't register until after driver model init */
1782 if (WARN_ON(!is_registered)) {
1788 if (WARN(!adap->name[0], "i2c adapter has no name"))
1792 pr_err("adapter '%s': no algo supplied!\n", adap->name);
1796 if (!adap->lock_ops)
1797 adap->lock_ops = &i2c_adapter_lock_ops;
1799 rt_mutex_init(&adap->bus_lock);
1800 rt_mutex_init(&adap->mux_lock);
1801 mutex_init(&adap->userspace_clients_lock);
1802 INIT_LIST_HEAD(&adap->userspace_clients);
1804 /* Set default timeout to 1 second if not already set */
1805 if (adap->timeout == 0)
1808 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
1809 adap->dev.bus = &i2c_bus_type;
1810 adap->dev.type = &i2c_adapter_type;
1811 res = device_register(&adap->dev);
1813 pr_err("adapter '%s': can't register device (%d)\n", adap->name, res);
1817 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
1819 pm_runtime_no_callbacks(&adap->dev);
1820 pm_suspend_ignore_children(&adap->dev, true);
1821 pm_runtime_enable(&adap->dev);
1823 #ifdef CONFIG_I2C_COMPAT
1824 res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
1827 dev_warn(&adap->dev,
1828 "Failed to create compatibility class link\n");
1831 i2c_init_recovery(adap);
1833 /* create pre-declared device nodes */
1834 of_i2c_register_devices(adap);
1835 i2c_acpi_register_devices(adap);
1836 i2c_acpi_install_space_handler(adap);
1838 if (adap->nr < __i2c_first_dynamic_bus_num)
1839 i2c_scan_static_board_info(adap);
1841 /* Notify drivers */
1842 mutex_lock(&core_lock);
1843 bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
1844 mutex_unlock(&core_lock);
1849 mutex_lock(&core_lock);
1850 idr_remove(&i2c_adapter_idr, adap->nr);
1851 mutex_unlock(&core_lock);
1856 * __i2c_add_numbered_adapter - i2c_add_numbered_adapter where nr is never -1
1857 * @adap: the adapter to register (with adap->nr initialized)
1858 * Context: can sleep
1860 * See i2c_add_numbered_adapter() for details.
1862 static int __i2c_add_numbered_adapter(struct i2c_adapter *adap)
1866 mutex_lock(&core_lock);
1867 id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1, GFP_KERNEL);
1868 mutex_unlock(&core_lock);
1869 if (WARN(id < 0, "couldn't get idr"))
1870 return id == -ENOSPC ? -EBUSY : id;
1872 return i2c_register_adapter(adap);
1876 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
1877 * @adapter: the adapter to add
1878 * Context: can sleep
1880 * This routine is used to declare an I2C adapter when its bus number
1881 * doesn't matter or when its bus number is specified by an dt alias.
1882 * Examples of bases when the bus number doesn't matter: I2C adapters
1883 * dynamically added by USB links or PCI plugin cards.
1885 * When this returns zero, a new bus number was allocated and stored
1886 * in adap->nr, and the specified adapter became available for clients.
1887 * Otherwise, a negative errno value is returned.
1889 int i2c_add_adapter(struct i2c_adapter *adapter)
1891 struct device *dev = &adapter->dev;
1895 id = of_alias_get_id(dev->of_node, "i2c");
1898 return __i2c_add_numbered_adapter(adapter);
1902 mutex_lock(&core_lock);
1903 id = idr_alloc(&i2c_adapter_idr, adapter,
1904 __i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
1905 mutex_unlock(&core_lock);
1906 if (WARN(id < 0, "couldn't get idr"))
1911 return i2c_register_adapter(adapter);
1913 EXPORT_SYMBOL(i2c_add_adapter);
1916 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
1917 * @adap: the adapter to register (with adap->nr initialized)
1918 * Context: can sleep
1920 * This routine is used to declare an I2C adapter when its bus number
1921 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
1922 * or otherwise built in to the system's mainboard, and where i2c_board_info
1923 * is used to properly configure I2C devices.
1925 * If the requested bus number is set to -1, then this function will behave
1926 * identically to i2c_add_adapter, and will dynamically assign a bus number.
1928 * If no devices have pre-been declared for this bus, then be sure to
1929 * register the adapter before any dynamically allocated ones. Otherwise
1930 * the required bus ID may not be available.
1932 * When this returns zero, the specified adapter became available for
1933 * clients using the bus number provided in adap->nr. Also, the table
1934 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
1935 * and the appropriate driver model device nodes are created. Otherwise, a
1936 * negative errno value is returned.
1938 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
1940 if (adap->nr == -1) /* -1 means dynamically assign bus id */
1941 return i2c_add_adapter(adap);
1943 return __i2c_add_numbered_adapter(adap);
1945 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
1947 static void i2c_do_del_adapter(struct i2c_driver *driver,
1948 struct i2c_adapter *adapter)
1950 struct i2c_client *client, *_n;
1952 /* Remove the devices we created ourselves as the result of hardware
1953 * probing (using a driver's detect method) */
1954 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
1955 if (client->adapter == adapter) {
1956 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
1957 client->name, client->addr);
1958 list_del(&client->detected);
1959 i2c_unregister_device(client);
1964 static int __unregister_client(struct device *dev, void *dummy)
1966 struct i2c_client *client = i2c_verify_client(dev);
1967 if (client && strcmp(client->name, "dummy"))
1968 i2c_unregister_device(client);
1972 static int __unregister_dummy(struct device *dev, void *dummy)
1974 struct i2c_client *client = i2c_verify_client(dev);
1976 i2c_unregister_device(client);
1980 static int __process_removed_adapter(struct device_driver *d, void *data)
1982 i2c_do_del_adapter(to_i2c_driver(d), data);
1987 * i2c_del_adapter - unregister I2C adapter
1988 * @adap: the adapter being unregistered
1989 * Context: can sleep
1991 * This unregisters an I2C adapter which was previously registered
1992 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
1994 void i2c_del_adapter(struct i2c_adapter *adap)
1996 struct i2c_adapter *found;
1997 struct i2c_client *client, *next;
1999 /* First make sure that this adapter was ever added */
2000 mutex_lock(&core_lock);
2001 found = idr_find(&i2c_adapter_idr, adap->nr);
2002 mutex_unlock(&core_lock);
2003 if (found != adap) {
2004 pr_debug("attempting to delete unregistered adapter [%s]\n", adap->name);
2008 i2c_acpi_remove_space_handler(adap);
2009 /* Tell drivers about this removal */
2010 mutex_lock(&core_lock);
2011 bus_for_each_drv(&i2c_bus_type, NULL, adap,
2012 __process_removed_adapter);
2013 mutex_unlock(&core_lock);
2015 /* Remove devices instantiated from sysfs */
2016 mutex_lock_nested(&adap->userspace_clients_lock,
2017 i2c_adapter_depth(adap));
2018 list_for_each_entry_safe(client, next, &adap->userspace_clients,
2020 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
2022 list_del(&client->detected);
2023 i2c_unregister_device(client);
2025 mutex_unlock(&adap->userspace_clients_lock);
2027 /* Detach any active clients. This can't fail, thus we do not
2028 * check the returned value. This is a two-pass process, because
2029 * we can't remove the dummy devices during the first pass: they
2030 * could have been instantiated by real devices wishing to clean
2031 * them up properly, so we give them a chance to do that first. */
2032 device_for_each_child(&adap->dev, NULL, __unregister_client);
2033 device_for_each_child(&adap->dev, NULL, __unregister_dummy);
2035 #ifdef CONFIG_I2C_COMPAT
2036 class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
2040 /* device name is gone after device_unregister */
2041 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
2043 pm_runtime_disable(&adap->dev);
2045 /* wait until all references to the device are gone
2047 * FIXME: This is old code and should ideally be replaced by an
2048 * alternative which results in decoupling the lifetime of the struct
2049 * device from the i2c_adapter, like spi or netdev do. Any solution
2050 * should be thoroughly tested with DEBUG_KOBJECT_RELEASE enabled!
2052 init_completion(&adap->dev_released);
2053 device_unregister(&adap->dev);
2054 wait_for_completion(&adap->dev_released);
2057 mutex_lock(&core_lock);
2058 idr_remove(&i2c_adapter_idr, adap->nr);
2059 mutex_unlock(&core_lock);
2061 /* Clear the device structure in case this adapter is ever going to be
2063 memset(&adap->dev, 0, sizeof(adap->dev));
2065 EXPORT_SYMBOL(i2c_del_adapter);
2068 * i2c_parse_fw_timings - get I2C related timing parameters from firmware
2069 * @dev: The device to scan for I2C timing properties
2070 * @t: the i2c_timings struct to be filled with values
2071 * @use_defaults: bool to use sane defaults derived from the I2C specification
2072 * when properties are not found, otherwise use 0
2074 * Scan the device for the generic I2C properties describing timing parameters
2075 * for the signal and fill the given struct with the results. If a property was
2076 * not found and use_defaults was true, then maximum timings are assumed which
2077 * are derived from the I2C specification. If use_defaults is not used, the
2078 * results will be 0, so drivers can apply their own defaults later. The latter
2079 * is mainly intended for avoiding regressions of existing drivers which want
2080 * to switch to this function. New drivers almost always should use the defaults.
2083 void i2c_parse_fw_timings(struct device *dev, struct i2c_timings *t, bool use_defaults)
2087 memset(t, 0, sizeof(*t));
2089 ret = device_property_read_u32(dev, "clock-frequency", &t->bus_freq_hz);
2090 if (ret && use_defaults)
2091 t->bus_freq_hz = 100000;
2093 ret = device_property_read_u32(dev, "i2c-scl-rising-time-ns", &t->scl_rise_ns);
2094 if (ret && use_defaults) {
2095 if (t->bus_freq_hz <= 100000)
2096 t->scl_rise_ns = 1000;
2097 else if (t->bus_freq_hz <= 400000)
2098 t->scl_rise_ns = 300;
2100 t->scl_rise_ns = 120;
2103 ret = device_property_read_u32(dev, "i2c-scl-falling-time-ns", &t->scl_fall_ns);
2104 if (ret && use_defaults) {
2105 if (t->bus_freq_hz <= 400000)
2106 t->scl_fall_ns = 300;
2108 t->scl_fall_ns = 120;
2111 device_property_read_u32(dev, "i2c-scl-internal-delay-ns", &t->scl_int_delay_ns);
2113 ret = device_property_read_u32(dev, "i2c-sda-falling-time-ns", &t->sda_fall_ns);
2114 if (ret && use_defaults)
2115 t->sda_fall_ns = t->scl_fall_ns;
2117 EXPORT_SYMBOL_GPL(i2c_parse_fw_timings);
2119 /* ------------------------------------------------------------------------- */
2121 int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
2125 mutex_lock(&core_lock);
2126 res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
2127 mutex_unlock(&core_lock);
2131 EXPORT_SYMBOL_GPL(i2c_for_each_dev);
2133 static int __process_new_driver(struct device *dev, void *data)
2135 if (dev->type != &i2c_adapter_type)
2137 return i2c_do_add_adapter(data, to_i2c_adapter(dev));
2141 * An i2c_driver is used with one or more i2c_client (device) nodes to access
2142 * i2c slave chips, on a bus instance associated with some i2c_adapter.
2145 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
2149 /* Can't register until after driver model init */
2150 if (WARN_ON(!is_registered))
2153 /* add the driver to the list of i2c drivers in the driver core */
2154 driver->driver.owner = owner;
2155 driver->driver.bus = &i2c_bus_type;
2157 /* When registration returns, the driver core
2158 * will have called probe() for all matching-but-unbound devices.
2160 res = driver_register(&driver->driver);
2164 pr_debug("driver [%s] registered\n", driver->driver.name);
2166 INIT_LIST_HEAD(&driver->clients);
2167 /* Walk the adapters that are already present */
2168 i2c_for_each_dev(driver, __process_new_driver);
2172 EXPORT_SYMBOL(i2c_register_driver);
2174 static int __process_removed_driver(struct device *dev, void *data)
2176 if (dev->type == &i2c_adapter_type)
2177 i2c_do_del_adapter(data, to_i2c_adapter(dev));
2182 * i2c_del_driver - unregister I2C driver
2183 * @driver: the driver being unregistered
2184 * Context: can sleep
2186 void i2c_del_driver(struct i2c_driver *driver)
2188 i2c_for_each_dev(driver, __process_removed_driver);
2190 driver_unregister(&driver->driver);
2191 pr_debug("driver [%s] unregistered\n", driver->driver.name);
2193 EXPORT_SYMBOL(i2c_del_driver);
2195 /* ------------------------------------------------------------------------- */
2198 * i2c_use_client - increments the reference count of the i2c client structure
2199 * @client: the client being referenced
2201 * Each live reference to a client should be refcounted. The driver model does
2202 * that automatically as part of driver binding, so that most drivers don't
2203 * need to do this explicitly: they hold a reference until they're unbound
2206 * A pointer to the client with the incremented reference counter is returned.
2208 struct i2c_client *i2c_use_client(struct i2c_client *client)
2210 if (client && get_device(&client->dev))
2214 EXPORT_SYMBOL(i2c_use_client);
2217 * i2c_release_client - release a use of the i2c client structure
2218 * @client: the client being no longer referenced
2220 * Must be called when a user of a client is finished with it.
2222 void i2c_release_client(struct i2c_client *client)
2225 put_device(&client->dev);
2227 EXPORT_SYMBOL(i2c_release_client);
2229 struct i2c_cmd_arg {
2234 static int i2c_cmd(struct device *dev, void *_arg)
2236 struct i2c_client *client = i2c_verify_client(dev);
2237 struct i2c_cmd_arg *arg = _arg;
2238 struct i2c_driver *driver;
2240 if (!client || !client->dev.driver)
2243 driver = to_i2c_driver(client->dev.driver);
2244 if (driver->command)
2245 driver->command(client, arg->cmd, arg->arg);
2249 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
2251 struct i2c_cmd_arg cmd_arg;
2255 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
2257 EXPORT_SYMBOL(i2c_clients_command);
2259 #if IS_ENABLED(CONFIG_OF_DYNAMIC)
2260 static int of_i2c_notify(struct notifier_block *nb, unsigned long action,
2263 struct of_reconfig_data *rd = arg;
2264 struct i2c_adapter *adap;
2265 struct i2c_client *client;
2267 switch (of_reconfig_get_state_change(action, rd)) {
2268 case OF_RECONFIG_CHANGE_ADD:
2269 adap = of_find_i2c_adapter_by_node(rd->dn->parent);
2271 return NOTIFY_OK; /* not for us */
2273 if (of_node_test_and_set_flag(rd->dn, OF_POPULATED)) {
2274 put_device(&adap->dev);
2278 client = of_i2c_register_device(adap, rd->dn);
2279 put_device(&adap->dev);
2281 if (IS_ERR(client)) {
2282 dev_err(&adap->dev, "failed to create client for '%s'\n",
2284 return notifier_from_errno(PTR_ERR(client));
2287 case OF_RECONFIG_CHANGE_REMOVE:
2288 /* already depopulated? */
2289 if (!of_node_check_flag(rd->dn, OF_POPULATED))
2292 /* find our device by node */
2293 client = of_find_i2c_device_by_node(rd->dn);
2295 return NOTIFY_OK; /* no? not meant for us */
2297 /* unregister takes one ref away */
2298 i2c_unregister_device(client);
2300 /* and put the reference of the find */
2301 put_device(&client->dev);
2307 static struct notifier_block i2c_of_notifier = {
2308 .notifier_call = of_i2c_notify,
2311 extern struct notifier_block i2c_of_notifier;
2312 #endif /* CONFIG_OF_DYNAMIC */
2314 static int __init i2c_init(void)
2318 retval = of_alias_get_highest_id("i2c");
2320 down_write(&__i2c_board_lock);
2321 if (retval >= __i2c_first_dynamic_bus_num)
2322 __i2c_first_dynamic_bus_num = retval + 1;
2323 up_write(&__i2c_board_lock);
2325 retval = bus_register(&i2c_bus_type);
2329 is_registered = true;
2331 #ifdef CONFIG_I2C_COMPAT
2332 i2c_adapter_compat_class = class_compat_register("i2c-adapter");
2333 if (!i2c_adapter_compat_class) {
2338 retval = i2c_add_driver(&dummy_driver);
2342 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2343 WARN_ON(of_reconfig_notifier_register(&i2c_of_notifier));
2344 if (IS_ENABLED(CONFIG_ACPI))
2345 WARN_ON(acpi_reconfig_notifier_register(&i2c_acpi_notifier));
2350 #ifdef CONFIG_I2C_COMPAT
2351 class_compat_unregister(i2c_adapter_compat_class);
2354 is_registered = false;
2355 bus_unregister(&i2c_bus_type);
2359 static void __exit i2c_exit(void)
2361 if (IS_ENABLED(CONFIG_ACPI))
2362 WARN_ON(acpi_reconfig_notifier_unregister(&i2c_acpi_notifier));
2363 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2364 WARN_ON(of_reconfig_notifier_unregister(&i2c_of_notifier));
2365 i2c_del_driver(&dummy_driver);
2366 #ifdef CONFIG_I2C_COMPAT
2367 class_compat_unregister(i2c_adapter_compat_class);
2369 bus_unregister(&i2c_bus_type);
2370 tracepoint_synchronize_unregister();
2373 /* We must initialize early, because some subsystems register i2c drivers
2374 * in subsys_initcall() code, but are linked (and initialized) before i2c.
2376 postcore_initcall(i2c_init);
2377 module_exit(i2c_exit);
2379 /* ----------------------------------------------------
2380 * the functional interface to the i2c busses.
2381 * ----------------------------------------------------
2384 /* Check if val is exceeding the quirk IFF quirk is non 0 */
2385 #define i2c_quirk_exceeded(val, quirk) ((quirk) && ((val) > (quirk)))
2387 static int i2c_quirk_error(struct i2c_adapter *adap, struct i2c_msg *msg, char *err_msg)
2389 dev_err_ratelimited(&adap->dev, "adapter quirk: %s (addr 0x%04x, size %u, %s)\n",
2390 err_msg, msg->addr, msg->len,
2391 msg->flags & I2C_M_RD ? "read" : "write");
2395 static int i2c_check_for_quirks(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2397 const struct i2c_adapter_quirks *q = adap->quirks;
2398 int max_num = q->max_num_msgs, i;
2399 bool do_len_check = true;
2401 if (q->flags & I2C_AQ_COMB) {
2404 /* special checks for combined messages */
2406 if (q->flags & I2C_AQ_COMB_WRITE_FIRST && msgs[0].flags & I2C_M_RD)
2407 return i2c_quirk_error(adap, &msgs[0], "1st comb msg must be write");
2409 if (q->flags & I2C_AQ_COMB_READ_SECOND && !(msgs[1].flags & I2C_M_RD))
2410 return i2c_quirk_error(adap, &msgs[1], "2nd comb msg must be read");
2412 if (q->flags & I2C_AQ_COMB_SAME_ADDR && msgs[0].addr != msgs[1].addr)
2413 return i2c_quirk_error(adap, &msgs[0], "comb msg only to same addr");
2415 if (i2c_quirk_exceeded(msgs[0].len, q->max_comb_1st_msg_len))
2416 return i2c_quirk_error(adap, &msgs[0], "msg too long");
2418 if (i2c_quirk_exceeded(msgs[1].len, q->max_comb_2nd_msg_len))
2419 return i2c_quirk_error(adap, &msgs[1], "msg too long");
2421 do_len_check = false;
2425 if (i2c_quirk_exceeded(num, max_num))
2426 return i2c_quirk_error(adap, &msgs[0], "too many messages");
2428 for (i = 0; i < num; i++) {
2429 u16 len = msgs[i].len;
2431 if (msgs[i].flags & I2C_M_RD) {
2432 if (do_len_check && i2c_quirk_exceeded(len, q->max_read_len))
2433 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2435 if (do_len_check && i2c_quirk_exceeded(len, q->max_write_len))
2436 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2444 * __i2c_transfer - unlocked flavor of i2c_transfer
2445 * @adap: Handle to I2C bus
2446 * @msgs: One or more messages to execute before STOP is issued to
2447 * terminate the operation; each message begins with a START.
2448 * @num: Number of messages to be executed.
2450 * Returns negative errno, else the number of messages executed.
2452 * Adapter lock must be held when calling this function. No debug logging
2453 * takes place. adap->algo->master_xfer existence isn't checked.
2455 int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2457 unsigned long orig_jiffies;
2460 if (adap->quirks && i2c_check_for_quirks(adap, msgs, num))
2463 /* i2c_trace_msg gets enabled when tracepoint i2c_transfer gets
2464 * enabled. This is an efficient way of keeping the for-loop from
2465 * being executed when not needed.
2467 if (static_key_false(&i2c_trace_msg)) {
2469 for (i = 0; i < num; i++)
2470 if (msgs[i].flags & I2C_M_RD)
2471 trace_i2c_read(adap, &msgs[i], i);
2473 trace_i2c_write(adap, &msgs[i], i);
2476 /* Retry automatically on arbitration loss */
2477 orig_jiffies = jiffies;
2478 for (ret = 0, try = 0; try <= adap->retries; try++) {
2479 ret = adap->algo->master_xfer(adap, msgs, num);
2482 if (time_after(jiffies, orig_jiffies + adap->timeout))
2486 if (static_key_false(&i2c_trace_msg)) {
2488 for (i = 0; i < ret; i++)
2489 if (msgs[i].flags & I2C_M_RD)
2490 trace_i2c_reply(adap, &msgs[i], i);
2491 trace_i2c_result(adap, i, ret);
2496 EXPORT_SYMBOL(__i2c_transfer);
2499 * i2c_transfer - execute a single or combined I2C message
2500 * @adap: Handle to I2C bus
2501 * @msgs: One or more messages to execute before STOP is issued to
2502 * terminate the operation; each message begins with a START.
2503 * @num: Number of messages to be executed.
2505 * Returns negative errno, else the number of messages executed.
2507 * Note that there is no requirement that each message be sent to
2508 * the same slave address, although that is the most common model.
2510 int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2514 /* REVISIT the fault reporting model here is weak:
2516 * - When we get an error after receiving N bytes from a slave,
2517 * there is no way to report "N".
2519 * - When we get a NAK after transmitting N bytes to a slave,
2520 * there is no way to report "N" ... or to let the master
2521 * continue executing the rest of this combined message, if
2522 * that's the appropriate response.
2524 * - When for example "num" is two and we successfully complete
2525 * the first message but get an error part way through the
2526 * second, it's unclear whether that should be reported as
2527 * one (discarding status on the second message) or errno
2528 * (discarding status on the first one).
2531 if (adap->algo->master_xfer) {
2533 for (ret = 0; ret < num; ret++) {
2534 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
2535 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
2536 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
2537 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
2541 if (in_atomic() || irqs_disabled()) {
2542 ret = i2c_trylock_bus(adap, I2C_LOCK_SEGMENT);
2544 /* I2C activity is ongoing. */
2547 i2c_lock_bus(adap, I2C_LOCK_SEGMENT);
2550 ret = __i2c_transfer(adap, msgs, num);
2551 i2c_unlock_bus(adap, I2C_LOCK_SEGMENT);
2555 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
2559 EXPORT_SYMBOL(i2c_transfer);
2562 * i2c_master_send - issue a single I2C message in master transmit mode
2563 * @client: Handle to slave device
2564 * @buf: Data that will be written to the slave
2565 * @count: How many bytes to write, must be less than 64k since msg.len is u16
2567 * Returns negative errno, or else the number of bytes written.
2569 int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
2572 struct i2c_adapter *adap = client->adapter;
2575 msg.addr = client->addr;
2576 msg.flags = client->flags & I2C_M_TEN;
2578 msg.buf = (char *)buf;
2580 ret = i2c_transfer(adap, &msg, 1);
2583 * If everything went ok (i.e. 1 msg transmitted), return #bytes
2584 * transmitted, else error code.
2586 return (ret == 1) ? count : ret;
2588 EXPORT_SYMBOL(i2c_master_send);
2591 * i2c_master_recv - issue a single I2C message in master receive mode
2592 * @client: Handle to slave device
2593 * @buf: Where to store data read from slave
2594 * @count: How many bytes to read, must be less than 64k since msg.len is u16
2596 * Returns negative errno, or else the number of bytes read.
2598 int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
2600 struct i2c_adapter *adap = client->adapter;
2604 msg.addr = client->addr;
2605 msg.flags = client->flags & I2C_M_TEN;
2606 msg.flags |= I2C_M_RD;
2610 ret = i2c_transfer(adap, &msg, 1);
2613 * If everything went ok (i.e. 1 msg received), return #bytes received,
2616 return (ret == 1) ? count : ret;
2618 EXPORT_SYMBOL(i2c_master_recv);
2620 /* ----------------------------------------------------
2621 * the i2c address scanning function
2622 * Will not work for 10-bit addresses!
2623 * ----------------------------------------------------
2627 * Legacy default probe function, mostly relevant for SMBus. The default
2628 * probe method is a quick write, but it is known to corrupt the 24RF08
2629 * EEPROMs due to a state machine bug, and could also irreversibly
2630 * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
2631 * we use a short byte read instead. Also, some bus drivers don't implement
2632 * quick write, so we fallback to a byte read in that case too.
2633 * On x86, there is another special case for FSC hardware monitoring chips,
2634 * which want regular byte reads (address 0x73.) Fortunately, these are the
2635 * only known chips using this I2C address on PC hardware.
2636 * Returns 1 if probe succeeded, 0 if not.
2638 static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
2641 union i2c_smbus_data dummy;
2644 if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
2645 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
2646 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2647 I2C_SMBUS_BYTE_DATA, &dummy);
2650 if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
2651 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
2652 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
2653 I2C_SMBUS_QUICK, NULL);
2654 else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
2655 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2656 I2C_SMBUS_BYTE, &dummy);
2658 dev_warn(&adap->dev, "No suitable probing method supported for address 0x%02X\n",
2666 static int i2c_detect_address(struct i2c_client *temp_client,
2667 struct i2c_driver *driver)
2669 struct i2c_board_info info;
2670 struct i2c_adapter *adapter = temp_client->adapter;
2671 int addr = temp_client->addr;
2674 /* Make sure the address is valid */
2675 err = i2c_check_7bit_addr_validity_strict(addr);
2677 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
2682 /* Skip if already in use (7 bit, no need to encode flags) */
2683 if (i2c_check_addr_busy(adapter, addr))
2686 /* Make sure there is something at this address */
2687 if (!i2c_default_probe(adapter, addr))
2690 /* Finally call the custom detection function */
2691 memset(&info, 0, sizeof(struct i2c_board_info));
2693 err = driver->detect(temp_client, &info);
2695 /* -ENODEV is returned if the detection fails. We catch it
2696 here as this isn't an error. */
2697 return err == -ENODEV ? 0 : err;
2700 /* Consistency check */
2701 if (info.type[0] == '\0') {
2702 dev_err(&adapter->dev, "%s detection function provided "
2703 "no name for 0x%x\n", driver->driver.name,
2706 struct i2c_client *client;
2708 /* Detection succeeded, instantiate the device */
2709 if (adapter->class & I2C_CLASS_DEPRECATED)
2710 dev_warn(&adapter->dev,
2711 "This adapter will soon drop class based instantiation of devices. "
2712 "Please make sure client 0x%02x gets instantiated by other means. "
2713 "Check 'Documentation/i2c/instantiating-devices' for details.\n",
2716 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
2717 info.type, info.addr);
2718 client = i2c_new_device(adapter, &info);
2720 list_add_tail(&client->detected, &driver->clients);
2722 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
2723 info.type, info.addr);
2728 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
2730 const unsigned short *address_list;
2731 struct i2c_client *temp_client;
2733 int adap_id = i2c_adapter_id(adapter);
2735 address_list = driver->address_list;
2736 if (!driver->detect || !address_list)
2739 /* Warn that the adapter lost class based instantiation */
2740 if (adapter->class == I2C_CLASS_DEPRECATED) {
2741 dev_dbg(&adapter->dev,
2742 "This adapter dropped support for I2C classes and "
2743 "won't auto-detect %s devices anymore. If you need it, check "
2744 "'Documentation/i2c/instantiating-devices' for alternatives.\n",
2745 driver->driver.name);
2749 /* Stop here if the classes do not match */
2750 if (!(adapter->class & driver->class))
2753 /* Set up a temporary client to help detect callback */
2754 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
2757 temp_client->adapter = adapter;
2759 for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
2760 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
2761 "addr 0x%02x\n", adap_id, address_list[i]);
2762 temp_client->addr = address_list[i];
2763 err = i2c_detect_address(temp_client, driver);
2772 int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
2774 return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2775 I2C_SMBUS_QUICK, NULL) >= 0;
2777 EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
2780 i2c_new_probed_device(struct i2c_adapter *adap,
2781 struct i2c_board_info *info,
2782 unsigned short const *addr_list,
2783 int (*probe)(struct i2c_adapter *, unsigned short addr))
2788 probe = i2c_default_probe;
2790 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
2791 /* Check address validity */
2792 if (i2c_check_7bit_addr_validity_strict(addr_list[i]) < 0) {
2793 dev_warn(&adap->dev, "Invalid 7-bit address "
2794 "0x%02x\n", addr_list[i]);
2798 /* Check address availability (7 bit, no need to encode flags) */
2799 if (i2c_check_addr_busy(adap, addr_list[i])) {
2800 dev_dbg(&adap->dev, "Address 0x%02x already in "
2801 "use, not probing\n", addr_list[i]);
2805 /* Test address responsiveness */
2806 if (probe(adap, addr_list[i]))
2810 if (addr_list[i] == I2C_CLIENT_END) {
2811 dev_dbg(&adap->dev, "Probing failed, no device found\n");
2815 info->addr = addr_list[i];
2816 return i2c_new_device(adap, info);
2818 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
2820 struct i2c_adapter *i2c_get_adapter(int nr)
2822 struct i2c_adapter *adapter;
2824 mutex_lock(&core_lock);
2825 adapter = idr_find(&i2c_adapter_idr, nr);
2829 if (try_module_get(adapter->owner))
2830 get_device(&adapter->dev);
2835 mutex_unlock(&core_lock);
2838 EXPORT_SYMBOL(i2c_get_adapter);
2840 void i2c_put_adapter(struct i2c_adapter *adap)
2845 put_device(&adap->dev);
2846 module_put(adap->owner);
2848 EXPORT_SYMBOL(i2c_put_adapter);
2850 /* The SMBus parts */
2852 #define POLY (0x1070U << 3)
2853 static u8 crc8(u16 data)
2857 for (i = 0; i < 8; i++) {
2862 return (u8)(data >> 8);
2865 /* Incremental CRC8 over count bytes in the array pointed to by p */
2866 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
2870 for (i = 0; i < count; i++)
2871 crc = crc8((crc ^ p[i]) << 8);
2875 /* Assume a 7-bit address, which is reasonable for SMBus */
2876 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
2878 /* The address will be sent first */
2879 u8 addr = i2c_8bit_addr_from_msg(msg);
2880 pec = i2c_smbus_pec(pec, &addr, 1);
2882 /* The data buffer follows */
2883 return i2c_smbus_pec(pec, msg->buf, msg->len);
2886 /* Used for write only transactions */
2887 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
2889 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
2893 /* Return <0 on CRC error
2894 If there was a write before this read (most cases) we need to take the
2895 partial CRC from the write part into account.
2896 Note that this function does modify the message (we need to decrease the
2897 message length to hide the CRC byte from the caller). */
2898 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
2900 u8 rpec = msg->buf[--msg->len];
2901 cpec = i2c_smbus_msg_pec(cpec, msg);
2904 pr_debug("Bad PEC 0x%02x vs. 0x%02x\n",
2912 * i2c_smbus_read_byte - SMBus "receive byte" protocol
2913 * @client: Handle to slave device
2915 * This executes the SMBus "receive byte" protocol, returning negative errno
2916 * else the byte received from the device.
2918 s32 i2c_smbus_read_byte(const struct i2c_client *client)
2920 union i2c_smbus_data data;
2923 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2925 I2C_SMBUS_BYTE, &data);
2926 return (status < 0) ? status : data.byte;
2928 EXPORT_SYMBOL(i2c_smbus_read_byte);
2931 * i2c_smbus_write_byte - SMBus "send byte" protocol
2932 * @client: Handle to slave device
2933 * @value: Byte to be sent
2935 * This executes the SMBus "send byte" protocol, returning negative errno
2936 * else zero on success.
2938 s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
2940 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2941 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
2943 EXPORT_SYMBOL(i2c_smbus_write_byte);
2946 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
2947 * @client: Handle to slave device
2948 * @command: Byte interpreted by slave
2950 * This executes the SMBus "read byte" protocol, returning negative errno
2951 * else a data byte received from the device.
2953 s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
2955 union i2c_smbus_data data;
2958 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2959 I2C_SMBUS_READ, command,
2960 I2C_SMBUS_BYTE_DATA, &data);
2961 return (status < 0) ? status : data.byte;
2963 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
2966 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
2967 * @client: Handle to slave device
2968 * @command: Byte interpreted by slave
2969 * @value: Byte being written
2971 * This executes the SMBus "write byte" protocol, returning negative errno
2972 * else zero on success.
2974 s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
2977 union i2c_smbus_data data;
2979 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2980 I2C_SMBUS_WRITE, command,
2981 I2C_SMBUS_BYTE_DATA, &data);
2983 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
2986 * i2c_smbus_read_word_data - SMBus "read word" protocol
2987 * @client: Handle to slave device
2988 * @command: Byte interpreted by slave
2990 * This executes the SMBus "read word" protocol, returning negative errno
2991 * else a 16-bit unsigned "word" received from the device.
2993 s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
2995 union i2c_smbus_data data;
2998 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2999 I2C_SMBUS_READ, command,
3000 I2C_SMBUS_WORD_DATA, &data);
3001 return (status < 0) ? status : data.word;
3003 EXPORT_SYMBOL(i2c_smbus_read_word_data);
3006 * i2c_smbus_write_word_data - SMBus "write word" protocol
3007 * @client: Handle to slave device
3008 * @command: Byte interpreted by slave
3009 * @value: 16-bit "word" being written
3011 * This executes the SMBus "write word" protocol, returning negative errno
3012 * else zero on success.
3014 s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
3017 union i2c_smbus_data data;
3019 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3020 I2C_SMBUS_WRITE, command,
3021 I2C_SMBUS_WORD_DATA, &data);
3023 EXPORT_SYMBOL(i2c_smbus_write_word_data);
3026 * i2c_smbus_read_block_data - SMBus "block read" protocol
3027 * @client: Handle to slave device
3028 * @command: Byte interpreted by slave
3029 * @values: Byte array into which data will be read; big enough to hold
3030 * the data returned by the slave. SMBus allows at most 32 bytes.
3032 * This executes the SMBus "block read" protocol, returning negative errno
3033 * else the number of data bytes in the slave's response.
3035 * Note that using this function requires that the client's adapter support
3036 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
3037 * support this; its emulation through I2C messaging relies on a specific
3038 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
3040 s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
3043 union i2c_smbus_data data;
3046 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3047 I2C_SMBUS_READ, command,
3048 I2C_SMBUS_BLOCK_DATA, &data);
3052 memcpy(values, &data.block[1], data.block[0]);
3053 return data.block[0];
3055 EXPORT_SYMBOL(i2c_smbus_read_block_data);
3058 * i2c_smbus_write_block_data - SMBus "block write" protocol
3059 * @client: Handle to slave device
3060 * @command: Byte interpreted by slave
3061 * @length: Size of data block; SMBus allows at most 32 bytes
3062 * @values: Byte array which will be written.
3064 * This executes the SMBus "block write" protocol, returning negative errno
3065 * else zero on success.
3067 s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
3068 u8 length, const u8 *values)
3070 union i2c_smbus_data data;
3072 if (length > I2C_SMBUS_BLOCK_MAX)
3073 length = I2C_SMBUS_BLOCK_MAX;
3074 data.block[0] = length;
3075 memcpy(&data.block[1], values, length);
3076 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3077 I2C_SMBUS_WRITE, command,
3078 I2C_SMBUS_BLOCK_DATA, &data);
3080 EXPORT_SYMBOL(i2c_smbus_write_block_data);
3082 /* Returns the number of read bytes */
3083 s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
3084 u8 length, u8 *values)
3086 union i2c_smbus_data data;
3089 if (length > I2C_SMBUS_BLOCK_MAX)
3090 length = I2C_SMBUS_BLOCK_MAX;
3091 data.block[0] = length;
3092 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3093 I2C_SMBUS_READ, command,
3094 I2C_SMBUS_I2C_BLOCK_DATA, &data);
3098 memcpy(values, &data.block[1], data.block[0]);
3099 return data.block[0];
3101 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
3103 s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
3104 u8 length, const u8 *values)
3106 union i2c_smbus_data data;
3108 if (length > I2C_SMBUS_BLOCK_MAX)
3109 length = I2C_SMBUS_BLOCK_MAX;
3110 data.block[0] = length;
3111 memcpy(data.block + 1, values, length);
3112 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3113 I2C_SMBUS_WRITE, command,
3114 I2C_SMBUS_I2C_BLOCK_DATA, &data);
3116 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
3118 /* Simulate a SMBus command using the i2c protocol
3119 No checking of parameters is done! */
3120 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
3121 unsigned short flags,
3122 char read_write, u8 command, int size,
3123 union i2c_smbus_data *data)
3125 /* So we need to generate a series of msgs. In the case of writing, we
3126 need to use only one message; when reading, we need two. We initialize
3127 most things with sane defaults, to keep the code below somewhat
3129 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
3130 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
3131 int num = read_write == I2C_SMBUS_READ ? 2 : 1;
3135 struct i2c_msg msg[2] = {
3143 .flags = flags | I2C_M_RD,
3149 msgbuf0[0] = command;
3151 case I2C_SMBUS_QUICK:
3153 /* Special case: The read/write field is used as data */
3154 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
3158 case I2C_SMBUS_BYTE:
3159 if (read_write == I2C_SMBUS_READ) {
3160 /* Special case: only a read! */
3161 msg[0].flags = I2C_M_RD | flags;
3165 case I2C_SMBUS_BYTE_DATA:
3166 if (read_write == I2C_SMBUS_READ)
3170 msgbuf0[1] = data->byte;
3173 case I2C_SMBUS_WORD_DATA:
3174 if (read_write == I2C_SMBUS_READ)
3178 msgbuf0[1] = data->word & 0xff;
3179 msgbuf0[2] = data->word >> 8;
3182 case I2C_SMBUS_PROC_CALL:
3183 num = 2; /* Special case */
3184 read_write = I2C_SMBUS_READ;
3187 msgbuf0[1] = data->word & 0xff;
3188 msgbuf0[2] = data->word >> 8;
3190 case I2C_SMBUS_BLOCK_DATA:
3191 if (read_write == I2C_SMBUS_READ) {
3192 msg[1].flags |= I2C_M_RECV_LEN;
3193 msg[1].len = 1; /* block length will be added by
3194 the underlying bus driver */
3196 msg[0].len = data->block[0] + 2;
3197 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
3198 dev_err(&adapter->dev,
3199 "Invalid block write size %d\n",
3203 for (i = 1; i < msg[0].len; i++)
3204 msgbuf0[i] = data->block[i-1];
3207 case I2C_SMBUS_BLOCK_PROC_CALL:
3208 num = 2; /* Another special case */
3209 read_write = I2C_SMBUS_READ;
3210 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
3211 dev_err(&adapter->dev,
3212 "Invalid block write size %d\n",
3216 msg[0].len = data->block[0] + 2;
3217 for (i = 1; i < msg[0].len; i++)
3218 msgbuf0[i] = data->block[i-1];
3219 msg[1].flags |= I2C_M_RECV_LEN;
3220 msg[1].len = 1; /* block length will be added by
3221 the underlying bus driver */
3223 case I2C_SMBUS_I2C_BLOCK_DATA:
3224 if (read_write == I2C_SMBUS_READ) {
3225 msg[1].len = data->block[0];
3227 msg[0].len = data->block[0] + 1;
3228 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
3229 dev_err(&adapter->dev,
3230 "Invalid block write size %d\n",
3234 for (i = 1; i <= data->block[0]; i++)
3235 msgbuf0[i] = data->block[i];
3239 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
3243 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
3244 && size != I2C_SMBUS_I2C_BLOCK_DATA);
3246 /* Compute PEC if first message is a write */
3247 if (!(msg[0].flags & I2C_M_RD)) {
3248 if (num == 1) /* Write only */
3249 i2c_smbus_add_pec(&msg[0]);
3250 else /* Write followed by read */
3251 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
3253 /* Ask for PEC if last message is a read */
3254 if (msg[num-1].flags & I2C_M_RD)
3258 status = i2c_transfer(adapter, msg, num);
3262 /* Check PEC if last message is a read */
3263 if (i && (msg[num-1].flags & I2C_M_RD)) {
3264 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
3269 if (read_write == I2C_SMBUS_READ)
3271 case I2C_SMBUS_BYTE:
3272 data->byte = msgbuf0[0];
3274 case I2C_SMBUS_BYTE_DATA:
3275 data->byte = msgbuf1[0];
3277 case I2C_SMBUS_WORD_DATA:
3278 case I2C_SMBUS_PROC_CALL:
3279 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
3281 case I2C_SMBUS_I2C_BLOCK_DATA:
3282 for (i = 0; i < data->block[0]; i++)
3283 data->block[i+1] = msgbuf1[i];
3285 case I2C_SMBUS_BLOCK_DATA:
3286 case I2C_SMBUS_BLOCK_PROC_CALL:
3287 for (i = 0; i < msgbuf1[0] + 1; i++)
3288 data->block[i] = msgbuf1[i];
3295 * i2c_smbus_xfer - execute SMBus protocol operations
3296 * @adapter: Handle to I2C bus
3297 * @addr: Address of SMBus slave on that bus
3298 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
3299 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
3300 * @command: Byte interpreted by slave, for protocols which use such bytes
3301 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
3302 * @data: Data to be read or written
3304 * This executes an SMBus protocol operation, and returns a negative
3305 * errno code else zero on success.
3307 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
3308 char read_write, u8 command, int protocol,
3309 union i2c_smbus_data *data)
3311 unsigned long orig_jiffies;
3315 /* If enabled, the following two tracepoints are conditional on
3316 * read_write and protocol.
3318 trace_smbus_write(adapter, addr, flags, read_write,
3319 command, protocol, data);
3320 trace_smbus_read(adapter, addr, flags, read_write,
3323 flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
3325 if (adapter->algo->smbus_xfer) {
3326 i2c_lock_bus(adapter, I2C_LOCK_SEGMENT);
3328 /* Retry automatically on arbitration loss */
3329 orig_jiffies = jiffies;
3330 for (res = 0, try = 0; try <= adapter->retries; try++) {
3331 res = adapter->algo->smbus_xfer(adapter, addr, flags,
3332 read_write, command,
3336 if (time_after(jiffies,
3337 orig_jiffies + adapter->timeout))
3340 i2c_unlock_bus(adapter, I2C_LOCK_SEGMENT);
3342 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
3345 * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
3346 * implement native support for the SMBus operation.
3350 res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
3351 command, protocol, data);
3354 /* If enabled, the reply tracepoint is conditional on read_write. */
3355 trace_smbus_reply(adapter, addr, flags, read_write,
3356 command, protocol, data);
3357 trace_smbus_result(adapter, addr, flags, read_write,
3358 command, protocol, res);
3362 EXPORT_SYMBOL(i2c_smbus_xfer);
3365 * i2c_smbus_read_i2c_block_data_or_emulated - read block or emulate
3366 * @client: Handle to slave device
3367 * @command: Byte interpreted by slave
3368 * @length: Size of data block; SMBus allows at most I2C_SMBUS_BLOCK_MAX bytes
3369 * @values: Byte array into which data will be read; big enough to hold
3370 * the data returned by the slave. SMBus allows at most
3371 * I2C_SMBUS_BLOCK_MAX bytes.
3373 * This executes the SMBus "block read" protocol if supported by the adapter.
3374 * If block read is not supported, it emulates it using either word or byte
3375 * read protocols depending on availability.
3377 * The addresses of the I2C slave device that are accessed with this function
3378 * must be mapped to a linear region, so that a block read will have the same
3379 * effect as a byte read. Before using this function you must double-check
3380 * if the I2C slave does support exchanging a block transfer with a byte
3383 s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
3384 u8 command, u8 length, u8 *values)
3389 if (length > I2C_SMBUS_BLOCK_MAX)
3390 length = I2C_SMBUS_BLOCK_MAX;
3392 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK))
3393 return i2c_smbus_read_i2c_block_data(client, command, length, values);
3395 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA))
3398 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_WORD_DATA)) {
3399 while ((i + 2) <= length) {
3400 status = i2c_smbus_read_word_data(client, command + i);
3403 values[i] = status & 0xff;
3404 values[i + 1] = status >> 8;
3409 while (i < length) {
3410 status = i2c_smbus_read_byte_data(client, command + i);
3419 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data_or_emulated);
3421 #if IS_ENABLED(CONFIG_I2C_SLAVE)
3422 int i2c_slave_register(struct i2c_client *client, i2c_slave_cb_t slave_cb)
3426 if (!client || !slave_cb) {
3427 WARN(1, "insufficent data\n");
3431 if (!(client->flags & I2C_CLIENT_SLAVE))
3432 dev_warn(&client->dev, "%s: client slave flag not set. You might see address collisions\n",
3435 if (!(client->flags & I2C_CLIENT_TEN)) {
3436 /* Enforce stricter address checking */
3437 ret = i2c_check_7bit_addr_validity_strict(client->addr);
3439 dev_err(&client->dev, "%s: invalid address\n", __func__);
3444 if (!client->adapter->algo->reg_slave) {
3445 dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
3449 client->slave_cb = slave_cb;
3451 i2c_lock_adapter(client->adapter);
3452 ret = client->adapter->algo->reg_slave(client);
3453 i2c_unlock_adapter(client->adapter);
3456 client->slave_cb = NULL;
3457 dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
3462 EXPORT_SYMBOL_GPL(i2c_slave_register);
3464 int i2c_slave_unregister(struct i2c_client *client)
3468 if (!client->adapter->algo->unreg_slave) {
3469 dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
3473 i2c_lock_adapter(client->adapter);
3474 ret = client->adapter->algo->unreg_slave(client);
3475 i2c_unlock_adapter(client->adapter);
3478 client->slave_cb = NULL;
3480 dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
3484 EXPORT_SYMBOL_GPL(i2c_slave_unregister);
3487 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
3488 MODULE_DESCRIPTION("I2C-Bus main module");
3489 MODULE_LICENSE("GPL");