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)
685 while (id->name[0]) {
686 if (strcmp(client->name, id->name) == 0)
693 static int i2c_device_match(struct device *dev, struct device_driver *drv)
695 struct i2c_client *client = i2c_verify_client(dev);
696 struct i2c_driver *driver;
699 /* Attempt an OF style match */
700 if (i2c_of_match_device(drv->of_match_table, client))
703 /* Then ACPI style match */
704 if (acpi_driver_match_device(dev, drv))
707 driver = to_i2c_driver(drv);
709 /* Finally an I2C match */
710 if (i2c_match_id(driver->id_table, client))
716 static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
718 struct i2c_client *client = to_i2c_client(dev);
721 rc = acpi_device_uevent_modalias(dev, env);
725 return add_uevent_var(env, "MODALIAS=%s%s", I2C_MODULE_PREFIX, client->name);
728 /* i2c bus recovery routines */
729 static int get_scl_gpio_value(struct i2c_adapter *adap)
731 return gpio_get_value(adap->bus_recovery_info->scl_gpio);
734 static void set_scl_gpio_value(struct i2c_adapter *adap, int val)
736 gpio_set_value(adap->bus_recovery_info->scl_gpio, val);
739 static int get_sda_gpio_value(struct i2c_adapter *adap)
741 return gpio_get_value(adap->bus_recovery_info->sda_gpio);
744 static int i2c_get_gpios_for_recovery(struct i2c_adapter *adap)
746 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
747 struct device *dev = &adap->dev;
750 ret = gpio_request_one(bri->scl_gpio, GPIOF_OPEN_DRAIN |
751 GPIOF_OUT_INIT_HIGH, "i2c-scl");
753 dev_warn(dev, "Can't get SCL gpio: %d\n", bri->scl_gpio);
758 if (gpio_request_one(bri->sda_gpio, GPIOF_IN, "i2c-sda")) {
759 /* work without SDA polling */
760 dev_warn(dev, "Can't get SDA gpio: %d. Not using SDA polling\n",
769 static void i2c_put_gpios_for_recovery(struct i2c_adapter *adap)
771 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
774 gpio_free(bri->sda_gpio);
776 gpio_free(bri->scl_gpio);
780 * We are generating clock pulses. ndelay() determines durating of clk pulses.
781 * We will generate clock with rate 100 KHz and so duration of both clock levels
782 * is: delay in ns = (10^6 / 100) / 2
784 #define RECOVERY_NDELAY 5000
785 #define RECOVERY_CLK_CNT 9
787 static int i2c_generic_recovery(struct i2c_adapter *adap)
789 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
790 int i = 0, val = 1, ret = 0;
792 if (bri->prepare_recovery)
793 bri->prepare_recovery(adap);
795 bri->set_scl(adap, val);
796 ndelay(RECOVERY_NDELAY);
799 * By this time SCL is high, as we need to give 9 falling-rising edges
801 while (i++ < RECOVERY_CLK_CNT * 2) {
803 /* Break if SDA is high */
804 if (bri->get_sda && bri->get_sda(adap))
806 /* SCL shouldn't be low here */
807 if (!bri->get_scl(adap)) {
809 "SCL is stuck low, exit recovery\n");
816 bri->set_scl(adap, val);
817 ndelay(RECOVERY_NDELAY);
820 if (bri->unprepare_recovery)
821 bri->unprepare_recovery(adap);
826 int i2c_generic_scl_recovery(struct i2c_adapter *adap)
828 return i2c_generic_recovery(adap);
830 EXPORT_SYMBOL_GPL(i2c_generic_scl_recovery);
832 int i2c_generic_gpio_recovery(struct i2c_adapter *adap)
836 ret = i2c_get_gpios_for_recovery(adap);
840 ret = i2c_generic_recovery(adap);
841 i2c_put_gpios_for_recovery(adap);
845 EXPORT_SYMBOL_GPL(i2c_generic_gpio_recovery);
847 int i2c_recover_bus(struct i2c_adapter *adap)
849 if (!adap->bus_recovery_info)
852 dev_dbg(&adap->dev, "Trying i2c bus recovery\n");
853 return adap->bus_recovery_info->recover_bus(adap);
855 EXPORT_SYMBOL_GPL(i2c_recover_bus);
857 static void i2c_init_recovery(struct i2c_adapter *adap)
859 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
865 if (!bri->recover_bus) {
866 err_str = "no recover_bus() found";
870 /* Generic GPIO recovery */
871 if (bri->recover_bus == i2c_generic_gpio_recovery) {
872 if (!gpio_is_valid(bri->scl_gpio)) {
873 err_str = "invalid SCL gpio";
877 if (gpio_is_valid(bri->sda_gpio))
878 bri->get_sda = get_sda_gpio_value;
882 bri->get_scl = get_scl_gpio_value;
883 bri->set_scl = set_scl_gpio_value;
884 } else if (bri->recover_bus == i2c_generic_scl_recovery) {
885 /* Generic SCL recovery */
886 if (!bri->set_scl || !bri->get_scl) {
887 err_str = "no {get|set}_scl() found";
894 dev_err(&adap->dev, "Not using recovery: %s\n", err_str);
895 adap->bus_recovery_info = NULL;
898 static int i2c_device_probe(struct device *dev)
900 struct i2c_client *client = i2c_verify_client(dev);
901 struct i2c_driver *driver;
911 irq = of_irq_get_byname(dev->of_node, "irq");
912 if (irq == -EINVAL || irq == -ENODATA)
913 irq = of_irq_get(dev->of_node, 0);
914 } else if (ACPI_COMPANION(dev)) {
915 irq = acpi_dev_gpio_irq_get(ACPI_COMPANION(dev), 0);
917 if (irq == -EPROBE_DEFER)
925 driver = to_i2c_driver(dev->driver);
930 * An I2C ID table is not mandatory, if and only if, a suitable Device
931 * Tree match table entry is supplied for the probing device.
933 if (!driver->id_table &&
934 !i2c_of_match_device(dev->driver->of_match_table, client))
937 if (client->flags & I2C_CLIENT_WAKE) {
938 int wakeirq = -ENOENT;
941 wakeirq = of_irq_get_byname(dev->of_node, "wakeup");
942 if (wakeirq == -EPROBE_DEFER)
946 device_init_wakeup(&client->dev, true);
948 if (wakeirq > 0 && wakeirq != client->irq)
949 status = dev_pm_set_dedicated_wake_irq(dev, wakeirq);
950 else if (client->irq > 0)
951 status = dev_pm_set_wake_irq(dev, client->irq);
956 dev_warn(&client->dev, "failed to set up wakeup irq\n");
959 dev_dbg(dev, "probe\n");
961 status = of_clk_set_defaults(dev->of_node, false);
963 goto err_clear_wakeup_irq;
965 status = dev_pm_domain_attach(&client->dev, true);
966 if (status == -EPROBE_DEFER)
967 goto err_clear_wakeup_irq;
969 status = driver->probe(client, i2c_match_id(driver->id_table, client));
971 goto err_detach_pm_domain;
975 err_detach_pm_domain:
976 dev_pm_domain_detach(&client->dev, true);
977 err_clear_wakeup_irq:
978 dev_pm_clear_wake_irq(&client->dev);
979 device_init_wakeup(&client->dev, false);
983 static int i2c_device_remove(struct device *dev)
985 struct i2c_client *client = i2c_verify_client(dev);
986 struct i2c_driver *driver;
989 if (!client || !dev->driver)
992 driver = to_i2c_driver(dev->driver);
993 if (driver->remove) {
994 dev_dbg(dev, "remove\n");
995 status = driver->remove(client);
998 dev_pm_domain_detach(&client->dev, true);
1000 dev_pm_clear_wake_irq(&client->dev);
1001 device_init_wakeup(&client->dev, false);
1006 static void i2c_device_shutdown(struct device *dev)
1008 struct i2c_client *client = i2c_verify_client(dev);
1009 struct i2c_driver *driver;
1011 if (!client || !dev->driver)
1013 driver = to_i2c_driver(dev->driver);
1014 if (driver->shutdown)
1015 driver->shutdown(client);
1018 static void i2c_client_dev_release(struct device *dev)
1020 kfree(to_i2c_client(dev));
1024 show_name(struct device *dev, struct device_attribute *attr, char *buf)
1026 return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
1027 to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
1029 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
1032 show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
1034 struct i2c_client *client = to_i2c_client(dev);
1037 len = acpi_device_modalias(dev, buf, PAGE_SIZE -1);
1041 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
1043 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
1045 static struct attribute *i2c_dev_attrs[] = {
1046 &dev_attr_name.attr,
1047 /* modalias helps coldplug: modprobe $(cat .../modalias) */
1048 &dev_attr_modalias.attr,
1051 ATTRIBUTE_GROUPS(i2c_dev);
1053 struct bus_type i2c_bus_type = {
1055 .match = i2c_device_match,
1056 .probe = i2c_device_probe,
1057 .remove = i2c_device_remove,
1058 .shutdown = i2c_device_shutdown,
1060 EXPORT_SYMBOL_GPL(i2c_bus_type);
1062 static struct device_type i2c_client_type = {
1063 .groups = i2c_dev_groups,
1064 .uevent = i2c_device_uevent,
1065 .release = i2c_client_dev_release,
1070 * i2c_verify_client - return parameter as i2c_client, or NULL
1071 * @dev: device, probably from some driver model iterator
1073 * When traversing the driver model tree, perhaps using driver model
1074 * iterators like @device_for_each_child(), you can't assume very much
1075 * about the nodes you find. Use this function to avoid oopses caused
1076 * by wrongly treating some non-I2C device as an i2c_client.
1078 struct i2c_client *i2c_verify_client(struct device *dev)
1080 return (dev->type == &i2c_client_type)
1081 ? to_i2c_client(dev)
1084 EXPORT_SYMBOL(i2c_verify_client);
1087 /* Return a unique address which takes the flags of the client into account */
1088 static unsigned short i2c_encode_flags_to_addr(struct i2c_client *client)
1090 unsigned short addr = client->addr;
1092 /* For some client flags, add an arbitrary offset to avoid collisions */
1093 if (client->flags & I2C_CLIENT_TEN)
1094 addr |= I2C_ADDR_OFFSET_TEN_BIT;
1096 if (client->flags & I2C_CLIENT_SLAVE)
1097 addr |= I2C_ADDR_OFFSET_SLAVE;
1102 /* This is a permissive address validity check, I2C address map constraints
1103 * are purposely not enforced, except for the general call address. */
1104 static int i2c_check_addr_validity(unsigned addr, unsigned short flags)
1106 if (flags & I2C_CLIENT_TEN) {
1107 /* 10-bit address, all values are valid */
1111 /* 7-bit address, reject the general call address */
1112 if (addr == 0x00 || addr > 0x7f)
1118 /* And this is a strict address validity check, used when probing. If a
1119 * device uses a reserved address, then it shouldn't be probed. 7-bit
1120 * addressing is assumed, 10-bit address devices are rare and should be
1121 * explicitly enumerated. */
1122 static int i2c_check_7bit_addr_validity_strict(unsigned short addr)
1125 * Reserved addresses per I2C specification:
1126 * 0x00 General call address / START byte
1128 * 0x02 Reserved for different bus format
1129 * 0x03 Reserved for future purposes
1130 * 0x04-0x07 Hs-mode master code
1131 * 0x78-0x7b 10-bit slave addressing
1132 * 0x7c-0x7f Reserved for future purposes
1134 if (addr < 0x08 || addr > 0x77)
1139 static int __i2c_check_addr_busy(struct device *dev, void *addrp)
1141 struct i2c_client *client = i2c_verify_client(dev);
1142 int addr = *(int *)addrp;
1144 if (client && i2c_encode_flags_to_addr(client) == addr)
1149 /* walk up mux tree */
1150 static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
1152 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
1155 result = device_for_each_child(&adapter->dev, &addr,
1156 __i2c_check_addr_busy);
1158 if (!result && parent)
1159 result = i2c_check_mux_parents(parent, addr);
1164 /* recurse down mux tree */
1165 static int i2c_check_mux_children(struct device *dev, void *addrp)
1169 if (dev->type == &i2c_adapter_type)
1170 result = device_for_each_child(dev, addrp,
1171 i2c_check_mux_children);
1173 result = __i2c_check_addr_busy(dev, addrp);
1178 static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
1180 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
1184 result = i2c_check_mux_parents(parent, addr);
1187 result = device_for_each_child(&adapter->dev, &addr,
1188 i2c_check_mux_children);
1194 * i2c_adapter_lock_bus - Get exclusive access to an I2C bus segment
1195 * @adapter: Target I2C bus segment
1196 * @flags: I2C_LOCK_ROOT_ADAPTER locks the root i2c adapter, I2C_LOCK_SEGMENT
1197 * locks only this branch in the adapter tree
1199 static void i2c_adapter_lock_bus(struct i2c_adapter *adapter,
1202 rt_mutex_lock(&adapter->bus_lock);
1206 * i2c_adapter_trylock_bus - Try to get exclusive access to an I2C bus segment
1207 * @adapter: Target I2C bus segment
1208 * @flags: I2C_LOCK_ROOT_ADAPTER trylocks the root i2c adapter, I2C_LOCK_SEGMENT
1209 * trylocks only this branch in the adapter tree
1211 static int i2c_adapter_trylock_bus(struct i2c_adapter *adapter,
1214 return rt_mutex_trylock(&adapter->bus_lock);
1218 * i2c_adapter_unlock_bus - Release exclusive access to an I2C bus segment
1219 * @adapter: Target I2C bus segment
1220 * @flags: I2C_LOCK_ROOT_ADAPTER unlocks the root i2c adapter, I2C_LOCK_SEGMENT
1221 * unlocks only this branch in the adapter tree
1223 static void i2c_adapter_unlock_bus(struct i2c_adapter *adapter,
1226 rt_mutex_unlock(&adapter->bus_lock);
1229 static void i2c_dev_set_name(struct i2c_adapter *adap,
1230 struct i2c_client *client)
1232 struct acpi_device *adev = ACPI_COMPANION(&client->dev);
1235 dev_set_name(&client->dev, "i2c-%s", acpi_dev_name(adev));
1239 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
1240 i2c_encode_flags_to_addr(client));
1244 * i2c_new_device - instantiate an i2c device
1245 * @adap: the adapter managing the device
1246 * @info: describes one I2C device; bus_num is ignored
1247 * Context: can sleep
1249 * Create an i2c device. Binding is handled through driver model
1250 * probe()/remove() methods. A driver may be bound to this device when we
1251 * return from this function, or any later moment (e.g. maybe hotplugging will
1252 * load the driver module). This call is not appropriate for use by mainboard
1253 * initialization logic, which usually runs during an arch_initcall() long
1254 * before any i2c_adapter could exist.
1256 * This returns the new i2c client, which may be saved for later use with
1257 * i2c_unregister_device(); or NULL to indicate an error.
1260 i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
1262 struct i2c_client *client;
1265 client = kzalloc(sizeof *client, GFP_KERNEL);
1269 client->adapter = adap;
1271 client->dev.platform_data = info->platform_data;
1274 client->dev.archdata = *info->archdata;
1276 client->flags = info->flags;
1277 client->addr = info->addr;
1278 client->irq = info->irq;
1280 strlcpy(client->name, info->type, sizeof(client->name));
1282 status = i2c_check_addr_validity(client->addr, client->flags);
1284 dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
1285 client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
1286 goto out_err_silent;
1289 /* Check for address business */
1290 status = i2c_check_addr_busy(adap, i2c_encode_flags_to_addr(client));
1294 client->dev.parent = &client->adapter->dev;
1295 client->dev.bus = &i2c_bus_type;
1296 client->dev.type = &i2c_client_type;
1297 client->dev.of_node = info->of_node;
1298 client->dev.fwnode = info->fwnode;
1300 i2c_dev_set_name(adap, client);
1301 status = device_register(&client->dev);
1305 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
1306 client->name, dev_name(&client->dev));
1312 "Failed to register i2c client %s at 0x%02x (%d)\n",
1313 client->name, client->addr, status);
1318 EXPORT_SYMBOL_GPL(i2c_new_device);
1322 * i2c_unregister_device - reverse effect of i2c_new_device()
1323 * @client: value returned from i2c_new_device()
1324 * Context: can sleep
1326 void i2c_unregister_device(struct i2c_client *client)
1328 if (client->dev.of_node)
1329 of_node_clear_flag(client->dev.of_node, OF_POPULATED);
1330 if (ACPI_COMPANION(&client->dev))
1331 acpi_device_clear_enumerated(ACPI_COMPANION(&client->dev));
1332 device_unregister(&client->dev);
1334 EXPORT_SYMBOL_GPL(i2c_unregister_device);
1337 static const struct i2c_device_id dummy_id[] = {
1342 static int dummy_probe(struct i2c_client *client,
1343 const struct i2c_device_id *id)
1348 static int dummy_remove(struct i2c_client *client)
1353 static struct i2c_driver dummy_driver = {
1354 .driver.name = "dummy",
1355 .probe = dummy_probe,
1356 .remove = dummy_remove,
1357 .id_table = dummy_id,
1361 * i2c_new_dummy - return a new i2c device bound to a dummy driver
1362 * @adapter: the adapter managing the device
1363 * @address: seven bit address to be used
1364 * Context: can sleep
1366 * This returns an I2C client bound to the "dummy" driver, intended for use
1367 * with devices that consume multiple addresses. Examples of such chips
1368 * include various EEPROMS (like 24c04 and 24c08 models).
1370 * These dummy devices have two main uses. First, most I2C and SMBus calls
1371 * except i2c_transfer() need a client handle; the dummy will be that handle.
1372 * And second, this prevents the specified address from being bound to a
1375 * This returns the new i2c client, which should be saved for later use with
1376 * i2c_unregister_device(); or NULL to indicate an error.
1378 struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
1380 struct i2c_board_info info = {
1381 I2C_BOARD_INFO("dummy", address),
1384 return i2c_new_device(adapter, &info);
1386 EXPORT_SYMBOL_GPL(i2c_new_dummy);
1389 * i2c_new_secondary_device - Helper to get the instantiated secondary address
1390 * and create the associated device
1391 * @client: Handle to the primary client
1392 * @name: Handle to specify which secondary address to get
1393 * @default_addr: Used as a fallback if no secondary address was specified
1394 * Context: can sleep
1396 * I2C clients can be composed of multiple I2C slaves bound together in a single
1397 * component. The I2C client driver then binds to the master I2C slave and needs
1398 * to create I2C dummy clients to communicate with all the other slaves.
1400 * This function creates and returns an I2C dummy client whose I2C address is
1401 * retrieved from the platform firmware based on the given slave name. If no
1402 * address is specified by the firmware default_addr is used.
1404 * On DT-based platforms the address is retrieved from the "reg" property entry
1405 * cell whose "reg-names" value matches the slave name.
1407 * This returns the new i2c client, which should be saved for later use with
1408 * i2c_unregister_device(); or NULL to indicate an error.
1410 struct i2c_client *i2c_new_secondary_device(struct i2c_client *client,
1414 struct device_node *np = client->dev.of_node;
1415 u32 addr = default_addr;
1419 i = of_property_match_string(np, "reg-names", name);
1421 of_property_read_u32_index(np, "reg", i, &addr);
1424 dev_dbg(&client->adapter->dev, "Address for %s : 0x%x\n", name, addr);
1425 return i2c_new_dummy(client->adapter, addr);
1427 EXPORT_SYMBOL_GPL(i2c_new_secondary_device);
1429 /* ------------------------------------------------------------------------- */
1431 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
1433 static void i2c_adapter_dev_release(struct device *dev)
1435 struct i2c_adapter *adap = to_i2c_adapter(dev);
1436 complete(&adap->dev_released);
1439 unsigned int i2c_adapter_depth(struct i2c_adapter *adapter)
1441 unsigned int depth = 0;
1443 while ((adapter = i2c_parent_is_i2c_adapter(adapter)))
1446 WARN_ONCE(depth >= MAX_LOCKDEP_SUBCLASSES,
1447 "adapter depth exceeds lockdep subclass limit\n");
1451 EXPORT_SYMBOL_GPL(i2c_adapter_depth);
1454 * Let users instantiate I2C devices through sysfs. This can be used when
1455 * platform initialization code doesn't contain the proper data for
1456 * whatever reason. Also useful for drivers that do device detection and
1457 * detection fails, either because the device uses an unexpected address,
1458 * or this is a compatible device with different ID register values.
1460 * Parameter checking may look overzealous, but we really don't want
1461 * the user to provide incorrect parameters.
1464 i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
1465 const char *buf, size_t count)
1467 struct i2c_adapter *adap = to_i2c_adapter(dev);
1468 struct i2c_board_info info;
1469 struct i2c_client *client;
1473 memset(&info, 0, sizeof(struct i2c_board_info));
1475 blank = strchr(buf, ' ');
1477 dev_err(dev, "%s: Missing parameters\n", "new_device");
1480 if (blank - buf > I2C_NAME_SIZE - 1) {
1481 dev_err(dev, "%s: Invalid device name\n", "new_device");
1484 memcpy(info.type, buf, blank - buf);
1486 /* Parse remaining parameters, reject extra parameters */
1487 res = sscanf(++blank, "%hi%c", &info.addr, &end);
1489 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
1492 if (res > 1 && end != '\n') {
1493 dev_err(dev, "%s: Extra parameters\n", "new_device");
1497 if ((info.addr & I2C_ADDR_OFFSET_TEN_BIT) == I2C_ADDR_OFFSET_TEN_BIT) {
1498 info.addr &= ~I2C_ADDR_OFFSET_TEN_BIT;
1499 info.flags |= I2C_CLIENT_TEN;
1502 if (info.addr & I2C_ADDR_OFFSET_SLAVE) {
1503 info.addr &= ~I2C_ADDR_OFFSET_SLAVE;
1504 info.flags |= I2C_CLIENT_SLAVE;
1507 client = i2c_new_device(adap, &info);
1511 /* Keep track of the added device */
1512 mutex_lock(&adap->userspace_clients_lock);
1513 list_add_tail(&client->detected, &adap->userspace_clients);
1514 mutex_unlock(&adap->userspace_clients_lock);
1515 dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
1516 info.type, info.addr);
1520 static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
1523 * And of course let the users delete the devices they instantiated, if
1524 * they got it wrong. This interface can only be used to delete devices
1525 * instantiated by i2c_sysfs_new_device above. This guarantees that we
1526 * don't delete devices to which some kernel code still has references.
1528 * Parameter checking may look overzealous, but we really don't want
1529 * the user to delete the wrong device.
1532 i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
1533 const char *buf, size_t count)
1535 struct i2c_adapter *adap = to_i2c_adapter(dev);
1536 struct i2c_client *client, *next;
1537 unsigned short addr;
1541 /* Parse parameters, reject extra parameters */
1542 res = sscanf(buf, "%hi%c", &addr, &end);
1544 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
1547 if (res > 1 && end != '\n') {
1548 dev_err(dev, "%s: Extra parameters\n", "delete_device");
1552 /* Make sure the device was added through sysfs */
1554 mutex_lock_nested(&adap->userspace_clients_lock,
1555 i2c_adapter_depth(adap));
1556 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1558 if (i2c_encode_flags_to_addr(client) == addr) {
1559 dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
1560 "delete_device", client->name, client->addr);
1562 list_del(&client->detected);
1563 i2c_unregister_device(client);
1568 mutex_unlock(&adap->userspace_clients_lock);
1571 dev_err(dev, "%s: Can't find device in list\n",
1575 static DEVICE_ATTR_IGNORE_LOCKDEP(delete_device, S_IWUSR, NULL,
1576 i2c_sysfs_delete_device);
1578 static struct attribute *i2c_adapter_attrs[] = {
1579 &dev_attr_name.attr,
1580 &dev_attr_new_device.attr,
1581 &dev_attr_delete_device.attr,
1584 ATTRIBUTE_GROUPS(i2c_adapter);
1586 struct device_type i2c_adapter_type = {
1587 .groups = i2c_adapter_groups,
1588 .release = i2c_adapter_dev_release,
1590 EXPORT_SYMBOL_GPL(i2c_adapter_type);
1593 * i2c_verify_adapter - return parameter as i2c_adapter or NULL
1594 * @dev: device, probably from some driver model iterator
1596 * When traversing the driver model tree, perhaps using driver model
1597 * iterators like @device_for_each_child(), you can't assume very much
1598 * about the nodes you find. Use this function to avoid oopses caused
1599 * by wrongly treating some non-I2C device as an i2c_adapter.
1601 struct i2c_adapter *i2c_verify_adapter(struct device *dev)
1603 return (dev->type == &i2c_adapter_type)
1604 ? to_i2c_adapter(dev)
1607 EXPORT_SYMBOL(i2c_verify_adapter);
1609 #ifdef CONFIG_I2C_COMPAT
1610 static struct class_compat *i2c_adapter_compat_class;
1613 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
1615 struct i2c_devinfo *devinfo;
1617 down_read(&__i2c_board_lock);
1618 list_for_each_entry(devinfo, &__i2c_board_list, list) {
1619 if (devinfo->busnum == adapter->nr
1620 && !i2c_new_device(adapter,
1621 &devinfo->board_info))
1622 dev_err(&adapter->dev,
1623 "Can't create device at 0x%02x\n",
1624 devinfo->board_info.addr);
1626 up_read(&__i2c_board_lock);
1629 /* OF support code */
1631 #if IS_ENABLED(CONFIG_OF)
1632 static struct i2c_client *of_i2c_register_device(struct i2c_adapter *adap,
1633 struct device_node *node)
1635 struct i2c_client *result;
1636 struct i2c_board_info info = {};
1637 struct dev_archdata dev_ad = {};
1638 const __be32 *addr_be;
1642 dev_dbg(&adap->dev, "of_i2c: register %s\n", node->full_name);
1644 if (of_modalias_node(node, info.type, sizeof(info.type)) < 0) {
1645 dev_err(&adap->dev, "of_i2c: modalias failure on %s\n",
1647 return ERR_PTR(-EINVAL);
1650 addr_be = of_get_property(node, "reg", &len);
1651 if (!addr_be || (len < sizeof(*addr_be))) {
1652 dev_err(&adap->dev, "of_i2c: invalid reg on %s\n",
1654 return ERR_PTR(-EINVAL);
1657 addr = be32_to_cpup(addr_be);
1658 if (addr & I2C_TEN_BIT_ADDRESS) {
1659 addr &= ~I2C_TEN_BIT_ADDRESS;
1660 info.flags |= I2C_CLIENT_TEN;
1663 if (addr & I2C_OWN_SLAVE_ADDRESS) {
1664 addr &= ~I2C_OWN_SLAVE_ADDRESS;
1665 info.flags |= I2C_CLIENT_SLAVE;
1668 if (i2c_check_addr_validity(addr, info.flags)) {
1669 dev_err(&adap->dev, "of_i2c: invalid addr=%x on %s\n",
1670 info.addr, node->full_name);
1671 return ERR_PTR(-EINVAL);
1675 info.of_node = of_node_get(node);
1676 info.archdata = &dev_ad;
1678 if (of_get_property(node, "wakeup-source", NULL))
1679 info.flags |= I2C_CLIENT_WAKE;
1681 result = i2c_new_device(adap, &info);
1682 if (result == NULL) {
1683 dev_err(&adap->dev, "of_i2c: Failure registering %s\n",
1686 return ERR_PTR(-EINVAL);
1691 static void of_i2c_register_devices(struct i2c_adapter *adap)
1693 struct device_node *bus, *node;
1694 struct i2c_client *client;
1696 /* Only register child devices if the adapter has a node pointer set */
1697 if (!adap->dev.of_node)
1700 dev_dbg(&adap->dev, "of_i2c: walking child nodes\n");
1702 bus = of_get_child_by_name(adap->dev.of_node, "i2c-bus");
1704 bus = of_node_get(adap->dev.of_node);
1706 for_each_available_child_of_node(bus, node) {
1707 if (of_node_test_and_set_flag(node, OF_POPULATED))
1710 client = of_i2c_register_device(adap, node);
1711 if (IS_ERR(client)) {
1712 dev_warn(&adap->dev,
1713 "Failed to create I2C device for %s\n",
1715 of_node_clear_flag(node, OF_POPULATED);
1722 static int of_dev_node_match(struct device *dev, void *data)
1724 return dev->of_node == data;
1727 /* must call put_device() when done with returned i2c_client device */
1728 struct i2c_client *of_find_i2c_device_by_node(struct device_node *node)
1731 struct i2c_client *client;
1733 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
1737 client = i2c_verify_client(dev);
1743 EXPORT_SYMBOL(of_find_i2c_device_by_node);
1745 /* must call put_device() when done with returned i2c_adapter device */
1746 struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node)
1749 struct i2c_adapter *adapter;
1751 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
1755 adapter = i2c_verify_adapter(dev);
1761 EXPORT_SYMBOL(of_find_i2c_adapter_by_node);
1763 /* must call i2c_put_adapter() when done with returned i2c_adapter device */
1764 struct i2c_adapter *of_get_i2c_adapter_by_node(struct device_node *node)
1766 struct i2c_adapter *adapter;
1768 adapter = of_find_i2c_adapter_by_node(node);
1772 if (!try_module_get(adapter->owner)) {
1773 put_device(&adapter->dev);
1779 EXPORT_SYMBOL(of_get_i2c_adapter_by_node);
1781 static const struct of_device_id*
1782 i2c_of_match_device_sysfs(const struct of_device_id *matches,
1783 struct i2c_client *client)
1787 for (; matches->compatible[0]; matches++) {
1789 * Adding devices through the i2c sysfs interface provides us
1790 * a string to match which may be compatible with the device
1791 * tree compatible strings, however with no actual of_node the
1792 * of_match_device() will not match
1794 if (sysfs_streq(client->name, matches->compatible))
1797 name = strchr(matches->compatible, ',');
1799 name = matches->compatible;
1803 if (sysfs_streq(client->name, name))
1810 const struct of_device_id
1811 *i2c_of_match_device(const struct of_device_id *matches,
1812 struct i2c_client *client)
1814 const struct of_device_id *match;
1816 if (!(client && matches))
1819 match = of_match_device(matches, &client->dev);
1823 return i2c_of_match_device_sysfs(matches, client);
1825 EXPORT_SYMBOL_GPL(i2c_of_match_device);
1827 static void of_i2c_register_devices(struct i2c_adapter *adap) { }
1828 #endif /* CONFIG_OF */
1830 static int i2c_do_add_adapter(struct i2c_driver *driver,
1831 struct i2c_adapter *adap)
1833 /* Detect supported devices on that bus, and instantiate them */
1834 i2c_detect(adap, driver);
1836 /* Let legacy drivers scan this bus for matching devices */
1837 if (driver->attach_adapter) {
1838 dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
1839 driver->driver.name);
1840 dev_warn(&adap->dev,
1841 "Please use another way to instantiate your i2c_client\n");
1842 /* We ignore the return code; if it fails, too bad */
1843 driver->attach_adapter(adap);
1848 static int __process_new_adapter(struct device_driver *d, void *data)
1850 return i2c_do_add_adapter(to_i2c_driver(d), data);
1853 static const struct i2c_lock_operations i2c_adapter_lock_ops = {
1854 .lock_bus = i2c_adapter_lock_bus,
1855 .trylock_bus = i2c_adapter_trylock_bus,
1856 .unlock_bus = i2c_adapter_unlock_bus,
1859 static int i2c_register_adapter(struct i2c_adapter *adap)
1863 /* Can't register until after driver model init */
1864 if (WARN_ON(!is_registered)) {
1870 if (WARN(!adap->name[0], "i2c adapter has no name"))
1874 pr_err("adapter '%s': no algo supplied!\n", adap->name);
1878 if (!adap->lock_ops)
1879 adap->lock_ops = &i2c_adapter_lock_ops;
1881 rt_mutex_init(&adap->bus_lock);
1882 rt_mutex_init(&adap->mux_lock);
1883 mutex_init(&adap->userspace_clients_lock);
1884 INIT_LIST_HEAD(&adap->userspace_clients);
1886 /* Set default timeout to 1 second if not already set */
1887 if (adap->timeout == 0)
1890 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
1891 adap->dev.bus = &i2c_bus_type;
1892 adap->dev.type = &i2c_adapter_type;
1893 res = device_register(&adap->dev);
1895 pr_err("adapter '%s': can't register device (%d)\n", adap->name, res);
1899 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
1901 pm_runtime_no_callbacks(&adap->dev);
1902 pm_suspend_ignore_children(&adap->dev, true);
1903 pm_runtime_enable(&adap->dev);
1905 #ifdef CONFIG_I2C_COMPAT
1906 res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
1909 dev_warn(&adap->dev,
1910 "Failed to create compatibility class link\n");
1913 i2c_init_recovery(adap);
1915 /* create pre-declared device nodes */
1916 of_i2c_register_devices(adap);
1917 i2c_acpi_register_devices(adap);
1918 i2c_acpi_install_space_handler(adap);
1920 if (adap->nr < __i2c_first_dynamic_bus_num)
1921 i2c_scan_static_board_info(adap);
1923 /* Notify drivers */
1924 mutex_lock(&core_lock);
1925 bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
1926 mutex_unlock(&core_lock);
1931 mutex_lock(&core_lock);
1932 idr_remove(&i2c_adapter_idr, adap->nr);
1933 mutex_unlock(&core_lock);
1938 * __i2c_add_numbered_adapter - i2c_add_numbered_adapter where nr is never -1
1939 * @adap: the adapter to register (with adap->nr initialized)
1940 * Context: can sleep
1942 * See i2c_add_numbered_adapter() for details.
1944 static int __i2c_add_numbered_adapter(struct i2c_adapter *adap)
1948 mutex_lock(&core_lock);
1949 id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1, GFP_KERNEL);
1950 mutex_unlock(&core_lock);
1951 if (WARN(id < 0, "couldn't get idr"))
1952 return id == -ENOSPC ? -EBUSY : id;
1954 return i2c_register_adapter(adap);
1958 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
1959 * @adapter: the adapter to add
1960 * Context: can sleep
1962 * This routine is used to declare an I2C adapter when its bus number
1963 * doesn't matter or when its bus number is specified by an dt alias.
1964 * Examples of bases when the bus number doesn't matter: I2C adapters
1965 * dynamically added by USB links or PCI plugin cards.
1967 * When this returns zero, a new bus number was allocated and stored
1968 * in adap->nr, and the specified adapter became available for clients.
1969 * Otherwise, a negative errno value is returned.
1971 int i2c_add_adapter(struct i2c_adapter *adapter)
1973 struct device *dev = &adapter->dev;
1977 id = of_alias_get_id(dev->of_node, "i2c");
1980 return __i2c_add_numbered_adapter(adapter);
1984 mutex_lock(&core_lock);
1985 id = idr_alloc(&i2c_adapter_idr, adapter,
1986 __i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
1987 mutex_unlock(&core_lock);
1988 if (WARN(id < 0, "couldn't get idr"))
1993 return i2c_register_adapter(adapter);
1995 EXPORT_SYMBOL(i2c_add_adapter);
1998 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
1999 * @adap: the adapter to register (with adap->nr initialized)
2000 * Context: can sleep
2002 * This routine is used to declare an I2C adapter when its bus number
2003 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
2004 * or otherwise built in to the system's mainboard, and where i2c_board_info
2005 * is used to properly configure I2C devices.
2007 * If the requested bus number is set to -1, then this function will behave
2008 * identically to i2c_add_adapter, and will dynamically assign a bus number.
2010 * If no devices have pre-been declared for this bus, then be sure to
2011 * register the adapter before any dynamically allocated ones. Otherwise
2012 * the required bus ID may not be available.
2014 * When this returns zero, the specified adapter became available for
2015 * clients using the bus number provided in adap->nr. Also, the table
2016 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
2017 * and the appropriate driver model device nodes are created. Otherwise, a
2018 * negative errno value is returned.
2020 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
2022 if (adap->nr == -1) /* -1 means dynamically assign bus id */
2023 return i2c_add_adapter(adap);
2025 return __i2c_add_numbered_adapter(adap);
2027 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
2029 static void i2c_do_del_adapter(struct i2c_driver *driver,
2030 struct i2c_adapter *adapter)
2032 struct i2c_client *client, *_n;
2034 /* Remove the devices we created ourselves as the result of hardware
2035 * probing (using a driver's detect method) */
2036 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
2037 if (client->adapter == adapter) {
2038 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
2039 client->name, client->addr);
2040 list_del(&client->detected);
2041 i2c_unregister_device(client);
2046 static int __unregister_client(struct device *dev, void *dummy)
2048 struct i2c_client *client = i2c_verify_client(dev);
2049 if (client && strcmp(client->name, "dummy"))
2050 i2c_unregister_device(client);
2054 static int __unregister_dummy(struct device *dev, void *dummy)
2056 struct i2c_client *client = i2c_verify_client(dev);
2058 i2c_unregister_device(client);
2062 static int __process_removed_adapter(struct device_driver *d, void *data)
2064 i2c_do_del_adapter(to_i2c_driver(d), data);
2069 * i2c_del_adapter - unregister I2C adapter
2070 * @adap: the adapter being unregistered
2071 * Context: can sleep
2073 * This unregisters an I2C adapter which was previously registered
2074 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
2076 void i2c_del_adapter(struct i2c_adapter *adap)
2078 struct i2c_adapter *found;
2079 struct i2c_client *client, *next;
2081 /* First make sure that this adapter was ever added */
2082 mutex_lock(&core_lock);
2083 found = idr_find(&i2c_adapter_idr, adap->nr);
2084 mutex_unlock(&core_lock);
2085 if (found != adap) {
2086 pr_debug("attempting to delete unregistered adapter [%s]\n", adap->name);
2090 i2c_acpi_remove_space_handler(adap);
2091 /* Tell drivers about this removal */
2092 mutex_lock(&core_lock);
2093 bus_for_each_drv(&i2c_bus_type, NULL, adap,
2094 __process_removed_adapter);
2095 mutex_unlock(&core_lock);
2097 /* Remove devices instantiated from sysfs */
2098 mutex_lock_nested(&adap->userspace_clients_lock,
2099 i2c_adapter_depth(adap));
2100 list_for_each_entry_safe(client, next, &adap->userspace_clients,
2102 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
2104 list_del(&client->detected);
2105 i2c_unregister_device(client);
2107 mutex_unlock(&adap->userspace_clients_lock);
2109 /* Detach any active clients. This can't fail, thus we do not
2110 * check the returned value. This is a two-pass process, because
2111 * we can't remove the dummy devices during the first pass: they
2112 * could have been instantiated by real devices wishing to clean
2113 * them up properly, so we give them a chance to do that first. */
2114 device_for_each_child(&adap->dev, NULL, __unregister_client);
2115 device_for_each_child(&adap->dev, NULL, __unregister_dummy);
2117 #ifdef CONFIG_I2C_COMPAT
2118 class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
2122 /* device name is gone after device_unregister */
2123 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
2125 pm_runtime_disable(&adap->dev);
2127 /* wait until all references to the device are gone
2129 * FIXME: This is old code and should ideally be replaced by an
2130 * alternative which results in decoupling the lifetime of the struct
2131 * device from the i2c_adapter, like spi or netdev do. Any solution
2132 * should be thoroughly tested with DEBUG_KOBJECT_RELEASE enabled!
2134 init_completion(&adap->dev_released);
2135 device_unregister(&adap->dev);
2136 wait_for_completion(&adap->dev_released);
2139 mutex_lock(&core_lock);
2140 idr_remove(&i2c_adapter_idr, adap->nr);
2141 mutex_unlock(&core_lock);
2143 /* Clear the device structure in case this adapter is ever going to be
2145 memset(&adap->dev, 0, sizeof(adap->dev));
2147 EXPORT_SYMBOL(i2c_del_adapter);
2150 * i2c_parse_fw_timings - get I2C related timing parameters from firmware
2151 * @dev: The device to scan for I2C timing properties
2152 * @t: the i2c_timings struct to be filled with values
2153 * @use_defaults: bool to use sane defaults derived from the I2C specification
2154 * when properties are not found, otherwise use 0
2156 * Scan the device for the generic I2C properties describing timing parameters
2157 * for the signal and fill the given struct with the results. If a property was
2158 * not found and use_defaults was true, then maximum timings are assumed which
2159 * are derived from the I2C specification. If use_defaults is not used, the
2160 * results will be 0, so drivers can apply their own defaults later. The latter
2161 * is mainly intended for avoiding regressions of existing drivers which want
2162 * to switch to this function. New drivers almost always should use the defaults.
2165 void i2c_parse_fw_timings(struct device *dev, struct i2c_timings *t, bool use_defaults)
2169 memset(t, 0, sizeof(*t));
2171 ret = device_property_read_u32(dev, "clock-frequency", &t->bus_freq_hz);
2172 if (ret && use_defaults)
2173 t->bus_freq_hz = 100000;
2175 ret = device_property_read_u32(dev, "i2c-scl-rising-time-ns", &t->scl_rise_ns);
2176 if (ret && use_defaults) {
2177 if (t->bus_freq_hz <= 100000)
2178 t->scl_rise_ns = 1000;
2179 else if (t->bus_freq_hz <= 400000)
2180 t->scl_rise_ns = 300;
2182 t->scl_rise_ns = 120;
2185 ret = device_property_read_u32(dev, "i2c-scl-falling-time-ns", &t->scl_fall_ns);
2186 if (ret && use_defaults) {
2187 if (t->bus_freq_hz <= 400000)
2188 t->scl_fall_ns = 300;
2190 t->scl_fall_ns = 120;
2193 device_property_read_u32(dev, "i2c-scl-internal-delay-ns", &t->scl_int_delay_ns);
2195 ret = device_property_read_u32(dev, "i2c-sda-falling-time-ns", &t->sda_fall_ns);
2196 if (ret && use_defaults)
2197 t->sda_fall_ns = t->scl_fall_ns;
2199 EXPORT_SYMBOL_GPL(i2c_parse_fw_timings);
2201 /* ------------------------------------------------------------------------- */
2203 int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
2207 mutex_lock(&core_lock);
2208 res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
2209 mutex_unlock(&core_lock);
2213 EXPORT_SYMBOL_GPL(i2c_for_each_dev);
2215 static int __process_new_driver(struct device *dev, void *data)
2217 if (dev->type != &i2c_adapter_type)
2219 return i2c_do_add_adapter(data, to_i2c_adapter(dev));
2223 * An i2c_driver is used with one or more i2c_client (device) nodes to access
2224 * i2c slave chips, on a bus instance associated with some i2c_adapter.
2227 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
2231 /* Can't register until after driver model init */
2232 if (WARN_ON(!is_registered))
2235 /* add the driver to the list of i2c drivers in the driver core */
2236 driver->driver.owner = owner;
2237 driver->driver.bus = &i2c_bus_type;
2238 INIT_LIST_HEAD(&driver->clients);
2240 /* When registration returns, the driver core
2241 * will have called probe() for all matching-but-unbound devices.
2243 res = driver_register(&driver->driver);
2247 pr_debug("driver [%s] registered\n", driver->driver.name);
2249 /* Walk the adapters that are already present */
2250 i2c_for_each_dev(driver, __process_new_driver);
2254 EXPORT_SYMBOL(i2c_register_driver);
2256 static int __process_removed_driver(struct device *dev, void *data)
2258 if (dev->type == &i2c_adapter_type)
2259 i2c_do_del_adapter(data, to_i2c_adapter(dev));
2264 * i2c_del_driver - unregister I2C driver
2265 * @driver: the driver being unregistered
2266 * Context: can sleep
2268 void i2c_del_driver(struct i2c_driver *driver)
2270 i2c_for_each_dev(driver, __process_removed_driver);
2272 driver_unregister(&driver->driver);
2273 pr_debug("driver [%s] unregistered\n", driver->driver.name);
2275 EXPORT_SYMBOL(i2c_del_driver);
2277 /* ------------------------------------------------------------------------- */
2280 * i2c_use_client - increments the reference count of the i2c client structure
2281 * @client: the client being referenced
2283 * Each live reference to a client should be refcounted. The driver model does
2284 * that automatically as part of driver binding, so that most drivers don't
2285 * need to do this explicitly: they hold a reference until they're unbound
2288 * A pointer to the client with the incremented reference counter is returned.
2290 struct i2c_client *i2c_use_client(struct i2c_client *client)
2292 if (client && get_device(&client->dev))
2296 EXPORT_SYMBOL(i2c_use_client);
2299 * i2c_release_client - release a use of the i2c client structure
2300 * @client: the client being no longer referenced
2302 * Must be called when a user of a client is finished with it.
2304 void i2c_release_client(struct i2c_client *client)
2307 put_device(&client->dev);
2309 EXPORT_SYMBOL(i2c_release_client);
2311 struct i2c_cmd_arg {
2316 static int i2c_cmd(struct device *dev, void *_arg)
2318 struct i2c_client *client = i2c_verify_client(dev);
2319 struct i2c_cmd_arg *arg = _arg;
2320 struct i2c_driver *driver;
2322 if (!client || !client->dev.driver)
2325 driver = to_i2c_driver(client->dev.driver);
2326 if (driver->command)
2327 driver->command(client, arg->cmd, arg->arg);
2331 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
2333 struct i2c_cmd_arg cmd_arg;
2337 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
2339 EXPORT_SYMBOL(i2c_clients_command);
2341 #if IS_ENABLED(CONFIG_OF_DYNAMIC)
2342 static int of_i2c_notify(struct notifier_block *nb, unsigned long action,
2345 struct of_reconfig_data *rd = arg;
2346 struct i2c_adapter *adap;
2347 struct i2c_client *client;
2349 switch (of_reconfig_get_state_change(action, rd)) {
2350 case OF_RECONFIG_CHANGE_ADD:
2351 adap = of_find_i2c_adapter_by_node(rd->dn->parent);
2353 return NOTIFY_OK; /* not for us */
2355 if (of_node_test_and_set_flag(rd->dn, OF_POPULATED)) {
2356 put_device(&adap->dev);
2360 client = of_i2c_register_device(adap, rd->dn);
2361 put_device(&adap->dev);
2363 if (IS_ERR(client)) {
2364 dev_err(&adap->dev, "failed to create client for '%s'\n",
2366 of_node_clear_flag(rd->dn, OF_POPULATED);
2367 return notifier_from_errno(PTR_ERR(client));
2370 case OF_RECONFIG_CHANGE_REMOVE:
2371 /* already depopulated? */
2372 if (!of_node_check_flag(rd->dn, OF_POPULATED))
2375 /* find our device by node */
2376 client = of_find_i2c_device_by_node(rd->dn);
2378 return NOTIFY_OK; /* no? not meant for us */
2380 /* unregister takes one ref away */
2381 i2c_unregister_device(client);
2383 /* and put the reference of the find */
2384 put_device(&client->dev);
2390 static struct notifier_block i2c_of_notifier = {
2391 .notifier_call = of_i2c_notify,
2394 extern struct notifier_block i2c_of_notifier;
2395 #endif /* CONFIG_OF_DYNAMIC */
2397 static int __init i2c_init(void)
2401 retval = of_alias_get_highest_id("i2c");
2403 down_write(&__i2c_board_lock);
2404 if (retval >= __i2c_first_dynamic_bus_num)
2405 __i2c_first_dynamic_bus_num = retval + 1;
2406 up_write(&__i2c_board_lock);
2408 retval = bus_register(&i2c_bus_type);
2412 is_registered = true;
2414 #ifdef CONFIG_I2C_COMPAT
2415 i2c_adapter_compat_class = class_compat_register("i2c-adapter");
2416 if (!i2c_adapter_compat_class) {
2421 retval = i2c_add_driver(&dummy_driver);
2425 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2426 WARN_ON(of_reconfig_notifier_register(&i2c_of_notifier));
2427 if (IS_ENABLED(CONFIG_ACPI))
2428 WARN_ON(acpi_reconfig_notifier_register(&i2c_acpi_notifier));
2433 #ifdef CONFIG_I2C_COMPAT
2434 class_compat_unregister(i2c_adapter_compat_class);
2437 is_registered = false;
2438 bus_unregister(&i2c_bus_type);
2442 static void __exit i2c_exit(void)
2444 if (IS_ENABLED(CONFIG_ACPI))
2445 WARN_ON(acpi_reconfig_notifier_unregister(&i2c_acpi_notifier));
2446 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2447 WARN_ON(of_reconfig_notifier_unregister(&i2c_of_notifier));
2448 i2c_del_driver(&dummy_driver);
2449 #ifdef CONFIG_I2C_COMPAT
2450 class_compat_unregister(i2c_adapter_compat_class);
2452 bus_unregister(&i2c_bus_type);
2453 tracepoint_synchronize_unregister();
2456 /* We must initialize early, because some subsystems register i2c drivers
2457 * in subsys_initcall() code, but are linked (and initialized) before i2c.
2459 postcore_initcall(i2c_init);
2460 module_exit(i2c_exit);
2462 /* ----------------------------------------------------
2463 * the functional interface to the i2c busses.
2464 * ----------------------------------------------------
2467 /* Check if val is exceeding the quirk IFF quirk is non 0 */
2468 #define i2c_quirk_exceeded(val, quirk) ((quirk) && ((val) > (quirk)))
2470 static int i2c_quirk_error(struct i2c_adapter *adap, struct i2c_msg *msg, char *err_msg)
2472 dev_err_ratelimited(&adap->dev, "adapter quirk: %s (addr 0x%04x, size %u, %s)\n",
2473 err_msg, msg->addr, msg->len,
2474 msg->flags & I2C_M_RD ? "read" : "write");
2478 static int i2c_check_for_quirks(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2480 const struct i2c_adapter_quirks *q = adap->quirks;
2481 int max_num = q->max_num_msgs, i;
2482 bool do_len_check = true;
2484 if (q->flags & I2C_AQ_COMB) {
2487 /* special checks for combined messages */
2489 if (q->flags & I2C_AQ_COMB_WRITE_FIRST && msgs[0].flags & I2C_M_RD)
2490 return i2c_quirk_error(adap, &msgs[0], "1st comb msg must be write");
2492 if (q->flags & I2C_AQ_COMB_READ_SECOND && !(msgs[1].flags & I2C_M_RD))
2493 return i2c_quirk_error(adap, &msgs[1], "2nd comb msg must be read");
2495 if (q->flags & I2C_AQ_COMB_SAME_ADDR && msgs[0].addr != msgs[1].addr)
2496 return i2c_quirk_error(adap, &msgs[0], "comb msg only to same addr");
2498 if (i2c_quirk_exceeded(msgs[0].len, q->max_comb_1st_msg_len))
2499 return i2c_quirk_error(adap, &msgs[0], "msg too long");
2501 if (i2c_quirk_exceeded(msgs[1].len, q->max_comb_2nd_msg_len))
2502 return i2c_quirk_error(adap, &msgs[1], "msg too long");
2504 do_len_check = false;
2508 if (i2c_quirk_exceeded(num, max_num))
2509 return i2c_quirk_error(adap, &msgs[0], "too many messages");
2511 for (i = 0; i < num; i++) {
2512 u16 len = msgs[i].len;
2514 if (msgs[i].flags & I2C_M_RD) {
2515 if (do_len_check && i2c_quirk_exceeded(len, q->max_read_len))
2516 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2518 if (do_len_check && i2c_quirk_exceeded(len, q->max_write_len))
2519 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2527 * __i2c_transfer - unlocked flavor of i2c_transfer
2528 * @adap: Handle to I2C bus
2529 * @msgs: One or more messages to execute before STOP is issued to
2530 * terminate the operation; each message begins with a START.
2531 * @num: Number of messages to be executed.
2533 * Returns negative errno, else the number of messages executed.
2535 * Adapter lock must be held when calling this function. No debug logging
2536 * takes place. adap->algo->master_xfer existence isn't checked.
2538 int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2540 unsigned long orig_jiffies;
2543 if (adap->quirks && i2c_check_for_quirks(adap, msgs, num))
2546 /* i2c_trace_msg gets enabled when tracepoint i2c_transfer gets
2547 * enabled. This is an efficient way of keeping the for-loop from
2548 * being executed when not needed.
2550 if (static_key_false(&i2c_trace_msg)) {
2552 for (i = 0; i < num; i++)
2553 if (msgs[i].flags & I2C_M_RD)
2554 trace_i2c_read(adap, &msgs[i], i);
2556 trace_i2c_write(adap, &msgs[i], i);
2559 /* Retry automatically on arbitration loss */
2560 orig_jiffies = jiffies;
2561 for (ret = 0, try = 0; try <= adap->retries; try++) {
2562 ret = adap->algo->master_xfer(adap, msgs, num);
2565 if (time_after(jiffies, orig_jiffies + adap->timeout))
2569 if (static_key_false(&i2c_trace_msg)) {
2571 for (i = 0; i < ret; i++)
2572 if (msgs[i].flags & I2C_M_RD)
2573 trace_i2c_reply(adap, &msgs[i], i);
2574 trace_i2c_result(adap, i, ret);
2579 EXPORT_SYMBOL(__i2c_transfer);
2582 * i2c_transfer - execute a single or combined I2C message
2583 * @adap: Handle to I2C bus
2584 * @msgs: One or more messages to execute before STOP is issued to
2585 * terminate the operation; each message begins with a START.
2586 * @num: Number of messages to be executed.
2588 * Returns negative errno, else the number of messages executed.
2590 * Note that there is no requirement that each message be sent to
2591 * the same slave address, although that is the most common model.
2593 int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2597 /* REVISIT the fault reporting model here is weak:
2599 * - When we get an error after receiving N bytes from a slave,
2600 * there is no way to report "N".
2602 * - When we get a NAK after transmitting N bytes to a slave,
2603 * there is no way to report "N" ... or to let the master
2604 * continue executing the rest of this combined message, if
2605 * that's the appropriate response.
2607 * - When for example "num" is two and we successfully complete
2608 * the first message but get an error part way through the
2609 * second, it's unclear whether that should be reported as
2610 * one (discarding status on the second message) or errno
2611 * (discarding status on the first one).
2614 if (adap->algo->master_xfer) {
2616 for (ret = 0; ret < num; ret++) {
2618 "master_xfer[%d] %c, addr=0x%02x, len=%d%s\n",
2619 ret, (msgs[ret].flags & I2C_M_RD) ? 'R' : 'W',
2620 msgs[ret].addr, msgs[ret].len,
2621 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
2625 if (in_atomic() || irqs_disabled()) {
2626 ret = i2c_trylock_bus(adap, I2C_LOCK_SEGMENT);
2628 /* I2C activity is ongoing. */
2631 i2c_lock_bus(adap, I2C_LOCK_SEGMENT);
2634 ret = __i2c_transfer(adap, msgs, num);
2635 i2c_unlock_bus(adap, I2C_LOCK_SEGMENT);
2639 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
2643 EXPORT_SYMBOL(i2c_transfer);
2646 * i2c_master_send - issue a single I2C message in master transmit mode
2647 * @client: Handle to slave device
2648 * @buf: Data that will be written to the slave
2649 * @count: How many bytes to write, must be less than 64k since msg.len is u16
2651 * Returns negative errno, or else the number of bytes written.
2653 int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
2656 struct i2c_adapter *adap = client->adapter;
2659 msg.addr = client->addr;
2660 msg.flags = client->flags & I2C_M_TEN;
2662 msg.buf = (char *)buf;
2664 ret = i2c_transfer(adap, &msg, 1);
2667 * If everything went ok (i.e. 1 msg transmitted), return #bytes
2668 * transmitted, else error code.
2670 return (ret == 1) ? count : ret;
2672 EXPORT_SYMBOL(i2c_master_send);
2675 * i2c_master_recv - issue a single I2C message in master receive mode
2676 * @client: Handle to slave device
2677 * @buf: Where to store data read from slave
2678 * @count: How many bytes to read, must be less than 64k since msg.len is u16
2680 * Returns negative errno, or else the number of bytes read.
2682 int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
2684 struct i2c_adapter *adap = client->adapter;
2688 msg.addr = client->addr;
2689 msg.flags = client->flags & I2C_M_TEN;
2690 msg.flags |= I2C_M_RD;
2694 ret = i2c_transfer(adap, &msg, 1);
2697 * If everything went ok (i.e. 1 msg received), return #bytes received,
2700 return (ret == 1) ? count : ret;
2702 EXPORT_SYMBOL(i2c_master_recv);
2704 /* ----------------------------------------------------
2705 * the i2c address scanning function
2706 * Will not work for 10-bit addresses!
2707 * ----------------------------------------------------
2711 * Legacy default probe function, mostly relevant for SMBus. The default
2712 * probe method is a quick write, but it is known to corrupt the 24RF08
2713 * EEPROMs due to a state machine bug, and could also irreversibly
2714 * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
2715 * we use a short byte read instead. Also, some bus drivers don't implement
2716 * quick write, so we fallback to a byte read in that case too.
2717 * On x86, there is another special case for FSC hardware monitoring chips,
2718 * which want regular byte reads (address 0x73.) Fortunately, these are the
2719 * only known chips using this I2C address on PC hardware.
2720 * Returns 1 if probe succeeded, 0 if not.
2722 static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
2725 union i2c_smbus_data dummy;
2728 if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
2729 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
2730 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2731 I2C_SMBUS_BYTE_DATA, &dummy);
2734 if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
2735 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
2736 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
2737 I2C_SMBUS_QUICK, NULL);
2738 else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
2739 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2740 I2C_SMBUS_BYTE, &dummy);
2742 dev_warn(&adap->dev, "No suitable probing method supported for address 0x%02X\n",
2750 static int i2c_detect_address(struct i2c_client *temp_client,
2751 struct i2c_driver *driver)
2753 struct i2c_board_info info;
2754 struct i2c_adapter *adapter = temp_client->adapter;
2755 int addr = temp_client->addr;
2758 /* Make sure the address is valid */
2759 err = i2c_check_7bit_addr_validity_strict(addr);
2761 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
2766 /* Skip if already in use (7 bit, no need to encode flags) */
2767 if (i2c_check_addr_busy(adapter, addr))
2770 /* Make sure there is something at this address */
2771 if (!i2c_default_probe(adapter, addr))
2774 /* Finally call the custom detection function */
2775 memset(&info, 0, sizeof(struct i2c_board_info));
2777 err = driver->detect(temp_client, &info);
2779 /* -ENODEV is returned if the detection fails. We catch it
2780 here as this isn't an error. */
2781 return err == -ENODEV ? 0 : err;
2784 /* Consistency check */
2785 if (info.type[0] == '\0') {
2786 dev_err(&adapter->dev,
2787 "%s detection function provided no name for 0x%x\n",
2788 driver->driver.name, addr);
2790 struct i2c_client *client;
2792 /* Detection succeeded, instantiate the device */
2793 if (adapter->class & I2C_CLASS_DEPRECATED)
2794 dev_warn(&adapter->dev,
2795 "This adapter will soon drop class based instantiation of devices. "
2796 "Please make sure client 0x%02x gets instantiated by other means. "
2797 "Check 'Documentation/i2c/instantiating-devices' for details.\n",
2800 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
2801 info.type, info.addr);
2802 client = i2c_new_device(adapter, &info);
2804 list_add_tail(&client->detected, &driver->clients);
2806 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
2807 info.type, info.addr);
2812 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
2814 const unsigned short *address_list;
2815 struct i2c_client *temp_client;
2817 int adap_id = i2c_adapter_id(adapter);
2819 address_list = driver->address_list;
2820 if (!driver->detect || !address_list)
2823 /* Warn that the adapter lost class based instantiation */
2824 if (adapter->class == I2C_CLASS_DEPRECATED) {
2825 dev_dbg(&adapter->dev,
2826 "This adapter dropped support for I2C classes and won't auto-detect %s devices anymore. "
2827 "If you need it, check 'Documentation/i2c/instantiating-devices' for alternatives.\n",
2828 driver->driver.name);
2832 /* Stop here if the classes do not match */
2833 if (!(adapter->class & driver->class))
2836 /* Set up a temporary client to help detect callback */
2837 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
2840 temp_client->adapter = adapter;
2842 for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
2843 dev_dbg(&adapter->dev,
2844 "found normal entry for adapter %d, addr 0x%02x\n",
2845 adap_id, address_list[i]);
2846 temp_client->addr = address_list[i];
2847 err = i2c_detect_address(temp_client, driver);
2856 int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
2858 return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2859 I2C_SMBUS_QUICK, NULL) >= 0;
2861 EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
2864 i2c_new_probed_device(struct i2c_adapter *adap,
2865 struct i2c_board_info *info,
2866 unsigned short const *addr_list,
2867 int (*probe)(struct i2c_adapter *, unsigned short addr))
2872 probe = i2c_default_probe;
2874 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
2875 /* Check address validity */
2876 if (i2c_check_7bit_addr_validity_strict(addr_list[i]) < 0) {
2877 dev_warn(&adap->dev, "Invalid 7-bit address 0x%02x\n",
2882 /* Check address availability (7 bit, no need to encode flags) */
2883 if (i2c_check_addr_busy(adap, addr_list[i])) {
2885 "Address 0x%02x already in use, not probing\n",
2890 /* Test address responsiveness */
2891 if (probe(adap, addr_list[i]))
2895 if (addr_list[i] == I2C_CLIENT_END) {
2896 dev_dbg(&adap->dev, "Probing failed, no device found\n");
2900 info->addr = addr_list[i];
2901 return i2c_new_device(adap, info);
2903 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
2905 struct i2c_adapter *i2c_get_adapter(int nr)
2907 struct i2c_adapter *adapter;
2909 mutex_lock(&core_lock);
2910 adapter = idr_find(&i2c_adapter_idr, nr);
2914 if (try_module_get(adapter->owner))
2915 get_device(&adapter->dev);
2920 mutex_unlock(&core_lock);
2923 EXPORT_SYMBOL(i2c_get_adapter);
2925 void i2c_put_adapter(struct i2c_adapter *adap)
2930 put_device(&adap->dev);
2931 module_put(adap->owner);
2933 EXPORT_SYMBOL(i2c_put_adapter);
2935 /* The SMBus parts */
2937 #define POLY (0x1070U << 3)
2938 static u8 crc8(u16 data)
2942 for (i = 0; i < 8; i++) {
2947 return (u8)(data >> 8);
2950 /* Incremental CRC8 over count bytes in the array pointed to by p */
2951 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
2955 for (i = 0; i < count; i++)
2956 crc = crc8((crc ^ p[i]) << 8);
2960 /* Assume a 7-bit address, which is reasonable for SMBus */
2961 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
2963 /* The address will be sent first */
2964 u8 addr = i2c_8bit_addr_from_msg(msg);
2965 pec = i2c_smbus_pec(pec, &addr, 1);
2967 /* The data buffer follows */
2968 return i2c_smbus_pec(pec, msg->buf, msg->len);
2971 /* Used for write only transactions */
2972 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
2974 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
2978 /* Return <0 on CRC error
2979 If there was a write before this read (most cases) we need to take the
2980 partial CRC from the write part into account.
2981 Note that this function does modify the message (we need to decrease the
2982 message length to hide the CRC byte from the caller). */
2983 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
2985 u8 rpec = msg->buf[--msg->len];
2986 cpec = i2c_smbus_msg_pec(cpec, msg);
2989 pr_debug("Bad PEC 0x%02x vs. 0x%02x\n",
2997 * i2c_smbus_read_byte - SMBus "receive byte" protocol
2998 * @client: Handle to slave device
3000 * This executes the SMBus "receive byte" protocol, returning negative errno
3001 * else the byte received from the device.
3003 s32 i2c_smbus_read_byte(const struct i2c_client *client)
3005 union i2c_smbus_data data;
3008 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3010 I2C_SMBUS_BYTE, &data);
3011 return (status < 0) ? status : data.byte;
3013 EXPORT_SYMBOL(i2c_smbus_read_byte);
3016 * i2c_smbus_write_byte - SMBus "send byte" protocol
3017 * @client: Handle to slave device
3018 * @value: Byte to be sent
3020 * This executes the SMBus "send byte" protocol, returning negative errno
3021 * else zero on success.
3023 s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
3025 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3026 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
3028 EXPORT_SYMBOL(i2c_smbus_write_byte);
3031 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
3032 * @client: Handle to slave device
3033 * @command: Byte interpreted by slave
3035 * This executes the SMBus "read byte" protocol, returning negative errno
3036 * else a data byte received from the device.
3038 s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
3040 union i2c_smbus_data data;
3043 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3044 I2C_SMBUS_READ, command,
3045 I2C_SMBUS_BYTE_DATA, &data);
3046 return (status < 0) ? status : data.byte;
3048 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
3051 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
3052 * @client: Handle to slave device
3053 * @command: Byte interpreted by slave
3054 * @value: Byte being written
3056 * This executes the SMBus "write byte" protocol, returning negative errno
3057 * else zero on success.
3059 s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
3062 union i2c_smbus_data data;
3064 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3065 I2C_SMBUS_WRITE, command,
3066 I2C_SMBUS_BYTE_DATA, &data);
3068 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
3071 * i2c_smbus_read_word_data - SMBus "read word" protocol
3072 * @client: Handle to slave device
3073 * @command: Byte interpreted by slave
3075 * This executes the SMBus "read word" protocol, returning negative errno
3076 * else a 16-bit unsigned "word" received from the device.
3078 s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
3080 union i2c_smbus_data data;
3083 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3084 I2C_SMBUS_READ, command,
3085 I2C_SMBUS_WORD_DATA, &data);
3086 return (status < 0) ? status : data.word;
3088 EXPORT_SYMBOL(i2c_smbus_read_word_data);
3091 * i2c_smbus_write_word_data - SMBus "write word" protocol
3092 * @client: Handle to slave device
3093 * @command: Byte interpreted by slave
3094 * @value: 16-bit "word" being written
3096 * This executes the SMBus "write word" protocol, returning negative errno
3097 * else zero on success.
3099 s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
3102 union i2c_smbus_data data;
3104 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3105 I2C_SMBUS_WRITE, command,
3106 I2C_SMBUS_WORD_DATA, &data);
3108 EXPORT_SYMBOL(i2c_smbus_write_word_data);
3111 * i2c_smbus_read_block_data - SMBus "block read" protocol
3112 * @client: Handle to slave device
3113 * @command: Byte interpreted by slave
3114 * @values: Byte array into which data will be read; big enough to hold
3115 * the data returned by the slave. SMBus allows at most 32 bytes.
3117 * This executes the SMBus "block read" protocol, returning negative errno
3118 * else the number of data bytes in the slave's response.
3120 * Note that using this function requires that the client's adapter support
3121 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
3122 * support this; its emulation through I2C messaging relies on a specific
3123 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
3125 s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
3128 union i2c_smbus_data data;
3131 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3132 I2C_SMBUS_READ, command,
3133 I2C_SMBUS_BLOCK_DATA, &data);
3137 memcpy(values, &data.block[1], data.block[0]);
3138 return data.block[0];
3140 EXPORT_SYMBOL(i2c_smbus_read_block_data);
3143 * i2c_smbus_write_block_data - SMBus "block write" protocol
3144 * @client: Handle to slave device
3145 * @command: Byte interpreted by slave
3146 * @length: Size of data block; SMBus allows at most 32 bytes
3147 * @values: Byte array which will be written.
3149 * This executes the SMBus "block write" protocol, returning negative errno
3150 * else zero on success.
3152 s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
3153 u8 length, const u8 *values)
3155 union i2c_smbus_data data;
3157 if (length > I2C_SMBUS_BLOCK_MAX)
3158 length = I2C_SMBUS_BLOCK_MAX;
3159 data.block[0] = length;
3160 memcpy(&data.block[1], values, length);
3161 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3162 I2C_SMBUS_WRITE, command,
3163 I2C_SMBUS_BLOCK_DATA, &data);
3165 EXPORT_SYMBOL(i2c_smbus_write_block_data);
3167 /* Returns the number of read bytes */
3168 s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
3169 u8 length, u8 *values)
3171 union i2c_smbus_data data;
3174 if (length > I2C_SMBUS_BLOCK_MAX)
3175 length = I2C_SMBUS_BLOCK_MAX;
3176 data.block[0] = length;
3177 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3178 I2C_SMBUS_READ, command,
3179 I2C_SMBUS_I2C_BLOCK_DATA, &data);
3183 memcpy(values, &data.block[1], data.block[0]);
3184 return data.block[0];
3186 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
3188 s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
3189 u8 length, const u8 *values)
3191 union i2c_smbus_data data;
3193 if (length > I2C_SMBUS_BLOCK_MAX)
3194 length = I2C_SMBUS_BLOCK_MAX;
3195 data.block[0] = length;
3196 memcpy(data.block + 1, values, length);
3197 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3198 I2C_SMBUS_WRITE, command,
3199 I2C_SMBUS_I2C_BLOCK_DATA, &data);
3201 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
3203 /* Simulate a SMBus command using the i2c protocol
3204 No checking of parameters is done! */
3205 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
3206 unsigned short flags,
3207 char read_write, u8 command, int size,
3208 union i2c_smbus_data *data)
3210 /* So we need to generate a series of msgs. In the case of writing, we
3211 need to use only one message; when reading, we need two. We initialize
3212 most things with sane defaults, to keep the code below somewhat
3214 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
3215 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
3216 int num = read_write == I2C_SMBUS_READ ? 2 : 1;
3220 struct i2c_msg msg[2] = {
3228 .flags = flags | I2C_M_RD,
3234 msgbuf0[0] = command;
3236 case I2C_SMBUS_QUICK:
3238 /* Special case: The read/write field is used as data */
3239 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
3243 case I2C_SMBUS_BYTE:
3244 if (read_write == I2C_SMBUS_READ) {
3245 /* Special case: only a read! */
3246 msg[0].flags = I2C_M_RD | flags;
3250 case I2C_SMBUS_BYTE_DATA:
3251 if (read_write == I2C_SMBUS_READ)
3255 msgbuf0[1] = data->byte;
3258 case I2C_SMBUS_WORD_DATA:
3259 if (read_write == I2C_SMBUS_READ)
3263 msgbuf0[1] = data->word & 0xff;
3264 msgbuf0[2] = data->word >> 8;
3267 case I2C_SMBUS_PROC_CALL:
3268 num = 2; /* Special case */
3269 read_write = I2C_SMBUS_READ;
3272 msgbuf0[1] = data->word & 0xff;
3273 msgbuf0[2] = data->word >> 8;
3275 case I2C_SMBUS_BLOCK_DATA:
3276 if (read_write == I2C_SMBUS_READ) {
3277 msg[1].flags |= I2C_M_RECV_LEN;
3278 msg[1].len = 1; /* block length will be added by
3279 the underlying bus driver */
3281 msg[0].len = data->block[0] + 2;
3282 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
3283 dev_err(&adapter->dev,
3284 "Invalid block write size %d\n",
3288 for (i = 1; i < msg[0].len; i++)
3289 msgbuf0[i] = data->block[i-1];
3292 case I2C_SMBUS_BLOCK_PROC_CALL:
3293 num = 2; /* Another special case */
3294 read_write = I2C_SMBUS_READ;
3295 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
3296 dev_err(&adapter->dev,
3297 "Invalid block write size %d\n",
3301 msg[0].len = data->block[0] + 2;
3302 for (i = 1; i < msg[0].len; i++)
3303 msgbuf0[i] = data->block[i-1];
3304 msg[1].flags |= I2C_M_RECV_LEN;
3305 msg[1].len = 1; /* block length will be added by
3306 the underlying bus driver */
3308 case I2C_SMBUS_I2C_BLOCK_DATA:
3309 if (read_write == I2C_SMBUS_READ) {
3310 msg[1].len = data->block[0];
3312 msg[0].len = data->block[0] + 1;
3313 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
3314 dev_err(&adapter->dev,
3315 "Invalid block write size %d\n",
3319 for (i = 1; i <= data->block[0]; i++)
3320 msgbuf0[i] = data->block[i];
3324 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
3328 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
3329 && size != I2C_SMBUS_I2C_BLOCK_DATA);
3331 /* Compute PEC if first message is a write */
3332 if (!(msg[0].flags & I2C_M_RD)) {
3333 if (num == 1) /* Write only */
3334 i2c_smbus_add_pec(&msg[0]);
3335 else /* Write followed by read */
3336 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
3338 /* Ask for PEC if last message is a read */
3339 if (msg[num-1].flags & I2C_M_RD)
3343 status = i2c_transfer(adapter, msg, num);
3347 /* Check PEC if last message is a read */
3348 if (i && (msg[num-1].flags & I2C_M_RD)) {
3349 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
3354 if (read_write == I2C_SMBUS_READ)
3356 case I2C_SMBUS_BYTE:
3357 data->byte = msgbuf0[0];
3359 case I2C_SMBUS_BYTE_DATA:
3360 data->byte = msgbuf1[0];
3362 case I2C_SMBUS_WORD_DATA:
3363 case I2C_SMBUS_PROC_CALL:
3364 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
3366 case I2C_SMBUS_I2C_BLOCK_DATA:
3367 for (i = 0; i < data->block[0]; i++)
3368 data->block[i+1] = msgbuf1[i];
3370 case I2C_SMBUS_BLOCK_DATA:
3371 case I2C_SMBUS_BLOCK_PROC_CALL:
3372 for (i = 0; i < msgbuf1[0] + 1; i++)
3373 data->block[i] = msgbuf1[i];
3380 * i2c_smbus_xfer - execute SMBus protocol operations
3381 * @adapter: Handle to I2C bus
3382 * @addr: Address of SMBus slave on that bus
3383 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
3384 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
3385 * @command: Byte interpreted by slave, for protocols which use such bytes
3386 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
3387 * @data: Data to be read or written
3389 * This executes an SMBus protocol operation, and returns a negative
3390 * errno code else zero on success.
3392 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
3393 char read_write, u8 command, int protocol,
3394 union i2c_smbus_data *data)
3396 unsigned long orig_jiffies;
3400 /* If enabled, the following two tracepoints are conditional on
3401 * read_write and protocol.
3403 trace_smbus_write(adapter, addr, flags, read_write,
3404 command, protocol, data);
3405 trace_smbus_read(adapter, addr, flags, read_write,
3408 flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
3410 if (adapter->algo->smbus_xfer) {
3411 i2c_lock_bus(adapter, I2C_LOCK_SEGMENT);
3413 /* Retry automatically on arbitration loss */
3414 orig_jiffies = jiffies;
3415 for (res = 0, try = 0; try <= adapter->retries; try++) {
3416 res = adapter->algo->smbus_xfer(adapter, addr, flags,
3417 read_write, command,
3421 if (time_after(jiffies,
3422 orig_jiffies + adapter->timeout))
3425 i2c_unlock_bus(adapter, I2C_LOCK_SEGMENT);
3427 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
3430 * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
3431 * implement native support for the SMBus operation.
3435 res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
3436 command, protocol, data);
3439 /* If enabled, the reply tracepoint is conditional on read_write. */
3440 trace_smbus_reply(adapter, addr, flags, read_write,
3441 command, protocol, data);
3442 trace_smbus_result(adapter, addr, flags, read_write,
3443 command, protocol, res);
3447 EXPORT_SYMBOL(i2c_smbus_xfer);
3450 * i2c_smbus_read_i2c_block_data_or_emulated - read block or emulate
3451 * @client: Handle to slave device
3452 * @command: Byte interpreted by slave
3453 * @length: Size of data block; SMBus allows at most I2C_SMBUS_BLOCK_MAX bytes
3454 * @values: Byte array into which data will be read; big enough to hold
3455 * the data returned by the slave. SMBus allows at most
3456 * I2C_SMBUS_BLOCK_MAX bytes.
3458 * This executes the SMBus "block read" protocol if supported by the adapter.
3459 * If block read is not supported, it emulates it using either word or byte
3460 * read protocols depending on availability.
3462 * The addresses of the I2C slave device that are accessed with this function
3463 * must be mapped to a linear region, so that a block read will have the same
3464 * effect as a byte read. Before using this function you must double-check
3465 * if the I2C slave does support exchanging a block transfer with a byte
3468 s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
3469 u8 command, u8 length, u8 *values)
3474 if (length > I2C_SMBUS_BLOCK_MAX)
3475 length = I2C_SMBUS_BLOCK_MAX;
3477 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK))
3478 return i2c_smbus_read_i2c_block_data(client, command, length, values);
3480 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA))
3483 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_WORD_DATA)) {
3484 while ((i + 2) <= length) {
3485 status = i2c_smbus_read_word_data(client, command + i);
3488 values[i] = status & 0xff;
3489 values[i + 1] = status >> 8;
3494 while (i < length) {
3495 status = i2c_smbus_read_byte_data(client, command + i);
3504 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data_or_emulated);
3506 #if IS_ENABLED(CONFIG_I2C_SLAVE)
3507 int i2c_slave_register(struct i2c_client *client, i2c_slave_cb_t slave_cb)
3511 if (!client || !slave_cb) {
3512 WARN(1, "insufficent data\n");
3516 if (!(client->flags & I2C_CLIENT_SLAVE))
3517 dev_warn(&client->dev, "%s: client slave flag not set. You might see address collisions\n",
3520 if (!(client->flags & I2C_CLIENT_TEN)) {
3521 /* Enforce stricter address checking */
3522 ret = i2c_check_7bit_addr_validity_strict(client->addr);
3524 dev_err(&client->dev, "%s: invalid address\n", __func__);
3529 if (!client->adapter->algo->reg_slave) {
3530 dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
3534 client->slave_cb = slave_cb;
3536 i2c_lock_adapter(client->adapter);
3537 ret = client->adapter->algo->reg_slave(client);
3538 i2c_unlock_adapter(client->adapter);
3541 client->slave_cb = NULL;
3542 dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
3547 EXPORT_SYMBOL_GPL(i2c_slave_register);
3549 int i2c_slave_unregister(struct i2c_client *client)
3553 if (!client->adapter->algo->unreg_slave) {
3554 dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
3558 i2c_lock_adapter(client->adapter);
3559 ret = client->adapter->algo->unreg_slave(client);
3560 i2c_unlock_adapter(client->adapter);
3563 client->slave_cb = NULL;
3565 dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
3569 EXPORT_SYMBOL_GPL(i2c_slave_unregister);
3572 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
3573 MODULE_DESCRIPTION("I2C-Bus main module");
3574 MODULE_LICENSE("GPL");