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 struct i2c_adapter *adapter; /* set only when registering slaves */
109 acpi_handle adapter_handle;
110 acpi_handle device_handle;
114 static int i2c_acpi_find_resource(struct acpi_resource *ares, void *data)
116 struct i2c_acpi_lookup *lookup = data;
117 struct i2c_board_info *info = lookup->info;
118 struct acpi_resource_i2c_serialbus *sb;
119 acpi_handle adapter_handle;
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)
130 * Extract the ResourceSource and make sure that the handle matches
131 * with the I2C adapter handle.
133 status = acpi_get_handle(lookup->device_handle,
134 sb->resource_source.string_ptr,
136 if (ACPI_SUCCESS(status) && adapter_handle == lookup->adapter_handle) {
137 info->addr = sb->slave_address;
138 if (sb->access_mode == ACPI_I2C_10BIT_MODE)
139 info->flags |= I2C_CLIENT_TEN;
140 /* Save speed of the slowest device */
141 if (sb->connection_speed < lookup->min_speed)
142 lookup->min_speed = sb->connection_speed;
148 static acpi_status i2c_acpi_slave_lookup(acpi_handle handle, u32 level,
149 void *data, void **return_value)
151 struct i2c_acpi_lookup *lookup = data;
152 struct i2c_adapter *adapter = lookup->adapter;
153 struct list_head resource_list;
154 struct resource_entry *entry;
155 struct i2c_board_info info;
156 struct acpi_device *adev;
159 if (acpi_bus_get_device(handle, &adev))
161 if (acpi_bus_get_status(adev) || !adev->status.present)
164 memset(&info, 0, sizeof(info));
165 info.fwnode = acpi_fwnode_handle(adev);
167 lookup->device_handle = handle;
168 lookup->info = &info;
171 * Look up for I2cSerialBus resource with ResourceSource that
172 * matches with this adapter.
174 INIT_LIST_HEAD(&resource_list);
175 ret = acpi_dev_get_resources(adev, &resource_list,
176 i2c_acpi_find_resource, lookup);
177 acpi_dev_free_resource_list(&resource_list);
179 if (ret < 0 || !info.addr || !lookup->adapter)
182 /* Then fill IRQ number if any */
183 ret = acpi_dev_get_resources(adev, &resource_list, NULL, NULL);
187 resource_list_for_each_entry(entry, &resource_list) {
188 if (resource_type(entry->res) == IORESOURCE_IRQ) {
189 info.irq = entry->res->start;
194 acpi_dev_free_resource_list(&resource_list);
196 adev->power.flags.ignore_parent = true;
197 strlcpy(info.type, dev_name(&adev->dev), sizeof(info.type));
198 if (!i2c_new_device(adapter, &info)) {
199 adev->power.flags.ignore_parent = false;
200 dev_err(&adapter->dev,
201 "failed to add I2C device %s from ACPI\n",
202 dev_name(&adev->dev));
208 #define I2C_ACPI_MAX_SCAN_DEPTH 32
210 static acpi_status i2c_acpi_walk(struct i2c_acpi_lookup *lookup)
212 return acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
213 I2C_ACPI_MAX_SCAN_DEPTH,
214 i2c_acpi_slave_lookup, NULL,
219 * i2c_acpi_register_devices - enumerate I2C slave devices behind adapter
220 * @adap: pointer to adapter
222 * Enumerate all I2C slave devices behind this adapter by walking the ACPI
223 * namespace. When a device is found it will be added to the Linux device
224 * model and bound to the corresponding ACPI handle.
226 static void i2c_acpi_register_devices(struct i2c_adapter *adap)
228 struct i2c_acpi_lookup lookup;
231 if (!has_acpi_companion(&adap->dev))
234 memset(&lookup, 0, sizeof(lookup));
235 lookup.adapter = adap;
236 lookup.adapter_handle = ACPI_HANDLE(&adap->dev);
238 status = i2c_acpi_walk(&lookup);
239 if (ACPI_FAILURE(status))
240 dev_warn(&adap->dev, "failed to enumerate I2C slaves\n");
244 * i2c_acpi_find_bus_speed - find I2C bus speed from ACPI
245 * @dev: The device owning the bus
247 * Find the I2C bus speed by walking the ACPI namespace for all I2C slaves
248 * devices connected to this bus and use the speed of slowest device.
250 * Returns the speed in Hz or zero
252 u32 i2c_acpi_find_bus_speed(struct device *dev)
254 struct i2c_acpi_lookup lookup;
257 if (!has_acpi_companion(dev))
260 memset(&lookup, 0, sizeof(lookup));
261 lookup.adapter_handle = ACPI_HANDLE(dev);
262 lookup.min_speed = UINT_MAX;
264 status = i2c_acpi_walk(&lookup);
265 if (ACPI_FAILURE(status)) {
266 dev_warn(dev, "unable to find I2C bus speed from ACPI\n");
270 return lookup.min_speed != UINT_MAX ? lookup.min_speed : 0;
272 EXPORT_SYMBOL_GPL(i2c_acpi_find_bus_speed);
274 #else /* CONFIG_ACPI */
275 static inline void i2c_acpi_register_devices(struct i2c_adapter *adap) { }
276 #endif /* CONFIG_ACPI */
278 #ifdef CONFIG_ACPI_I2C_OPREGION
279 static int acpi_gsb_i2c_read_bytes(struct i2c_client *client,
280 u8 cmd, u8 *data, u8 data_len)
283 struct i2c_msg msgs[2];
287 buffer = kzalloc(data_len, GFP_KERNEL);
291 msgs[0].addr = client->addr;
292 msgs[0].flags = client->flags;
296 msgs[1].addr = client->addr;
297 msgs[1].flags = client->flags | I2C_M_RD;
298 msgs[1].len = data_len;
299 msgs[1].buf = buffer;
301 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
303 dev_err(&client->adapter->dev, "i2c read failed\n");
305 memcpy(data, buffer, data_len);
311 static int acpi_gsb_i2c_write_bytes(struct i2c_client *client,
312 u8 cmd, u8 *data, u8 data_len)
315 struct i2c_msg msgs[1];
319 buffer = kzalloc(data_len + 1, GFP_KERNEL);
324 memcpy(buffer + 1, data, data_len);
326 msgs[0].addr = client->addr;
327 msgs[0].flags = client->flags;
328 msgs[0].len = data_len + 1;
329 msgs[0].buf = buffer;
331 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
333 dev_err(&client->adapter->dev, "i2c write failed\n");
340 i2c_acpi_space_handler(u32 function, acpi_physical_address command,
341 u32 bits, u64 *value64,
342 void *handler_context, void *region_context)
344 struct gsb_buffer *gsb = (struct gsb_buffer *)value64;
345 struct i2c_acpi_handler_data *data = handler_context;
346 struct acpi_connection_info *info = &data->info;
347 struct acpi_resource_i2c_serialbus *sb;
348 struct i2c_adapter *adapter = data->adapter;
349 struct i2c_client *client;
350 struct acpi_resource *ares;
351 u32 accessor_type = function >> 16;
352 u8 action = function & ACPI_IO_MASK;
356 ret = acpi_buffer_to_resource(info->connection, info->length, &ares);
357 if (ACPI_FAILURE(ret))
360 client = kzalloc(sizeof(*client), GFP_KERNEL);
366 if (!value64 || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) {
367 ret = AE_BAD_PARAMETER;
371 sb = &ares->data.i2c_serial_bus;
372 if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C) {
373 ret = AE_BAD_PARAMETER;
377 client->adapter = adapter;
378 client->addr = sb->slave_address;
380 if (sb->access_mode == ACPI_I2C_10BIT_MODE)
381 client->flags |= I2C_CLIENT_TEN;
383 switch (accessor_type) {
384 case ACPI_GSB_ACCESS_ATTRIB_SEND_RCV:
385 if (action == ACPI_READ) {
386 status = i2c_smbus_read_byte(client);
392 status = i2c_smbus_write_byte(client, gsb->bdata);
396 case ACPI_GSB_ACCESS_ATTRIB_BYTE:
397 if (action == ACPI_READ) {
398 status = i2c_smbus_read_byte_data(client, command);
404 status = i2c_smbus_write_byte_data(client, command,
409 case ACPI_GSB_ACCESS_ATTRIB_WORD:
410 if (action == ACPI_READ) {
411 status = i2c_smbus_read_word_data(client, command);
417 status = i2c_smbus_write_word_data(client, command,
422 case ACPI_GSB_ACCESS_ATTRIB_BLOCK:
423 if (action == ACPI_READ) {
424 status = i2c_smbus_read_block_data(client, command,
431 status = i2c_smbus_write_block_data(client, command,
432 gsb->len, gsb->data);
436 case ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE:
437 if (action == ACPI_READ) {
438 status = acpi_gsb_i2c_read_bytes(client, command,
439 gsb->data, info->access_length);
443 status = acpi_gsb_i2c_write_bytes(client, command,
444 gsb->data, info->access_length);
449 dev_warn(&adapter->dev, "protocol 0x%02x not supported for client 0x%02x\n",
450 accessor_type, client->addr);
451 ret = AE_BAD_PARAMETER;
455 gsb->status = status;
464 static int i2c_acpi_install_space_handler(struct i2c_adapter *adapter)
467 struct i2c_acpi_handler_data *data;
470 if (!adapter->dev.parent)
473 handle = ACPI_HANDLE(adapter->dev.parent);
478 data = kzalloc(sizeof(struct i2c_acpi_handler_data),
483 data->adapter = adapter;
484 status = acpi_bus_attach_private_data(handle, (void *)data);
485 if (ACPI_FAILURE(status)) {
490 status = acpi_install_address_space_handler(handle,
491 ACPI_ADR_SPACE_GSBUS,
492 &i2c_acpi_space_handler,
495 if (ACPI_FAILURE(status)) {
496 dev_err(&adapter->dev, "Error installing i2c space handler\n");
497 acpi_bus_detach_private_data(handle);
502 acpi_walk_dep_device_list(handle);
506 static void i2c_acpi_remove_space_handler(struct i2c_adapter *adapter)
509 struct i2c_acpi_handler_data *data;
512 if (!adapter->dev.parent)
515 handle = ACPI_HANDLE(adapter->dev.parent);
520 acpi_remove_address_space_handler(handle,
521 ACPI_ADR_SPACE_GSBUS,
522 &i2c_acpi_space_handler);
524 status = acpi_bus_get_private_data(handle, (void **)&data);
525 if (ACPI_SUCCESS(status))
528 acpi_bus_detach_private_data(handle);
530 #else /* CONFIG_ACPI_I2C_OPREGION */
531 static inline void i2c_acpi_remove_space_handler(struct i2c_adapter *adapter)
534 static inline int i2c_acpi_install_space_handler(struct i2c_adapter *adapter)
536 #endif /* CONFIG_ACPI_I2C_OPREGION */
538 /* ------------------------------------------------------------------------- */
540 static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
541 const struct i2c_client *client)
543 while (id->name[0]) {
544 if (strcmp(client->name, id->name) == 0)
551 static int i2c_device_match(struct device *dev, struct device_driver *drv)
553 struct i2c_client *client = i2c_verify_client(dev);
554 struct i2c_driver *driver;
559 /* Attempt an OF style match */
560 if (of_driver_match_device(dev, drv))
563 /* Then ACPI style match */
564 if (acpi_driver_match_device(dev, drv))
567 driver = to_i2c_driver(drv);
568 /* match on an id table if there is one */
569 if (driver->id_table)
570 return i2c_match_id(driver->id_table, client) != NULL;
575 static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
577 struct i2c_client *client = to_i2c_client(dev);
580 rc = acpi_device_uevent_modalias(dev, env);
584 return add_uevent_var(env, "MODALIAS=%s%s", I2C_MODULE_PREFIX, client->name);
587 /* i2c bus recovery routines */
588 static int get_scl_gpio_value(struct i2c_adapter *adap)
590 return gpio_get_value(adap->bus_recovery_info->scl_gpio);
593 static void set_scl_gpio_value(struct i2c_adapter *adap, int val)
595 gpio_set_value(adap->bus_recovery_info->scl_gpio, val);
598 static int get_sda_gpio_value(struct i2c_adapter *adap)
600 return gpio_get_value(adap->bus_recovery_info->sda_gpio);
603 static int i2c_get_gpios_for_recovery(struct i2c_adapter *adap)
605 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
606 struct device *dev = &adap->dev;
609 ret = gpio_request_one(bri->scl_gpio, GPIOF_OPEN_DRAIN |
610 GPIOF_OUT_INIT_HIGH, "i2c-scl");
612 dev_warn(dev, "Can't get SCL gpio: %d\n", bri->scl_gpio);
617 if (gpio_request_one(bri->sda_gpio, GPIOF_IN, "i2c-sda")) {
618 /* work without SDA polling */
619 dev_warn(dev, "Can't get SDA gpio: %d. Not using SDA polling\n",
628 static void i2c_put_gpios_for_recovery(struct i2c_adapter *adap)
630 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
633 gpio_free(bri->sda_gpio);
635 gpio_free(bri->scl_gpio);
639 * We are generating clock pulses. ndelay() determines durating of clk pulses.
640 * We will generate clock with rate 100 KHz and so duration of both clock levels
641 * is: delay in ns = (10^6 / 100) / 2
643 #define RECOVERY_NDELAY 5000
644 #define RECOVERY_CLK_CNT 9
646 static int i2c_generic_recovery(struct i2c_adapter *adap)
648 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
649 int i = 0, val = 1, ret = 0;
651 if (bri->prepare_recovery)
652 bri->prepare_recovery(adap);
654 bri->set_scl(adap, val);
655 ndelay(RECOVERY_NDELAY);
658 * By this time SCL is high, as we need to give 9 falling-rising edges
660 while (i++ < RECOVERY_CLK_CNT * 2) {
662 /* Break if SDA is high */
663 if (bri->get_sda && bri->get_sda(adap))
665 /* SCL shouldn't be low here */
666 if (!bri->get_scl(adap)) {
668 "SCL is stuck low, exit recovery\n");
675 bri->set_scl(adap, val);
676 ndelay(RECOVERY_NDELAY);
679 if (bri->unprepare_recovery)
680 bri->unprepare_recovery(adap);
685 int i2c_generic_scl_recovery(struct i2c_adapter *adap)
687 return i2c_generic_recovery(adap);
689 EXPORT_SYMBOL_GPL(i2c_generic_scl_recovery);
691 int i2c_generic_gpio_recovery(struct i2c_adapter *adap)
695 ret = i2c_get_gpios_for_recovery(adap);
699 ret = i2c_generic_recovery(adap);
700 i2c_put_gpios_for_recovery(adap);
704 EXPORT_SYMBOL_GPL(i2c_generic_gpio_recovery);
706 int i2c_recover_bus(struct i2c_adapter *adap)
708 if (!adap->bus_recovery_info)
711 dev_dbg(&adap->dev, "Trying i2c bus recovery\n");
712 return adap->bus_recovery_info->recover_bus(adap);
714 EXPORT_SYMBOL_GPL(i2c_recover_bus);
716 static void i2c_init_recovery(struct i2c_adapter *adap)
718 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
724 if (!bri->recover_bus) {
725 err_str = "no recover_bus() found";
729 /* Generic GPIO recovery */
730 if (bri->recover_bus == i2c_generic_gpio_recovery) {
731 if (!gpio_is_valid(bri->scl_gpio)) {
732 err_str = "invalid SCL gpio";
736 if (gpio_is_valid(bri->sda_gpio))
737 bri->get_sda = get_sda_gpio_value;
741 bri->get_scl = get_scl_gpio_value;
742 bri->set_scl = set_scl_gpio_value;
743 } else if (bri->recover_bus == i2c_generic_scl_recovery) {
744 /* Generic SCL recovery */
745 if (!bri->set_scl || !bri->get_scl) {
746 err_str = "no {get|set}_scl() found";
753 dev_err(&adap->dev, "Not using recovery: %s\n", err_str);
754 adap->bus_recovery_info = NULL;
757 static int i2c_device_probe(struct device *dev)
759 struct i2c_client *client = i2c_verify_client(dev);
760 struct i2c_driver *driver;
770 irq = of_irq_get_byname(dev->of_node, "irq");
771 if (irq == -EINVAL || irq == -ENODATA)
772 irq = of_irq_get(dev->of_node, 0);
773 } else if (ACPI_COMPANION(dev)) {
774 irq = acpi_dev_gpio_irq_get(ACPI_COMPANION(dev), 0);
776 if (irq == -EPROBE_DEFER)
784 driver = to_i2c_driver(dev->driver);
785 if (!driver->probe || !driver->id_table)
788 if (client->flags & I2C_CLIENT_WAKE) {
789 int wakeirq = -ENOENT;
792 wakeirq = of_irq_get_byname(dev->of_node, "wakeup");
793 if (wakeirq == -EPROBE_DEFER)
797 device_init_wakeup(&client->dev, true);
799 if (wakeirq > 0 && wakeirq != client->irq)
800 status = dev_pm_set_dedicated_wake_irq(dev, wakeirq);
801 else if (client->irq > 0)
802 status = dev_pm_set_wake_irq(dev, client->irq);
807 dev_warn(&client->dev, "failed to set up wakeup irq");
810 dev_dbg(dev, "probe\n");
812 status = of_clk_set_defaults(dev->of_node, false);
814 goto err_clear_wakeup_irq;
816 status = dev_pm_domain_attach(&client->dev, true);
817 if (status == -EPROBE_DEFER)
818 goto err_clear_wakeup_irq;
820 status = driver->probe(client, i2c_match_id(driver->id_table, client));
822 goto err_detach_pm_domain;
826 err_detach_pm_domain:
827 dev_pm_domain_detach(&client->dev, true);
828 err_clear_wakeup_irq:
829 dev_pm_clear_wake_irq(&client->dev);
830 device_init_wakeup(&client->dev, false);
834 static int i2c_device_remove(struct device *dev)
836 struct i2c_client *client = i2c_verify_client(dev);
837 struct i2c_driver *driver;
840 if (!client || !dev->driver)
843 driver = to_i2c_driver(dev->driver);
844 if (driver->remove) {
845 dev_dbg(dev, "remove\n");
846 status = driver->remove(client);
849 dev_pm_domain_detach(&client->dev, true);
851 dev_pm_clear_wake_irq(&client->dev);
852 device_init_wakeup(&client->dev, false);
857 static void i2c_device_shutdown(struct device *dev)
859 struct i2c_client *client = i2c_verify_client(dev);
860 struct i2c_driver *driver;
862 if (!client || !dev->driver)
864 driver = to_i2c_driver(dev->driver);
865 if (driver->shutdown)
866 driver->shutdown(client);
869 static void i2c_client_dev_release(struct device *dev)
871 kfree(to_i2c_client(dev));
875 show_name(struct device *dev, struct device_attribute *attr, char *buf)
877 return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
878 to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
880 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
883 show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
885 struct i2c_client *client = to_i2c_client(dev);
888 len = acpi_device_modalias(dev, buf, PAGE_SIZE -1);
892 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
894 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
896 static struct attribute *i2c_dev_attrs[] = {
898 /* modalias helps coldplug: modprobe $(cat .../modalias) */
899 &dev_attr_modalias.attr,
902 ATTRIBUTE_GROUPS(i2c_dev);
904 struct bus_type i2c_bus_type = {
906 .match = i2c_device_match,
907 .probe = i2c_device_probe,
908 .remove = i2c_device_remove,
909 .shutdown = i2c_device_shutdown,
911 EXPORT_SYMBOL_GPL(i2c_bus_type);
913 static struct device_type i2c_client_type = {
914 .groups = i2c_dev_groups,
915 .uevent = i2c_device_uevent,
916 .release = i2c_client_dev_release,
921 * i2c_verify_client - return parameter as i2c_client, or NULL
922 * @dev: device, probably from some driver model iterator
924 * When traversing the driver model tree, perhaps using driver model
925 * iterators like @device_for_each_child(), you can't assume very much
926 * about the nodes you find. Use this function to avoid oopses caused
927 * by wrongly treating some non-I2C device as an i2c_client.
929 struct i2c_client *i2c_verify_client(struct device *dev)
931 return (dev->type == &i2c_client_type)
935 EXPORT_SYMBOL(i2c_verify_client);
938 /* Return a unique address which takes the flags of the client into account */
939 static unsigned short i2c_encode_flags_to_addr(struct i2c_client *client)
941 unsigned short addr = client->addr;
943 /* For some client flags, add an arbitrary offset to avoid collisions */
944 if (client->flags & I2C_CLIENT_TEN)
945 addr |= I2C_ADDR_OFFSET_TEN_BIT;
947 if (client->flags & I2C_CLIENT_SLAVE)
948 addr |= I2C_ADDR_OFFSET_SLAVE;
953 /* This is a permissive address validity check, I2C address map constraints
954 * are purposely not enforced, except for the general call address. */
955 static int i2c_check_addr_validity(unsigned addr, unsigned short flags)
957 if (flags & I2C_CLIENT_TEN) {
958 /* 10-bit address, all values are valid */
962 /* 7-bit address, reject the general call address */
963 if (addr == 0x00 || addr > 0x7f)
969 /* And this is a strict address validity check, used when probing. If a
970 * device uses a reserved address, then it shouldn't be probed. 7-bit
971 * addressing is assumed, 10-bit address devices are rare and should be
972 * explicitly enumerated. */
973 static int i2c_check_7bit_addr_validity_strict(unsigned short addr)
976 * Reserved addresses per I2C specification:
977 * 0x00 General call address / START byte
979 * 0x02 Reserved for different bus format
980 * 0x03 Reserved for future purposes
981 * 0x04-0x07 Hs-mode master code
982 * 0x78-0x7b 10-bit slave addressing
983 * 0x7c-0x7f Reserved for future purposes
985 if (addr < 0x08 || addr > 0x77)
990 static int __i2c_check_addr_busy(struct device *dev, void *addrp)
992 struct i2c_client *client = i2c_verify_client(dev);
993 int addr = *(int *)addrp;
995 if (client && i2c_encode_flags_to_addr(client) == addr)
1000 /* walk up mux tree */
1001 static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
1003 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
1006 result = device_for_each_child(&adapter->dev, &addr,
1007 __i2c_check_addr_busy);
1009 if (!result && parent)
1010 result = i2c_check_mux_parents(parent, addr);
1015 /* recurse down mux tree */
1016 static int i2c_check_mux_children(struct device *dev, void *addrp)
1020 if (dev->type == &i2c_adapter_type)
1021 result = device_for_each_child(dev, addrp,
1022 i2c_check_mux_children);
1024 result = __i2c_check_addr_busy(dev, addrp);
1029 static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
1031 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
1035 result = i2c_check_mux_parents(parent, addr);
1038 result = device_for_each_child(&adapter->dev, &addr,
1039 i2c_check_mux_children);
1045 * i2c_adapter_lock_bus - Get exclusive access to an I2C bus segment
1046 * @adapter: Target I2C bus segment
1047 * @flags: I2C_LOCK_ROOT_ADAPTER locks the root i2c adapter, I2C_LOCK_SEGMENT
1048 * locks only this branch in the adapter tree
1050 static void i2c_adapter_lock_bus(struct i2c_adapter *adapter,
1053 rt_mutex_lock(&adapter->bus_lock);
1057 * i2c_adapter_trylock_bus - Try to get exclusive access to an I2C bus segment
1058 * @adapter: Target I2C bus segment
1059 * @flags: I2C_LOCK_ROOT_ADAPTER trylocks the root i2c adapter, I2C_LOCK_SEGMENT
1060 * trylocks only this branch in the adapter tree
1062 static int i2c_adapter_trylock_bus(struct i2c_adapter *adapter,
1065 return rt_mutex_trylock(&adapter->bus_lock);
1069 * i2c_adapter_unlock_bus - Release exclusive access to an I2C bus segment
1070 * @adapter: Target I2C bus segment
1071 * @flags: I2C_LOCK_ROOT_ADAPTER unlocks the root i2c adapter, I2C_LOCK_SEGMENT
1072 * unlocks only this branch in the adapter tree
1074 static void i2c_adapter_unlock_bus(struct i2c_adapter *adapter,
1077 rt_mutex_unlock(&adapter->bus_lock);
1080 static void i2c_dev_set_name(struct i2c_adapter *adap,
1081 struct i2c_client *client)
1083 struct acpi_device *adev = ACPI_COMPANION(&client->dev);
1086 dev_set_name(&client->dev, "i2c-%s", acpi_dev_name(adev));
1090 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
1091 i2c_encode_flags_to_addr(client));
1095 * i2c_new_device - instantiate an i2c device
1096 * @adap: the adapter managing the device
1097 * @info: describes one I2C device; bus_num is ignored
1098 * Context: can sleep
1100 * Create an i2c device. Binding is handled through driver model
1101 * probe()/remove() methods. A driver may be bound to this device when we
1102 * return from this function, or any later moment (e.g. maybe hotplugging will
1103 * load the driver module). This call is not appropriate for use by mainboard
1104 * initialization logic, which usually runs during an arch_initcall() long
1105 * before any i2c_adapter could exist.
1107 * This returns the new i2c client, which may be saved for later use with
1108 * i2c_unregister_device(); or NULL to indicate an error.
1111 i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
1113 struct i2c_client *client;
1116 client = kzalloc(sizeof *client, GFP_KERNEL);
1120 client->adapter = adap;
1122 client->dev.platform_data = info->platform_data;
1125 client->dev.archdata = *info->archdata;
1127 client->flags = info->flags;
1128 client->addr = info->addr;
1129 client->irq = info->irq;
1131 strlcpy(client->name, info->type, sizeof(client->name));
1133 status = i2c_check_addr_validity(client->addr, client->flags);
1135 dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
1136 client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
1137 goto out_err_silent;
1140 /* Check for address business */
1141 status = i2c_check_addr_busy(adap, i2c_encode_flags_to_addr(client));
1145 client->dev.parent = &client->adapter->dev;
1146 client->dev.bus = &i2c_bus_type;
1147 client->dev.type = &i2c_client_type;
1148 client->dev.of_node = info->of_node;
1149 client->dev.fwnode = info->fwnode;
1151 i2c_dev_set_name(adap, client);
1152 status = device_register(&client->dev);
1156 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
1157 client->name, dev_name(&client->dev));
1162 dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
1163 "(%d)\n", client->name, client->addr, status);
1168 EXPORT_SYMBOL_GPL(i2c_new_device);
1172 * i2c_unregister_device - reverse effect of i2c_new_device()
1173 * @client: value returned from i2c_new_device()
1174 * Context: can sleep
1176 void i2c_unregister_device(struct i2c_client *client)
1178 if (client->dev.of_node)
1179 of_node_clear_flag(client->dev.of_node, OF_POPULATED);
1180 device_unregister(&client->dev);
1182 EXPORT_SYMBOL_GPL(i2c_unregister_device);
1185 static const struct i2c_device_id dummy_id[] = {
1190 static int dummy_probe(struct i2c_client *client,
1191 const struct i2c_device_id *id)
1196 static int dummy_remove(struct i2c_client *client)
1201 static struct i2c_driver dummy_driver = {
1202 .driver.name = "dummy",
1203 .probe = dummy_probe,
1204 .remove = dummy_remove,
1205 .id_table = dummy_id,
1209 * i2c_new_dummy - return a new i2c device bound to a dummy driver
1210 * @adapter: the adapter managing the device
1211 * @address: seven bit address to be used
1212 * Context: can sleep
1214 * This returns an I2C client bound to the "dummy" driver, intended for use
1215 * with devices that consume multiple addresses. Examples of such chips
1216 * include various EEPROMS (like 24c04 and 24c08 models).
1218 * These dummy devices have two main uses. First, most I2C and SMBus calls
1219 * except i2c_transfer() need a client handle; the dummy will be that handle.
1220 * And second, this prevents the specified address from being bound to a
1223 * This returns the new i2c client, which should be saved for later use with
1224 * i2c_unregister_device(); or NULL to indicate an error.
1226 struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
1228 struct i2c_board_info info = {
1229 I2C_BOARD_INFO("dummy", address),
1232 return i2c_new_device(adapter, &info);
1234 EXPORT_SYMBOL_GPL(i2c_new_dummy);
1237 * i2c_new_secondary_device - Helper to get the instantiated secondary address
1238 * and create the associated device
1239 * @client: Handle to the primary client
1240 * @name: Handle to specify which secondary address to get
1241 * @default_addr: Used as a fallback if no secondary address was specified
1242 * Context: can sleep
1244 * I2C clients can be composed of multiple I2C slaves bound together in a single
1245 * component. The I2C client driver then binds to the master I2C slave and needs
1246 * to create I2C dummy clients to communicate with all the other slaves.
1248 * This function creates and returns an I2C dummy client whose I2C address is
1249 * retrieved from the platform firmware based on the given slave name. If no
1250 * address is specified by the firmware default_addr is used.
1252 * On DT-based platforms the address is retrieved from the "reg" property entry
1253 * cell whose "reg-names" value matches the slave name.
1255 * This returns the new i2c client, which should be saved for later use with
1256 * i2c_unregister_device(); or NULL to indicate an error.
1258 struct i2c_client *i2c_new_secondary_device(struct i2c_client *client,
1262 struct device_node *np = client->dev.of_node;
1263 u32 addr = default_addr;
1267 i = of_property_match_string(np, "reg-names", name);
1269 of_property_read_u32_index(np, "reg", i, &addr);
1272 dev_dbg(&client->adapter->dev, "Address for %s : 0x%x\n", name, addr);
1273 return i2c_new_dummy(client->adapter, addr);
1275 EXPORT_SYMBOL_GPL(i2c_new_secondary_device);
1277 /* ------------------------------------------------------------------------- */
1279 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
1281 static void i2c_adapter_dev_release(struct device *dev)
1283 struct i2c_adapter *adap = to_i2c_adapter(dev);
1284 complete(&adap->dev_released);
1288 * This function is only needed for mutex_lock_nested, so it is never
1289 * called unless locking correctness checking is enabled. Thus we
1290 * make it inline to avoid a compiler warning. That's what gcc ends up
1293 static inline unsigned int i2c_adapter_depth(struct i2c_adapter *adapter)
1295 unsigned int depth = 0;
1297 while ((adapter = i2c_parent_is_i2c_adapter(adapter)))
1304 * Let users instantiate I2C devices through sysfs. This can be used when
1305 * platform initialization code doesn't contain the proper data for
1306 * whatever reason. Also useful for drivers that do device detection and
1307 * detection fails, either because the device uses an unexpected address,
1308 * or this is a compatible device with different ID register values.
1310 * Parameter checking may look overzealous, but we really don't want
1311 * the user to provide incorrect parameters.
1314 i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
1315 const char *buf, size_t count)
1317 struct i2c_adapter *adap = to_i2c_adapter(dev);
1318 struct i2c_board_info info;
1319 struct i2c_client *client;
1323 memset(&info, 0, sizeof(struct i2c_board_info));
1325 blank = strchr(buf, ' ');
1327 dev_err(dev, "%s: Missing parameters\n", "new_device");
1330 if (blank - buf > I2C_NAME_SIZE - 1) {
1331 dev_err(dev, "%s: Invalid device name\n", "new_device");
1334 memcpy(info.type, buf, blank - buf);
1336 /* Parse remaining parameters, reject extra parameters */
1337 res = sscanf(++blank, "%hi%c", &info.addr, &end);
1339 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
1342 if (res > 1 && end != '\n') {
1343 dev_err(dev, "%s: Extra parameters\n", "new_device");
1347 if ((info.addr & I2C_ADDR_OFFSET_TEN_BIT) == I2C_ADDR_OFFSET_TEN_BIT) {
1348 info.addr &= ~I2C_ADDR_OFFSET_TEN_BIT;
1349 info.flags |= I2C_CLIENT_TEN;
1352 if (info.addr & I2C_ADDR_OFFSET_SLAVE) {
1353 info.addr &= ~I2C_ADDR_OFFSET_SLAVE;
1354 info.flags |= I2C_CLIENT_SLAVE;
1357 client = i2c_new_device(adap, &info);
1361 /* Keep track of the added device */
1362 mutex_lock(&adap->userspace_clients_lock);
1363 list_add_tail(&client->detected, &adap->userspace_clients);
1364 mutex_unlock(&adap->userspace_clients_lock);
1365 dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
1366 info.type, info.addr);
1370 static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
1373 * And of course let the users delete the devices they instantiated, if
1374 * they got it wrong. This interface can only be used to delete devices
1375 * instantiated by i2c_sysfs_new_device above. This guarantees that we
1376 * don't delete devices to which some kernel code still has references.
1378 * Parameter checking may look overzealous, but we really don't want
1379 * the user to delete the wrong device.
1382 i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
1383 const char *buf, size_t count)
1385 struct i2c_adapter *adap = to_i2c_adapter(dev);
1386 struct i2c_client *client, *next;
1387 unsigned short addr;
1391 /* Parse parameters, reject extra parameters */
1392 res = sscanf(buf, "%hi%c", &addr, &end);
1394 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
1397 if (res > 1 && end != '\n') {
1398 dev_err(dev, "%s: Extra parameters\n", "delete_device");
1402 /* Make sure the device was added through sysfs */
1404 mutex_lock_nested(&adap->userspace_clients_lock,
1405 i2c_adapter_depth(adap));
1406 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1408 if (i2c_encode_flags_to_addr(client) == addr) {
1409 dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
1410 "delete_device", client->name, client->addr);
1412 list_del(&client->detected);
1413 i2c_unregister_device(client);
1418 mutex_unlock(&adap->userspace_clients_lock);
1421 dev_err(dev, "%s: Can't find device in list\n",
1425 static DEVICE_ATTR_IGNORE_LOCKDEP(delete_device, S_IWUSR, NULL,
1426 i2c_sysfs_delete_device);
1428 static struct attribute *i2c_adapter_attrs[] = {
1429 &dev_attr_name.attr,
1430 &dev_attr_new_device.attr,
1431 &dev_attr_delete_device.attr,
1434 ATTRIBUTE_GROUPS(i2c_adapter);
1436 struct device_type i2c_adapter_type = {
1437 .groups = i2c_adapter_groups,
1438 .release = i2c_adapter_dev_release,
1440 EXPORT_SYMBOL_GPL(i2c_adapter_type);
1443 * i2c_verify_adapter - return parameter as i2c_adapter or NULL
1444 * @dev: device, probably from some driver model iterator
1446 * When traversing the driver model tree, perhaps using driver model
1447 * iterators like @device_for_each_child(), you can't assume very much
1448 * about the nodes you find. Use this function to avoid oopses caused
1449 * by wrongly treating some non-I2C device as an i2c_adapter.
1451 struct i2c_adapter *i2c_verify_adapter(struct device *dev)
1453 return (dev->type == &i2c_adapter_type)
1454 ? to_i2c_adapter(dev)
1457 EXPORT_SYMBOL(i2c_verify_adapter);
1459 #ifdef CONFIG_I2C_COMPAT
1460 static struct class_compat *i2c_adapter_compat_class;
1463 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
1465 struct i2c_devinfo *devinfo;
1467 down_read(&__i2c_board_lock);
1468 list_for_each_entry(devinfo, &__i2c_board_list, list) {
1469 if (devinfo->busnum == adapter->nr
1470 && !i2c_new_device(adapter,
1471 &devinfo->board_info))
1472 dev_err(&adapter->dev,
1473 "Can't create device at 0x%02x\n",
1474 devinfo->board_info.addr);
1476 up_read(&__i2c_board_lock);
1479 /* OF support code */
1481 #if IS_ENABLED(CONFIG_OF)
1482 static struct i2c_client *of_i2c_register_device(struct i2c_adapter *adap,
1483 struct device_node *node)
1485 struct i2c_client *result;
1486 struct i2c_board_info info = {};
1487 struct dev_archdata dev_ad = {};
1488 const __be32 *addr_be;
1492 dev_dbg(&adap->dev, "of_i2c: register %s\n", node->full_name);
1494 if (of_modalias_node(node, info.type, sizeof(info.type)) < 0) {
1495 dev_err(&adap->dev, "of_i2c: modalias failure on %s\n",
1497 return ERR_PTR(-EINVAL);
1500 addr_be = of_get_property(node, "reg", &len);
1501 if (!addr_be || (len < sizeof(*addr_be))) {
1502 dev_err(&adap->dev, "of_i2c: invalid reg on %s\n",
1504 return ERR_PTR(-EINVAL);
1507 addr = be32_to_cpup(addr_be);
1508 if (addr & I2C_TEN_BIT_ADDRESS) {
1509 addr &= ~I2C_TEN_BIT_ADDRESS;
1510 info.flags |= I2C_CLIENT_TEN;
1513 if (addr & I2C_OWN_SLAVE_ADDRESS) {
1514 addr &= ~I2C_OWN_SLAVE_ADDRESS;
1515 info.flags |= I2C_CLIENT_SLAVE;
1518 if (i2c_check_addr_validity(addr, info.flags)) {
1519 dev_err(&adap->dev, "of_i2c: invalid addr=%x on %s\n",
1520 info.addr, node->full_name);
1521 return ERR_PTR(-EINVAL);
1525 info.of_node = of_node_get(node);
1526 info.archdata = &dev_ad;
1528 if (of_get_property(node, "wakeup-source", NULL))
1529 info.flags |= I2C_CLIENT_WAKE;
1531 result = i2c_new_device(adap, &info);
1532 if (result == NULL) {
1533 dev_err(&adap->dev, "of_i2c: Failure registering %s\n",
1536 return ERR_PTR(-EINVAL);
1541 static void of_i2c_register_devices(struct i2c_adapter *adap)
1543 struct device_node *node;
1545 /* Only register child devices if the adapter has a node pointer set */
1546 if (!adap->dev.of_node)
1549 dev_dbg(&adap->dev, "of_i2c: walking child nodes\n");
1551 for_each_available_child_of_node(adap->dev.of_node, node) {
1552 if (of_node_test_and_set_flag(node, OF_POPULATED))
1554 of_i2c_register_device(adap, node);
1558 static int of_dev_node_match(struct device *dev, void *data)
1560 return dev->of_node == data;
1563 /* must call put_device() when done with returned i2c_client device */
1564 struct i2c_client *of_find_i2c_device_by_node(struct device_node *node)
1567 struct i2c_client *client;
1569 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
1573 client = i2c_verify_client(dev);
1579 EXPORT_SYMBOL(of_find_i2c_device_by_node);
1581 /* must call put_device() when done with returned i2c_adapter device */
1582 struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node)
1585 struct i2c_adapter *adapter;
1587 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
1591 adapter = i2c_verify_adapter(dev);
1597 EXPORT_SYMBOL(of_find_i2c_adapter_by_node);
1599 /* must call i2c_put_adapter() when done with returned i2c_adapter device */
1600 struct i2c_adapter *of_get_i2c_adapter_by_node(struct device_node *node)
1602 struct i2c_adapter *adapter;
1604 adapter = of_find_i2c_adapter_by_node(node);
1608 if (!try_module_get(adapter->owner)) {
1609 put_device(&adapter->dev);
1615 EXPORT_SYMBOL(of_get_i2c_adapter_by_node);
1617 static void of_i2c_register_devices(struct i2c_adapter *adap) { }
1618 #endif /* CONFIG_OF */
1620 static int i2c_do_add_adapter(struct i2c_driver *driver,
1621 struct i2c_adapter *adap)
1623 /* Detect supported devices on that bus, and instantiate them */
1624 i2c_detect(adap, driver);
1626 /* Let legacy drivers scan this bus for matching devices */
1627 if (driver->attach_adapter) {
1628 dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
1629 driver->driver.name);
1630 dev_warn(&adap->dev, "Please use another way to instantiate "
1631 "your i2c_client\n");
1632 /* We ignore the return code; if it fails, too bad */
1633 driver->attach_adapter(adap);
1638 static int __process_new_adapter(struct device_driver *d, void *data)
1640 return i2c_do_add_adapter(to_i2c_driver(d), data);
1643 static int i2c_register_adapter(struct i2c_adapter *adap)
1647 /* Can't register until after driver model init */
1648 if (WARN_ON(!is_registered)) {
1654 if (WARN(!adap->name[0], "i2c adapter has no name"))
1658 pr_err("adapter '%s': no algo supplied!\n", adap->name);
1662 if (!adap->lock_bus) {
1663 adap->lock_bus = i2c_adapter_lock_bus;
1664 adap->trylock_bus = i2c_adapter_trylock_bus;
1665 adap->unlock_bus = i2c_adapter_unlock_bus;
1668 rt_mutex_init(&adap->bus_lock);
1669 rt_mutex_init(&adap->mux_lock);
1670 mutex_init(&adap->userspace_clients_lock);
1671 INIT_LIST_HEAD(&adap->userspace_clients);
1673 /* Set default timeout to 1 second if not already set */
1674 if (adap->timeout == 0)
1677 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
1678 adap->dev.bus = &i2c_bus_type;
1679 adap->dev.type = &i2c_adapter_type;
1680 res = device_register(&adap->dev);
1682 pr_err("adapter '%s': can't register device (%d)\n", adap->name, res);
1686 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
1688 pm_runtime_no_callbacks(&adap->dev);
1689 pm_suspend_ignore_children(&adap->dev, true);
1690 pm_runtime_enable(&adap->dev);
1692 #ifdef CONFIG_I2C_COMPAT
1693 res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
1696 dev_warn(&adap->dev,
1697 "Failed to create compatibility class link\n");
1700 i2c_init_recovery(adap);
1702 /* create pre-declared device nodes */
1703 of_i2c_register_devices(adap);
1704 i2c_acpi_register_devices(adap);
1705 i2c_acpi_install_space_handler(adap);
1707 if (adap->nr < __i2c_first_dynamic_bus_num)
1708 i2c_scan_static_board_info(adap);
1710 /* Notify drivers */
1711 mutex_lock(&core_lock);
1712 bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
1713 mutex_unlock(&core_lock);
1718 mutex_lock(&core_lock);
1719 idr_remove(&i2c_adapter_idr, adap->nr);
1720 mutex_unlock(&core_lock);
1725 * __i2c_add_numbered_adapter - i2c_add_numbered_adapter where nr is never -1
1726 * @adap: the adapter to register (with adap->nr initialized)
1727 * Context: can sleep
1729 * See i2c_add_numbered_adapter() for details.
1731 static int __i2c_add_numbered_adapter(struct i2c_adapter *adap)
1735 mutex_lock(&core_lock);
1736 id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1, GFP_KERNEL);
1737 mutex_unlock(&core_lock);
1738 if (WARN(id < 0, "couldn't get idr"))
1739 return id == -ENOSPC ? -EBUSY : id;
1741 return i2c_register_adapter(adap);
1745 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
1746 * @adapter: the adapter to add
1747 * Context: can sleep
1749 * This routine is used to declare an I2C adapter when its bus number
1750 * doesn't matter or when its bus number is specified by an dt alias.
1751 * Examples of bases when the bus number doesn't matter: I2C adapters
1752 * dynamically added by USB links or PCI plugin cards.
1754 * When this returns zero, a new bus number was allocated and stored
1755 * in adap->nr, and the specified adapter became available for clients.
1756 * Otherwise, a negative errno value is returned.
1758 int i2c_add_adapter(struct i2c_adapter *adapter)
1760 struct device *dev = &adapter->dev;
1764 id = of_alias_get_id(dev->of_node, "i2c");
1767 return __i2c_add_numbered_adapter(adapter);
1771 mutex_lock(&core_lock);
1772 id = idr_alloc(&i2c_adapter_idr, adapter,
1773 __i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
1774 mutex_unlock(&core_lock);
1775 if (WARN(id < 0, "couldn't get idr"))
1780 return i2c_register_adapter(adapter);
1782 EXPORT_SYMBOL(i2c_add_adapter);
1785 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
1786 * @adap: the adapter to register (with adap->nr initialized)
1787 * Context: can sleep
1789 * This routine is used to declare an I2C adapter when its bus number
1790 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
1791 * or otherwise built in to the system's mainboard, and where i2c_board_info
1792 * is used to properly configure I2C devices.
1794 * If the requested bus number is set to -1, then this function will behave
1795 * identically to i2c_add_adapter, and will dynamically assign a bus number.
1797 * If no devices have pre-been declared for this bus, then be sure to
1798 * register the adapter before any dynamically allocated ones. Otherwise
1799 * the required bus ID may not be available.
1801 * When this returns zero, the specified adapter became available for
1802 * clients using the bus number provided in adap->nr. Also, the table
1803 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
1804 * and the appropriate driver model device nodes are created. Otherwise, a
1805 * negative errno value is returned.
1807 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
1809 if (adap->nr == -1) /* -1 means dynamically assign bus id */
1810 return i2c_add_adapter(adap);
1812 return __i2c_add_numbered_adapter(adap);
1814 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
1816 static void i2c_do_del_adapter(struct i2c_driver *driver,
1817 struct i2c_adapter *adapter)
1819 struct i2c_client *client, *_n;
1821 /* Remove the devices we created ourselves as the result of hardware
1822 * probing (using a driver's detect method) */
1823 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
1824 if (client->adapter == adapter) {
1825 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
1826 client->name, client->addr);
1827 list_del(&client->detected);
1828 i2c_unregister_device(client);
1833 static int __unregister_client(struct device *dev, void *dummy)
1835 struct i2c_client *client = i2c_verify_client(dev);
1836 if (client && strcmp(client->name, "dummy"))
1837 i2c_unregister_device(client);
1841 static int __unregister_dummy(struct device *dev, void *dummy)
1843 struct i2c_client *client = i2c_verify_client(dev);
1845 i2c_unregister_device(client);
1849 static int __process_removed_adapter(struct device_driver *d, void *data)
1851 i2c_do_del_adapter(to_i2c_driver(d), data);
1856 * i2c_del_adapter - unregister I2C adapter
1857 * @adap: the adapter being unregistered
1858 * Context: can sleep
1860 * This unregisters an I2C adapter which was previously registered
1861 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
1863 void i2c_del_adapter(struct i2c_adapter *adap)
1865 struct i2c_adapter *found;
1866 struct i2c_client *client, *next;
1868 /* First make sure that this adapter was ever added */
1869 mutex_lock(&core_lock);
1870 found = idr_find(&i2c_adapter_idr, adap->nr);
1871 mutex_unlock(&core_lock);
1872 if (found != adap) {
1873 pr_debug("attempting to delete unregistered adapter [%s]\n", adap->name);
1877 i2c_acpi_remove_space_handler(adap);
1878 /* Tell drivers about this removal */
1879 mutex_lock(&core_lock);
1880 bus_for_each_drv(&i2c_bus_type, NULL, adap,
1881 __process_removed_adapter);
1882 mutex_unlock(&core_lock);
1884 /* Remove devices instantiated from sysfs */
1885 mutex_lock_nested(&adap->userspace_clients_lock,
1886 i2c_adapter_depth(adap));
1887 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1889 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
1891 list_del(&client->detected);
1892 i2c_unregister_device(client);
1894 mutex_unlock(&adap->userspace_clients_lock);
1896 /* Detach any active clients. This can't fail, thus we do not
1897 * check the returned value. This is a two-pass process, because
1898 * we can't remove the dummy devices during the first pass: they
1899 * could have been instantiated by real devices wishing to clean
1900 * them up properly, so we give them a chance to do that first. */
1901 device_for_each_child(&adap->dev, NULL, __unregister_client);
1902 device_for_each_child(&adap->dev, NULL, __unregister_dummy);
1904 #ifdef CONFIG_I2C_COMPAT
1905 class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
1909 /* device name is gone after device_unregister */
1910 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
1912 pm_runtime_disable(&adap->dev);
1914 /* wait until all references to the device are gone
1916 * FIXME: This is old code and should ideally be replaced by an
1917 * alternative which results in decoupling the lifetime of the struct
1918 * device from the i2c_adapter, like spi or netdev do. Any solution
1919 * should be thoroughly tested with DEBUG_KOBJECT_RELEASE enabled!
1921 init_completion(&adap->dev_released);
1922 device_unregister(&adap->dev);
1923 wait_for_completion(&adap->dev_released);
1926 mutex_lock(&core_lock);
1927 idr_remove(&i2c_adapter_idr, adap->nr);
1928 mutex_unlock(&core_lock);
1930 /* Clear the device structure in case this adapter is ever going to be
1932 memset(&adap->dev, 0, sizeof(adap->dev));
1934 EXPORT_SYMBOL(i2c_del_adapter);
1937 * i2c_parse_fw_timings - get I2C related timing parameters from firmware
1938 * @dev: The device to scan for I2C timing properties
1939 * @t: the i2c_timings struct to be filled with values
1940 * @use_defaults: bool to use sane defaults derived from the I2C specification
1941 * when properties are not found, otherwise use 0
1943 * Scan the device for the generic I2C properties describing timing parameters
1944 * for the signal and fill the given struct with the results. If a property was
1945 * not found and use_defaults was true, then maximum timings are assumed which
1946 * are derived from the I2C specification. If use_defaults is not used, the
1947 * results will be 0, so drivers can apply their own defaults later. The latter
1948 * is mainly intended for avoiding regressions of existing drivers which want
1949 * to switch to this function. New drivers almost always should use the defaults.
1952 void i2c_parse_fw_timings(struct device *dev, struct i2c_timings *t, bool use_defaults)
1956 memset(t, 0, sizeof(*t));
1958 ret = device_property_read_u32(dev, "clock-frequency", &t->bus_freq_hz);
1959 if (ret && use_defaults)
1960 t->bus_freq_hz = 100000;
1962 ret = device_property_read_u32(dev, "i2c-scl-rising-time-ns", &t->scl_rise_ns);
1963 if (ret && use_defaults) {
1964 if (t->bus_freq_hz <= 100000)
1965 t->scl_rise_ns = 1000;
1966 else if (t->bus_freq_hz <= 400000)
1967 t->scl_rise_ns = 300;
1969 t->scl_rise_ns = 120;
1972 ret = device_property_read_u32(dev, "i2c-scl-falling-time-ns", &t->scl_fall_ns);
1973 if (ret && use_defaults) {
1974 if (t->bus_freq_hz <= 400000)
1975 t->scl_fall_ns = 300;
1977 t->scl_fall_ns = 120;
1980 device_property_read_u32(dev, "i2c-scl-internal-delay-ns", &t->scl_int_delay_ns);
1982 ret = device_property_read_u32(dev, "i2c-sda-falling-time-ns", &t->sda_fall_ns);
1983 if (ret && use_defaults)
1984 t->sda_fall_ns = t->scl_fall_ns;
1986 EXPORT_SYMBOL_GPL(i2c_parse_fw_timings);
1988 /* ------------------------------------------------------------------------- */
1990 int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
1994 mutex_lock(&core_lock);
1995 res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
1996 mutex_unlock(&core_lock);
2000 EXPORT_SYMBOL_GPL(i2c_for_each_dev);
2002 static int __process_new_driver(struct device *dev, void *data)
2004 if (dev->type != &i2c_adapter_type)
2006 return i2c_do_add_adapter(data, to_i2c_adapter(dev));
2010 * An i2c_driver is used with one or more i2c_client (device) nodes to access
2011 * i2c slave chips, on a bus instance associated with some i2c_adapter.
2014 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
2018 /* Can't register until after driver model init */
2019 if (WARN_ON(!is_registered))
2022 /* add the driver to the list of i2c drivers in the driver core */
2023 driver->driver.owner = owner;
2024 driver->driver.bus = &i2c_bus_type;
2026 /* When registration returns, the driver core
2027 * will have called probe() for all matching-but-unbound devices.
2029 res = driver_register(&driver->driver);
2033 pr_debug("driver [%s] registered\n", driver->driver.name);
2035 INIT_LIST_HEAD(&driver->clients);
2036 /* Walk the adapters that are already present */
2037 i2c_for_each_dev(driver, __process_new_driver);
2041 EXPORT_SYMBOL(i2c_register_driver);
2043 static int __process_removed_driver(struct device *dev, void *data)
2045 if (dev->type == &i2c_adapter_type)
2046 i2c_do_del_adapter(data, to_i2c_adapter(dev));
2051 * i2c_del_driver - unregister I2C driver
2052 * @driver: the driver being unregistered
2053 * Context: can sleep
2055 void i2c_del_driver(struct i2c_driver *driver)
2057 i2c_for_each_dev(driver, __process_removed_driver);
2059 driver_unregister(&driver->driver);
2060 pr_debug("driver [%s] unregistered\n", driver->driver.name);
2062 EXPORT_SYMBOL(i2c_del_driver);
2064 /* ------------------------------------------------------------------------- */
2067 * i2c_use_client - increments the reference count of the i2c client structure
2068 * @client: the client being referenced
2070 * Each live reference to a client should be refcounted. The driver model does
2071 * that automatically as part of driver binding, so that most drivers don't
2072 * need to do this explicitly: they hold a reference until they're unbound
2075 * A pointer to the client with the incremented reference counter is returned.
2077 struct i2c_client *i2c_use_client(struct i2c_client *client)
2079 if (client && get_device(&client->dev))
2083 EXPORT_SYMBOL(i2c_use_client);
2086 * i2c_release_client - release a use of the i2c client structure
2087 * @client: the client being no longer referenced
2089 * Must be called when a user of a client is finished with it.
2091 void i2c_release_client(struct i2c_client *client)
2094 put_device(&client->dev);
2096 EXPORT_SYMBOL(i2c_release_client);
2098 struct i2c_cmd_arg {
2103 static int i2c_cmd(struct device *dev, void *_arg)
2105 struct i2c_client *client = i2c_verify_client(dev);
2106 struct i2c_cmd_arg *arg = _arg;
2107 struct i2c_driver *driver;
2109 if (!client || !client->dev.driver)
2112 driver = to_i2c_driver(client->dev.driver);
2113 if (driver->command)
2114 driver->command(client, arg->cmd, arg->arg);
2118 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
2120 struct i2c_cmd_arg cmd_arg;
2124 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
2126 EXPORT_SYMBOL(i2c_clients_command);
2128 #if IS_ENABLED(CONFIG_OF_DYNAMIC)
2129 static int of_i2c_notify(struct notifier_block *nb, unsigned long action,
2132 struct of_reconfig_data *rd = arg;
2133 struct i2c_adapter *adap;
2134 struct i2c_client *client;
2136 switch (of_reconfig_get_state_change(action, rd)) {
2137 case OF_RECONFIG_CHANGE_ADD:
2138 adap = of_find_i2c_adapter_by_node(rd->dn->parent);
2140 return NOTIFY_OK; /* not for us */
2142 if (of_node_test_and_set_flag(rd->dn, OF_POPULATED)) {
2143 put_device(&adap->dev);
2147 client = of_i2c_register_device(adap, rd->dn);
2148 put_device(&adap->dev);
2150 if (IS_ERR(client)) {
2151 dev_err(&adap->dev, "failed to create client for '%s'\n",
2153 return notifier_from_errno(PTR_ERR(client));
2156 case OF_RECONFIG_CHANGE_REMOVE:
2157 /* already depopulated? */
2158 if (!of_node_check_flag(rd->dn, OF_POPULATED))
2161 /* find our device by node */
2162 client = of_find_i2c_device_by_node(rd->dn);
2164 return NOTIFY_OK; /* no? not meant for us */
2166 /* unregister takes one ref away */
2167 i2c_unregister_device(client);
2169 /* and put the reference of the find */
2170 put_device(&client->dev);
2176 static struct notifier_block i2c_of_notifier = {
2177 .notifier_call = of_i2c_notify,
2180 extern struct notifier_block i2c_of_notifier;
2181 #endif /* CONFIG_OF_DYNAMIC */
2183 static int __init i2c_init(void)
2187 retval = of_alias_get_highest_id("i2c");
2189 down_write(&__i2c_board_lock);
2190 if (retval >= __i2c_first_dynamic_bus_num)
2191 __i2c_first_dynamic_bus_num = retval + 1;
2192 up_write(&__i2c_board_lock);
2194 retval = bus_register(&i2c_bus_type);
2198 is_registered = true;
2200 #ifdef CONFIG_I2C_COMPAT
2201 i2c_adapter_compat_class = class_compat_register("i2c-adapter");
2202 if (!i2c_adapter_compat_class) {
2207 retval = i2c_add_driver(&dummy_driver);
2211 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2212 WARN_ON(of_reconfig_notifier_register(&i2c_of_notifier));
2217 #ifdef CONFIG_I2C_COMPAT
2218 class_compat_unregister(i2c_adapter_compat_class);
2221 is_registered = false;
2222 bus_unregister(&i2c_bus_type);
2226 static void __exit i2c_exit(void)
2228 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2229 WARN_ON(of_reconfig_notifier_unregister(&i2c_of_notifier));
2230 i2c_del_driver(&dummy_driver);
2231 #ifdef CONFIG_I2C_COMPAT
2232 class_compat_unregister(i2c_adapter_compat_class);
2234 bus_unregister(&i2c_bus_type);
2235 tracepoint_synchronize_unregister();
2238 /* We must initialize early, because some subsystems register i2c drivers
2239 * in subsys_initcall() code, but are linked (and initialized) before i2c.
2241 postcore_initcall(i2c_init);
2242 module_exit(i2c_exit);
2244 /* ----------------------------------------------------
2245 * the functional interface to the i2c busses.
2246 * ----------------------------------------------------
2249 /* Check if val is exceeding the quirk IFF quirk is non 0 */
2250 #define i2c_quirk_exceeded(val, quirk) ((quirk) && ((val) > (quirk)))
2252 static int i2c_quirk_error(struct i2c_adapter *adap, struct i2c_msg *msg, char *err_msg)
2254 dev_err_ratelimited(&adap->dev, "adapter quirk: %s (addr 0x%04x, size %u, %s)\n",
2255 err_msg, msg->addr, msg->len,
2256 msg->flags & I2C_M_RD ? "read" : "write");
2260 static int i2c_check_for_quirks(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2262 const struct i2c_adapter_quirks *q = adap->quirks;
2263 int max_num = q->max_num_msgs, i;
2264 bool do_len_check = true;
2266 if (q->flags & I2C_AQ_COMB) {
2269 /* special checks for combined messages */
2271 if (q->flags & I2C_AQ_COMB_WRITE_FIRST && msgs[0].flags & I2C_M_RD)
2272 return i2c_quirk_error(adap, &msgs[0], "1st comb msg must be write");
2274 if (q->flags & I2C_AQ_COMB_READ_SECOND && !(msgs[1].flags & I2C_M_RD))
2275 return i2c_quirk_error(adap, &msgs[1], "2nd comb msg must be read");
2277 if (q->flags & I2C_AQ_COMB_SAME_ADDR && msgs[0].addr != msgs[1].addr)
2278 return i2c_quirk_error(adap, &msgs[0], "comb msg only to same addr");
2280 if (i2c_quirk_exceeded(msgs[0].len, q->max_comb_1st_msg_len))
2281 return i2c_quirk_error(adap, &msgs[0], "msg too long");
2283 if (i2c_quirk_exceeded(msgs[1].len, q->max_comb_2nd_msg_len))
2284 return i2c_quirk_error(adap, &msgs[1], "msg too long");
2286 do_len_check = false;
2290 if (i2c_quirk_exceeded(num, max_num))
2291 return i2c_quirk_error(adap, &msgs[0], "too many messages");
2293 for (i = 0; i < num; i++) {
2294 u16 len = msgs[i].len;
2296 if (msgs[i].flags & I2C_M_RD) {
2297 if (do_len_check && i2c_quirk_exceeded(len, q->max_read_len))
2298 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2300 if (do_len_check && i2c_quirk_exceeded(len, q->max_write_len))
2301 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2309 * __i2c_transfer - unlocked flavor of i2c_transfer
2310 * @adap: Handle to I2C bus
2311 * @msgs: One or more messages to execute before STOP is issued to
2312 * terminate the operation; each message begins with a START.
2313 * @num: Number of messages to be executed.
2315 * Returns negative errno, else the number of messages executed.
2317 * Adapter lock must be held when calling this function. No debug logging
2318 * takes place. adap->algo->master_xfer existence isn't checked.
2320 int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2322 unsigned long orig_jiffies;
2325 if (adap->quirks && i2c_check_for_quirks(adap, msgs, num))
2328 /* i2c_trace_msg gets enabled when tracepoint i2c_transfer gets
2329 * enabled. This is an efficient way of keeping the for-loop from
2330 * being executed when not needed.
2332 if (static_key_false(&i2c_trace_msg)) {
2334 for (i = 0; i < num; i++)
2335 if (msgs[i].flags & I2C_M_RD)
2336 trace_i2c_read(adap, &msgs[i], i);
2338 trace_i2c_write(adap, &msgs[i], i);
2341 /* Retry automatically on arbitration loss */
2342 orig_jiffies = jiffies;
2343 for (ret = 0, try = 0; try <= adap->retries; try++) {
2344 ret = adap->algo->master_xfer(adap, msgs, num);
2347 if (time_after(jiffies, orig_jiffies + adap->timeout))
2351 if (static_key_false(&i2c_trace_msg)) {
2353 for (i = 0; i < ret; i++)
2354 if (msgs[i].flags & I2C_M_RD)
2355 trace_i2c_reply(adap, &msgs[i], i);
2356 trace_i2c_result(adap, i, ret);
2361 EXPORT_SYMBOL(__i2c_transfer);
2364 * i2c_transfer - execute a single or combined I2C message
2365 * @adap: Handle to I2C bus
2366 * @msgs: One or more messages to execute before STOP is issued to
2367 * terminate the operation; each message begins with a START.
2368 * @num: Number of messages to be executed.
2370 * Returns negative errno, else the number of messages executed.
2372 * Note that there is no requirement that each message be sent to
2373 * the same slave address, although that is the most common model.
2375 int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2379 /* REVISIT the fault reporting model here is weak:
2381 * - When we get an error after receiving N bytes from a slave,
2382 * there is no way to report "N".
2384 * - When we get a NAK after transmitting N bytes to a slave,
2385 * there is no way to report "N" ... or to let the master
2386 * continue executing the rest of this combined message, if
2387 * that's the appropriate response.
2389 * - When for example "num" is two and we successfully complete
2390 * the first message but get an error part way through the
2391 * second, it's unclear whether that should be reported as
2392 * one (discarding status on the second message) or errno
2393 * (discarding status on the first one).
2396 if (adap->algo->master_xfer) {
2398 for (ret = 0; ret < num; ret++) {
2399 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
2400 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
2401 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
2402 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
2406 if (in_atomic() || irqs_disabled()) {
2407 ret = adap->trylock_bus(adap, I2C_LOCK_SEGMENT);
2409 /* I2C activity is ongoing. */
2412 i2c_lock_bus(adap, I2C_LOCK_SEGMENT);
2415 ret = __i2c_transfer(adap, msgs, num);
2416 i2c_unlock_bus(adap, I2C_LOCK_SEGMENT);
2420 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
2424 EXPORT_SYMBOL(i2c_transfer);
2427 * i2c_master_send - issue a single I2C message in master transmit mode
2428 * @client: Handle to slave device
2429 * @buf: Data that will be written to the slave
2430 * @count: How many bytes to write, must be less than 64k since msg.len is u16
2432 * Returns negative errno, or else the number of bytes written.
2434 int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
2437 struct i2c_adapter *adap = client->adapter;
2440 msg.addr = client->addr;
2441 msg.flags = client->flags & I2C_M_TEN;
2443 msg.buf = (char *)buf;
2445 ret = i2c_transfer(adap, &msg, 1);
2448 * If everything went ok (i.e. 1 msg transmitted), return #bytes
2449 * transmitted, else error code.
2451 return (ret == 1) ? count : ret;
2453 EXPORT_SYMBOL(i2c_master_send);
2456 * i2c_master_recv - issue a single I2C message in master receive mode
2457 * @client: Handle to slave device
2458 * @buf: Where to store data read from slave
2459 * @count: How many bytes to read, must be less than 64k since msg.len is u16
2461 * Returns negative errno, or else the number of bytes read.
2463 int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
2465 struct i2c_adapter *adap = client->adapter;
2469 msg.addr = client->addr;
2470 msg.flags = client->flags & I2C_M_TEN;
2471 msg.flags |= I2C_M_RD;
2475 ret = i2c_transfer(adap, &msg, 1);
2478 * If everything went ok (i.e. 1 msg received), return #bytes received,
2481 return (ret == 1) ? count : ret;
2483 EXPORT_SYMBOL(i2c_master_recv);
2485 /* ----------------------------------------------------
2486 * the i2c address scanning function
2487 * Will not work for 10-bit addresses!
2488 * ----------------------------------------------------
2492 * Legacy default probe function, mostly relevant for SMBus. The default
2493 * probe method is a quick write, but it is known to corrupt the 24RF08
2494 * EEPROMs due to a state machine bug, and could also irreversibly
2495 * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
2496 * we use a short byte read instead. Also, some bus drivers don't implement
2497 * quick write, so we fallback to a byte read in that case too.
2498 * On x86, there is another special case for FSC hardware monitoring chips,
2499 * which want regular byte reads (address 0x73.) Fortunately, these are the
2500 * only known chips using this I2C address on PC hardware.
2501 * Returns 1 if probe succeeded, 0 if not.
2503 static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
2506 union i2c_smbus_data dummy;
2509 if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
2510 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
2511 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2512 I2C_SMBUS_BYTE_DATA, &dummy);
2515 if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
2516 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
2517 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
2518 I2C_SMBUS_QUICK, NULL);
2519 else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
2520 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2521 I2C_SMBUS_BYTE, &dummy);
2523 dev_warn(&adap->dev, "No suitable probing method supported for address 0x%02X\n",
2531 static int i2c_detect_address(struct i2c_client *temp_client,
2532 struct i2c_driver *driver)
2534 struct i2c_board_info info;
2535 struct i2c_adapter *adapter = temp_client->adapter;
2536 int addr = temp_client->addr;
2539 /* Make sure the address is valid */
2540 err = i2c_check_7bit_addr_validity_strict(addr);
2542 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
2547 /* Skip if already in use (7 bit, no need to encode flags) */
2548 if (i2c_check_addr_busy(adapter, addr))
2551 /* Make sure there is something at this address */
2552 if (!i2c_default_probe(adapter, addr))
2555 /* Finally call the custom detection function */
2556 memset(&info, 0, sizeof(struct i2c_board_info));
2558 err = driver->detect(temp_client, &info);
2560 /* -ENODEV is returned if the detection fails. We catch it
2561 here as this isn't an error. */
2562 return err == -ENODEV ? 0 : err;
2565 /* Consistency check */
2566 if (info.type[0] == '\0') {
2567 dev_err(&adapter->dev, "%s detection function provided "
2568 "no name for 0x%x\n", driver->driver.name,
2571 struct i2c_client *client;
2573 /* Detection succeeded, instantiate the device */
2574 if (adapter->class & I2C_CLASS_DEPRECATED)
2575 dev_warn(&adapter->dev,
2576 "This adapter will soon drop class based instantiation of devices. "
2577 "Please make sure client 0x%02x gets instantiated by other means. "
2578 "Check 'Documentation/i2c/instantiating-devices' for details.\n",
2581 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
2582 info.type, info.addr);
2583 client = i2c_new_device(adapter, &info);
2585 list_add_tail(&client->detected, &driver->clients);
2587 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
2588 info.type, info.addr);
2593 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
2595 const unsigned short *address_list;
2596 struct i2c_client *temp_client;
2598 int adap_id = i2c_adapter_id(adapter);
2600 address_list = driver->address_list;
2601 if (!driver->detect || !address_list)
2604 /* Warn that the adapter lost class based instantiation */
2605 if (adapter->class == I2C_CLASS_DEPRECATED) {
2606 dev_dbg(&adapter->dev,
2607 "This adapter dropped support for I2C classes and "
2608 "won't auto-detect %s devices anymore. If you need it, check "
2609 "'Documentation/i2c/instantiating-devices' for alternatives.\n",
2610 driver->driver.name);
2614 /* Stop here if the classes do not match */
2615 if (!(adapter->class & driver->class))
2618 /* Set up a temporary client to help detect callback */
2619 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
2622 temp_client->adapter = adapter;
2624 for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
2625 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
2626 "addr 0x%02x\n", adap_id, address_list[i]);
2627 temp_client->addr = address_list[i];
2628 err = i2c_detect_address(temp_client, driver);
2637 int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
2639 return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2640 I2C_SMBUS_QUICK, NULL) >= 0;
2642 EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
2645 i2c_new_probed_device(struct i2c_adapter *adap,
2646 struct i2c_board_info *info,
2647 unsigned short const *addr_list,
2648 int (*probe)(struct i2c_adapter *, unsigned short addr))
2653 probe = i2c_default_probe;
2655 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
2656 /* Check address validity */
2657 if (i2c_check_7bit_addr_validity_strict(addr_list[i]) < 0) {
2658 dev_warn(&adap->dev, "Invalid 7-bit address "
2659 "0x%02x\n", addr_list[i]);
2663 /* Check address availability (7 bit, no need to encode flags) */
2664 if (i2c_check_addr_busy(adap, addr_list[i])) {
2665 dev_dbg(&adap->dev, "Address 0x%02x already in "
2666 "use, not probing\n", addr_list[i]);
2670 /* Test address responsiveness */
2671 if (probe(adap, addr_list[i]))
2675 if (addr_list[i] == I2C_CLIENT_END) {
2676 dev_dbg(&adap->dev, "Probing failed, no device found\n");
2680 info->addr = addr_list[i];
2681 return i2c_new_device(adap, info);
2683 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
2685 struct i2c_adapter *i2c_get_adapter(int nr)
2687 struct i2c_adapter *adapter;
2689 mutex_lock(&core_lock);
2690 adapter = idr_find(&i2c_adapter_idr, nr);
2694 if (try_module_get(adapter->owner))
2695 get_device(&adapter->dev);
2700 mutex_unlock(&core_lock);
2703 EXPORT_SYMBOL(i2c_get_adapter);
2705 void i2c_put_adapter(struct i2c_adapter *adap)
2710 put_device(&adap->dev);
2711 module_put(adap->owner);
2713 EXPORT_SYMBOL(i2c_put_adapter);
2715 /* The SMBus parts */
2717 #define POLY (0x1070U << 3)
2718 static u8 crc8(u16 data)
2722 for (i = 0; i < 8; i++) {
2727 return (u8)(data >> 8);
2730 /* Incremental CRC8 over count bytes in the array pointed to by p */
2731 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
2735 for (i = 0; i < count; i++)
2736 crc = crc8((crc ^ p[i]) << 8);
2740 /* Assume a 7-bit address, which is reasonable for SMBus */
2741 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
2743 /* The address will be sent first */
2744 u8 addr = i2c_8bit_addr_from_msg(msg);
2745 pec = i2c_smbus_pec(pec, &addr, 1);
2747 /* The data buffer follows */
2748 return i2c_smbus_pec(pec, msg->buf, msg->len);
2751 /* Used for write only transactions */
2752 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
2754 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
2758 /* Return <0 on CRC error
2759 If there was a write before this read (most cases) we need to take the
2760 partial CRC from the write part into account.
2761 Note that this function does modify the message (we need to decrease the
2762 message length to hide the CRC byte from the caller). */
2763 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
2765 u8 rpec = msg->buf[--msg->len];
2766 cpec = i2c_smbus_msg_pec(cpec, msg);
2769 pr_debug("Bad PEC 0x%02x vs. 0x%02x\n",
2777 * i2c_smbus_read_byte - SMBus "receive byte" protocol
2778 * @client: Handle to slave device
2780 * This executes the SMBus "receive byte" protocol, returning negative errno
2781 * else the byte received from the device.
2783 s32 i2c_smbus_read_byte(const struct i2c_client *client)
2785 union i2c_smbus_data data;
2788 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2790 I2C_SMBUS_BYTE, &data);
2791 return (status < 0) ? status : data.byte;
2793 EXPORT_SYMBOL(i2c_smbus_read_byte);
2796 * i2c_smbus_write_byte - SMBus "send byte" protocol
2797 * @client: Handle to slave device
2798 * @value: Byte to be sent
2800 * This executes the SMBus "send byte" protocol, returning negative errno
2801 * else zero on success.
2803 s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
2805 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2806 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
2808 EXPORT_SYMBOL(i2c_smbus_write_byte);
2811 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
2812 * @client: Handle to slave device
2813 * @command: Byte interpreted by slave
2815 * This executes the SMBus "read byte" protocol, returning negative errno
2816 * else a data byte received from the device.
2818 s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
2820 union i2c_smbus_data data;
2823 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2824 I2C_SMBUS_READ, command,
2825 I2C_SMBUS_BYTE_DATA, &data);
2826 return (status < 0) ? status : data.byte;
2828 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
2831 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
2832 * @client: Handle to slave device
2833 * @command: Byte interpreted by slave
2834 * @value: Byte being written
2836 * This executes the SMBus "write byte" protocol, returning negative errno
2837 * else zero on success.
2839 s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
2842 union i2c_smbus_data data;
2844 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2845 I2C_SMBUS_WRITE, command,
2846 I2C_SMBUS_BYTE_DATA, &data);
2848 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
2851 * i2c_smbus_read_word_data - SMBus "read word" protocol
2852 * @client: Handle to slave device
2853 * @command: Byte interpreted by slave
2855 * This executes the SMBus "read word" protocol, returning negative errno
2856 * else a 16-bit unsigned "word" received from the device.
2858 s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
2860 union i2c_smbus_data data;
2863 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2864 I2C_SMBUS_READ, command,
2865 I2C_SMBUS_WORD_DATA, &data);
2866 return (status < 0) ? status : data.word;
2868 EXPORT_SYMBOL(i2c_smbus_read_word_data);
2871 * i2c_smbus_write_word_data - SMBus "write word" protocol
2872 * @client: Handle to slave device
2873 * @command: Byte interpreted by slave
2874 * @value: 16-bit "word" being written
2876 * This executes the SMBus "write word" protocol, returning negative errno
2877 * else zero on success.
2879 s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
2882 union i2c_smbus_data data;
2884 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2885 I2C_SMBUS_WRITE, command,
2886 I2C_SMBUS_WORD_DATA, &data);
2888 EXPORT_SYMBOL(i2c_smbus_write_word_data);
2891 * i2c_smbus_read_block_data - SMBus "block read" protocol
2892 * @client: Handle to slave device
2893 * @command: Byte interpreted by slave
2894 * @values: Byte array into which data will be read; big enough to hold
2895 * the data returned by the slave. SMBus allows at most 32 bytes.
2897 * This executes the SMBus "block read" protocol, returning negative errno
2898 * else the number of data bytes in the slave's response.
2900 * Note that using this function requires that the client's adapter support
2901 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
2902 * support this; its emulation through I2C messaging relies on a specific
2903 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
2905 s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
2908 union i2c_smbus_data data;
2911 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2912 I2C_SMBUS_READ, command,
2913 I2C_SMBUS_BLOCK_DATA, &data);
2917 memcpy(values, &data.block[1], data.block[0]);
2918 return data.block[0];
2920 EXPORT_SYMBOL(i2c_smbus_read_block_data);
2923 * i2c_smbus_write_block_data - SMBus "block write" protocol
2924 * @client: Handle to slave device
2925 * @command: Byte interpreted by slave
2926 * @length: Size of data block; SMBus allows at most 32 bytes
2927 * @values: Byte array which will be written.
2929 * This executes the SMBus "block write" protocol, returning negative errno
2930 * else zero on success.
2932 s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
2933 u8 length, const u8 *values)
2935 union i2c_smbus_data data;
2937 if (length > I2C_SMBUS_BLOCK_MAX)
2938 length = I2C_SMBUS_BLOCK_MAX;
2939 data.block[0] = length;
2940 memcpy(&data.block[1], values, length);
2941 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2942 I2C_SMBUS_WRITE, command,
2943 I2C_SMBUS_BLOCK_DATA, &data);
2945 EXPORT_SYMBOL(i2c_smbus_write_block_data);
2947 /* Returns the number of read bytes */
2948 s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
2949 u8 length, u8 *values)
2951 union i2c_smbus_data data;
2954 if (length > I2C_SMBUS_BLOCK_MAX)
2955 length = I2C_SMBUS_BLOCK_MAX;
2956 data.block[0] = length;
2957 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2958 I2C_SMBUS_READ, command,
2959 I2C_SMBUS_I2C_BLOCK_DATA, &data);
2963 memcpy(values, &data.block[1], data.block[0]);
2964 return data.block[0];
2966 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
2968 s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
2969 u8 length, const u8 *values)
2971 union i2c_smbus_data data;
2973 if (length > I2C_SMBUS_BLOCK_MAX)
2974 length = I2C_SMBUS_BLOCK_MAX;
2975 data.block[0] = length;
2976 memcpy(data.block + 1, values, length);
2977 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2978 I2C_SMBUS_WRITE, command,
2979 I2C_SMBUS_I2C_BLOCK_DATA, &data);
2981 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
2983 /* Simulate a SMBus command using the i2c protocol
2984 No checking of parameters is done! */
2985 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
2986 unsigned short flags,
2987 char read_write, u8 command, int size,
2988 union i2c_smbus_data *data)
2990 /* So we need to generate a series of msgs. In the case of writing, we
2991 need to use only one message; when reading, we need two. We initialize
2992 most things with sane defaults, to keep the code below somewhat
2994 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
2995 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
2996 int num = read_write == I2C_SMBUS_READ ? 2 : 1;
3000 struct i2c_msg msg[2] = {
3008 .flags = flags | I2C_M_RD,
3014 msgbuf0[0] = command;
3016 case I2C_SMBUS_QUICK:
3018 /* Special case: The read/write field is used as data */
3019 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
3023 case I2C_SMBUS_BYTE:
3024 if (read_write == I2C_SMBUS_READ) {
3025 /* Special case: only a read! */
3026 msg[0].flags = I2C_M_RD | flags;
3030 case I2C_SMBUS_BYTE_DATA:
3031 if (read_write == I2C_SMBUS_READ)
3035 msgbuf0[1] = data->byte;
3038 case I2C_SMBUS_WORD_DATA:
3039 if (read_write == I2C_SMBUS_READ)
3043 msgbuf0[1] = data->word & 0xff;
3044 msgbuf0[2] = data->word >> 8;
3047 case I2C_SMBUS_PROC_CALL:
3048 num = 2; /* Special case */
3049 read_write = I2C_SMBUS_READ;
3052 msgbuf0[1] = data->word & 0xff;
3053 msgbuf0[2] = data->word >> 8;
3055 case I2C_SMBUS_BLOCK_DATA:
3056 if (read_write == I2C_SMBUS_READ) {
3057 msg[1].flags |= I2C_M_RECV_LEN;
3058 msg[1].len = 1; /* block length will be added by
3059 the underlying bus driver */
3061 msg[0].len = data->block[0] + 2;
3062 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
3063 dev_err(&adapter->dev,
3064 "Invalid block write size %d\n",
3068 for (i = 1; i < msg[0].len; i++)
3069 msgbuf0[i] = data->block[i-1];
3072 case I2C_SMBUS_BLOCK_PROC_CALL:
3073 num = 2; /* Another special case */
3074 read_write = I2C_SMBUS_READ;
3075 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
3076 dev_err(&adapter->dev,
3077 "Invalid block write size %d\n",
3081 msg[0].len = data->block[0] + 2;
3082 for (i = 1; i < msg[0].len; i++)
3083 msgbuf0[i] = data->block[i-1];
3084 msg[1].flags |= I2C_M_RECV_LEN;
3085 msg[1].len = 1; /* block length will be added by
3086 the underlying bus driver */
3088 case I2C_SMBUS_I2C_BLOCK_DATA:
3089 if (read_write == I2C_SMBUS_READ) {
3090 msg[1].len = data->block[0];
3092 msg[0].len = data->block[0] + 1;
3093 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
3094 dev_err(&adapter->dev,
3095 "Invalid block write size %d\n",
3099 for (i = 1; i <= data->block[0]; i++)
3100 msgbuf0[i] = data->block[i];
3104 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
3108 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
3109 && size != I2C_SMBUS_I2C_BLOCK_DATA);
3111 /* Compute PEC if first message is a write */
3112 if (!(msg[0].flags & I2C_M_RD)) {
3113 if (num == 1) /* Write only */
3114 i2c_smbus_add_pec(&msg[0]);
3115 else /* Write followed by read */
3116 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
3118 /* Ask for PEC if last message is a read */
3119 if (msg[num-1].flags & I2C_M_RD)
3123 status = i2c_transfer(adapter, msg, num);
3127 /* Check PEC if last message is a read */
3128 if (i && (msg[num-1].flags & I2C_M_RD)) {
3129 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
3134 if (read_write == I2C_SMBUS_READ)
3136 case I2C_SMBUS_BYTE:
3137 data->byte = msgbuf0[0];
3139 case I2C_SMBUS_BYTE_DATA:
3140 data->byte = msgbuf1[0];
3142 case I2C_SMBUS_WORD_DATA:
3143 case I2C_SMBUS_PROC_CALL:
3144 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
3146 case I2C_SMBUS_I2C_BLOCK_DATA:
3147 for (i = 0; i < data->block[0]; i++)
3148 data->block[i+1] = msgbuf1[i];
3150 case I2C_SMBUS_BLOCK_DATA:
3151 case I2C_SMBUS_BLOCK_PROC_CALL:
3152 for (i = 0; i < msgbuf1[0] + 1; i++)
3153 data->block[i] = msgbuf1[i];
3160 * i2c_smbus_xfer - execute SMBus protocol operations
3161 * @adapter: Handle to I2C bus
3162 * @addr: Address of SMBus slave on that bus
3163 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
3164 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
3165 * @command: Byte interpreted by slave, for protocols which use such bytes
3166 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
3167 * @data: Data to be read or written
3169 * This executes an SMBus protocol operation, and returns a negative
3170 * errno code else zero on success.
3172 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
3173 char read_write, u8 command, int protocol,
3174 union i2c_smbus_data *data)
3176 unsigned long orig_jiffies;
3180 /* If enabled, the following two tracepoints are conditional on
3181 * read_write and protocol.
3183 trace_smbus_write(adapter, addr, flags, read_write,
3184 command, protocol, data);
3185 trace_smbus_read(adapter, addr, flags, read_write,
3188 flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
3190 if (adapter->algo->smbus_xfer) {
3191 i2c_lock_bus(adapter, I2C_LOCK_SEGMENT);
3193 /* Retry automatically on arbitration loss */
3194 orig_jiffies = jiffies;
3195 for (res = 0, try = 0; try <= adapter->retries; try++) {
3196 res = adapter->algo->smbus_xfer(adapter, addr, flags,
3197 read_write, command,
3201 if (time_after(jiffies,
3202 orig_jiffies + adapter->timeout))
3205 i2c_unlock_bus(adapter, I2C_LOCK_SEGMENT);
3207 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
3210 * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
3211 * implement native support for the SMBus operation.
3215 res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
3216 command, protocol, data);
3219 /* If enabled, the reply tracepoint is conditional on read_write. */
3220 trace_smbus_reply(adapter, addr, flags, read_write,
3221 command, protocol, data);
3222 trace_smbus_result(adapter, addr, flags, read_write,
3223 command, protocol, res);
3227 EXPORT_SYMBOL(i2c_smbus_xfer);
3230 * i2c_smbus_read_i2c_block_data_or_emulated - read block or emulate
3231 * @client: Handle to slave device
3232 * @command: Byte interpreted by slave
3233 * @length: Size of data block; SMBus allows at most I2C_SMBUS_BLOCK_MAX bytes
3234 * @values: Byte array into which data will be read; big enough to hold
3235 * the data returned by the slave. SMBus allows at most
3236 * I2C_SMBUS_BLOCK_MAX bytes.
3238 * This executes the SMBus "block read" protocol if supported by the adapter.
3239 * If block read is not supported, it emulates it using either word or byte
3240 * read protocols depending on availability.
3242 * The addresses of the I2C slave device that are accessed with this function
3243 * must be mapped to a linear region, so that a block read will have the same
3244 * effect as a byte read. Before using this function you must double-check
3245 * if the I2C slave does support exchanging a block transfer with a byte
3248 s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
3249 u8 command, u8 length, u8 *values)
3254 if (length > I2C_SMBUS_BLOCK_MAX)
3255 length = I2C_SMBUS_BLOCK_MAX;
3257 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK))
3258 return i2c_smbus_read_i2c_block_data(client, command, length, values);
3260 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA))
3263 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_WORD_DATA)) {
3264 while ((i + 2) <= length) {
3265 status = i2c_smbus_read_word_data(client, command + i);
3268 values[i] = status & 0xff;
3269 values[i + 1] = status >> 8;
3274 while (i < length) {
3275 status = i2c_smbus_read_byte_data(client, command + i);
3284 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data_or_emulated);
3286 #if IS_ENABLED(CONFIG_I2C_SLAVE)
3287 int i2c_slave_register(struct i2c_client *client, i2c_slave_cb_t slave_cb)
3291 if (!client || !slave_cb) {
3292 WARN(1, "insufficent data\n");
3296 if (!(client->flags & I2C_CLIENT_SLAVE))
3297 dev_warn(&client->dev, "%s: client slave flag not set. You might see address collisions\n",
3300 if (!(client->flags & I2C_CLIENT_TEN)) {
3301 /* Enforce stricter address checking */
3302 ret = i2c_check_7bit_addr_validity_strict(client->addr);
3304 dev_err(&client->dev, "%s: invalid address\n", __func__);
3309 if (!client->adapter->algo->reg_slave) {
3310 dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
3314 client->slave_cb = slave_cb;
3316 i2c_lock_adapter(client->adapter);
3317 ret = client->adapter->algo->reg_slave(client);
3318 i2c_unlock_adapter(client->adapter);
3321 client->slave_cb = NULL;
3322 dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
3327 EXPORT_SYMBOL_GPL(i2c_slave_register);
3329 int i2c_slave_unregister(struct i2c_client *client)
3333 if (!client->adapter->algo->unreg_slave) {
3334 dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
3338 i2c_lock_adapter(client->adapter);
3339 ret = client->adapter->algo->unreg_slave(client);
3340 i2c_unlock_adapter(client->adapter);
3343 client->slave_cb = NULL;
3345 dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
3349 EXPORT_SYMBOL_GPL(i2c_slave_unregister);
3352 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
3353 MODULE_DESCRIPTION("I2C-Bus main module");
3354 MODULE_LICENSE("GPL");