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 #include <linux/module.h>
31 #include <linux/kernel.h>
32 #include <linux/delay.h>
33 #include <linux/errno.h>
34 #include <linux/gpio.h>
35 #include <linux/slab.h>
36 #include <linux/i2c.h>
37 #include <linux/init.h>
38 #include <linux/idr.h>
39 #include <linux/mutex.h>
41 #include <linux/of_device.h>
42 #include <linux/of_irq.h>
43 #include <linux/clk/clk-conf.h>
44 #include <linux/completion.h>
45 #include <linux/hardirq.h>
46 #include <linux/irqflags.h>
47 #include <linux/rwsem.h>
48 #include <linux/pm_runtime.h>
49 #include <linux/pm_domain.h>
50 #include <linux/acpi.h>
51 #include <linux/jump_label.h>
52 #include <asm/uaccess.h>
53 #include <linux/err.h>
57 #define CREATE_TRACE_POINTS
58 #include <trace/events/i2c.h>
60 /* core_lock protects i2c_adapter_idr, and guarantees
61 that device detection, deletion of detected devices, and attach_adapter
62 calls are serialized */
63 static DEFINE_MUTEX(core_lock);
64 static DEFINE_IDR(i2c_adapter_idr);
66 static struct device_type i2c_client_type;
67 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
69 static struct static_key i2c_trace_msg = STATIC_KEY_INIT_FALSE;
71 void i2c_transfer_trace_reg(void)
73 static_key_slow_inc(&i2c_trace_msg);
76 void i2c_transfer_trace_unreg(void)
78 static_key_slow_dec(&i2c_trace_msg);
81 #if defined(CONFIG_ACPI)
82 struct acpi_i2c_handler_data {
83 struct acpi_connection_info info;
84 struct i2c_adapter *adapter;
97 static int acpi_i2c_add_resource(struct acpi_resource *ares, void *data)
99 struct i2c_board_info *info = data;
101 if (ares->type == ACPI_RESOURCE_TYPE_SERIAL_BUS) {
102 struct acpi_resource_i2c_serialbus *sb;
104 sb = &ares->data.i2c_serial_bus;
105 if (sb->type == ACPI_RESOURCE_SERIAL_TYPE_I2C) {
106 info->addr = sb->slave_address;
107 if (sb->access_mode == ACPI_I2C_10BIT_MODE)
108 info->flags |= I2C_CLIENT_TEN;
110 } else if (info->irq < 0) {
113 if (acpi_dev_resource_interrupt(ares, 0, &r))
117 /* Tell the ACPI core to skip this resource */
121 static acpi_status acpi_i2c_add_device(acpi_handle handle, u32 level,
122 void *data, void **return_value)
124 struct i2c_adapter *adapter = data;
125 struct list_head resource_list;
126 struct i2c_board_info info;
127 struct acpi_device *adev;
130 if (acpi_bus_get_device(handle, &adev))
132 if (acpi_bus_get_status(adev) || !adev->status.present)
135 memset(&info, 0, sizeof(info));
136 info.acpi_node.companion = adev;
139 INIT_LIST_HEAD(&resource_list);
140 ret = acpi_dev_get_resources(adev, &resource_list,
141 acpi_i2c_add_resource, &info);
142 acpi_dev_free_resource_list(&resource_list);
144 if (ret < 0 || !info.addr)
147 adev->power.flags.ignore_parent = true;
148 strlcpy(info.type, dev_name(&adev->dev), sizeof(info.type));
149 if (!i2c_new_device(adapter, &info)) {
150 adev->power.flags.ignore_parent = false;
151 dev_err(&adapter->dev,
152 "failed to add I2C device %s from ACPI\n",
153 dev_name(&adev->dev));
160 * acpi_i2c_register_devices - enumerate I2C slave devices behind adapter
161 * @adap: pointer to adapter
163 * Enumerate all I2C slave devices behind this adapter by walking the ACPI
164 * namespace. When a device is found it will be added to the Linux device
165 * model and bound to the corresponding ACPI handle.
167 static void acpi_i2c_register_devices(struct i2c_adapter *adap)
172 if (!adap->dev.parent)
175 handle = ACPI_HANDLE(adap->dev.parent);
179 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1,
180 acpi_i2c_add_device, NULL,
182 if (ACPI_FAILURE(status))
183 dev_warn(&adap->dev, "failed to enumerate I2C slaves\n");
186 #else /* CONFIG_ACPI */
187 static inline void acpi_i2c_register_devices(struct i2c_adapter *adap) { }
188 #endif /* CONFIG_ACPI */
190 #ifdef CONFIG_ACPI_I2C_OPREGION
191 static int acpi_gsb_i2c_read_bytes(struct i2c_client *client,
192 u8 cmd, u8 *data, u8 data_len)
195 struct i2c_msg msgs[2];
199 buffer = kzalloc(data_len, GFP_KERNEL);
203 msgs[0].addr = client->addr;
204 msgs[0].flags = client->flags;
208 msgs[1].addr = client->addr;
209 msgs[1].flags = client->flags | I2C_M_RD;
210 msgs[1].len = data_len;
211 msgs[1].buf = buffer;
213 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
215 dev_err(&client->adapter->dev, "i2c read failed\n");
217 memcpy(data, buffer, data_len);
223 static int acpi_gsb_i2c_write_bytes(struct i2c_client *client,
224 u8 cmd, u8 *data, u8 data_len)
227 struct i2c_msg msgs[1];
231 buffer = kzalloc(data_len + 1, GFP_KERNEL);
236 memcpy(buffer + 1, data, data_len);
238 msgs[0].addr = client->addr;
239 msgs[0].flags = client->flags;
240 msgs[0].len = data_len + 1;
241 msgs[0].buf = buffer;
243 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
245 dev_err(&client->adapter->dev, "i2c write failed\n");
252 acpi_i2c_space_handler(u32 function, acpi_physical_address command,
253 u32 bits, u64 *value64,
254 void *handler_context, void *region_context)
256 struct gsb_buffer *gsb = (struct gsb_buffer *)value64;
257 struct acpi_i2c_handler_data *data = handler_context;
258 struct acpi_connection_info *info = &data->info;
259 struct acpi_resource_i2c_serialbus *sb;
260 struct i2c_adapter *adapter = data->adapter;
261 struct i2c_client client;
262 struct acpi_resource *ares;
263 u32 accessor_type = function >> 16;
264 u8 action = function & ACPI_IO_MASK;
268 ret = acpi_buffer_to_resource(info->connection, info->length, &ares);
269 if (ACPI_FAILURE(ret))
272 if (!value64 || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) {
273 ret = AE_BAD_PARAMETER;
277 sb = &ares->data.i2c_serial_bus;
278 if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C) {
279 ret = AE_BAD_PARAMETER;
283 memset(&client, 0, sizeof(client));
284 client.adapter = adapter;
285 client.addr = sb->slave_address;
288 if (sb->access_mode == ACPI_I2C_10BIT_MODE)
289 client.flags |= I2C_CLIENT_TEN;
291 switch (accessor_type) {
292 case ACPI_GSB_ACCESS_ATTRIB_SEND_RCV:
293 if (action == ACPI_READ) {
294 status = i2c_smbus_read_byte(&client);
300 status = i2c_smbus_write_byte(&client, gsb->bdata);
304 case ACPI_GSB_ACCESS_ATTRIB_BYTE:
305 if (action == ACPI_READ) {
306 status = i2c_smbus_read_byte_data(&client, command);
312 status = i2c_smbus_write_byte_data(&client, command,
317 case ACPI_GSB_ACCESS_ATTRIB_WORD:
318 if (action == ACPI_READ) {
319 status = i2c_smbus_read_word_data(&client, command);
325 status = i2c_smbus_write_word_data(&client, command,
330 case ACPI_GSB_ACCESS_ATTRIB_BLOCK:
331 if (action == ACPI_READ) {
332 status = i2c_smbus_read_block_data(&client, command,
339 status = i2c_smbus_write_block_data(&client, command,
340 gsb->len, gsb->data);
344 case ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE:
345 if (action == ACPI_READ) {
346 status = acpi_gsb_i2c_read_bytes(&client, command,
347 gsb->data, info->access_length);
351 status = acpi_gsb_i2c_write_bytes(&client, command,
352 gsb->data, info->access_length);
357 pr_info("protocol(0x%02x) is not supported.\n", accessor_type);
358 ret = AE_BAD_PARAMETER;
362 gsb->status = status;
370 static int acpi_i2c_install_space_handler(struct i2c_adapter *adapter)
373 struct acpi_i2c_handler_data *data;
376 if (!adapter->dev.parent)
379 handle = ACPI_HANDLE(adapter->dev.parent);
384 data = kzalloc(sizeof(struct acpi_i2c_handler_data),
389 data->adapter = adapter;
390 status = acpi_bus_attach_private_data(handle, (void *)data);
391 if (ACPI_FAILURE(status)) {
396 status = acpi_install_address_space_handler(handle,
397 ACPI_ADR_SPACE_GSBUS,
398 &acpi_i2c_space_handler,
401 if (ACPI_FAILURE(status)) {
402 dev_err(&adapter->dev, "Error installing i2c space handler\n");
403 acpi_bus_detach_private_data(handle);
408 acpi_walk_dep_device_list(handle);
412 static void acpi_i2c_remove_space_handler(struct i2c_adapter *adapter)
415 struct acpi_i2c_handler_data *data;
418 if (!adapter->dev.parent)
421 handle = ACPI_HANDLE(adapter->dev.parent);
426 acpi_remove_address_space_handler(handle,
427 ACPI_ADR_SPACE_GSBUS,
428 &acpi_i2c_space_handler);
430 status = acpi_bus_get_private_data(handle, (void **)&data);
431 if (ACPI_SUCCESS(status))
434 acpi_bus_detach_private_data(handle);
436 #else /* CONFIG_ACPI_I2C_OPREGION */
437 static inline void acpi_i2c_remove_space_handler(struct i2c_adapter *adapter)
440 static inline int acpi_i2c_install_space_handler(struct i2c_adapter *adapter)
442 #endif /* CONFIG_ACPI_I2C_OPREGION */
444 /* ------------------------------------------------------------------------- */
446 static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
447 const struct i2c_client *client)
449 while (id->name[0]) {
450 if (strcmp(client->name, id->name) == 0)
457 static int i2c_device_match(struct device *dev, struct device_driver *drv)
459 struct i2c_client *client = i2c_verify_client(dev);
460 struct i2c_driver *driver;
465 /* Attempt an OF style match */
466 if (of_driver_match_device(dev, drv))
469 /* Then ACPI style match */
470 if (acpi_driver_match_device(dev, drv))
473 driver = to_i2c_driver(drv);
474 /* match on an id table if there is one */
475 if (driver->id_table)
476 return i2c_match_id(driver->id_table, client) != NULL;
482 /* uevent helps with hotplug: modprobe -q $(MODALIAS) */
483 static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
485 struct i2c_client *client = to_i2c_client(dev);
488 rc = acpi_device_uevent_modalias(dev, env);
492 if (add_uevent_var(env, "MODALIAS=%s%s",
493 I2C_MODULE_PREFIX, client->name))
495 dev_dbg(dev, "uevent\n");
499 /* i2c bus recovery routines */
500 static int get_scl_gpio_value(struct i2c_adapter *adap)
502 return gpio_get_value(adap->bus_recovery_info->scl_gpio);
505 static void set_scl_gpio_value(struct i2c_adapter *adap, int val)
507 gpio_set_value(adap->bus_recovery_info->scl_gpio, val);
510 static int get_sda_gpio_value(struct i2c_adapter *adap)
512 return gpio_get_value(adap->bus_recovery_info->sda_gpio);
515 static int i2c_get_gpios_for_recovery(struct i2c_adapter *adap)
517 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
518 struct device *dev = &adap->dev;
521 ret = gpio_request_one(bri->scl_gpio, GPIOF_OPEN_DRAIN |
522 GPIOF_OUT_INIT_HIGH, "i2c-scl");
524 dev_warn(dev, "Can't get SCL gpio: %d\n", bri->scl_gpio);
529 if (gpio_request_one(bri->sda_gpio, GPIOF_IN, "i2c-sda")) {
530 /* work without SDA polling */
531 dev_warn(dev, "Can't get SDA gpio: %d. Not using SDA polling\n",
540 static void i2c_put_gpios_for_recovery(struct i2c_adapter *adap)
542 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
545 gpio_free(bri->sda_gpio);
547 gpio_free(bri->scl_gpio);
551 * We are generating clock pulses. ndelay() determines durating of clk pulses.
552 * We will generate clock with rate 100 KHz and so duration of both clock levels
553 * is: delay in ns = (10^6 / 100) / 2
555 #define RECOVERY_NDELAY 5000
556 #define RECOVERY_CLK_CNT 9
558 static int i2c_generic_recovery(struct i2c_adapter *adap)
560 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
561 int i = 0, val = 1, ret = 0;
563 if (bri->prepare_recovery)
564 bri->prepare_recovery(bri);
567 * By this time SCL is high, as we need to give 9 falling-rising edges
569 while (i++ < RECOVERY_CLK_CNT * 2) {
571 /* Break if SDA is high */
572 if (bri->get_sda && bri->get_sda(adap))
574 /* SCL shouldn't be low here */
575 if (!bri->get_scl(adap)) {
577 "SCL is stuck low, exit recovery\n");
584 bri->set_scl(adap, val);
585 ndelay(RECOVERY_NDELAY);
588 if (bri->unprepare_recovery)
589 bri->unprepare_recovery(bri);
594 int i2c_generic_scl_recovery(struct i2c_adapter *adap)
596 adap->bus_recovery_info->set_scl(adap, 1);
597 return i2c_generic_recovery(adap);
600 int i2c_generic_gpio_recovery(struct i2c_adapter *adap)
604 ret = i2c_get_gpios_for_recovery(adap);
608 ret = i2c_generic_recovery(adap);
609 i2c_put_gpios_for_recovery(adap);
614 int i2c_recover_bus(struct i2c_adapter *adap)
616 if (!adap->bus_recovery_info)
619 dev_dbg(&adap->dev, "Trying i2c bus recovery\n");
620 return adap->bus_recovery_info->recover_bus(adap);
623 static int i2c_device_probe(struct device *dev)
625 struct i2c_client *client = i2c_verify_client(dev);
626 struct i2c_driver *driver;
632 if (!client->irq && dev->of_node) {
633 int irq = of_irq_get(dev->of_node, 0);
635 if (irq == -EPROBE_DEFER)
643 driver = to_i2c_driver(dev->driver);
644 if (!driver->probe || !driver->id_table)
647 if (!device_can_wakeup(&client->dev))
648 device_init_wakeup(&client->dev,
649 client->flags & I2C_CLIENT_WAKE);
650 dev_dbg(dev, "probe\n");
652 status = of_clk_set_defaults(dev->of_node, false);
656 status = dev_pm_domain_attach(&client->dev, true);
657 if (status != -EPROBE_DEFER) {
658 status = driver->probe(client, i2c_match_id(driver->id_table,
661 dev_pm_domain_detach(&client->dev, true);
667 static int i2c_device_remove(struct device *dev)
669 struct i2c_client *client = i2c_verify_client(dev);
670 struct i2c_driver *driver;
673 if (!client || !dev->driver)
676 driver = to_i2c_driver(dev->driver);
677 if (driver->remove) {
678 dev_dbg(dev, "remove\n");
679 status = driver->remove(client);
683 irq_dispose_mapping(client->irq);
685 dev_pm_domain_detach(&client->dev, true);
689 static void i2c_device_shutdown(struct device *dev)
691 struct i2c_client *client = i2c_verify_client(dev);
692 struct i2c_driver *driver;
694 if (!client || !dev->driver)
696 driver = to_i2c_driver(dev->driver);
697 if (driver->shutdown)
698 driver->shutdown(client);
701 static void i2c_client_dev_release(struct device *dev)
703 kfree(to_i2c_client(dev));
707 show_name(struct device *dev, struct device_attribute *attr, char *buf)
709 return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
710 to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
714 show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
716 struct i2c_client *client = to_i2c_client(dev);
719 len = acpi_device_modalias(dev, buf, PAGE_SIZE -1);
723 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
726 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
727 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
729 static struct attribute *i2c_dev_attrs[] = {
731 /* modalias helps coldplug: modprobe $(cat .../modalias) */
732 &dev_attr_modalias.attr,
736 static struct attribute_group i2c_dev_attr_group = {
737 .attrs = i2c_dev_attrs,
740 static const struct attribute_group *i2c_dev_attr_groups[] = {
745 struct bus_type i2c_bus_type = {
747 .match = i2c_device_match,
748 .probe = i2c_device_probe,
749 .remove = i2c_device_remove,
750 .shutdown = i2c_device_shutdown,
752 EXPORT_SYMBOL_GPL(i2c_bus_type);
754 static struct device_type i2c_client_type = {
755 .groups = i2c_dev_attr_groups,
756 .uevent = i2c_device_uevent,
757 .release = i2c_client_dev_release,
762 * i2c_verify_client - return parameter as i2c_client, or NULL
763 * @dev: device, probably from some driver model iterator
765 * When traversing the driver model tree, perhaps using driver model
766 * iterators like @device_for_each_child(), you can't assume very much
767 * about the nodes you find. Use this function to avoid oopses caused
768 * by wrongly treating some non-I2C device as an i2c_client.
770 struct i2c_client *i2c_verify_client(struct device *dev)
772 return (dev->type == &i2c_client_type)
776 EXPORT_SYMBOL(i2c_verify_client);
779 /* This is a permissive address validity check, I2C address map constraints
780 * are purposely not enforced, except for the general call address. */
781 static int i2c_check_client_addr_validity(const struct i2c_client *client)
783 if (client->flags & I2C_CLIENT_TEN) {
784 /* 10-bit address, all values are valid */
785 if (client->addr > 0x3ff)
788 /* 7-bit address, reject the general call address */
789 if (client->addr == 0x00 || client->addr > 0x7f)
795 /* And this is a strict address validity check, used when probing. If a
796 * device uses a reserved address, then it shouldn't be probed. 7-bit
797 * addressing is assumed, 10-bit address devices are rare and should be
798 * explicitly enumerated. */
799 static int i2c_check_addr_validity(unsigned short addr)
802 * Reserved addresses per I2C specification:
803 * 0x00 General call address / START byte
805 * 0x02 Reserved for different bus format
806 * 0x03 Reserved for future purposes
807 * 0x04-0x07 Hs-mode master code
808 * 0x78-0x7b 10-bit slave addressing
809 * 0x7c-0x7f Reserved for future purposes
811 if (addr < 0x08 || addr > 0x77)
816 static int __i2c_check_addr_busy(struct device *dev, void *addrp)
818 struct i2c_client *client = i2c_verify_client(dev);
819 int addr = *(int *)addrp;
821 if (client && client->addr == addr)
826 /* walk up mux tree */
827 static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
829 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
832 result = device_for_each_child(&adapter->dev, &addr,
833 __i2c_check_addr_busy);
835 if (!result && parent)
836 result = i2c_check_mux_parents(parent, addr);
841 /* recurse down mux tree */
842 static int i2c_check_mux_children(struct device *dev, void *addrp)
846 if (dev->type == &i2c_adapter_type)
847 result = device_for_each_child(dev, addrp,
848 i2c_check_mux_children);
850 result = __i2c_check_addr_busy(dev, addrp);
855 static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
857 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
861 result = i2c_check_mux_parents(parent, addr);
864 result = device_for_each_child(&adapter->dev, &addr,
865 i2c_check_mux_children);
871 * i2c_lock_adapter - Get exclusive access to an I2C bus segment
872 * @adapter: Target I2C bus segment
874 void i2c_lock_adapter(struct i2c_adapter *adapter)
876 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
879 i2c_lock_adapter(parent);
881 rt_mutex_lock(&adapter->bus_lock);
883 EXPORT_SYMBOL_GPL(i2c_lock_adapter);
886 * i2c_trylock_adapter - Try to get exclusive access to an I2C bus segment
887 * @adapter: Target I2C bus segment
889 static int i2c_trylock_adapter(struct i2c_adapter *adapter)
891 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
894 return i2c_trylock_adapter(parent);
896 return rt_mutex_trylock(&adapter->bus_lock);
900 * i2c_unlock_adapter - Release exclusive access to an I2C bus segment
901 * @adapter: Target I2C bus segment
903 void i2c_unlock_adapter(struct i2c_adapter *adapter)
905 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
908 i2c_unlock_adapter(parent);
910 rt_mutex_unlock(&adapter->bus_lock);
912 EXPORT_SYMBOL_GPL(i2c_unlock_adapter);
914 static void i2c_dev_set_name(struct i2c_adapter *adap,
915 struct i2c_client *client)
917 struct acpi_device *adev = ACPI_COMPANION(&client->dev);
920 dev_set_name(&client->dev, "i2c-%s", acpi_dev_name(adev));
924 /* For 10-bit clients, add an arbitrary offset to avoid collisions */
925 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
926 client->addr | ((client->flags & I2C_CLIENT_TEN)
931 * i2c_new_device - instantiate an i2c device
932 * @adap: the adapter managing the device
933 * @info: describes one I2C device; bus_num is ignored
936 * Create an i2c device. Binding is handled through driver model
937 * probe()/remove() methods. A driver may be bound to this device when we
938 * return from this function, or any later moment (e.g. maybe hotplugging will
939 * load the driver module). This call is not appropriate for use by mainboard
940 * initialization logic, which usually runs during an arch_initcall() long
941 * before any i2c_adapter could exist.
943 * This returns the new i2c client, which may be saved for later use with
944 * i2c_unregister_device(); or NULL to indicate an error.
947 i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
949 struct i2c_client *client;
952 client = kzalloc(sizeof *client, GFP_KERNEL);
956 client->adapter = adap;
958 client->dev.platform_data = info->platform_data;
961 client->dev.archdata = *info->archdata;
963 client->flags = info->flags;
964 client->addr = info->addr;
965 client->irq = info->irq;
967 strlcpy(client->name, info->type, sizeof(client->name));
969 /* Check for address validity */
970 status = i2c_check_client_addr_validity(client);
972 dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
973 client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
977 /* Check for address business */
978 status = i2c_check_addr_busy(adap, client->addr);
982 client->dev.parent = &client->adapter->dev;
983 client->dev.bus = &i2c_bus_type;
984 client->dev.type = &i2c_client_type;
985 client->dev.of_node = info->of_node;
986 ACPI_COMPANION_SET(&client->dev, info->acpi_node.companion);
988 i2c_dev_set_name(adap, client);
989 status = device_register(&client->dev);
993 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
994 client->name, dev_name(&client->dev));
999 dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
1000 "(%d)\n", client->name, client->addr, status);
1005 EXPORT_SYMBOL_GPL(i2c_new_device);
1009 * i2c_unregister_device - reverse effect of i2c_new_device()
1010 * @client: value returned from i2c_new_device()
1011 * Context: can sleep
1013 void i2c_unregister_device(struct i2c_client *client)
1015 device_unregister(&client->dev);
1017 EXPORT_SYMBOL_GPL(i2c_unregister_device);
1020 static const struct i2c_device_id dummy_id[] = {
1025 static int dummy_probe(struct i2c_client *client,
1026 const struct i2c_device_id *id)
1031 static int dummy_remove(struct i2c_client *client)
1036 static struct i2c_driver dummy_driver = {
1037 .driver.name = "dummy",
1038 .probe = dummy_probe,
1039 .remove = dummy_remove,
1040 .id_table = dummy_id,
1044 * i2c_new_dummy - return a new i2c device bound to a dummy driver
1045 * @adapter: the adapter managing the device
1046 * @address: seven bit address to be used
1047 * Context: can sleep
1049 * This returns an I2C client bound to the "dummy" driver, intended for use
1050 * with devices that consume multiple addresses. Examples of such chips
1051 * include various EEPROMS (like 24c04 and 24c08 models).
1053 * These dummy devices have two main uses. First, most I2C and SMBus calls
1054 * except i2c_transfer() need a client handle; the dummy will be that handle.
1055 * And second, this prevents the specified address from being bound to a
1058 * This returns the new i2c client, which should be saved for later use with
1059 * i2c_unregister_device(); or NULL to indicate an error.
1061 struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
1063 struct i2c_board_info info = {
1064 I2C_BOARD_INFO("dummy", address),
1067 return i2c_new_device(adapter, &info);
1069 EXPORT_SYMBOL_GPL(i2c_new_dummy);
1071 /* ------------------------------------------------------------------------- */
1073 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
1075 static void i2c_adapter_dev_release(struct device *dev)
1077 struct i2c_adapter *adap = to_i2c_adapter(dev);
1078 complete(&adap->dev_released);
1082 * This function is only needed for mutex_lock_nested, so it is never
1083 * called unless locking correctness checking is enabled. Thus we
1084 * make it inline to avoid a compiler warning. That's what gcc ends up
1087 static inline unsigned int i2c_adapter_depth(struct i2c_adapter *adapter)
1089 unsigned int depth = 0;
1091 while ((adapter = i2c_parent_is_i2c_adapter(adapter)))
1098 * Let users instantiate I2C devices through sysfs. This can be used when
1099 * platform initialization code doesn't contain the proper data for
1100 * whatever reason. Also useful for drivers that do device detection and
1101 * detection fails, either because the device uses an unexpected address,
1102 * or this is a compatible device with different ID register values.
1104 * Parameter checking may look overzealous, but we really don't want
1105 * the user to provide incorrect parameters.
1108 i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
1109 const char *buf, size_t count)
1111 struct i2c_adapter *adap = to_i2c_adapter(dev);
1112 struct i2c_board_info info;
1113 struct i2c_client *client;
1117 memset(&info, 0, sizeof(struct i2c_board_info));
1119 blank = strchr(buf, ' ');
1121 dev_err(dev, "%s: Missing parameters\n", "new_device");
1124 if (blank - buf > I2C_NAME_SIZE - 1) {
1125 dev_err(dev, "%s: Invalid device name\n", "new_device");
1128 memcpy(info.type, buf, blank - buf);
1130 /* Parse remaining parameters, reject extra parameters */
1131 res = sscanf(++blank, "%hi%c", &info.addr, &end);
1133 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
1136 if (res > 1 && end != '\n') {
1137 dev_err(dev, "%s: Extra parameters\n", "new_device");
1141 client = i2c_new_device(adap, &info);
1145 /* Keep track of the added device */
1146 mutex_lock(&adap->userspace_clients_lock);
1147 list_add_tail(&client->detected, &adap->userspace_clients);
1148 mutex_unlock(&adap->userspace_clients_lock);
1149 dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
1150 info.type, info.addr);
1156 * And of course let the users delete the devices they instantiated, if
1157 * they got it wrong. This interface can only be used to delete devices
1158 * instantiated by i2c_sysfs_new_device above. This guarantees that we
1159 * don't delete devices to which some kernel code still has references.
1161 * Parameter checking may look overzealous, but we really don't want
1162 * the user to delete the wrong device.
1165 i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
1166 const char *buf, size_t count)
1168 struct i2c_adapter *adap = to_i2c_adapter(dev);
1169 struct i2c_client *client, *next;
1170 unsigned short addr;
1174 /* Parse parameters, reject extra parameters */
1175 res = sscanf(buf, "%hi%c", &addr, &end);
1177 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
1180 if (res > 1 && end != '\n') {
1181 dev_err(dev, "%s: Extra parameters\n", "delete_device");
1185 /* Make sure the device was added through sysfs */
1187 mutex_lock_nested(&adap->userspace_clients_lock,
1188 i2c_adapter_depth(adap));
1189 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1191 if (client->addr == addr) {
1192 dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
1193 "delete_device", client->name, client->addr);
1195 list_del(&client->detected);
1196 i2c_unregister_device(client);
1201 mutex_unlock(&adap->userspace_clients_lock);
1204 dev_err(dev, "%s: Can't find device in list\n",
1209 static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
1210 static DEVICE_ATTR_IGNORE_LOCKDEP(delete_device, S_IWUSR, NULL,
1211 i2c_sysfs_delete_device);
1213 static struct attribute *i2c_adapter_attrs[] = {
1214 &dev_attr_name.attr,
1215 &dev_attr_new_device.attr,
1216 &dev_attr_delete_device.attr,
1220 static struct attribute_group i2c_adapter_attr_group = {
1221 .attrs = i2c_adapter_attrs,
1224 static const struct attribute_group *i2c_adapter_attr_groups[] = {
1225 &i2c_adapter_attr_group,
1229 struct device_type i2c_adapter_type = {
1230 .groups = i2c_adapter_attr_groups,
1231 .release = i2c_adapter_dev_release,
1233 EXPORT_SYMBOL_GPL(i2c_adapter_type);
1236 * i2c_verify_adapter - return parameter as i2c_adapter or NULL
1237 * @dev: device, probably from some driver model iterator
1239 * When traversing the driver model tree, perhaps using driver model
1240 * iterators like @device_for_each_child(), you can't assume very much
1241 * about the nodes you find. Use this function to avoid oopses caused
1242 * by wrongly treating some non-I2C device as an i2c_adapter.
1244 struct i2c_adapter *i2c_verify_adapter(struct device *dev)
1246 return (dev->type == &i2c_adapter_type)
1247 ? to_i2c_adapter(dev)
1250 EXPORT_SYMBOL(i2c_verify_adapter);
1252 #ifdef CONFIG_I2C_COMPAT
1253 static struct class_compat *i2c_adapter_compat_class;
1256 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
1258 struct i2c_devinfo *devinfo;
1260 down_read(&__i2c_board_lock);
1261 list_for_each_entry(devinfo, &__i2c_board_list, list) {
1262 if (devinfo->busnum == adapter->nr
1263 && !i2c_new_device(adapter,
1264 &devinfo->board_info))
1265 dev_err(&adapter->dev,
1266 "Can't create device at 0x%02x\n",
1267 devinfo->board_info.addr);
1269 up_read(&__i2c_board_lock);
1272 /* OF support code */
1274 #if IS_ENABLED(CONFIG_OF)
1275 static struct i2c_client *of_i2c_register_device(struct i2c_adapter *adap,
1276 struct device_node *node)
1278 struct i2c_client *result;
1279 struct i2c_board_info info = {};
1280 struct dev_archdata dev_ad = {};
1284 dev_dbg(&adap->dev, "of_i2c: register %s\n", node->full_name);
1286 if (of_modalias_node(node, info.type, sizeof(info.type)) < 0) {
1287 dev_err(&adap->dev, "of_i2c: modalias failure on %s\n",
1289 return ERR_PTR(-EINVAL);
1292 addr = of_get_property(node, "reg", &len);
1293 if (!addr || (len < sizeof(int))) {
1294 dev_err(&adap->dev, "of_i2c: invalid reg on %s\n",
1296 return ERR_PTR(-EINVAL);
1299 info.addr = be32_to_cpup(addr);
1300 if (info.addr > (1 << 10) - 1) {
1301 dev_err(&adap->dev, "of_i2c: invalid addr=%x on %s\n",
1302 info.addr, node->full_name);
1303 return ERR_PTR(-EINVAL);
1306 info.of_node = of_node_get(node);
1307 info.archdata = &dev_ad;
1309 if (of_get_property(node, "wakeup-source", NULL))
1310 info.flags |= I2C_CLIENT_WAKE;
1312 request_module("%s%s", I2C_MODULE_PREFIX, info.type);
1314 result = i2c_new_device(adap, &info);
1315 if (result == NULL) {
1316 dev_err(&adap->dev, "of_i2c: Failure registering %s\n",
1319 return ERR_PTR(-EINVAL);
1324 static void of_i2c_register_devices(struct i2c_adapter *adap)
1326 struct device_node *node;
1328 /* Only register child devices if the adapter has a node pointer set */
1329 if (!adap->dev.of_node)
1332 dev_dbg(&adap->dev, "of_i2c: walking child nodes\n");
1334 for_each_available_child_of_node(adap->dev.of_node, node)
1335 of_i2c_register_device(adap, node);
1338 static int of_dev_node_match(struct device *dev, void *data)
1340 return dev->of_node == data;
1343 /* must call put_device() when done with returned i2c_client device */
1344 struct i2c_client *of_find_i2c_device_by_node(struct device_node *node)
1348 dev = bus_find_device(&i2c_bus_type, NULL, node,
1353 return i2c_verify_client(dev);
1355 EXPORT_SYMBOL(of_find_i2c_device_by_node);
1357 /* must call put_device() when done with returned i2c_adapter device */
1358 struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node)
1362 dev = bus_find_device(&i2c_bus_type, NULL, node,
1367 return i2c_verify_adapter(dev);
1369 EXPORT_SYMBOL(of_find_i2c_adapter_by_node);
1371 static void of_i2c_register_devices(struct i2c_adapter *adap) { }
1372 #endif /* CONFIG_OF */
1374 static int i2c_do_add_adapter(struct i2c_driver *driver,
1375 struct i2c_adapter *adap)
1377 /* Detect supported devices on that bus, and instantiate them */
1378 i2c_detect(adap, driver);
1380 /* Let legacy drivers scan this bus for matching devices */
1381 if (driver->attach_adapter) {
1382 dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
1383 driver->driver.name);
1384 dev_warn(&adap->dev, "Please use another way to instantiate "
1385 "your i2c_client\n");
1386 /* We ignore the return code; if it fails, too bad */
1387 driver->attach_adapter(adap);
1392 static int __process_new_adapter(struct device_driver *d, void *data)
1394 return i2c_do_add_adapter(to_i2c_driver(d), data);
1397 static int i2c_register_adapter(struct i2c_adapter *adap)
1401 /* Can't register until after driver model init */
1402 if (unlikely(WARN_ON(!i2c_bus_type.p))) {
1408 if (unlikely(adap->name[0] == '\0')) {
1409 pr_err("i2c-core: Attempt to register an adapter with "
1413 if (unlikely(!adap->algo)) {
1414 pr_err("i2c-core: Attempt to register adapter '%s' with "
1415 "no algo!\n", adap->name);
1419 rt_mutex_init(&adap->bus_lock);
1420 mutex_init(&adap->userspace_clients_lock);
1421 INIT_LIST_HEAD(&adap->userspace_clients);
1423 /* Set default timeout to 1 second if not already set */
1424 if (adap->timeout == 0)
1427 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
1428 adap->dev.bus = &i2c_bus_type;
1429 adap->dev.type = &i2c_adapter_type;
1430 res = device_register(&adap->dev);
1434 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
1436 #ifdef CONFIG_I2C_COMPAT
1437 res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
1440 dev_warn(&adap->dev,
1441 "Failed to create compatibility class link\n");
1444 /* bus recovery specific initialization */
1445 if (adap->bus_recovery_info) {
1446 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
1448 if (!bri->recover_bus) {
1449 dev_err(&adap->dev, "No recover_bus() found, not using recovery\n");
1450 adap->bus_recovery_info = NULL;
1454 /* Generic GPIO recovery */
1455 if (bri->recover_bus == i2c_generic_gpio_recovery) {
1456 if (!gpio_is_valid(bri->scl_gpio)) {
1457 dev_err(&adap->dev, "Invalid SCL gpio, not using recovery\n");
1458 adap->bus_recovery_info = NULL;
1462 if (gpio_is_valid(bri->sda_gpio))
1463 bri->get_sda = get_sda_gpio_value;
1465 bri->get_sda = NULL;
1467 bri->get_scl = get_scl_gpio_value;
1468 bri->set_scl = set_scl_gpio_value;
1469 } else if (!bri->set_scl || !bri->get_scl) {
1470 /* Generic SCL recovery */
1471 dev_err(&adap->dev, "No {get|set}_gpio() found, not using recovery\n");
1472 adap->bus_recovery_info = NULL;
1477 /* create pre-declared device nodes */
1478 of_i2c_register_devices(adap);
1479 acpi_i2c_register_devices(adap);
1480 acpi_i2c_install_space_handler(adap);
1482 if (adap->nr < __i2c_first_dynamic_bus_num)
1483 i2c_scan_static_board_info(adap);
1485 /* Notify drivers */
1486 mutex_lock(&core_lock);
1487 bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
1488 mutex_unlock(&core_lock);
1493 mutex_lock(&core_lock);
1494 idr_remove(&i2c_adapter_idr, adap->nr);
1495 mutex_unlock(&core_lock);
1500 * __i2c_add_numbered_adapter - i2c_add_numbered_adapter where nr is never -1
1501 * @adap: the adapter to register (with adap->nr initialized)
1502 * Context: can sleep
1504 * See i2c_add_numbered_adapter() for details.
1506 static int __i2c_add_numbered_adapter(struct i2c_adapter *adap)
1510 mutex_lock(&core_lock);
1511 id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1,
1513 mutex_unlock(&core_lock);
1515 return id == -ENOSPC ? -EBUSY : id;
1517 return i2c_register_adapter(adap);
1521 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
1522 * @adapter: the adapter to add
1523 * Context: can sleep
1525 * This routine is used to declare an I2C adapter when its bus number
1526 * doesn't matter or when its bus number is specified by an dt alias.
1527 * Examples of bases when the bus number doesn't matter: I2C adapters
1528 * dynamically added by USB links or PCI plugin cards.
1530 * When this returns zero, a new bus number was allocated and stored
1531 * in adap->nr, and the specified adapter became available for clients.
1532 * Otherwise, a negative errno value is returned.
1534 int i2c_add_adapter(struct i2c_adapter *adapter)
1536 struct device *dev = &adapter->dev;
1540 id = of_alias_get_id(dev->of_node, "i2c");
1543 return __i2c_add_numbered_adapter(adapter);
1547 mutex_lock(&core_lock);
1548 id = idr_alloc(&i2c_adapter_idr, adapter,
1549 __i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
1550 mutex_unlock(&core_lock);
1556 return i2c_register_adapter(adapter);
1558 EXPORT_SYMBOL(i2c_add_adapter);
1561 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
1562 * @adap: the adapter to register (with adap->nr initialized)
1563 * Context: can sleep
1565 * This routine is used to declare an I2C adapter when its bus number
1566 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
1567 * or otherwise built in to the system's mainboard, and where i2c_board_info
1568 * is used to properly configure I2C devices.
1570 * If the requested bus number is set to -1, then this function will behave
1571 * identically to i2c_add_adapter, and will dynamically assign a bus number.
1573 * If no devices have pre-been declared for this bus, then be sure to
1574 * register the adapter before any dynamically allocated ones. Otherwise
1575 * the required bus ID may not be available.
1577 * When this returns zero, the specified adapter became available for
1578 * clients using the bus number provided in adap->nr. Also, the table
1579 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
1580 * and the appropriate driver model device nodes are created. Otherwise, a
1581 * negative errno value is returned.
1583 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
1585 if (adap->nr == -1) /* -1 means dynamically assign bus id */
1586 return i2c_add_adapter(adap);
1588 return __i2c_add_numbered_adapter(adap);
1590 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
1592 static void i2c_do_del_adapter(struct i2c_driver *driver,
1593 struct i2c_adapter *adapter)
1595 struct i2c_client *client, *_n;
1597 /* Remove the devices we created ourselves as the result of hardware
1598 * probing (using a driver's detect method) */
1599 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
1600 if (client->adapter == adapter) {
1601 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
1602 client->name, client->addr);
1603 list_del(&client->detected);
1604 i2c_unregister_device(client);
1609 static int __unregister_client(struct device *dev, void *dummy)
1611 struct i2c_client *client = i2c_verify_client(dev);
1612 if (client && strcmp(client->name, "dummy"))
1613 i2c_unregister_device(client);
1617 static int __unregister_dummy(struct device *dev, void *dummy)
1619 struct i2c_client *client = i2c_verify_client(dev);
1621 i2c_unregister_device(client);
1625 static int __process_removed_adapter(struct device_driver *d, void *data)
1627 i2c_do_del_adapter(to_i2c_driver(d), data);
1632 * i2c_del_adapter - unregister I2C adapter
1633 * @adap: the adapter being unregistered
1634 * Context: can sleep
1636 * This unregisters an I2C adapter which was previously registered
1637 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
1639 void i2c_del_adapter(struct i2c_adapter *adap)
1641 struct i2c_adapter *found;
1642 struct i2c_client *client, *next;
1644 /* First make sure that this adapter was ever added */
1645 mutex_lock(&core_lock);
1646 found = idr_find(&i2c_adapter_idr, adap->nr);
1647 mutex_unlock(&core_lock);
1648 if (found != adap) {
1649 pr_debug("i2c-core: attempting to delete unregistered "
1650 "adapter [%s]\n", adap->name);
1654 acpi_i2c_remove_space_handler(adap);
1655 /* Tell drivers about this removal */
1656 mutex_lock(&core_lock);
1657 bus_for_each_drv(&i2c_bus_type, NULL, adap,
1658 __process_removed_adapter);
1659 mutex_unlock(&core_lock);
1661 /* Remove devices instantiated from sysfs */
1662 mutex_lock_nested(&adap->userspace_clients_lock,
1663 i2c_adapter_depth(adap));
1664 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1666 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
1668 list_del(&client->detected);
1669 i2c_unregister_device(client);
1671 mutex_unlock(&adap->userspace_clients_lock);
1673 /* Detach any active clients. This can't fail, thus we do not
1674 * check the returned value. This is a two-pass process, because
1675 * we can't remove the dummy devices during the first pass: they
1676 * could have been instantiated by real devices wishing to clean
1677 * them up properly, so we give them a chance to do that first. */
1678 device_for_each_child(&adap->dev, NULL, __unregister_client);
1679 device_for_each_child(&adap->dev, NULL, __unregister_dummy);
1681 #ifdef CONFIG_I2C_COMPAT
1682 class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
1686 /* device name is gone after device_unregister */
1687 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
1689 /* clean up the sysfs representation */
1690 init_completion(&adap->dev_released);
1691 device_unregister(&adap->dev);
1693 /* wait for sysfs to drop all references */
1694 wait_for_completion(&adap->dev_released);
1697 mutex_lock(&core_lock);
1698 idr_remove(&i2c_adapter_idr, adap->nr);
1699 mutex_unlock(&core_lock);
1701 /* Clear the device structure in case this adapter is ever going to be
1703 memset(&adap->dev, 0, sizeof(adap->dev));
1705 EXPORT_SYMBOL(i2c_del_adapter);
1707 /* ------------------------------------------------------------------------- */
1709 int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
1713 mutex_lock(&core_lock);
1714 res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
1715 mutex_unlock(&core_lock);
1719 EXPORT_SYMBOL_GPL(i2c_for_each_dev);
1721 static int __process_new_driver(struct device *dev, void *data)
1723 if (dev->type != &i2c_adapter_type)
1725 return i2c_do_add_adapter(data, to_i2c_adapter(dev));
1729 * An i2c_driver is used with one or more i2c_client (device) nodes to access
1730 * i2c slave chips, on a bus instance associated with some i2c_adapter.
1733 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
1737 /* Can't register until after driver model init */
1738 if (unlikely(WARN_ON(!i2c_bus_type.p)))
1741 /* add the driver to the list of i2c drivers in the driver core */
1742 driver->driver.owner = owner;
1743 driver->driver.bus = &i2c_bus_type;
1745 /* When registration returns, the driver core
1746 * will have called probe() for all matching-but-unbound devices.
1748 res = driver_register(&driver->driver);
1752 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
1754 INIT_LIST_HEAD(&driver->clients);
1755 /* Walk the adapters that are already present */
1756 i2c_for_each_dev(driver, __process_new_driver);
1760 EXPORT_SYMBOL(i2c_register_driver);
1762 static int __process_removed_driver(struct device *dev, void *data)
1764 if (dev->type == &i2c_adapter_type)
1765 i2c_do_del_adapter(data, to_i2c_adapter(dev));
1770 * i2c_del_driver - unregister I2C driver
1771 * @driver: the driver being unregistered
1772 * Context: can sleep
1774 void i2c_del_driver(struct i2c_driver *driver)
1776 i2c_for_each_dev(driver, __process_removed_driver);
1778 driver_unregister(&driver->driver);
1779 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
1781 EXPORT_SYMBOL(i2c_del_driver);
1783 /* ------------------------------------------------------------------------- */
1786 * i2c_use_client - increments the reference count of the i2c client structure
1787 * @client: the client being referenced
1789 * Each live reference to a client should be refcounted. The driver model does
1790 * that automatically as part of driver binding, so that most drivers don't
1791 * need to do this explicitly: they hold a reference until they're unbound
1794 * A pointer to the client with the incremented reference counter is returned.
1796 struct i2c_client *i2c_use_client(struct i2c_client *client)
1798 if (client && get_device(&client->dev))
1802 EXPORT_SYMBOL(i2c_use_client);
1805 * i2c_release_client - release a use of the i2c client structure
1806 * @client: the client being no longer referenced
1808 * Must be called when a user of a client is finished with it.
1810 void i2c_release_client(struct i2c_client *client)
1813 put_device(&client->dev);
1815 EXPORT_SYMBOL(i2c_release_client);
1817 struct i2c_cmd_arg {
1822 static int i2c_cmd(struct device *dev, void *_arg)
1824 struct i2c_client *client = i2c_verify_client(dev);
1825 struct i2c_cmd_arg *arg = _arg;
1826 struct i2c_driver *driver;
1828 if (!client || !client->dev.driver)
1831 driver = to_i2c_driver(client->dev.driver);
1832 if (driver->command)
1833 driver->command(client, arg->cmd, arg->arg);
1837 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
1839 struct i2c_cmd_arg cmd_arg;
1843 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
1845 EXPORT_SYMBOL(i2c_clients_command);
1847 #if IS_ENABLED(CONFIG_OF_DYNAMIC)
1848 static int of_i2c_notify(struct notifier_block *nb, unsigned long action,
1851 struct of_reconfig_data *rd = arg;
1852 struct i2c_adapter *adap;
1853 struct i2c_client *client;
1855 switch (of_reconfig_get_state_change(action, rd)) {
1856 case OF_RECONFIG_CHANGE_ADD:
1857 adap = of_find_i2c_adapter_by_node(rd->dn->parent);
1859 return NOTIFY_OK; /* not for us */
1861 client = of_i2c_register_device(adap, rd->dn);
1862 put_device(&adap->dev);
1864 if (IS_ERR(client)) {
1865 pr_err("%s: failed to create for '%s'\n",
1866 __func__, rd->dn->full_name);
1867 return notifier_from_errno(PTR_ERR(client));
1870 case OF_RECONFIG_CHANGE_REMOVE:
1871 /* find our device by node */
1872 client = of_find_i2c_device_by_node(rd->dn);
1874 return NOTIFY_OK; /* no? not meant for us */
1876 /* unregister takes one ref away */
1877 i2c_unregister_device(client);
1879 /* and put the reference of the find */
1880 put_device(&client->dev);
1886 static struct notifier_block i2c_of_notifier = {
1887 .notifier_call = of_i2c_notify,
1890 extern struct notifier_block i2c_of_notifier;
1891 #endif /* CONFIG_OF_DYNAMIC */
1893 static int __init i2c_init(void)
1897 retval = bus_register(&i2c_bus_type);
1900 #ifdef CONFIG_I2C_COMPAT
1901 i2c_adapter_compat_class = class_compat_register("i2c-adapter");
1902 if (!i2c_adapter_compat_class) {
1907 retval = i2c_add_driver(&dummy_driver);
1911 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
1912 WARN_ON(of_reconfig_notifier_register(&i2c_of_notifier));
1917 #ifdef CONFIG_I2C_COMPAT
1918 class_compat_unregister(i2c_adapter_compat_class);
1921 bus_unregister(&i2c_bus_type);
1925 static void __exit i2c_exit(void)
1927 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
1928 WARN_ON(of_reconfig_notifier_unregister(&i2c_of_notifier));
1929 i2c_del_driver(&dummy_driver);
1930 #ifdef CONFIG_I2C_COMPAT
1931 class_compat_unregister(i2c_adapter_compat_class);
1933 bus_unregister(&i2c_bus_type);
1934 tracepoint_synchronize_unregister();
1937 /* We must initialize early, because some subsystems register i2c drivers
1938 * in subsys_initcall() code, but are linked (and initialized) before i2c.
1940 postcore_initcall(i2c_init);
1941 module_exit(i2c_exit);
1943 /* ----------------------------------------------------
1944 * the functional interface to the i2c busses.
1945 * ----------------------------------------------------
1949 * __i2c_transfer - unlocked flavor of i2c_transfer
1950 * @adap: Handle to I2C bus
1951 * @msgs: One or more messages to execute before STOP is issued to
1952 * terminate the operation; each message begins with a START.
1953 * @num: Number of messages to be executed.
1955 * Returns negative errno, else the number of messages executed.
1957 * Adapter lock must be held when calling this function. No debug logging
1958 * takes place. adap->algo->master_xfer existence isn't checked.
1960 int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
1962 unsigned long orig_jiffies;
1965 /* i2c_trace_msg gets enabled when tracepoint i2c_transfer gets
1966 * enabled. This is an efficient way of keeping the for-loop from
1967 * being executed when not needed.
1969 if (static_key_false(&i2c_trace_msg)) {
1971 for (i = 0; i < num; i++)
1972 if (msgs[i].flags & I2C_M_RD)
1973 trace_i2c_read(adap, &msgs[i], i);
1975 trace_i2c_write(adap, &msgs[i], i);
1978 /* Retry automatically on arbitration loss */
1979 orig_jiffies = jiffies;
1980 for (ret = 0, try = 0; try <= adap->retries; try++) {
1981 ret = adap->algo->master_xfer(adap, msgs, num);
1984 if (time_after(jiffies, orig_jiffies + adap->timeout))
1988 if (static_key_false(&i2c_trace_msg)) {
1990 for (i = 0; i < ret; i++)
1991 if (msgs[i].flags & I2C_M_RD)
1992 trace_i2c_reply(adap, &msgs[i], i);
1993 trace_i2c_result(adap, i, ret);
1998 EXPORT_SYMBOL(__i2c_transfer);
2001 * i2c_transfer - execute a single or combined I2C message
2002 * @adap: Handle to I2C bus
2003 * @msgs: One or more messages to execute before STOP is issued to
2004 * terminate the operation; each message begins with a START.
2005 * @num: Number of messages to be executed.
2007 * Returns negative errno, else the number of messages executed.
2009 * Note that there is no requirement that each message be sent to
2010 * the same slave address, although that is the most common model.
2012 int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2016 /* REVISIT the fault reporting model here is weak:
2018 * - When we get an error after receiving N bytes from a slave,
2019 * there is no way to report "N".
2021 * - When we get a NAK after transmitting N bytes to a slave,
2022 * there is no way to report "N" ... or to let the master
2023 * continue executing the rest of this combined message, if
2024 * that's the appropriate response.
2026 * - When for example "num" is two and we successfully complete
2027 * the first message but get an error part way through the
2028 * second, it's unclear whether that should be reported as
2029 * one (discarding status on the second message) or errno
2030 * (discarding status on the first one).
2033 if (adap->algo->master_xfer) {
2035 for (ret = 0; ret < num; ret++) {
2036 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
2037 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
2038 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
2039 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
2043 if (in_atomic() || irqs_disabled()) {
2044 ret = i2c_trylock_adapter(adap);
2046 /* I2C activity is ongoing. */
2049 i2c_lock_adapter(adap);
2052 ret = __i2c_transfer(adap, msgs, num);
2053 i2c_unlock_adapter(adap);
2057 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
2061 EXPORT_SYMBOL(i2c_transfer);
2064 * i2c_master_send - issue a single I2C message in master transmit mode
2065 * @client: Handle to slave device
2066 * @buf: Data that will be written to the slave
2067 * @count: How many bytes to write, must be less than 64k since msg.len is u16
2069 * Returns negative errno, or else the number of bytes written.
2071 int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
2074 struct i2c_adapter *adap = client->adapter;
2077 msg.addr = client->addr;
2078 msg.flags = client->flags & I2C_M_TEN;
2080 msg.buf = (char *)buf;
2082 ret = i2c_transfer(adap, &msg, 1);
2085 * If everything went ok (i.e. 1 msg transmitted), return #bytes
2086 * transmitted, else error code.
2088 return (ret == 1) ? count : ret;
2090 EXPORT_SYMBOL(i2c_master_send);
2093 * i2c_master_recv - issue a single I2C message in master receive mode
2094 * @client: Handle to slave device
2095 * @buf: Where to store data read from slave
2096 * @count: How many bytes to read, must be less than 64k since msg.len is u16
2098 * Returns negative errno, or else the number of bytes read.
2100 int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
2102 struct i2c_adapter *adap = client->adapter;
2106 msg.addr = client->addr;
2107 msg.flags = client->flags & I2C_M_TEN;
2108 msg.flags |= I2C_M_RD;
2112 ret = i2c_transfer(adap, &msg, 1);
2115 * If everything went ok (i.e. 1 msg received), return #bytes received,
2118 return (ret == 1) ? count : ret;
2120 EXPORT_SYMBOL(i2c_master_recv);
2122 /* ----------------------------------------------------
2123 * the i2c address scanning function
2124 * Will not work for 10-bit addresses!
2125 * ----------------------------------------------------
2129 * Legacy default probe function, mostly relevant for SMBus. The default
2130 * probe method is a quick write, but it is known to corrupt the 24RF08
2131 * EEPROMs due to a state machine bug, and could also irreversibly
2132 * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
2133 * we use a short byte read instead. Also, some bus drivers don't implement
2134 * quick write, so we fallback to a byte read in that case too.
2135 * On x86, there is another special case for FSC hardware monitoring chips,
2136 * which want regular byte reads (address 0x73.) Fortunately, these are the
2137 * only known chips using this I2C address on PC hardware.
2138 * Returns 1 if probe succeeded, 0 if not.
2140 static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
2143 union i2c_smbus_data dummy;
2146 if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
2147 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
2148 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2149 I2C_SMBUS_BYTE_DATA, &dummy);
2152 if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
2153 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
2154 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
2155 I2C_SMBUS_QUICK, NULL);
2156 else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
2157 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2158 I2C_SMBUS_BYTE, &dummy);
2160 dev_warn(&adap->dev, "No suitable probing method supported for address 0x%02X\n",
2168 static int i2c_detect_address(struct i2c_client *temp_client,
2169 struct i2c_driver *driver)
2171 struct i2c_board_info info;
2172 struct i2c_adapter *adapter = temp_client->adapter;
2173 int addr = temp_client->addr;
2176 /* Make sure the address is valid */
2177 err = i2c_check_addr_validity(addr);
2179 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
2184 /* Skip if already in use */
2185 if (i2c_check_addr_busy(adapter, addr))
2188 /* Make sure there is something at this address */
2189 if (!i2c_default_probe(adapter, addr))
2192 /* Finally call the custom detection function */
2193 memset(&info, 0, sizeof(struct i2c_board_info));
2195 err = driver->detect(temp_client, &info);
2197 /* -ENODEV is returned if the detection fails. We catch it
2198 here as this isn't an error. */
2199 return err == -ENODEV ? 0 : err;
2202 /* Consistency check */
2203 if (info.type[0] == '\0') {
2204 dev_err(&adapter->dev, "%s detection function provided "
2205 "no name for 0x%x\n", driver->driver.name,
2208 struct i2c_client *client;
2210 /* Detection succeeded, instantiate the device */
2211 if (adapter->class & I2C_CLASS_DEPRECATED)
2212 dev_warn(&adapter->dev,
2213 "This adapter will soon drop class based instantiation of devices. "
2214 "Please make sure client 0x%02x gets instantiated by other means. "
2215 "Check 'Documentation/i2c/instantiating-devices' for details.\n",
2218 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
2219 info.type, info.addr);
2220 client = i2c_new_device(adapter, &info);
2222 list_add_tail(&client->detected, &driver->clients);
2224 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
2225 info.type, info.addr);
2230 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
2232 const unsigned short *address_list;
2233 struct i2c_client *temp_client;
2235 int adap_id = i2c_adapter_id(adapter);
2237 address_list = driver->address_list;
2238 if (!driver->detect || !address_list)
2241 /* Warn that the adapter lost class based instantiation */
2242 if (adapter->class == I2C_CLASS_DEPRECATED) {
2243 dev_dbg(&adapter->dev,
2244 "This adapter dropped support for I2C classes and "
2245 "won't auto-detect %s devices anymore. If you need it, check "
2246 "'Documentation/i2c/instantiating-devices' for alternatives.\n",
2247 driver->driver.name);
2251 /* Stop here if the classes do not match */
2252 if (!(adapter->class & driver->class))
2255 /* Set up a temporary client to help detect callback */
2256 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
2259 temp_client->adapter = adapter;
2261 for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
2262 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
2263 "addr 0x%02x\n", adap_id, address_list[i]);
2264 temp_client->addr = address_list[i];
2265 err = i2c_detect_address(temp_client, driver);
2274 int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
2276 return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2277 I2C_SMBUS_QUICK, NULL) >= 0;
2279 EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
2282 i2c_new_probed_device(struct i2c_adapter *adap,
2283 struct i2c_board_info *info,
2284 unsigned short const *addr_list,
2285 int (*probe)(struct i2c_adapter *, unsigned short addr))
2290 probe = i2c_default_probe;
2292 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
2293 /* Check address validity */
2294 if (i2c_check_addr_validity(addr_list[i]) < 0) {
2295 dev_warn(&adap->dev, "Invalid 7-bit address "
2296 "0x%02x\n", addr_list[i]);
2300 /* Check address availability */
2301 if (i2c_check_addr_busy(adap, addr_list[i])) {
2302 dev_dbg(&adap->dev, "Address 0x%02x already in "
2303 "use, not probing\n", addr_list[i]);
2307 /* Test address responsiveness */
2308 if (probe(adap, addr_list[i]))
2312 if (addr_list[i] == I2C_CLIENT_END) {
2313 dev_dbg(&adap->dev, "Probing failed, no device found\n");
2317 info->addr = addr_list[i];
2318 return i2c_new_device(adap, info);
2320 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
2322 struct i2c_adapter *i2c_get_adapter(int nr)
2324 struct i2c_adapter *adapter;
2326 mutex_lock(&core_lock);
2327 adapter = idr_find(&i2c_adapter_idr, nr);
2328 if (adapter && !try_module_get(adapter->owner))
2331 mutex_unlock(&core_lock);
2334 EXPORT_SYMBOL(i2c_get_adapter);
2336 void i2c_put_adapter(struct i2c_adapter *adap)
2339 module_put(adap->owner);
2341 EXPORT_SYMBOL(i2c_put_adapter);
2343 /* The SMBus parts */
2345 #define POLY (0x1070U << 3)
2346 static u8 crc8(u16 data)
2350 for (i = 0; i < 8; i++) {
2355 return (u8)(data >> 8);
2358 /* Incremental CRC8 over count bytes in the array pointed to by p */
2359 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
2363 for (i = 0; i < count; i++)
2364 crc = crc8((crc ^ p[i]) << 8);
2368 /* Assume a 7-bit address, which is reasonable for SMBus */
2369 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
2371 /* The address will be sent first */
2372 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
2373 pec = i2c_smbus_pec(pec, &addr, 1);
2375 /* The data buffer follows */
2376 return i2c_smbus_pec(pec, msg->buf, msg->len);
2379 /* Used for write only transactions */
2380 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
2382 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
2386 /* Return <0 on CRC error
2387 If there was a write before this read (most cases) we need to take the
2388 partial CRC from the write part into account.
2389 Note that this function does modify the message (we need to decrease the
2390 message length to hide the CRC byte from the caller). */
2391 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
2393 u8 rpec = msg->buf[--msg->len];
2394 cpec = i2c_smbus_msg_pec(cpec, msg);
2397 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
2405 * i2c_smbus_read_byte - SMBus "receive byte" protocol
2406 * @client: Handle to slave device
2408 * This executes the SMBus "receive byte" protocol, returning negative errno
2409 * else the byte received from the device.
2411 s32 i2c_smbus_read_byte(const struct i2c_client *client)
2413 union i2c_smbus_data data;
2416 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2418 I2C_SMBUS_BYTE, &data);
2419 return (status < 0) ? status : data.byte;
2421 EXPORT_SYMBOL(i2c_smbus_read_byte);
2424 * i2c_smbus_write_byte - SMBus "send byte" protocol
2425 * @client: Handle to slave device
2426 * @value: Byte to be sent
2428 * This executes the SMBus "send byte" protocol, returning negative errno
2429 * else zero on success.
2431 s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
2433 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2434 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
2436 EXPORT_SYMBOL(i2c_smbus_write_byte);
2439 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
2440 * @client: Handle to slave device
2441 * @command: Byte interpreted by slave
2443 * This executes the SMBus "read byte" protocol, returning negative errno
2444 * else a data byte received from the device.
2446 s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
2448 union i2c_smbus_data data;
2451 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2452 I2C_SMBUS_READ, command,
2453 I2C_SMBUS_BYTE_DATA, &data);
2454 return (status < 0) ? status : data.byte;
2456 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
2459 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
2460 * @client: Handle to slave device
2461 * @command: Byte interpreted by slave
2462 * @value: Byte being written
2464 * This executes the SMBus "write byte" protocol, returning negative errno
2465 * else zero on success.
2467 s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
2470 union i2c_smbus_data data;
2472 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2473 I2C_SMBUS_WRITE, command,
2474 I2C_SMBUS_BYTE_DATA, &data);
2476 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
2479 * i2c_smbus_read_word_data - SMBus "read word" protocol
2480 * @client: Handle to slave device
2481 * @command: Byte interpreted by slave
2483 * This executes the SMBus "read word" protocol, returning negative errno
2484 * else a 16-bit unsigned "word" received from the device.
2486 s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
2488 union i2c_smbus_data data;
2491 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2492 I2C_SMBUS_READ, command,
2493 I2C_SMBUS_WORD_DATA, &data);
2494 return (status < 0) ? status : data.word;
2496 EXPORT_SYMBOL(i2c_smbus_read_word_data);
2499 * i2c_smbus_write_word_data - SMBus "write word" protocol
2500 * @client: Handle to slave device
2501 * @command: Byte interpreted by slave
2502 * @value: 16-bit "word" being written
2504 * This executes the SMBus "write word" protocol, returning negative errno
2505 * else zero on success.
2507 s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
2510 union i2c_smbus_data data;
2512 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2513 I2C_SMBUS_WRITE, command,
2514 I2C_SMBUS_WORD_DATA, &data);
2516 EXPORT_SYMBOL(i2c_smbus_write_word_data);
2519 * i2c_smbus_read_block_data - SMBus "block read" protocol
2520 * @client: Handle to slave device
2521 * @command: Byte interpreted by slave
2522 * @values: Byte array into which data will be read; big enough to hold
2523 * the data returned by the slave. SMBus allows at most 32 bytes.
2525 * This executes the SMBus "block read" protocol, returning negative errno
2526 * else the number of data bytes in the slave's response.
2528 * Note that using this function requires that the client's adapter support
2529 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
2530 * support this; its emulation through I2C messaging relies on a specific
2531 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
2533 s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
2536 union i2c_smbus_data data;
2539 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2540 I2C_SMBUS_READ, command,
2541 I2C_SMBUS_BLOCK_DATA, &data);
2545 memcpy(values, &data.block[1], data.block[0]);
2546 return data.block[0];
2548 EXPORT_SYMBOL(i2c_smbus_read_block_data);
2551 * i2c_smbus_write_block_data - SMBus "block write" protocol
2552 * @client: Handle to slave device
2553 * @command: Byte interpreted by slave
2554 * @length: Size of data block; SMBus allows at most 32 bytes
2555 * @values: Byte array which will be written.
2557 * This executes the SMBus "block write" protocol, returning negative errno
2558 * else zero on success.
2560 s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
2561 u8 length, const u8 *values)
2563 union i2c_smbus_data data;
2565 if (length > I2C_SMBUS_BLOCK_MAX)
2566 length = I2C_SMBUS_BLOCK_MAX;
2567 data.block[0] = length;
2568 memcpy(&data.block[1], values, length);
2569 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2570 I2C_SMBUS_WRITE, command,
2571 I2C_SMBUS_BLOCK_DATA, &data);
2573 EXPORT_SYMBOL(i2c_smbus_write_block_data);
2575 /* Returns the number of read bytes */
2576 s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
2577 u8 length, u8 *values)
2579 union i2c_smbus_data data;
2582 if (length > I2C_SMBUS_BLOCK_MAX)
2583 length = I2C_SMBUS_BLOCK_MAX;
2584 data.block[0] = length;
2585 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2586 I2C_SMBUS_READ, command,
2587 I2C_SMBUS_I2C_BLOCK_DATA, &data);
2591 memcpy(values, &data.block[1], data.block[0]);
2592 return data.block[0];
2594 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
2596 s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
2597 u8 length, const u8 *values)
2599 union i2c_smbus_data data;
2601 if (length > I2C_SMBUS_BLOCK_MAX)
2602 length = I2C_SMBUS_BLOCK_MAX;
2603 data.block[0] = length;
2604 memcpy(data.block + 1, values, length);
2605 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2606 I2C_SMBUS_WRITE, command,
2607 I2C_SMBUS_I2C_BLOCK_DATA, &data);
2609 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
2611 /* Simulate a SMBus command using the i2c protocol
2612 No checking of parameters is done! */
2613 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
2614 unsigned short flags,
2615 char read_write, u8 command, int size,
2616 union i2c_smbus_data *data)
2618 /* So we need to generate a series of msgs. In the case of writing, we
2619 need to use only one message; when reading, we need two. We initialize
2620 most things with sane defaults, to keep the code below somewhat
2622 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
2623 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
2624 int num = read_write == I2C_SMBUS_READ ? 2 : 1;
2628 struct i2c_msg msg[2] = {
2636 .flags = flags | I2C_M_RD,
2642 msgbuf0[0] = command;
2644 case I2C_SMBUS_QUICK:
2646 /* Special case: The read/write field is used as data */
2647 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
2651 case I2C_SMBUS_BYTE:
2652 if (read_write == I2C_SMBUS_READ) {
2653 /* Special case: only a read! */
2654 msg[0].flags = I2C_M_RD | flags;
2658 case I2C_SMBUS_BYTE_DATA:
2659 if (read_write == I2C_SMBUS_READ)
2663 msgbuf0[1] = data->byte;
2666 case I2C_SMBUS_WORD_DATA:
2667 if (read_write == I2C_SMBUS_READ)
2671 msgbuf0[1] = data->word & 0xff;
2672 msgbuf0[2] = data->word >> 8;
2675 case I2C_SMBUS_PROC_CALL:
2676 num = 2; /* Special case */
2677 read_write = I2C_SMBUS_READ;
2680 msgbuf0[1] = data->word & 0xff;
2681 msgbuf0[2] = data->word >> 8;
2683 case I2C_SMBUS_BLOCK_DATA:
2684 if (read_write == I2C_SMBUS_READ) {
2685 msg[1].flags |= I2C_M_RECV_LEN;
2686 msg[1].len = 1; /* block length will be added by
2687 the underlying bus driver */
2689 msg[0].len = data->block[0] + 2;
2690 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
2691 dev_err(&adapter->dev,
2692 "Invalid block write size %d\n",
2696 for (i = 1; i < msg[0].len; i++)
2697 msgbuf0[i] = data->block[i-1];
2700 case I2C_SMBUS_BLOCK_PROC_CALL:
2701 num = 2; /* Another special case */
2702 read_write = I2C_SMBUS_READ;
2703 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
2704 dev_err(&adapter->dev,
2705 "Invalid block write size %d\n",
2709 msg[0].len = data->block[0] + 2;
2710 for (i = 1; i < msg[0].len; i++)
2711 msgbuf0[i] = data->block[i-1];
2712 msg[1].flags |= I2C_M_RECV_LEN;
2713 msg[1].len = 1; /* block length will be added by
2714 the underlying bus driver */
2716 case I2C_SMBUS_I2C_BLOCK_DATA:
2717 if (read_write == I2C_SMBUS_READ) {
2718 msg[1].len = data->block[0];
2720 msg[0].len = data->block[0] + 1;
2721 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
2722 dev_err(&adapter->dev,
2723 "Invalid block write size %d\n",
2727 for (i = 1; i <= data->block[0]; i++)
2728 msgbuf0[i] = data->block[i];
2732 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
2736 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
2737 && size != I2C_SMBUS_I2C_BLOCK_DATA);
2739 /* Compute PEC if first message is a write */
2740 if (!(msg[0].flags & I2C_M_RD)) {
2741 if (num == 1) /* Write only */
2742 i2c_smbus_add_pec(&msg[0]);
2743 else /* Write followed by read */
2744 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
2746 /* Ask for PEC if last message is a read */
2747 if (msg[num-1].flags & I2C_M_RD)
2751 status = i2c_transfer(adapter, msg, num);
2755 /* Check PEC if last message is a read */
2756 if (i && (msg[num-1].flags & I2C_M_RD)) {
2757 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
2762 if (read_write == I2C_SMBUS_READ)
2764 case I2C_SMBUS_BYTE:
2765 data->byte = msgbuf0[0];
2767 case I2C_SMBUS_BYTE_DATA:
2768 data->byte = msgbuf1[0];
2770 case I2C_SMBUS_WORD_DATA:
2771 case I2C_SMBUS_PROC_CALL:
2772 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
2774 case I2C_SMBUS_I2C_BLOCK_DATA:
2775 for (i = 0; i < data->block[0]; i++)
2776 data->block[i+1] = msgbuf1[i];
2778 case I2C_SMBUS_BLOCK_DATA:
2779 case I2C_SMBUS_BLOCK_PROC_CALL:
2780 for (i = 0; i < msgbuf1[0] + 1; i++)
2781 data->block[i] = msgbuf1[i];
2788 * i2c_smbus_xfer - execute SMBus protocol operations
2789 * @adapter: Handle to I2C bus
2790 * @addr: Address of SMBus slave on that bus
2791 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
2792 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
2793 * @command: Byte interpreted by slave, for protocols which use such bytes
2794 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
2795 * @data: Data to be read or written
2797 * This executes an SMBus protocol operation, and returns a negative
2798 * errno code else zero on success.
2800 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
2801 char read_write, u8 command, int protocol,
2802 union i2c_smbus_data *data)
2804 unsigned long orig_jiffies;
2808 /* If enabled, the following two tracepoints are conditional on
2809 * read_write and protocol.
2811 trace_smbus_write(adapter, addr, flags, read_write,
2812 command, protocol, data);
2813 trace_smbus_read(adapter, addr, flags, read_write,
2816 flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
2818 if (adapter->algo->smbus_xfer) {
2819 i2c_lock_adapter(adapter);
2821 /* Retry automatically on arbitration loss */
2822 orig_jiffies = jiffies;
2823 for (res = 0, try = 0; try <= adapter->retries; try++) {
2824 res = adapter->algo->smbus_xfer(adapter, addr, flags,
2825 read_write, command,
2829 if (time_after(jiffies,
2830 orig_jiffies + adapter->timeout))
2833 i2c_unlock_adapter(adapter);
2835 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
2838 * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
2839 * implement native support for the SMBus operation.
2843 res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
2844 command, protocol, data);
2847 /* If enabled, the reply tracepoint is conditional on read_write. */
2848 trace_smbus_reply(adapter, addr, flags, read_write,
2849 command, protocol, data);
2850 trace_smbus_result(adapter, addr, flags, read_write,
2851 command, protocol, res);
2855 EXPORT_SYMBOL(i2c_smbus_xfer);
2857 int i2c_slave_register(struct i2c_client *client, i2c_slave_cb_t slave_cb)
2861 if (!client || !slave_cb)
2864 if (!(client->flags & I2C_CLIENT_TEN)) {
2865 /* Enforce stricter address checking */
2866 ret = i2c_check_addr_validity(client->addr);
2871 if (!client->adapter->algo->reg_slave)
2874 client->slave_cb = slave_cb;
2876 i2c_lock_adapter(client->adapter);
2877 ret = client->adapter->algo->reg_slave(client);
2878 i2c_unlock_adapter(client->adapter);
2881 client->slave_cb = NULL;
2885 EXPORT_SYMBOL_GPL(i2c_slave_register);
2887 int i2c_slave_unregister(struct i2c_client *client)
2891 if (!client->adapter->algo->unreg_slave)
2894 i2c_lock_adapter(client->adapter);
2895 ret = client->adapter->algo->unreg_slave(client);
2896 i2c_unlock_adapter(client->adapter);
2899 client->slave_cb = NULL;
2903 EXPORT_SYMBOL_GPL(i2c_slave_unregister);
2905 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
2906 MODULE_DESCRIPTION("I2C-Bus main module");
2907 MODULE_LICENSE("GPL");