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 struct i2c_adapter *adapter,
172 acpi_handle *adapter_handle)
174 struct list_head resource_list;
175 struct resource_entry *entry;
176 struct i2c_acpi_lookup lookup;
179 memset(&lookup, 0, sizeof(lookup));
182 ret = i2c_acpi_do_lookup(adev, &lookup);
187 /* The adapter must match the one in I2cSerialBus() connector */
188 if (ACPI_HANDLE(&adapter->dev) != lookup.adapter_handle)
191 struct acpi_device *adapter_adev;
193 /* The adapter must be present */
194 if (acpi_bus_get_device(lookup.adapter_handle, &adapter_adev))
196 if (acpi_bus_get_status(adapter_adev) ||
197 !adapter_adev->status.present)
201 info->fwnode = acpi_fwnode_handle(adev);
203 *adapter_handle = lookup.adapter_handle;
205 /* Then fill IRQ number if any */
206 INIT_LIST_HEAD(&resource_list);
207 ret = acpi_dev_get_resources(adev, &resource_list, NULL, NULL);
211 resource_list_for_each_entry(entry, &resource_list) {
212 if (resource_type(entry->res) == IORESOURCE_IRQ) {
213 info->irq = entry->res->start;
218 acpi_dev_free_resource_list(&resource_list);
220 strlcpy(info->type, dev_name(&adev->dev), sizeof(info->type));
225 static void i2c_acpi_register_device(struct i2c_adapter *adapter,
226 struct acpi_device *adev,
227 struct i2c_board_info *info)
229 adev->power.flags.ignore_parent = true;
230 acpi_device_set_enumerated(adev);
232 if (!i2c_new_device(adapter, info)) {
233 adev->power.flags.ignore_parent = false;
234 dev_err(&adapter->dev,
235 "failed to add I2C device %s from ACPI\n",
236 dev_name(&adev->dev));
240 static acpi_status i2c_acpi_add_device(acpi_handle handle, u32 level,
241 void *data, void **return_value)
243 struct i2c_adapter *adapter = data;
244 struct acpi_device *adev;
245 struct i2c_board_info info;
247 if (acpi_bus_get_device(handle, &adev))
250 if (i2c_acpi_get_info(adev, &info, adapter, NULL))
253 i2c_acpi_register_device(adapter, adev, &info);
258 #define I2C_ACPI_MAX_SCAN_DEPTH 32
261 * i2c_acpi_register_devices - enumerate I2C slave devices behind adapter
262 * @adap: pointer to adapter
264 * Enumerate all I2C slave devices behind this adapter by walking the ACPI
265 * namespace. When a device is found it will be added to the Linux device
266 * model and bound to the corresponding ACPI handle.
268 static void i2c_acpi_register_devices(struct i2c_adapter *adap)
272 if (!has_acpi_companion(&adap->dev))
275 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
276 I2C_ACPI_MAX_SCAN_DEPTH,
277 i2c_acpi_add_device, NULL,
279 if (ACPI_FAILURE(status))
280 dev_warn(&adap->dev, "failed to enumerate I2C slaves\n");
283 static acpi_status i2c_acpi_lookup_speed(acpi_handle handle, u32 level,
284 void *data, void **return_value)
286 struct i2c_acpi_lookup *lookup = data;
287 struct acpi_device *adev;
289 if (acpi_bus_get_device(handle, &adev))
292 if (i2c_acpi_do_lookup(adev, lookup))
295 if (lookup->search_handle != lookup->adapter_handle)
298 if (lookup->speed <= lookup->min_speed)
299 lookup->min_speed = lookup->speed;
305 * i2c_acpi_find_bus_speed - find I2C bus speed from ACPI
306 * @dev: The device owning the bus
308 * Find the I2C bus speed by walking the ACPI namespace for all I2C slaves
309 * devices connected to this bus and use the speed of slowest device.
311 * Returns the speed in Hz or zero
313 u32 i2c_acpi_find_bus_speed(struct device *dev)
315 struct i2c_acpi_lookup lookup;
316 struct i2c_board_info dummy;
319 if (!has_acpi_companion(dev))
322 memset(&lookup, 0, sizeof(lookup));
323 lookup.search_handle = ACPI_HANDLE(dev);
324 lookup.min_speed = UINT_MAX;
325 lookup.info = &dummy;
327 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
328 I2C_ACPI_MAX_SCAN_DEPTH,
329 i2c_acpi_lookup_speed, NULL,
332 if (ACPI_FAILURE(status)) {
333 dev_warn(dev, "unable to find I2C bus speed from ACPI\n");
337 return lookup.min_speed != UINT_MAX ? lookup.min_speed : 0;
339 EXPORT_SYMBOL_GPL(i2c_acpi_find_bus_speed);
341 static int i2c_acpi_match_adapter(struct device *dev, void *data)
343 struct i2c_adapter *adapter = i2c_verify_adapter(dev);
348 return ACPI_HANDLE(dev) == (acpi_handle)data;
351 static int i2c_acpi_match_device(struct device *dev, void *data)
353 return ACPI_COMPANION(dev) == data;
356 static struct i2c_adapter *i2c_acpi_find_adapter_by_handle(acpi_handle handle)
360 dev = bus_find_device(&i2c_bus_type, NULL, handle,
361 i2c_acpi_match_adapter);
362 return dev ? i2c_verify_adapter(dev) : NULL;
365 static struct i2c_client *i2c_acpi_find_client_by_adev(struct acpi_device *adev)
369 dev = bus_find_device(&i2c_bus_type, NULL, adev, i2c_acpi_match_device);
370 return dev ? i2c_verify_client(dev) : NULL;
373 static int i2c_acpi_notify(struct notifier_block *nb, unsigned long value,
376 struct acpi_device *adev = arg;
377 struct i2c_board_info info;
378 acpi_handle adapter_handle;
379 struct i2c_adapter *adapter;
380 struct i2c_client *client;
383 case ACPI_RECONFIG_DEVICE_ADD:
384 if (i2c_acpi_get_info(adev, &info, NULL, &adapter_handle))
387 adapter = i2c_acpi_find_adapter_by_handle(adapter_handle);
391 i2c_acpi_register_device(adapter, adev, &info);
393 case ACPI_RECONFIG_DEVICE_REMOVE:
394 if (!acpi_device_enumerated(adev))
397 client = i2c_acpi_find_client_by_adev(adev);
401 i2c_unregister_device(client);
402 put_device(&client->dev);
409 static struct notifier_block i2c_acpi_notifier = {
410 .notifier_call = i2c_acpi_notify,
412 #else /* CONFIG_ACPI */
413 static inline void i2c_acpi_register_devices(struct i2c_adapter *adap) { }
414 extern struct notifier_block i2c_acpi_notifier;
415 #endif /* CONFIG_ACPI */
417 #ifdef CONFIG_ACPI_I2C_OPREGION
418 static int acpi_gsb_i2c_read_bytes(struct i2c_client *client,
419 u8 cmd, u8 *data, u8 data_len)
422 struct i2c_msg msgs[2];
426 buffer = kzalloc(data_len, GFP_KERNEL);
430 msgs[0].addr = client->addr;
431 msgs[0].flags = client->flags;
435 msgs[1].addr = client->addr;
436 msgs[1].flags = client->flags | I2C_M_RD;
437 msgs[1].len = data_len;
438 msgs[1].buf = buffer;
440 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
442 dev_err(&client->adapter->dev, "i2c read failed\n");
444 memcpy(data, buffer, data_len);
450 static int acpi_gsb_i2c_write_bytes(struct i2c_client *client,
451 u8 cmd, u8 *data, u8 data_len)
454 struct i2c_msg msgs[1];
458 buffer = kzalloc(data_len + 1, GFP_KERNEL);
463 memcpy(buffer + 1, data, data_len);
465 msgs[0].addr = client->addr;
466 msgs[0].flags = client->flags;
467 msgs[0].len = data_len + 1;
468 msgs[0].buf = buffer;
470 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
472 dev_err(&client->adapter->dev, "i2c write failed\n");
479 i2c_acpi_space_handler(u32 function, acpi_physical_address command,
480 u32 bits, u64 *value64,
481 void *handler_context, void *region_context)
483 struct gsb_buffer *gsb = (struct gsb_buffer *)value64;
484 struct i2c_acpi_handler_data *data = handler_context;
485 struct acpi_connection_info *info = &data->info;
486 struct acpi_resource_i2c_serialbus *sb;
487 struct i2c_adapter *adapter = data->adapter;
488 struct i2c_client *client;
489 struct acpi_resource *ares;
490 u32 accessor_type = function >> 16;
491 u8 action = function & ACPI_IO_MASK;
495 ret = acpi_buffer_to_resource(info->connection, info->length, &ares);
496 if (ACPI_FAILURE(ret))
499 client = kzalloc(sizeof(*client), GFP_KERNEL);
505 if (!value64 || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) {
506 ret = AE_BAD_PARAMETER;
510 sb = &ares->data.i2c_serial_bus;
511 if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C) {
512 ret = AE_BAD_PARAMETER;
516 client->adapter = adapter;
517 client->addr = sb->slave_address;
519 if (sb->access_mode == ACPI_I2C_10BIT_MODE)
520 client->flags |= I2C_CLIENT_TEN;
522 switch (accessor_type) {
523 case ACPI_GSB_ACCESS_ATTRIB_SEND_RCV:
524 if (action == ACPI_READ) {
525 status = i2c_smbus_read_byte(client);
531 status = i2c_smbus_write_byte(client, gsb->bdata);
535 case ACPI_GSB_ACCESS_ATTRIB_BYTE:
536 if (action == ACPI_READ) {
537 status = i2c_smbus_read_byte_data(client, command);
543 status = i2c_smbus_write_byte_data(client, command,
548 case ACPI_GSB_ACCESS_ATTRIB_WORD:
549 if (action == ACPI_READ) {
550 status = i2c_smbus_read_word_data(client, command);
556 status = i2c_smbus_write_word_data(client, command,
561 case ACPI_GSB_ACCESS_ATTRIB_BLOCK:
562 if (action == ACPI_READ) {
563 status = i2c_smbus_read_block_data(client, command,
570 status = i2c_smbus_write_block_data(client, command,
571 gsb->len, gsb->data);
575 case ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE:
576 if (action == ACPI_READ) {
577 status = acpi_gsb_i2c_read_bytes(client, command,
578 gsb->data, info->access_length);
582 status = acpi_gsb_i2c_write_bytes(client, command,
583 gsb->data, info->access_length);
588 dev_warn(&adapter->dev, "protocol 0x%02x not supported for client 0x%02x\n",
589 accessor_type, client->addr);
590 ret = AE_BAD_PARAMETER;
594 gsb->status = status;
603 static int i2c_acpi_install_space_handler(struct i2c_adapter *adapter)
606 struct i2c_acpi_handler_data *data;
609 if (!adapter->dev.parent)
612 handle = ACPI_HANDLE(adapter->dev.parent);
617 data = kzalloc(sizeof(struct i2c_acpi_handler_data),
622 data->adapter = adapter;
623 status = acpi_bus_attach_private_data(handle, (void *)data);
624 if (ACPI_FAILURE(status)) {
629 status = acpi_install_address_space_handler(handle,
630 ACPI_ADR_SPACE_GSBUS,
631 &i2c_acpi_space_handler,
634 if (ACPI_FAILURE(status)) {
635 dev_err(&adapter->dev, "Error installing i2c space handler\n");
636 acpi_bus_detach_private_data(handle);
641 acpi_walk_dep_device_list(handle);
645 static void i2c_acpi_remove_space_handler(struct i2c_adapter *adapter)
648 struct i2c_acpi_handler_data *data;
651 if (!adapter->dev.parent)
654 handle = ACPI_HANDLE(adapter->dev.parent);
659 acpi_remove_address_space_handler(handle,
660 ACPI_ADR_SPACE_GSBUS,
661 &i2c_acpi_space_handler);
663 status = acpi_bus_get_private_data(handle, (void **)&data);
664 if (ACPI_SUCCESS(status))
667 acpi_bus_detach_private_data(handle);
669 #else /* CONFIG_ACPI_I2C_OPREGION */
670 static inline void i2c_acpi_remove_space_handler(struct i2c_adapter *adapter)
673 static inline int i2c_acpi_install_space_handler(struct i2c_adapter *adapter)
675 #endif /* CONFIG_ACPI_I2C_OPREGION */
677 /* ------------------------------------------------------------------------- */
679 static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
680 const struct i2c_client *client)
682 while (id->name[0]) {
683 if (strcmp(client->name, id->name) == 0)
690 static int i2c_device_match(struct device *dev, struct device_driver *drv)
692 struct i2c_client *client = i2c_verify_client(dev);
693 struct i2c_driver *driver;
698 /* Attempt an OF style match */
699 if (of_driver_match_device(dev, drv))
702 /* Then ACPI style match */
703 if (acpi_driver_match_device(dev, drv))
706 driver = to_i2c_driver(drv);
707 /* match on an id table if there is one */
708 if (driver->id_table)
709 return i2c_match_id(driver->id_table, client) != NULL;
714 static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
716 struct i2c_client *client = to_i2c_client(dev);
719 rc = acpi_device_uevent_modalias(dev, env);
723 return add_uevent_var(env, "MODALIAS=%s%s", I2C_MODULE_PREFIX, client->name);
726 /* i2c bus recovery routines */
727 static int get_scl_gpio_value(struct i2c_adapter *adap)
729 return gpio_get_value(adap->bus_recovery_info->scl_gpio);
732 static void set_scl_gpio_value(struct i2c_adapter *adap, int val)
734 gpio_set_value(adap->bus_recovery_info->scl_gpio, val);
737 static int get_sda_gpio_value(struct i2c_adapter *adap)
739 return gpio_get_value(adap->bus_recovery_info->sda_gpio);
742 static int i2c_get_gpios_for_recovery(struct i2c_adapter *adap)
744 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
745 struct device *dev = &adap->dev;
748 ret = gpio_request_one(bri->scl_gpio, GPIOF_OPEN_DRAIN |
749 GPIOF_OUT_INIT_HIGH, "i2c-scl");
751 dev_warn(dev, "Can't get SCL gpio: %d\n", bri->scl_gpio);
756 if (gpio_request_one(bri->sda_gpio, GPIOF_IN, "i2c-sda")) {
757 /* work without SDA polling */
758 dev_warn(dev, "Can't get SDA gpio: %d. Not using SDA polling\n",
767 static void i2c_put_gpios_for_recovery(struct i2c_adapter *adap)
769 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
772 gpio_free(bri->sda_gpio);
774 gpio_free(bri->scl_gpio);
778 * We are generating clock pulses. ndelay() determines durating of clk pulses.
779 * We will generate clock with rate 100 KHz and so duration of both clock levels
780 * is: delay in ns = (10^6 / 100) / 2
782 #define RECOVERY_NDELAY 5000
783 #define RECOVERY_CLK_CNT 9
785 static int i2c_generic_recovery(struct i2c_adapter *adap)
787 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
788 int i = 0, val = 1, ret = 0;
790 if (bri->prepare_recovery)
791 bri->prepare_recovery(adap);
793 bri->set_scl(adap, val);
794 ndelay(RECOVERY_NDELAY);
797 * By this time SCL is high, as we need to give 9 falling-rising edges
799 while (i++ < RECOVERY_CLK_CNT * 2) {
801 /* Break if SDA is high */
802 if (bri->get_sda && bri->get_sda(adap))
804 /* SCL shouldn't be low here */
805 if (!bri->get_scl(adap)) {
807 "SCL is stuck low, exit recovery\n");
814 bri->set_scl(adap, val);
815 ndelay(RECOVERY_NDELAY);
818 if (bri->unprepare_recovery)
819 bri->unprepare_recovery(adap);
824 int i2c_generic_scl_recovery(struct i2c_adapter *adap)
826 return i2c_generic_recovery(adap);
828 EXPORT_SYMBOL_GPL(i2c_generic_scl_recovery);
830 int i2c_generic_gpio_recovery(struct i2c_adapter *adap)
834 ret = i2c_get_gpios_for_recovery(adap);
838 ret = i2c_generic_recovery(adap);
839 i2c_put_gpios_for_recovery(adap);
843 EXPORT_SYMBOL_GPL(i2c_generic_gpio_recovery);
845 int i2c_recover_bus(struct i2c_adapter *adap)
847 if (!adap->bus_recovery_info)
850 dev_dbg(&adap->dev, "Trying i2c bus recovery\n");
851 return adap->bus_recovery_info->recover_bus(adap);
853 EXPORT_SYMBOL_GPL(i2c_recover_bus);
855 static void i2c_init_recovery(struct i2c_adapter *adap)
857 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
863 if (!bri->recover_bus) {
864 err_str = "no recover_bus() found";
868 /* Generic GPIO recovery */
869 if (bri->recover_bus == i2c_generic_gpio_recovery) {
870 if (!gpio_is_valid(bri->scl_gpio)) {
871 err_str = "invalid SCL gpio";
875 if (gpio_is_valid(bri->sda_gpio))
876 bri->get_sda = get_sda_gpio_value;
880 bri->get_scl = get_scl_gpio_value;
881 bri->set_scl = set_scl_gpio_value;
882 } else if (bri->recover_bus == i2c_generic_scl_recovery) {
883 /* Generic SCL recovery */
884 if (!bri->set_scl || !bri->get_scl) {
885 err_str = "no {get|set}_scl() found";
892 dev_err(&adap->dev, "Not using recovery: %s\n", err_str);
893 adap->bus_recovery_info = NULL;
896 static int i2c_device_probe(struct device *dev)
898 struct i2c_client *client = i2c_verify_client(dev);
899 struct i2c_driver *driver;
909 irq = of_irq_get_byname(dev->of_node, "irq");
910 if (irq == -EINVAL || irq == -ENODATA)
911 irq = of_irq_get(dev->of_node, 0);
912 } else if (ACPI_COMPANION(dev)) {
913 irq = acpi_dev_gpio_irq_get(ACPI_COMPANION(dev), 0);
915 if (irq == -EPROBE_DEFER)
923 driver = to_i2c_driver(dev->driver);
924 if (!driver->probe || !driver->id_table)
927 if (client->flags & I2C_CLIENT_WAKE) {
928 int wakeirq = -ENOENT;
931 wakeirq = of_irq_get_byname(dev->of_node, "wakeup");
932 if (wakeirq == -EPROBE_DEFER)
936 device_init_wakeup(&client->dev, true);
938 if (wakeirq > 0 && wakeirq != client->irq)
939 status = dev_pm_set_dedicated_wake_irq(dev, wakeirq);
940 else if (client->irq > 0)
941 status = dev_pm_set_wake_irq(dev, client->irq);
946 dev_warn(&client->dev, "failed to set up wakeup irq\n");
949 dev_dbg(dev, "probe\n");
951 status = of_clk_set_defaults(dev->of_node, false);
953 goto err_clear_wakeup_irq;
955 status = dev_pm_domain_attach(&client->dev, true);
956 if (status == -EPROBE_DEFER)
957 goto err_clear_wakeup_irq;
959 status = driver->probe(client, i2c_match_id(driver->id_table, client));
961 goto err_detach_pm_domain;
965 err_detach_pm_domain:
966 dev_pm_domain_detach(&client->dev, true);
967 err_clear_wakeup_irq:
968 dev_pm_clear_wake_irq(&client->dev);
969 device_init_wakeup(&client->dev, false);
973 static int i2c_device_remove(struct device *dev)
975 struct i2c_client *client = i2c_verify_client(dev);
976 struct i2c_driver *driver;
979 if (!client || !dev->driver)
982 driver = to_i2c_driver(dev->driver);
983 if (driver->remove) {
984 dev_dbg(dev, "remove\n");
985 status = driver->remove(client);
988 dev_pm_domain_detach(&client->dev, true);
990 dev_pm_clear_wake_irq(&client->dev);
991 device_init_wakeup(&client->dev, false);
996 static void i2c_device_shutdown(struct device *dev)
998 struct i2c_client *client = i2c_verify_client(dev);
999 struct i2c_driver *driver;
1001 if (!client || !dev->driver)
1003 driver = to_i2c_driver(dev->driver);
1004 if (driver->shutdown)
1005 driver->shutdown(client);
1008 static void i2c_client_dev_release(struct device *dev)
1010 kfree(to_i2c_client(dev));
1014 show_name(struct device *dev, struct device_attribute *attr, char *buf)
1016 return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
1017 to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
1019 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
1022 show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
1024 struct i2c_client *client = to_i2c_client(dev);
1027 len = acpi_device_modalias(dev, buf, PAGE_SIZE -1);
1031 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
1033 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
1035 static struct attribute *i2c_dev_attrs[] = {
1036 &dev_attr_name.attr,
1037 /* modalias helps coldplug: modprobe $(cat .../modalias) */
1038 &dev_attr_modalias.attr,
1041 ATTRIBUTE_GROUPS(i2c_dev);
1043 struct bus_type i2c_bus_type = {
1045 .match = i2c_device_match,
1046 .probe = i2c_device_probe,
1047 .remove = i2c_device_remove,
1048 .shutdown = i2c_device_shutdown,
1050 EXPORT_SYMBOL_GPL(i2c_bus_type);
1052 static struct device_type i2c_client_type = {
1053 .groups = i2c_dev_groups,
1054 .uevent = i2c_device_uevent,
1055 .release = i2c_client_dev_release,
1060 * i2c_verify_client - return parameter as i2c_client, or NULL
1061 * @dev: device, probably from some driver model iterator
1063 * When traversing the driver model tree, perhaps using driver model
1064 * iterators like @device_for_each_child(), you can't assume very much
1065 * about the nodes you find. Use this function to avoid oopses caused
1066 * by wrongly treating some non-I2C device as an i2c_client.
1068 struct i2c_client *i2c_verify_client(struct device *dev)
1070 return (dev->type == &i2c_client_type)
1071 ? to_i2c_client(dev)
1074 EXPORT_SYMBOL(i2c_verify_client);
1077 /* Return a unique address which takes the flags of the client into account */
1078 static unsigned short i2c_encode_flags_to_addr(struct i2c_client *client)
1080 unsigned short addr = client->addr;
1082 /* For some client flags, add an arbitrary offset to avoid collisions */
1083 if (client->flags & I2C_CLIENT_TEN)
1084 addr |= I2C_ADDR_OFFSET_TEN_BIT;
1086 if (client->flags & I2C_CLIENT_SLAVE)
1087 addr |= I2C_ADDR_OFFSET_SLAVE;
1092 /* This is a permissive address validity check, I2C address map constraints
1093 * are purposely not enforced, except for the general call address. */
1094 static int i2c_check_addr_validity(unsigned addr, unsigned short flags)
1096 if (flags & I2C_CLIENT_TEN) {
1097 /* 10-bit address, all values are valid */
1101 /* 7-bit address, reject the general call address */
1102 if (addr == 0x00 || addr > 0x7f)
1108 /* And this is a strict address validity check, used when probing. If a
1109 * device uses a reserved address, then it shouldn't be probed. 7-bit
1110 * addressing is assumed, 10-bit address devices are rare and should be
1111 * explicitly enumerated. */
1112 static int i2c_check_7bit_addr_validity_strict(unsigned short addr)
1115 * Reserved addresses per I2C specification:
1116 * 0x00 General call address / START byte
1118 * 0x02 Reserved for different bus format
1119 * 0x03 Reserved for future purposes
1120 * 0x04-0x07 Hs-mode master code
1121 * 0x78-0x7b 10-bit slave addressing
1122 * 0x7c-0x7f Reserved for future purposes
1124 if (addr < 0x08 || addr > 0x77)
1129 static int __i2c_check_addr_busy(struct device *dev, void *addrp)
1131 struct i2c_client *client = i2c_verify_client(dev);
1132 int addr = *(int *)addrp;
1134 if (client && i2c_encode_flags_to_addr(client) == addr)
1139 /* walk up mux tree */
1140 static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
1142 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
1145 result = device_for_each_child(&adapter->dev, &addr,
1146 __i2c_check_addr_busy);
1148 if (!result && parent)
1149 result = i2c_check_mux_parents(parent, addr);
1154 /* recurse down mux tree */
1155 static int i2c_check_mux_children(struct device *dev, void *addrp)
1159 if (dev->type == &i2c_adapter_type)
1160 result = device_for_each_child(dev, addrp,
1161 i2c_check_mux_children);
1163 result = __i2c_check_addr_busy(dev, addrp);
1168 static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
1170 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
1174 result = i2c_check_mux_parents(parent, addr);
1177 result = device_for_each_child(&adapter->dev, &addr,
1178 i2c_check_mux_children);
1184 * i2c_adapter_lock_bus - Get exclusive access to an I2C bus segment
1185 * @adapter: Target I2C bus segment
1186 * @flags: I2C_LOCK_ROOT_ADAPTER locks the root i2c adapter, I2C_LOCK_SEGMENT
1187 * locks only this branch in the adapter tree
1189 static void i2c_adapter_lock_bus(struct i2c_adapter *adapter,
1192 rt_mutex_lock(&adapter->bus_lock);
1196 * i2c_adapter_trylock_bus - Try to get exclusive access to an I2C bus segment
1197 * @adapter: Target I2C bus segment
1198 * @flags: I2C_LOCK_ROOT_ADAPTER trylocks the root i2c adapter, I2C_LOCK_SEGMENT
1199 * trylocks only this branch in the adapter tree
1201 static int i2c_adapter_trylock_bus(struct i2c_adapter *adapter,
1204 return rt_mutex_trylock(&adapter->bus_lock);
1208 * i2c_adapter_unlock_bus - Release exclusive access to an I2C bus segment
1209 * @adapter: Target I2C bus segment
1210 * @flags: I2C_LOCK_ROOT_ADAPTER unlocks the root i2c adapter, I2C_LOCK_SEGMENT
1211 * unlocks only this branch in the adapter tree
1213 static void i2c_adapter_unlock_bus(struct i2c_adapter *adapter,
1216 rt_mutex_unlock(&adapter->bus_lock);
1219 static void i2c_dev_set_name(struct i2c_adapter *adap,
1220 struct i2c_client *client)
1222 struct acpi_device *adev = ACPI_COMPANION(&client->dev);
1225 dev_set_name(&client->dev, "i2c-%s", acpi_dev_name(adev));
1229 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
1230 i2c_encode_flags_to_addr(client));
1234 * i2c_new_device - instantiate an i2c device
1235 * @adap: the adapter managing the device
1236 * @info: describes one I2C device; bus_num is ignored
1237 * Context: can sleep
1239 * Create an i2c device. Binding is handled through driver model
1240 * probe()/remove() methods. A driver may be bound to this device when we
1241 * return from this function, or any later moment (e.g. maybe hotplugging will
1242 * load the driver module). This call is not appropriate for use by mainboard
1243 * initialization logic, which usually runs during an arch_initcall() long
1244 * before any i2c_adapter could exist.
1246 * This returns the new i2c client, which may be saved for later use with
1247 * i2c_unregister_device(); or NULL to indicate an error.
1250 i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
1252 struct i2c_client *client;
1255 client = kzalloc(sizeof *client, GFP_KERNEL);
1259 client->adapter = adap;
1261 client->dev.platform_data = info->platform_data;
1264 client->dev.archdata = *info->archdata;
1266 client->flags = info->flags;
1267 client->addr = info->addr;
1268 client->irq = info->irq;
1270 strlcpy(client->name, info->type, sizeof(client->name));
1272 status = i2c_check_addr_validity(client->addr, client->flags);
1274 dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
1275 client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
1276 goto out_err_silent;
1279 /* Check for address business */
1280 status = i2c_check_addr_busy(adap, i2c_encode_flags_to_addr(client));
1284 client->dev.parent = &client->adapter->dev;
1285 client->dev.bus = &i2c_bus_type;
1286 client->dev.type = &i2c_client_type;
1287 client->dev.of_node = info->of_node;
1288 client->dev.fwnode = info->fwnode;
1290 i2c_dev_set_name(adap, client);
1291 status = device_register(&client->dev);
1295 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
1296 client->name, dev_name(&client->dev));
1302 "Failed to register i2c client %s at 0x%02x (%d)\n",
1303 client->name, client->addr, status);
1308 EXPORT_SYMBOL_GPL(i2c_new_device);
1312 * i2c_unregister_device - reverse effect of i2c_new_device()
1313 * @client: value returned from i2c_new_device()
1314 * Context: can sleep
1316 void i2c_unregister_device(struct i2c_client *client)
1318 if (client->dev.of_node)
1319 of_node_clear_flag(client->dev.of_node, OF_POPULATED);
1320 if (ACPI_COMPANION(&client->dev))
1321 acpi_device_clear_enumerated(ACPI_COMPANION(&client->dev));
1322 device_unregister(&client->dev);
1324 EXPORT_SYMBOL_GPL(i2c_unregister_device);
1327 static const struct i2c_device_id dummy_id[] = {
1332 static int dummy_probe(struct i2c_client *client,
1333 const struct i2c_device_id *id)
1338 static int dummy_remove(struct i2c_client *client)
1343 static struct i2c_driver dummy_driver = {
1344 .driver.name = "dummy",
1345 .probe = dummy_probe,
1346 .remove = dummy_remove,
1347 .id_table = dummy_id,
1351 * i2c_new_dummy - return a new i2c device bound to a dummy driver
1352 * @adapter: the adapter managing the device
1353 * @address: seven bit address to be used
1354 * Context: can sleep
1356 * This returns an I2C client bound to the "dummy" driver, intended for use
1357 * with devices that consume multiple addresses. Examples of such chips
1358 * include various EEPROMS (like 24c04 and 24c08 models).
1360 * These dummy devices have two main uses. First, most I2C and SMBus calls
1361 * except i2c_transfer() need a client handle; the dummy will be that handle.
1362 * And second, this prevents the specified address from being bound to a
1365 * This returns the new i2c client, which should be saved for later use with
1366 * i2c_unregister_device(); or NULL to indicate an error.
1368 struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
1370 struct i2c_board_info info = {
1371 I2C_BOARD_INFO("dummy", address),
1374 return i2c_new_device(adapter, &info);
1376 EXPORT_SYMBOL_GPL(i2c_new_dummy);
1379 * i2c_new_secondary_device - Helper to get the instantiated secondary address
1380 * and create the associated device
1381 * @client: Handle to the primary client
1382 * @name: Handle to specify which secondary address to get
1383 * @default_addr: Used as a fallback if no secondary address was specified
1384 * Context: can sleep
1386 * I2C clients can be composed of multiple I2C slaves bound together in a single
1387 * component. The I2C client driver then binds to the master I2C slave and needs
1388 * to create I2C dummy clients to communicate with all the other slaves.
1390 * This function creates and returns an I2C dummy client whose I2C address is
1391 * retrieved from the platform firmware based on the given slave name. If no
1392 * address is specified by the firmware default_addr is used.
1394 * On DT-based platforms the address is retrieved from the "reg" property entry
1395 * cell whose "reg-names" value matches the slave name.
1397 * This returns the new i2c client, which should be saved for later use with
1398 * i2c_unregister_device(); or NULL to indicate an error.
1400 struct i2c_client *i2c_new_secondary_device(struct i2c_client *client,
1404 struct device_node *np = client->dev.of_node;
1405 u32 addr = default_addr;
1409 i = of_property_match_string(np, "reg-names", name);
1411 of_property_read_u32_index(np, "reg", i, &addr);
1414 dev_dbg(&client->adapter->dev, "Address for %s : 0x%x\n", name, addr);
1415 return i2c_new_dummy(client->adapter, addr);
1417 EXPORT_SYMBOL_GPL(i2c_new_secondary_device);
1419 /* ------------------------------------------------------------------------- */
1421 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
1423 static void i2c_adapter_dev_release(struct device *dev)
1425 struct i2c_adapter *adap = to_i2c_adapter(dev);
1426 complete(&adap->dev_released);
1429 unsigned int i2c_adapter_depth(struct i2c_adapter *adapter)
1431 unsigned int depth = 0;
1433 while ((adapter = i2c_parent_is_i2c_adapter(adapter)))
1436 WARN_ONCE(depth >= MAX_LOCKDEP_SUBCLASSES,
1437 "adapter depth exceeds lockdep subclass limit\n");
1441 EXPORT_SYMBOL_GPL(i2c_adapter_depth);
1444 * Let users instantiate I2C devices through sysfs. This can be used when
1445 * platform initialization code doesn't contain the proper data for
1446 * whatever reason. Also useful for drivers that do device detection and
1447 * detection fails, either because the device uses an unexpected address,
1448 * or this is a compatible device with different ID register values.
1450 * Parameter checking may look overzealous, but we really don't want
1451 * the user to provide incorrect parameters.
1454 i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
1455 const char *buf, size_t count)
1457 struct i2c_adapter *adap = to_i2c_adapter(dev);
1458 struct i2c_board_info info;
1459 struct i2c_client *client;
1463 memset(&info, 0, sizeof(struct i2c_board_info));
1465 blank = strchr(buf, ' ');
1467 dev_err(dev, "%s: Missing parameters\n", "new_device");
1470 if (blank - buf > I2C_NAME_SIZE - 1) {
1471 dev_err(dev, "%s: Invalid device name\n", "new_device");
1474 memcpy(info.type, buf, blank - buf);
1476 /* Parse remaining parameters, reject extra parameters */
1477 res = sscanf(++blank, "%hi%c", &info.addr, &end);
1479 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
1482 if (res > 1 && end != '\n') {
1483 dev_err(dev, "%s: Extra parameters\n", "new_device");
1487 if ((info.addr & I2C_ADDR_OFFSET_TEN_BIT) == I2C_ADDR_OFFSET_TEN_BIT) {
1488 info.addr &= ~I2C_ADDR_OFFSET_TEN_BIT;
1489 info.flags |= I2C_CLIENT_TEN;
1492 if (info.addr & I2C_ADDR_OFFSET_SLAVE) {
1493 info.addr &= ~I2C_ADDR_OFFSET_SLAVE;
1494 info.flags |= I2C_CLIENT_SLAVE;
1497 client = i2c_new_device(adap, &info);
1501 /* Keep track of the added device */
1502 mutex_lock(&adap->userspace_clients_lock);
1503 list_add_tail(&client->detected, &adap->userspace_clients);
1504 mutex_unlock(&adap->userspace_clients_lock);
1505 dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
1506 info.type, info.addr);
1510 static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
1513 * And of course let the users delete the devices they instantiated, if
1514 * they got it wrong. This interface can only be used to delete devices
1515 * instantiated by i2c_sysfs_new_device above. This guarantees that we
1516 * don't delete devices to which some kernel code still has references.
1518 * Parameter checking may look overzealous, but we really don't want
1519 * the user to delete the wrong device.
1522 i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
1523 const char *buf, size_t count)
1525 struct i2c_adapter *adap = to_i2c_adapter(dev);
1526 struct i2c_client *client, *next;
1527 unsigned short addr;
1531 /* Parse parameters, reject extra parameters */
1532 res = sscanf(buf, "%hi%c", &addr, &end);
1534 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
1537 if (res > 1 && end != '\n') {
1538 dev_err(dev, "%s: Extra parameters\n", "delete_device");
1542 /* Make sure the device was added through sysfs */
1544 mutex_lock_nested(&adap->userspace_clients_lock,
1545 i2c_adapter_depth(adap));
1546 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1548 if (i2c_encode_flags_to_addr(client) == addr) {
1549 dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
1550 "delete_device", client->name, client->addr);
1552 list_del(&client->detected);
1553 i2c_unregister_device(client);
1558 mutex_unlock(&adap->userspace_clients_lock);
1561 dev_err(dev, "%s: Can't find device in list\n",
1565 static DEVICE_ATTR_IGNORE_LOCKDEP(delete_device, S_IWUSR, NULL,
1566 i2c_sysfs_delete_device);
1568 static struct attribute *i2c_adapter_attrs[] = {
1569 &dev_attr_name.attr,
1570 &dev_attr_new_device.attr,
1571 &dev_attr_delete_device.attr,
1574 ATTRIBUTE_GROUPS(i2c_adapter);
1576 struct device_type i2c_adapter_type = {
1577 .groups = i2c_adapter_groups,
1578 .release = i2c_adapter_dev_release,
1580 EXPORT_SYMBOL_GPL(i2c_adapter_type);
1583 * i2c_verify_adapter - return parameter as i2c_adapter or NULL
1584 * @dev: device, probably from some driver model iterator
1586 * When traversing the driver model tree, perhaps using driver model
1587 * iterators like @device_for_each_child(), you can't assume very much
1588 * about the nodes you find. Use this function to avoid oopses caused
1589 * by wrongly treating some non-I2C device as an i2c_adapter.
1591 struct i2c_adapter *i2c_verify_adapter(struct device *dev)
1593 return (dev->type == &i2c_adapter_type)
1594 ? to_i2c_adapter(dev)
1597 EXPORT_SYMBOL(i2c_verify_adapter);
1599 #ifdef CONFIG_I2C_COMPAT
1600 static struct class_compat *i2c_adapter_compat_class;
1603 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
1605 struct i2c_devinfo *devinfo;
1607 down_read(&__i2c_board_lock);
1608 list_for_each_entry(devinfo, &__i2c_board_list, list) {
1609 if (devinfo->busnum == adapter->nr
1610 && !i2c_new_device(adapter,
1611 &devinfo->board_info))
1612 dev_err(&adapter->dev,
1613 "Can't create device at 0x%02x\n",
1614 devinfo->board_info.addr);
1616 up_read(&__i2c_board_lock);
1619 /* OF support code */
1621 #if IS_ENABLED(CONFIG_OF)
1622 static struct i2c_client *of_i2c_register_device(struct i2c_adapter *adap,
1623 struct device_node *node)
1625 struct i2c_client *result;
1626 struct i2c_board_info info = {};
1627 struct dev_archdata dev_ad = {};
1628 const __be32 *addr_be;
1632 dev_dbg(&adap->dev, "of_i2c: register %s\n", node->full_name);
1634 if (of_modalias_node(node, info.type, sizeof(info.type)) < 0) {
1635 dev_err(&adap->dev, "of_i2c: modalias failure on %s\n",
1637 return ERR_PTR(-EINVAL);
1640 addr_be = of_get_property(node, "reg", &len);
1641 if (!addr_be || (len < sizeof(*addr_be))) {
1642 dev_err(&adap->dev, "of_i2c: invalid reg on %s\n",
1644 return ERR_PTR(-EINVAL);
1647 addr = be32_to_cpup(addr_be);
1648 if (addr & I2C_TEN_BIT_ADDRESS) {
1649 addr &= ~I2C_TEN_BIT_ADDRESS;
1650 info.flags |= I2C_CLIENT_TEN;
1653 if (addr & I2C_OWN_SLAVE_ADDRESS) {
1654 addr &= ~I2C_OWN_SLAVE_ADDRESS;
1655 info.flags |= I2C_CLIENT_SLAVE;
1658 if (i2c_check_addr_validity(addr, info.flags)) {
1659 dev_err(&adap->dev, "of_i2c: invalid addr=%x on %s\n",
1660 info.addr, node->full_name);
1661 return ERR_PTR(-EINVAL);
1665 info.of_node = of_node_get(node);
1666 info.archdata = &dev_ad;
1668 if (of_get_property(node, "wakeup-source", NULL))
1669 info.flags |= I2C_CLIENT_WAKE;
1671 result = i2c_new_device(adap, &info);
1672 if (result == NULL) {
1673 dev_err(&adap->dev, "of_i2c: Failure registering %s\n",
1676 return ERR_PTR(-EINVAL);
1681 static void of_i2c_register_devices(struct i2c_adapter *adap)
1683 struct device_node *node;
1685 /* Only register child devices if the adapter has a node pointer set */
1686 if (!adap->dev.of_node)
1689 dev_dbg(&adap->dev, "of_i2c: walking child nodes\n");
1691 for_each_available_child_of_node(adap->dev.of_node, node) {
1692 if (of_node_test_and_set_flag(node, OF_POPULATED))
1694 of_i2c_register_device(adap, node);
1698 static int of_dev_node_match(struct device *dev, void *data)
1700 return dev->of_node == data;
1703 /* must call put_device() when done with returned i2c_client device */
1704 struct i2c_client *of_find_i2c_device_by_node(struct device_node *node)
1707 struct i2c_client *client;
1709 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
1713 client = i2c_verify_client(dev);
1719 EXPORT_SYMBOL(of_find_i2c_device_by_node);
1721 /* must call put_device() when done with returned i2c_adapter device */
1722 struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node)
1725 struct i2c_adapter *adapter;
1727 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
1731 adapter = i2c_verify_adapter(dev);
1737 EXPORT_SYMBOL(of_find_i2c_adapter_by_node);
1739 /* must call i2c_put_adapter() when done with returned i2c_adapter device */
1740 struct i2c_adapter *of_get_i2c_adapter_by_node(struct device_node *node)
1742 struct i2c_adapter *adapter;
1744 adapter = of_find_i2c_adapter_by_node(node);
1748 if (!try_module_get(adapter->owner)) {
1749 put_device(&adapter->dev);
1755 EXPORT_SYMBOL(of_get_i2c_adapter_by_node);
1757 static void of_i2c_register_devices(struct i2c_adapter *adap) { }
1758 #endif /* CONFIG_OF */
1760 static int i2c_do_add_adapter(struct i2c_driver *driver,
1761 struct i2c_adapter *adap)
1763 /* Detect supported devices on that bus, and instantiate them */
1764 i2c_detect(adap, driver);
1766 /* Let legacy drivers scan this bus for matching devices */
1767 if (driver->attach_adapter) {
1768 dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
1769 driver->driver.name);
1770 dev_warn(&adap->dev,
1771 "Please use another way to instantiate your i2c_client\n");
1772 /* We ignore the return code; if it fails, too bad */
1773 driver->attach_adapter(adap);
1778 static int __process_new_adapter(struct device_driver *d, void *data)
1780 return i2c_do_add_adapter(to_i2c_driver(d), data);
1783 static const struct i2c_lock_operations i2c_adapter_lock_ops = {
1784 .lock_bus = i2c_adapter_lock_bus,
1785 .trylock_bus = i2c_adapter_trylock_bus,
1786 .unlock_bus = i2c_adapter_unlock_bus,
1789 static int i2c_register_adapter(struct i2c_adapter *adap)
1793 /* Can't register until after driver model init */
1794 if (WARN_ON(!is_registered)) {
1800 if (WARN(!adap->name[0], "i2c adapter has no name"))
1804 pr_err("adapter '%s': no algo supplied!\n", adap->name);
1808 if (!adap->lock_ops)
1809 adap->lock_ops = &i2c_adapter_lock_ops;
1811 rt_mutex_init(&adap->bus_lock);
1812 rt_mutex_init(&adap->mux_lock);
1813 mutex_init(&adap->userspace_clients_lock);
1814 INIT_LIST_HEAD(&adap->userspace_clients);
1816 /* Set default timeout to 1 second if not already set */
1817 if (adap->timeout == 0)
1820 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
1821 adap->dev.bus = &i2c_bus_type;
1822 adap->dev.type = &i2c_adapter_type;
1823 res = device_register(&adap->dev);
1825 pr_err("adapter '%s': can't register device (%d)\n", adap->name, res);
1829 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
1831 pm_runtime_no_callbacks(&adap->dev);
1832 pm_suspend_ignore_children(&adap->dev, true);
1833 pm_runtime_enable(&adap->dev);
1835 #ifdef CONFIG_I2C_COMPAT
1836 res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
1839 dev_warn(&adap->dev,
1840 "Failed to create compatibility class link\n");
1843 i2c_init_recovery(adap);
1845 /* create pre-declared device nodes */
1846 of_i2c_register_devices(adap);
1847 i2c_acpi_register_devices(adap);
1848 i2c_acpi_install_space_handler(adap);
1850 if (adap->nr < __i2c_first_dynamic_bus_num)
1851 i2c_scan_static_board_info(adap);
1853 /* Notify drivers */
1854 mutex_lock(&core_lock);
1855 bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
1856 mutex_unlock(&core_lock);
1861 mutex_lock(&core_lock);
1862 idr_remove(&i2c_adapter_idr, adap->nr);
1863 mutex_unlock(&core_lock);
1868 * __i2c_add_numbered_adapter - i2c_add_numbered_adapter where nr is never -1
1869 * @adap: the adapter to register (with adap->nr initialized)
1870 * Context: can sleep
1872 * See i2c_add_numbered_adapter() for details.
1874 static int __i2c_add_numbered_adapter(struct i2c_adapter *adap)
1878 mutex_lock(&core_lock);
1879 id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1, GFP_KERNEL);
1880 mutex_unlock(&core_lock);
1881 if (WARN(id < 0, "couldn't get idr"))
1882 return id == -ENOSPC ? -EBUSY : id;
1884 return i2c_register_adapter(adap);
1888 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
1889 * @adapter: the adapter to add
1890 * Context: can sleep
1892 * This routine is used to declare an I2C adapter when its bus number
1893 * doesn't matter or when its bus number is specified by an dt alias.
1894 * Examples of bases when the bus number doesn't matter: I2C adapters
1895 * dynamically added by USB links or PCI plugin cards.
1897 * When this returns zero, a new bus number was allocated and stored
1898 * in adap->nr, and the specified adapter became available for clients.
1899 * Otherwise, a negative errno value is returned.
1901 int i2c_add_adapter(struct i2c_adapter *adapter)
1903 struct device *dev = &adapter->dev;
1907 id = of_alias_get_id(dev->of_node, "i2c");
1910 return __i2c_add_numbered_adapter(adapter);
1914 mutex_lock(&core_lock);
1915 id = idr_alloc(&i2c_adapter_idr, adapter,
1916 __i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
1917 mutex_unlock(&core_lock);
1918 if (WARN(id < 0, "couldn't get idr"))
1923 return i2c_register_adapter(adapter);
1925 EXPORT_SYMBOL(i2c_add_adapter);
1928 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
1929 * @adap: the adapter to register (with adap->nr initialized)
1930 * Context: can sleep
1932 * This routine is used to declare an I2C adapter when its bus number
1933 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
1934 * or otherwise built in to the system's mainboard, and where i2c_board_info
1935 * is used to properly configure I2C devices.
1937 * If the requested bus number is set to -1, then this function will behave
1938 * identically to i2c_add_adapter, and will dynamically assign a bus number.
1940 * If no devices have pre-been declared for this bus, then be sure to
1941 * register the adapter before any dynamically allocated ones. Otherwise
1942 * the required bus ID may not be available.
1944 * When this returns zero, the specified adapter became available for
1945 * clients using the bus number provided in adap->nr. Also, the table
1946 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
1947 * and the appropriate driver model device nodes are created. Otherwise, a
1948 * negative errno value is returned.
1950 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
1952 if (adap->nr == -1) /* -1 means dynamically assign bus id */
1953 return i2c_add_adapter(adap);
1955 return __i2c_add_numbered_adapter(adap);
1957 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
1959 static void i2c_do_del_adapter(struct i2c_driver *driver,
1960 struct i2c_adapter *adapter)
1962 struct i2c_client *client, *_n;
1964 /* Remove the devices we created ourselves as the result of hardware
1965 * probing (using a driver's detect method) */
1966 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
1967 if (client->adapter == adapter) {
1968 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
1969 client->name, client->addr);
1970 list_del(&client->detected);
1971 i2c_unregister_device(client);
1976 static int __unregister_client(struct device *dev, void *dummy)
1978 struct i2c_client *client = i2c_verify_client(dev);
1979 if (client && strcmp(client->name, "dummy"))
1980 i2c_unregister_device(client);
1984 static int __unregister_dummy(struct device *dev, void *dummy)
1986 struct i2c_client *client = i2c_verify_client(dev);
1988 i2c_unregister_device(client);
1992 static int __process_removed_adapter(struct device_driver *d, void *data)
1994 i2c_do_del_adapter(to_i2c_driver(d), data);
1999 * i2c_del_adapter - unregister I2C adapter
2000 * @adap: the adapter being unregistered
2001 * Context: can sleep
2003 * This unregisters an I2C adapter which was previously registered
2004 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
2006 void i2c_del_adapter(struct i2c_adapter *adap)
2008 struct i2c_adapter *found;
2009 struct i2c_client *client, *next;
2011 /* First make sure that this adapter was ever added */
2012 mutex_lock(&core_lock);
2013 found = idr_find(&i2c_adapter_idr, adap->nr);
2014 mutex_unlock(&core_lock);
2015 if (found != adap) {
2016 pr_debug("attempting to delete unregistered adapter [%s]\n", adap->name);
2020 i2c_acpi_remove_space_handler(adap);
2021 /* Tell drivers about this removal */
2022 mutex_lock(&core_lock);
2023 bus_for_each_drv(&i2c_bus_type, NULL, adap,
2024 __process_removed_adapter);
2025 mutex_unlock(&core_lock);
2027 /* Remove devices instantiated from sysfs */
2028 mutex_lock_nested(&adap->userspace_clients_lock,
2029 i2c_adapter_depth(adap));
2030 list_for_each_entry_safe(client, next, &adap->userspace_clients,
2032 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
2034 list_del(&client->detected);
2035 i2c_unregister_device(client);
2037 mutex_unlock(&adap->userspace_clients_lock);
2039 /* Detach any active clients. This can't fail, thus we do not
2040 * check the returned value. This is a two-pass process, because
2041 * we can't remove the dummy devices during the first pass: they
2042 * could have been instantiated by real devices wishing to clean
2043 * them up properly, so we give them a chance to do that first. */
2044 device_for_each_child(&adap->dev, NULL, __unregister_client);
2045 device_for_each_child(&adap->dev, NULL, __unregister_dummy);
2047 #ifdef CONFIG_I2C_COMPAT
2048 class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
2052 /* device name is gone after device_unregister */
2053 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
2055 pm_runtime_disable(&adap->dev);
2057 /* wait until all references to the device are gone
2059 * FIXME: This is old code and should ideally be replaced by an
2060 * alternative which results in decoupling the lifetime of the struct
2061 * device from the i2c_adapter, like spi or netdev do. Any solution
2062 * should be thoroughly tested with DEBUG_KOBJECT_RELEASE enabled!
2064 init_completion(&adap->dev_released);
2065 device_unregister(&adap->dev);
2066 wait_for_completion(&adap->dev_released);
2069 mutex_lock(&core_lock);
2070 idr_remove(&i2c_adapter_idr, adap->nr);
2071 mutex_unlock(&core_lock);
2073 /* Clear the device structure in case this adapter is ever going to be
2075 memset(&adap->dev, 0, sizeof(adap->dev));
2077 EXPORT_SYMBOL(i2c_del_adapter);
2080 * i2c_parse_fw_timings - get I2C related timing parameters from firmware
2081 * @dev: The device to scan for I2C timing properties
2082 * @t: the i2c_timings struct to be filled with values
2083 * @use_defaults: bool to use sane defaults derived from the I2C specification
2084 * when properties are not found, otherwise use 0
2086 * Scan the device for the generic I2C properties describing timing parameters
2087 * for the signal and fill the given struct with the results. If a property was
2088 * not found and use_defaults was true, then maximum timings are assumed which
2089 * are derived from the I2C specification. If use_defaults is not used, the
2090 * results will be 0, so drivers can apply their own defaults later. The latter
2091 * is mainly intended for avoiding regressions of existing drivers which want
2092 * to switch to this function. New drivers almost always should use the defaults.
2095 void i2c_parse_fw_timings(struct device *dev, struct i2c_timings *t, bool use_defaults)
2099 memset(t, 0, sizeof(*t));
2101 ret = device_property_read_u32(dev, "clock-frequency", &t->bus_freq_hz);
2102 if (ret && use_defaults)
2103 t->bus_freq_hz = 100000;
2105 ret = device_property_read_u32(dev, "i2c-scl-rising-time-ns", &t->scl_rise_ns);
2106 if (ret && use_defaults) {
2107 if (t->bus_freq_hz <= 100000)
2108 t->scl_rise_ns = 1000;
2109 else if (t->bus_freq_hz <= 400000)
2110 t->scl_rise_ns = 300;
2112 t->scl_rise_ns = 120;
2115 ret = device_property_read_u32(dev, "i2c-scl-falling-time-ns", &t->scl_fall_ns);
2116 if (ret && use_defaults) {
2117 if (t->bus_freq_hz <= 400000)
2118 t->scl_fall_ns = 300;
2120 t->scl_fall_ns = 120;
2123 device_property_read_u32(dev, "i2c-scl-internal-delay-ns", &t->scl_int_delay_ns);
2125 ret = device_property_read_u32(dev, "i2c-sda-falling-time-ns", &t->sda_fall_ns);
2126 if (ret && use_defaults)
2127 t->sda_fall_ns = t->scl_fall_ns;
2129 EXPORT_SYMBOL_GPL(i2c_parse_fw_timings);
2131 /* ------------------------------------------------------------------------- */
2133 int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
2137 mutex_lock(&core_lock);
2138 res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
2139 mutex_unlock(&core_lock);
2143 EXPORT_SYMBOL_GPL(i2c_for_each_dev);
2145 static int __process_new_driver(struct device *dev, void *data)
2147 if (dev->type != &i2c_adapter_type)
2149 return i2c_do_add_adapter(data, to_i2c_adapter(dev));
2153 * An i2c_driver is used with one or more i2c_client (device) nodes to access
2154 * i2c slave chips, on a bus instance associated with some i2c_adapter.
2157 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
2161 /* Can't register until after driver model init */
2162 if (WARN_ON(!is_registered))
2165 /* add the driver to the list of i2c drivers in the driver core */
2166 driver->driver.owner = owner;
2167 driver->driver.bus = &i2c_bus_type;
2169 /* When registration returns, the driver core
2170 * will have called probe() for all matching-but-unbound devices.
2172 res = driver_register(&driver->driver);
2176 pr_debug("driver [%s] registered\n", driver->driver.name);
2178 INIT_LIST_HEAD(&driver->clients);
2179 /* Walk the adapters that are already present */
2180 i2c_for_each_dev(driver, __process_new_driver);
2184 EXPORT_SYMBOL(i2c_register_driver);
2186 static int __process_removed_driver(struct device *dev, void *data)
2188 if (dev->type == &i2c_adapter_type)
2189 i2c_do_del_adapter(data, to_i2c_adapter(dev));
2194 * i2c_del_driver - unregister I2C driver
2195 * @driver: the driver being unregistered
2196 * Context: can sleep
2198 void i2c_del_driver(struct i2c_driver *driver)
2200 i2c_for_each_dev(driver, __process_removed_driver);
2202 driver_unregister(&driver->driver);
2203 pr_debug("driver [%s] unregistered\n", driver->driver.name);
2205 EXPORT_SYMBOL(i2c_del_driver);
2207 /* ------------------------------------------------------------------------- */
2210 * i2c_use_client - increments the reference count of the i2c client structure
2211 * @client: the client being referenced
2213 * Each live reference to a client should be refcounted. The driver model does
2214 * that automatically as part of driver binding, so that most drivers don't
2215 * need to do this explicitly: they hold a reference until they're unbound
2218 * A pointer to the client with the incremented reference counter is returned.
2220 struct i2c_client *i2c_use_client(struct i2c_client *client)
2222 if (client && get_device(&client->dev))
2226 EXPORT_SYMBOL(i2c_use_client);
2229 * i2c_release_client - release a use of the i2c client structure
2230 * @client: the client being no longer referenced
2232 * Must be called when a user of a client is finished with it.
2234 void i2c_release_client(struct i2c_client *client)
2237 put_device(&client->dev);
2239 EXPORT_SYMBOL(i2c_release_client);
2241 struct i2c_cmd_arg {
2246 static int i2c_cmd(struct device *dev, void *_arg)
2248 struct i2c_client *client = i2c_verify_client(dev);
2249 struct i2c_cmd_arg *arg = _arg;
2250 struct i2c_driver *driver;
2252 if (!client || !client->dev.driver)
2255 driver = to_i2c_driver(client->dev.driver);
2256 if (driver->command)
2257 driver->command(client, arg->cmd, arg->arg);
2261 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
2263 struct i2c_cmd_arg cmd_arg;
2267 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
2269 EXPORT_SYMBOL(i2c_clients_command);
2271 #if IS_ENABLED(CONFIG_OF_DYNAMIC)
2272 static int of_i2c_notify(struct notifier_block *nb, unsigned long action,
2275 struct of_reconfig_data *rd = arg;
2276 struct i2c_adapter *adap;
2277 struct i2c_client *client;
2279 switch (of_reconfig_get_state_change(action, rd)) {
2280 case OF_RECONFIG_CHANGE_ADD:
2281 adap = of_find_i2c_adapter_by_node(rd->dn->parent);
2283 return NOTIFY_OK; /* not for us */
2285 if (of_node_test_and_set_flag(rd->dn, OF_POPULATED)) {
2286 put_device(&adap->dev);
2290 client = of_i2c_register_device(adap, rd->dn);
2291 put_device(&adap->dev);
2293 if (IS_ERR(client)) {
2294 dev_err(&adap->dev, "failed to create client for '%s'\n",
2296 return notifier_from_errno(PTR_ERR(client));
2299 case OF_RECONFIG_CHANGE_REMOVE:
2300 /* already depopulated? */
2301 if (!of_node_check_flag(rd->dn, OF_POPULATED))
2304 /* find our device by node */
2305 client = of_find_i2c_device_by_node(rd->dn);
2307 return NOTIFY_OK; /* no? not meant for us */
2309 /* unregister takes one ref away */
2310 i2c_unregister_device(client);
2312 /* and put the reference of the find */
2313 put_device(&client->dev);
2319 static struct notifier_block i2c_of_notifier = {
2320 .notifier_call = of_i2c_notify,
2323 extern struct notifier_block i2c_of_notifier;
2324 #endif /* CONFIG_OF_DYNAMIC */
2326 static int __init i2c_init(void)
2330 retval = of_alias_get_highest_id("i2c");
2332 down_write(&__i2c_board_lock);
2333 if (retval >= __i2c_first_dynamic_bus_num)
2334 __i2c_first_dynamic_bus_num = retval + 1;
2335 up_write(&__i2c_board_lock);
2337 retval = bus_register(&i2c_bus_type);
2341 is_registered = true;
2343 #ifdef CONFIG_I2C_COMPAT
2344 i2c_adapter_compat_class = class_compat_register("i2c-adapter");
2345 if (!i2c_adapter_compat_class) {
2350 retval = i2c_add_driver(&dummy_driver);
2354 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2355 WARN_ON(of_reconfig_notifier_register(&i2c_of_notifier));
2356 if (IS_ENABLED(CONFIG_ACPI))
2357 WARN_ON(acpi_reconfig_notifier_register(&i2c_acpi_notifier));
2362 #ifdef CONFIG_I2C_COMPAT
2363 class_compat_unregister(i2c_adapter_compat_class);
2366 is_registered = false;
2367 bus_unregister(&i2c_bus_type);
2371 static void __exit i2c_exit(void)
2373 if (IS_ENABLED(CONFIG_ACPI))
2374 WARN_ON(acpi_reconfig_notifier_unregister(&i2c_acpi_notifier));
2375 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2376 WARN_ON(of_reconfig_notifier_unregister(&i2c_of_notifier));
2377 i2c_del_driver(&dummy_driver);
2378 #ifdef CONFIG_I2C_COMPAT
2379 class_compat_unregister(i2c_adapter_compat_class);
2381 bus_unregister(&i2c_bus_type);
2382 tracepoint_synchronize_unregister();
2385 /* We must initialize early, because some subsystems register i2c drivers
2386 * in subsys_initcall() code, but are linked (and initialized) before i2c.
2388 postcore_initcall(i2c_init);
2389 module_exit(i2c_exit);
2391 /* ----------------------------------------------------
2392 * the functional interface to the i2c busses.
2393 * ----------------------------------------------------
2396 /* Check if val is exceeding the quirk IFF quirk is non 0 */
2397 #define i2c_quirk_exceeded(val, quirk) ((quirk) && ((val) > (quirk)))
2399 static int i2c_quirk_error(struct i2c_adapter *adap, struct i2c_msg *msg, char *err_msg)
2401 dev_err_ratelimited(&adap->dev, "adapter quirk: %s (addr 0x%04x, size %u, %s)\n",
2402 err_msg, msg->addr, msg->len,
2403 msg->flags & I2C_M_RD ? "read" : "write");
2407 static int i2c_check_for_quirks(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2409 const struct i2c_adapter_quirks *q = adap->quirks;
2410 int max_num = q->max_num_msgs, i;
2411 bool do_len_check = true;
2413 if (q->flags & I2C_AQ_COMB) {
2416 /* special checks for combined messages */
2418 if (q->flags & I2C_AQ_COMB_WRITE_FIRST && msgs[0].flags & I2C_M_RD)
2419 return i2c_quirk_error(adap, &msgs[0], "1st comb msg must be write");
2421 if (q->flags & I2C_AQ_COMB_READ_SECOND && !(msgs[1].flags & I2C_M_RD))
2422 return i2c_quirk_error(adap, &msgs[1], "2nd comb msg must be read");
2424 if (q->flags & I2C_AQ_COMB_SAME_ADDR && msgs[0].addr != msgs[1].addr)
2425 return i2c_quirk_error(adap, &msgs[0], "comb msg only to same addr");
2427 if (i2c_quirk_exceeded(msgs[0].len, q->max_comb_1st_msg_len))
2428 return i2c_quirk_error(adap, &msgs[0], "msg too long");
2430 if (i2c_quirk_exceeded(msgs[1].len, q->max_comb_2nd_msg_len))
2431 return i2c_quirk_error(adap, &msgs[1], "msg too long");
2433 do_len_check = false;
2437 if (i2c_quirk_exceeded(num, max_num))
2438 return i2c_quirk_error(adap, &msgs[0], "too many messages");
2440 for (i = 0; i < num; i++) {
2441 u16 len = msgs[i].len;
2443 if (msgs[i].flags & I2C_M_RD) {
2444 if (do_len_check && i2c_quirk_exceeded(len, q->max_read_len))
2445 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2447 if (do_len_check && i2c_quirk_exceeded(len, q->max_write_len))
2448 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2456 * __i2c_transfer - unlocked flavor of i2c_transfer
2457 * @adap: Handle to I2C bus
2458 * @msgs: One or more messages to execute before STOP is issued to
2459 * terminate the operation; each message begins with a START.
2460 * @num: Number of messages to be executed.
2462 * Returns negative errno, else the number of messages executed.
2464 * Adapter lock must be held when calling this function. No debug logging
2465 * takes place. adap->algo->master_xfer existence isn't checked.
2467 int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2469 unsigned long orig_jiffies;
2472 if (adap->quirks && i2c_check_for_quirks(adap, msgs, num))
2475 /* i2c_trace_msg gets enabled when tracepoint i2c_transfer gets
2476 * enabled. This is an efficient way of keeping the for-loop from
2477 * being executed when not needed.
2479 if (static_key_false(&i2c_trace_msg)) {
2481 for (i = 0; i < num; i++)
2482 if (msgs[i].flags & I2C_M_RD)
2483 trace_i2c_read(adap, &msgs[i], i);
2485 trace_i2c_write(adap, &msgs[i], i);
2488 /* Retry automatically on arbitration loss */
2489 orig_jiffies = jiffies;
2490 for (ret = 0, try = 0; try <= adap->retries; try++) {
2491 ret = adap->algo->master_xfer(adap, msgs, num);
2494 if (time_after(jiffies, orig_jiffies + adap->timeout))
2498 if (static_key_false(&i2c_trace_msg)) {
2500 for (i = 0; i < ret; i++)
2501 if (msgs[i].flags & I2C_M_RD)
2502 trace_i2c_reply(adap, &msgs[i], i);
2503 trace_i2c_result(adap, i, ret);
2508 EXPORT_SYMBOL(__i2c_transfer);
2511 * i2c_transfer - execute a single or combined I2C message
2512 * @adap: Handle to I2C bus
2513 * @msgs: One or more messages to execute before STOP is issued to
2514 * terminate the operation; each message begins with a START.
2515 * @num: Number of messages to be executed.
2517 * Returns negative errno, else the number of messages executed.
2519 * Note that there is no requirement that each message be sent to
2520 * the same slave address, although that is the most common model.
2522 int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2526 /* REVISIT the fault reporting model here is weak:
2528 * - When we get an error after receiving N bytes from a slave,
2529 * there is no way to report "N".
2531 * - When we get a NAK after transmitting N bytes to a slave,
2532 * there is no way to report "N" ... or to let the master
2533 * continue executing the rest of this combined message, if
2534 * that's the appropriate response.
2536 * - When for example "num" is two and we successfully complete
2537 * the first message but get an error part way through the
2538 * second, it's unclear whether that should be reported as
2539 * one (discarding status on the second message) or errno
2540 * (discarding status on the first one).
2543 if (adap->algo->master_xfer) {
2545 for (ret = 0; ret < num; ret++) {
2547 "master_xfer[%d] %c, addr=0x%02x, len=%d%s\n",
2548 ret, (msgs[ret].flags & I2C_M_RD) ? 'R' : 'W',
2549 msgs[ret].addr, msgs[ret].len,
2550 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
2554 if (in_atomic() || irqs_disabled()) {
2555 ret = i2c_trylock_bus(adap, I2C_LOCK_SEGMENT);
2557 /* I2C activity is ongoing. */
2560 i2c_lock_bus(adap, I2C_LOCK_SEGMENT);
2563 ret = __i2c_transfer(adap, msgs, num);
2564 i2c_unlock_bus(adap, I2C_LOCK_SEGMENT);
2568 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
2572 EXPORT_SYMBOL(i2c_transfer);
2575 * i2c_master_send - issue a single I2C message in master transmit mode
2576 * @client: Handle to slave device
2577 * @buf: Data that will be written to the slave
2578 * @count: How many bytes to write, must be less than 64k since msg.len is u16
2580 * Returns negative errno, or else the number of bytes written.
2582 int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
2585 struct i2c_adapter *adap = client->adapter;
2588 msg.addr = client->addr;
2589 msg.flags = client->flags & I2C_M_TEN;
2591 msg.buf = (char *)buf;
2593 ret = i2c_transfer(adap, &msg, 1);
2596 * If everything went ok (i.e. 1 msg transmitted), return #bytes
2597 * transmitted, else error code.
2599 return (ret == 1) ? count : ret;
2601 EXPORT_SYMBOL(i2c_master_send);
2604 * i2c_master_recv - issue a single I2C message in master receive mode
2605 * @client: Handle to slave device
2606 * @buf: Where to store data read from slave
2607 * @count: How many bytes to read, must be less than 64k since msg.len is u16
2609 * Returns negative errno, or else the number of bytes read.
2611 int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
2613 struct i2c_adapter *adap = client->adapter;
2617 msg.addr = client->addr;
2618 msg.flags = client->flags & I2C_M_TEN;
2619 msg.flags |= I2C_M_RD;
2623 ret = i2c_transfer(adap, &msg, 1);
2626 * If everything went ok (i.e. 1 msg received), return #bytes received,
2629 return (ret == 1) ? count : ret;
2631 EXPORT_SYMBOL(i2c_master_recv);
2633 /* ----------------------------------------------------
2634 * the i2c address scanning function
2635 * Will not work for 10-bit addresses!
2636 * ----------------------------------------------------
2640 * Legacy default probe function, mostly relevant for SMBus. The default
2641 * probe method is a quick write, but it is known to corrupt the 24RF08
2642 * EEPROMs due to a state machine bug, and could also irreversibly
2643 * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
2644 * we use a short byte read instead. Also, some bus drivers don't implement
2645 * quick write, so we fallback to a byte read in that case too.
2646 * On x86, there is another special case for FSC hardware monitoring chips,
2647 * which want regular byte reads (address 0x73.) Fortunately, these are the
2648 * only known chips using this I2C address on PC hardware.
2649 * Returns 1 if probe succeeded, 0 if not.
2651 static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
2654 union i2c_smbus_data dummy;
2657 if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
2658 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
2659 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2660 I2C_SMBUS_BYTE_DATA, &dummy);
2663 if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
2664 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
2665 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
2666 I2C_SMBUS_QUICK, NULL);
2667 else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
2668 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2669 I2C_SMBUS_BYTE, &dummy);
2671 dev_warn(&adap->dev, "No suitable probing method supported for address 0x%02X\n",
2679 static int i2c_detect_address(struct i2c_client *temp_client,
2680 struct i2c_driver *driver)
2682 struct i2c_board_info info;
2683 struct i2c_adapter *adapter = temp_client->adapter;
2684 int addr = temp_client->addr;
2687 /* Make sure the address is valid */
2688 err = i2c_check_7bit_addr_validity_strict(addr);
2690 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
2695 /* Skip if already in use (7 bit, no need to encode flags) */
2696 if (i2c_check_addr_busy(adapter, addr))
2699 /* Make sure there is something at this address */
2700 if (!i2c_default_probe(adapter, addr))
2703 /* Finally call the custom detection function */
2704 memset(&info, 0, sizeof(struct i2c_board_info));
2706 err = driver->detect(temp_client, &info);
2708 /* -ENODEV is returned if the detection fails. We catch it
2709 here as this isn't an error. */
2710 return err == -ENODEV ? 0 : err;
2713 /* Consistency check */
2714 if (info.type[0] == '\0') {
2715 dev_err(&adapter->dev,
2716 "%s detection function provided no name for 0x%x\n",
2717 driver->driver.name, addr);
2719 struct i2c_client *client;
2721 /* Detection succeeded, instantiate the device */
2722 if (adapter->class & I2C_CLASS_DEPRECATED)
2723 dev_warn(&adapter->dev,
2724 "This adapter will soon drop class based instantiation of devices. "
2725 "Please make sure client 0x%02x gets instantiated by other means. "
2726 "Check 'Documentation/i2c/instantiating-devices' for details.\n",
2729 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
2730 info.type, info.addr);
2731 client = i2c_new_device(adapter, &info);
2733 list_add_tail(&client->detected, &driver->clients);
2735 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
2736 info.type, info.addr);
2741 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
2743 const unsigned short *address_list;
2744 struct i2c_client *temp_client;
2746 int adap_id = i2c_adapter_id(adapter);
2748 address_list = driver->address_list;
2749 if (!driver->detect || !address_list)
2752 /* Warn that the adapter lost class based instantiation */
2753 if (adapter->class == I2C_CLASS_DEPRECATED) {
2754 dev_dbg(&adapter->dev,
2755 "This adapter dropped support for I2C classes and won't auto-detect %s devices anymore. "
2756 "If you need it, check 'Documentation/i2c/instantiating-devices' for alternatives.\n",
2757 driver->driver.name);
2761 /* Stop here if the classes do not match */
2762 if (!(adapter->class & driver->class))
2765 /* Set up a temporary client to help detect callback */
2766 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
2769 temp_client->adapter = adapter;
2771 for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
2772 dev_dbg(&adapter->dev,
2773 "found normal entry for adapter %d, addr 0x%02x\n",
2774 adap_id, address_list[i]);
2775 temp_client->addr = address_list[i];
2776 err = i2c_detect_address(temp_client, driver);
2785 int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
2787 return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2788 I2C_SMBUS_QUICK, NULL) >= 0;
2790 EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
2793 i2c_new_probed_device(struct i2c_adapter *adap,
2794 struct i2c_board_info *info,
2795 unsigned short const *addr_list,
2796 int (*probe)(struct i2c_adapter *, unsigned short addr))
2801 probe = i2c_default_probe;
2803 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
2804 /* Check address validity */
2805 if (i2c_check_7bit_addr_validity_strict(addr_list[i]) < 0) {
2806 dev_warn(&adap->dev, "Invalid 7-bit address 0x%02x\n",
2811 /* Check address availability (7 bit, no need to encode flags) */
2812 if (i2c_check_addr_busy(adap, addr_list[i])) {
2814 "Address 0x%02x already in use, not probing\n",
2819 /* Test address responsiveness */
2820 if (probe(adap, addr_list[i]))
2824 if (addr_list[i] == I2C_CLIENT_END) {
2825 dev_dbg(&adap->dev, "Probing failed, no device found\n");
2829 info->addr = addr_list[i];
2830 return i2c_new_device(adap, info);
2832 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
2834 struct i2c_adapter *i2c_get_adapter(int nr)
2836 struct i2c_adapter *adapter;
2838 mutex_lock(&core_lock);
2839 adapter = idr_find(&i2c_adapter_idr, nr);
2843 if (try_module_get(adapter->owner))
2844 get_device(&adapter->dev);
2849 mutex_unlock(&core_lock);
2852 EXPORT_SYMBOL(i2c_get_adapter);
2854 void i2c_put_adapter(struct i2c_adapter *adap)
2859 put_device(&adap->dev);
2860 module_put(adap->owner);
2862 EXPORT_SYMBOL(i2c_put_adapter);
2864 /* The SMBus parts */
2866 #define POLY (0x1070U << 3)
2867 static u8 crc8(u16 data)
2871 for (i = 0; i < 8; i++) {
2876 return (u8)(data >> 8);
2879 /* Incremental CRC8 over count bytes in the array pointed to by p */
2880 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
2884 for (i = 0; i < count; i++)
2885 crc = crc8((crc ^ p[i]) << 8);
2889 /* Assume a 7-bit address, which is reasonable for SMBus */
2890 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
2892 /* The address will be sent first */
2893 u8 addr = i2c_8bit_addr_from_msg(msg);
2894 pec = i2c_smbus_pec(pec, &addr, 1);
2896 /* The data buffer follows */
2897 return i2c_smbus_pec(pec, msg->buf, msg->len);
2900 /* Used for write only transactions */
2901 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
2903 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
2907 /* Return <0 on CRC error
2908 If there was a write before this read (most cases) we need to take the
2909 partial CRC from the write part into account.
2910 Note that this function does modify the message (we need to decrease the
2911 message length to hide the CRC byte from the caller). */
2912 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
2914 u8 rpec = msg->buf[--msg->len];
2915 cpec = i2c_smbus_msg_pec(cpec, msg);
2918 pr_debug("Bad PEC 0x%02x vs. 0x%02x\n",
2926 * i2c_smbus_read_byte - SMBus "receive byte" protocol
2927 * @client: Handle to slave device
2929 * This executes the SMBus "receive byte" protocol, returning negative errno
2930 * else the byte received from the device.
2932 s32 i2c_smbus_read_byte(const struct i2c_client *client)
2934 union i2c_smbus_data data;
2937 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2939 I2C_SMBUS_BYTE, &data);
2940 return (status < 0) ? status : data.byte;
2942 EXPORT_SYMBOL(i2c_smbus_read_byte);
2945 * i2c_smbus_write_byte - SMBus "send byte" protocol
2946 * @client: Handle to slave device
2947 * @value: Byte to be sent
2949 * This executes the SMBus "send byte" protocol, returning negative errno
2950 * else zero on success.
2952 s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
2954 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2955 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
2957 EXPORT_SYMBOL(i2c_smbus_write_byte);
2960 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
2961 * @client: Handle to slave device
2962 * @command: Byte interpreted by slave
2964 * This executes the SMBus "read byte" protocol, returning negative errno
2965 * else a data byte received from the device.
2967 s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
2969 union i2c_smbus_data data;
2972 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2973 I2C_SMBUS_READ, command,
2974 I2C_SMBUS_BYTE_DATA, &data);
2975 return (status < 0) ? status : data.byte;
2977 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
2980 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
2981 * @client: Handle to slave device
2982 * @command: Byte interpreted by slave
2983 * @value: Byte being written
2985 * This executes the SMBus "write byte" protocol, returning negative errno
2986 * else zero on success.
2988 s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
2991 union i2c_smbus_data data;
2993 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2994 I2C_SMBUS_WRITE, command,
2995 I2C_SMBUS_BYTE_DATA, &data);
2997 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
3000 * i2c_smbus_read_word_data - SMBus "read word" protocol
3001 * @client: Handle to slave device
3002 * @command: Byte interpreted by slave
3004 * This executes the SMBus "read word" protocol, returning negative errno
3005 * else a 16-bit unsigned "word" received from the device.
3007 s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
3009 union i2c_smbus_data data;
3012 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3013 I2C_SMBUS_READ, command,
3014 I2C_SMBUS_WORD_DATA, &data);
3015 return (status < 0) ? status : data.word;
3017 EXPORT_SYMBOL(i2c_smbus_read_word_data);
3020 * i2c_smbus_write_word_data - SMBus "write word" protocol
3021 * @client: Handle to slave device
3022 * @command: Byte interpreted by slave
3023 * @value: 16-bit "word" being written
3025 * This executes the SMBus "write word" protocol, returning negative errno
3026 * else zero on success.
3028 s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
3031 union i2c_smbus_data data;
3033 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3034 I2C_SMBUS_WRITE, command,
3035 I2C_SMBUS_WORD_DATA, &data);
3037 EXPORT_SYMBOL(i2c_smbus_write_word_data);
3040 * i2c_smbus_read_block_data - SMBus "block read" protocol
3041 * @client: Handle to slave device
3042 * @command: Byte interpreted by slave
3043 * @values: Byte array into which data will be read; big enough to hold
3044 * the data returned by the slave. SMBus allows at most 32 bytes.
3046 * This executes the SMBus "block read" protocol, returning negative errno
3047 * else the number of data bytes in the slave's response.
3049 * Note that using this function requires that the client's adapter support
3050 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
3051 * support this; its emulation through I2C messaging relies on a specific
3052 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
3054 s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
3057 union i2c_smbus_data data;
3060 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3061 I2C_SMBUS_READ, command,
3062 I2C_SMBUS_BLOCK_DATA, &data);
3066 memcpy(values, &data.block[1], data.block[0]);
3067 return data.block[0];
3069 EXPORT_SYMBOL(i2c_smbus_read_block_data);
3072 * i2c_smbus_write_block_data - SMBus "block write" protocol
3073 * @client: Handle to slave device
3074 * @command: Byte interpreted by slave
3075 * @length: Size of data block; SMBus allows at most 32 bytes
3076 * @values: Byte array which will be written.
3078 * This executes the SMBus "block write" protocol, returning negative errno
3079 * else zero on success.
3081 s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
3082 u8 length, const u8 *values)
3084 union i2c_smbus_data data;
3086 if (length > I2C_SMBUS_BLOCK_MAX)
3087 length = I2C_SMBUS_BLOCK_MAX;
3088 data.block[0] = length;
3089 memcpy(&data.block[1], values, length);
3090 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3091 I2C_SMBUS_WRITE, command,
3092 I2C_SMBUS_BLOCK_DATA, &data);
3094 EXPORT_SYMBOL(i2c_smbus_write_block_data);
3096 /* Returns the number of read bytes */
3097 s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
3098 u8 length, u8 *values)
3100 union i2c_smbus_data data;
3103 if (length > I2C_SMBUS_BLOCK_MAX)
3104 length = I2C_SMBUS_BLOCK_MAX;
3105 data.block[0] = length;
3106 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3107 I2C_SMBUS_READ, command,
3108 I2C_SMBUS_I2C_BLOCK_DATA, &data);
3112 memcpy(values, &data.block[1], data.block[0]);
3113 return data.block[0];
3115 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
3117 s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
3118 u8 length, const u8 *values)
3120 union i2c_smbus_data data;
3122 if (length > I2C_SMBUS_BLOCK_MAX)
3123 length = I2C_SMBUS_BLOCK_MAX;
3124 data.block[0] = length;
3125 memcpy(data.block + 1, values, length);
3126 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3127 I2C_SMBUS_WRITE, command,
3128 I2C_SMBUS_I2C_BLOCK_DATA, &data);
3130 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
3132 /* Simulate a SMBus command using the i2c protocol
3133 No checking of parameters is done! */
3134 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
3135 unsigned short flags,
3136 char read_write, u8 command, int size,
3137 union i2c_smbus_data *data)
3139 /* So we need to generate a series of msgs. In the case of writing, we
3140 need to use only one message; when reading, we need two. We initialize
3141 most things with sane defaults, to keep the code below somewhat
3143 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
3144 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
3145 int num = read_write == I2C_SMBUS_READ ? 2 : 1;
3149 struct i2c_msg msg[2] = {
3157 .flags = flags | I2C_M_RD,
3163 msgbuf0[0] = command;
3165 case I2C_SMBUS_QUICK:
3167 /* Special case: The read/write field is used as data */
3168 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
3172 case I2C_SMBUS_BYTE:
3173 if (read_write == I2C_SMBUS_READ) {
3174 /* Special case: only a read! */
3175 msg[0].flags = I2C_M_RD | flags;
3179 case I2C_SMBUS_BYTE_DATA:
3180 if (read_write == I2C_SMBUS_READ)
3184 msgbuf0[1] = data->byte;
3187 case I2C_SMBUS_WORD_DATA:
3188 if (read_write == I2C_SMBUS_READ)
3192 msgbuf0[1] = data->word & 0xff;
3193 msgbuf0[2] = data->word >> 8;
3196 case I2C_SMBUS_PROC_CALL:
3197 num = 2; /* Special case */
3198 read_write = I2C_SMBUS_READ;
3201 msgbuf0[1] = data->word & 0xff;
3202 msgbuf0[2] = data->word >> 8;
3204 case I2C_SMBUS_BLOCK_DATA:
3205 if (read_write == I2C_SMBUS_READ) {
3206 msg[1].flags |= I2C_M_RECV_LEN;
3207 msg[1].len = 1; /* block length will be added by
3208 the underlying bus driver */
3210 msg[0].len = data->block[0] + 2;
3211 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
3212 dev_err(&adapter->dev,
3213 "Invalid block write size %d\n",
3217 for (i = 1; i < msg[0].len; i++)
3218 msgbuf0[i] = data->block[i-1];
3221 case I2C_SMBUS_BLOCK_PROC_CALL:
3222 num = 2; /* Another special case */
3223 read_write = I2C_SMBUS_READ;
3224 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
3225 dev_err(&adapter->dev,
3226 "Invalid block write size %d\n",
3230 msg[0].len = data->block[0] + 2;
3231 for (i = 1; i < msg[0].len; i++)
3232 msgbuf0[i] = data->block[i-1];
3233 msg[1].flags |= I2C_M_RECV_LEN;
3234 msg[1].len = 1; /* block length will be added by
3235 the underlying bus driver */
3237 case I2C_SMBUS_I2C_BLOCK_DATA:
3238 if (read_write == I2C_SMBUS_READ) {
3239 msg[1].len = data->block[0];
3241 msg[0].len = data->block[0] + 1;
3242 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
3243 dev_err(&adapter->dev,
3244 "Invalid block write size %d\n",
3248 for (i = 1; i <= data->block[0]; i++)
3249 msgbuf0[i] = data->block[i];
3253 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
3257 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
3258 && size != I2C_SMBUS_I2C_BLOCK_DATA);
3260 /* Compute PEC if first message is a write */
3261 if (!(msg[0].flags & I2C_M_RD)) {
3262 if (num == 1) /* Write only */
3263 i2c_smbus_add_pec(&msg[0]);
3264 else /* Write followed by read */
3265 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
3267 /* Ask for PEC if last message is a read */
3268 if (msg[num-1].flags & I2C_M_RD)
3272 status = i2c_transfer(adapter, msg, num);
3276 /* Check PEC if last message is a read */
3277 if (i && (msg[num-1].flags & I2C_M_RD)) {
3278 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
3283 if (read_write == I2C_SMBUS_READ)
3285 case I2C_SMBUS_BYTE:
3286 data->byte = msgbuf0[0];
3288 case I2C_SMBUS_BYTE_DATA:
3289 data->byte = msgbuf1[0];
3291 case I2C_SMBUS_WORD_DATA:
3292 case I2C_SMBUS_PROC_CALL:
3293 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
3295 case I2C_SMBUS_I2C_BLOCK_DATA:
3296 for (i = 0; i < data->block[0]; i++)
3297 data->block[i+1] = msgbuf1[i];
3299 case I2C_SMBUS_BLOCK_DATA:
3300 case I2C_SMBUS_BLOCK_PROC_CALL:
3301 for (i = 0; i < msgbuf1[0] + 1; i++)
3302 data->block[i] = msgbuf1[i];
3309 * i2c_smbus_xfer - execute SMBus protocol operations
3310 * @adapter: Handle to I2C bus
3311 * @addr: Address of SMBus slave on that bus
3312 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
3313 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
3314 * @command: Byte interpreted by slave, for protocols which use such bytes
3315 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
3316 * @data: Data to be read or written
3318 * This executes an SMBus protocol operation, and returns a negative
3319 * errno code else zero on success.
3321 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
3322 char read_write, u8 command, int protocol,
3323 union i2c_smbus_data *data)
3325 unsigned long orig_jiffies;
3329 /* If enabled, the following two tracepoints are conditional on
3330 * read_write and protocol.
3332 trace_smbus_write(adapter, addr, flags, read_write,
3333 command, protocol, data);
3334 trace_smbus_read(adapter, addr, flags, read_write,
3337 flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
3339 if (adapter->algo->smbus_xfer) {
3340 i2c_lock_bus(adapter, I2C_LOCK_SEGMENT);
3342 /* Retry automatically on arbitration loss */
3343 orig_jiffies = jiffies;
3344 for (res = 0, try = 0; try <= adapter->retries; try++) {
3345 res = adapter->algo->smbus_xfer(adapter, addr, flags,
3346 read_write, command,
3350 if (time_after(jiffies,
3351 orig_jiffies + adapter->timeout))
3354 i2c_unlock_bus(adapter, I2C_LOCK_SEGMENT);
3356 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
3359 * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
3360 * implement native support for the SMBus operation.
3364 res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
3365 command, protocol, data);
3368 /* If enabled, the reply tracepoint is conditional on read_write. */
3369 trace_smbus_reply(adapter, addr, flags, read_write,
3370 command, protocol, data);
3371 trace_smbus_result(adapter, addr, flags, read_write,
3372 command, protocol, res);
3376 EXPORT_SYMBOL(i2c_smbus_xfer);
3379 * i2c_smbus_read_i2c_block_data_or_emulated - read block or emulate
3380 * @client: Handle to slave device
3381 * @command: Byte interpreted by slave
3382 * @length: Size of data block; SMBus allows at most I2C_SMBUS_BLOCK_MAX bytes
3383 * @values: Byte array into which data will be read; big enough to hold
3384 * the data returned by the slave. SMBus allows at most
3385 * I2C_SMBUS_BLOCK_MAX bytes.
3387 * This executes the SMBus "block read" protocol if supported by the adapter.
3388 * If block read is not supported, it emulates it using either word or byte
3389 * read protocols depending on availability.
3391 * The addresses of the I2C slave device that are accessed with this function
3392 * must be mapped to a linear region, so that a block read will have the same
3393 * effect as a byte read. Before using this function you must double-check
3394 * if the I2C slave does support exchanging a block transfer with a byte
3397 s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
3398 u8 command, u8 length, u8 *values)
3403 if (length > I2C_SMBUS_BLOCK_MAX)
3404 length = I2C_SMBUS_BLOCK_MAX;
3406 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK))
3407 return i2c_smbus_read_i2c_block_data(client, command, length, values);
3409 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA))
3412 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_WORD_DATA)) {
3413 while ((i + 2) <= length) {
3414 status = i2c_smbus_read_word_data(client, command + i);
3417 values[i] = status & 0xff;
3418 values[i + 1] = status >> 8;
3423 while (i < length) {
3424 status = i2c_smbus_read_byte_data(client, command + i);
3433 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data_or_emulated);
3435 #if IS_ENABLED(CONFIG_I2C_SLAVE)
3436 int i2c_slave_register(struct i2c_client *client, i2c_slave_cb_t slave_cb)
3440 if (!client || !slave_cb) {
3441 WARN(1, "insufficent data\n");
3445 if (!(client->flags & I2C_CLIENT_SLAVE))
3446 dev_warn(&client->dev, "%s: client slave flag not set. You might see address collisions\n",
3449 if (!(client->flags & I2C_CLIENT_TEN)) {
3450 /* Enforce stricter address checking */
3451 ret = i2c_check_7bit_addr_validity_strict(client->addr);
3453 dev_err(&client->dev, "%s: invalid address\n", __func__);
3458 if (!client->adapter->algo->reg_slave) {
3459 dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
3463 client->slave_cb = slave_cb;
3465 i2c_lock_adapter(client->adapter);
3466 ret = client->adapter->algo->reg_slave(client);
3467 i2c_unlock_adapter(client->adapter);
3470 client->slave_cb = NULL;
3471 dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
3476 EXPORT_SYMBOL_GPL(i2c_slave_register);
3478 int i2c_slave_unregister(struct i2c_client *client)
3482 if (!client->adapter->algo->unreg_slave) {
3483 dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
3487 i2c_lock_adapter(client->adapter);
3488 ret = client->adapter->algo->unreg_slave(client);
3489 i2c_unlock_adapter(client->adapter);
3492 client->slave_cb = NULL;
3494 dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
3498 EXPORT_SYMBOL_GPL(i2c_slave_unregister);
3501 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
3502 MODULE_DESCRIPTION("I2C-Bus main module");
3503 MODULE_LICENSE("GPL");