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 #define I2C_ADDR_OFFSET_TEN_BIT 0xa000
61 #define I2C_ADDR_OFFSET_SLAVE 0x1000
63 /* core_lock protects i2c_adapter_idr, and guarantees
64 that device detection, deletion of detected devices, and attach_adapter
65 calls are serialized */
66 static DEFINE_MUTEX(core_lock
);
67 static DEFINE_IDR(i2c_adapter_idr
);
69 static struct device_type i2c_client_type
;
70 static int i2c_detect(struct i2c_adapter
*adapter
, struct i2c_driver
*driver
);
72 static struct static_key i2c_trace_msg
= STATIC_KEY_INIT_FALSE
;
74 void i2c_transfer_trace_reg(void)
76 static_key_slow_inc(&i2c_trace_msg
);
79 void i2c_transfer_trace_unreg(void)
81 static_key_slow_dec(&i2c_trace_msg
);
84 #if defined(CONFIG_ACPI)
85 struct acpi_i2c_handler_data
{
86 struct acpi_connection_info info
;
87 struct i2c_adapter
*adapter
;
100 static int acpi_i2c_add_resource(struct acpi_resource
*ares
, void *data
)
102 struct i2c_board_info
*info
= data
;
104 if (ares
->type
== ACPI_RESOURCE_TYPE_SERIAL_BUS
) {
105 struct acpi_resource_i2c_serialbus
*sb
;
107 sb
= &ares
->data
.i2c_serial_bus
;
108 if (!info
->addr
&& sb
->type
== ACPI_RESOURCE_SERIAL_TYPE_I2C
) {
109 info
->addr
= sb
->slave_address
;
110 if (sb
->access_mode
== ACPI_I2C_10BIT_MODE
)
111 info
->flags
|= I2C_CLIENT_TEN
;
113 } else if (!info
->irq
) {
116 if (acpi_dev_resource_interrupt(ares
, 0, &r
))
120 /* Tell the ACPI core to skip this resource */
124 static acpi_status
acpi_i2c_add_device(acpi_handle handle
, u32 level
,
125 void *data
, void **return_value
)
127 struct i2c_adapter
*adapter
= data
;
128 struct list_head resource_list
;
129 struct i2c_board_info info
;
130 struct acpi_device
*adev
;
133 if (acpi_bus_get_device(handle
, &adev
))
135 if (acpi_bus_get_status(adev
) || !adev
->status
.present
)
138 memset(&info
, 0, sizeof(info
));
139 info
.fwnode
= acpi_fwnode_handle(adev
);
141 INIT_LIST_HEAD(&resource_list
);
142 ret
= acpi_dev_get_resources(adev
, &resource_list
,
143 acpi_i2c_add_resource
, &info
);
144 acpi_dev_free_resource_list(&resource_list
);
146 if (ret
< 0 || !info
.addr
)
149 adev
->power
.flags
.ignore_parent
= true;
150 strlcpy(info
.type
, dev_name(&adev
->dev
), sizeof(info
.type
));
151 if (!i2c_new_device(adapter
, &info
)) {
152 adev
->power
.flags
.ignore_parent
= false;
153 dev_err(&adapter
->dev
,
154 "failed to add I2C device %s from ACPI\n",
155 dev_name(&adev
->dev
));
162 * acpi_i2c_register_devices - enumerate I2C slave devices behind adapter
163 * @adap: pointer to adapter
165 * Enumerate all I2C slave devices behind this adapter by walking the ACPI
166 * namespace. When a device is found it will be added to the Linux device
167 * model and bound to the corresponding ACPI handle.
169 static void acpi_i2c_register_devices(struct i2c_adapter
*adap
)
174 if (!adap
->dev
.parent
)
177 handle
= ACPI_HANDLE(adap
->dev
.parent
);
181 status
= acpi_walk_namespace(ACPI_TYPE_DEVICE
, handle
, 1,
182 acpi_i2c_add_device
, NULL
,
184 if (ACPI_FAILURE(status
))
185 dev_warn(&adap
->dev
, "failed to enumerate I2C slaves\n");
188 #else /* CONFIG_ACPI */
189 static inline void acpi_i2c_register_devices(struct i2c_adapter
*adap
) { }
190 #endif /* CONFIG_ACPI */
192 #ifdef CONFIG_ACPI_I2C_OPREGION
193 static int acpi_gsb_i2c_read_bytes(struct i2c_client
*client
,
194 u8 cmd
, u8
*data
, u8 data_len
)
197 struct i2c_msg msgs
[2];
201 buffer
= kzalloc(data_len
, GFP_KERNEL
);
205 msgs
[0].addr
= client
->addr
;
206 msgs
[0].flags
= client
->flags
;
210 msgs
[1].addr
= client
->addr
;
211 msgs
[1].flags
= client
->flags
| I2C_M_RD
;
212 msgs
[1].len
= data_len
;
213 msgs
[1].buf
= buffer
;
215 ret
= i2c_transfer(client
->adapter
, msgs
, ARRAY_SIZE(msgs
));
217 dev_err(&client
->adapter
->dev
, "i2c read failed\n");
219 memcpy(data
, buffer
, data_len
);
225 static int acpi_gsb_i2c_write_bytes(struct i2c_client
*client
,
226 u8 cmd
, u8
*data
, u8 data_len
)
229 struct i2c_msg msgs
[1];
233 buffer
= kzalloc(data_len
+ 1, GFP_KERNEL
);
238 memcpy(buffer
+ 1, data
, data_len
);
240 msgs
[0].addr
= client
->addr
;
241 msgs
[0].flags
= client
->flags
;
242 msgs
[0].len
= data_len
+ 1;
243 msgs
[0].buf
= buffer
;
245 ret
= i2c_transfer(client
->adapter
, msgs
, ARRAY_SIZE(msgs
));
247 dev_err(&client
->adapter
->dev
, "i2c write failed\n");
254 acpi_i2c_space_handler(u32 function
, acpi_physical_address command
,
255 u32 bits
, u64
*value64
,
256 void *handler_context
, void *region_context
)
258 struct gsb_buffer
*gsb
= (struct gsb_buffer
*)value64
;
259 struct acpi_i2c_handler_data
*data
= handler_context
;
260 struct acpi_connection_info
*info
= &data
->info
;
261 struct acpi_resource_i2c_serialbus
*sb
;
262 struct i2c_adapter
*adapter
= data
->adapter
;
263 struct i2c_client
*client
;
264 struct acpi_resource
*ares
;
265 u32 accessor_type
= function
>> 16;
266 u8 action
= function
& ACPI_IO_MASK
;
270 ret
= acpi_buffer_to_resource(info
->connection
, info
->length
, &ares
);
271 if (ACPI_FAILURE(ret
))
274 client
= kzalloc(sizeof(*client
), GFP_KERNEL
);
280 if (!value64
|| ares
->type
!= ACPI_RESOURCE_TYPE_SERIAL_BUS
) {
281 ret
= AE_BAD_PARAMETER
;
285 sb
= &ares
->data
.i2c_serial_bus
;
286 if (sb
->type
!= ACPI_RESOURCE_SERIAL_TYPE_I2C
) {
287 ret
= AE_BAD_PARAMETER
;
291 client
->adapter
= adapter
;
292 client
->addr
= sb
->slave_address
;
294 if (sb
->access_mode
== ACPI_I2C_10BIT_MODE
)
295 client
->flags
|= I2C_CLIENT_TEN
;
297 switch (accessor_type
) {
298 case ACPI_GSB_ACCESS_ATTRIB_SEND_RCV
:
299 if (action
== ACPI_READ
) {
300 status
= i2c_smbus_read_byte(client
);
306 status
= i2c_smbus_write_byte(client
, gsb
->bdata
);
310 case ACPI_GSB_ACCESS_ATTRIB_BYTE
:
311 if (action
== ACPI_READ
) {
312 status
= i2c_smbus_read_byte_data(client
, command
);
318 status
= i2c_smbus_write_byte_data(client
, command
,
323 case ACPI_GSB_ACCESS_ATTRIB_WORD
:
324 if (action
== ACPI_READ
) {
325 status
= i2c_smbus_read_word_data(client
, command
);
331 status
= i2c_smbus_write_word_data(client
, command
,
336 case ACPI_GSB_ACCESS_ATTRIB_BLOCK
:
337 if (action
== ACPI_READ
) {
338 status
= i2c_smbus_read_block_data(client
, command
,
345 status
= i2c_smbus_write_block_data(client
, command
,
346 gsb
->len
, gsb
->data
);
350 case ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE
:
351 if (action
== ACPI_READ
) {
352 status
= acpi_gsb_i2c_read_bytes(client
, command
,
353 gsb
->data
, info
->access_length
);
357 status
= acpi_gsb_i2c_write_bytes(client
, command
,
358 gsb
->data
, info
->access_length
);
363 pr_info("protocol(0x%02x) is not supported.\n", accessor_type
);
364 ret
= AE_BAD_PARAMETER
;
368 gsb
->status
= status
;
377 static int acpi_i2c_install_space_handler(struct i2c_adapter
*adapter
)
380 struct acpi_i2c_handler_data
*data
;
383 if (!adapter
->dev
.parent
)
386 handle
= ACPI_HANDLE(adapter
->dev
.parent
);
391 data
= kzalloc(sizeof(struct acpi_i2c_handler_data
),
396 data
->adapter
= adapter
;
397 status
= acpi_bus_attach_private_data(handle
, (void *)data
);
398 if (ACPI_FAILURE(status
)) {
403 status
= acpi_install_address_space_handler(handle
,
404 ACPI_ADR_SPACE_GSBUS
,
405 &acpi_i2c_space_handler
,
408 if (ACPI_FAILURE(status
)) {
409 dev_err(&adapter
->dev
, "Error installing i2c space handler\n");
410 acpi_bus_detach_private_data(handle
);
415 acpi_walk_dep_device_list(handle
);
419 static void acpi_i2c_remove_space_handler(struct i2c_adapter
*adapter
)
422 struct acpi_i2c_handler_data
*data
;
425 if (!adapter
->dev
.parent
)
428 handle
= ACPI_HANDLE(adapter
->dev
.parent
);
433 acpi_remove_address_space_handler(handle
,
434 ACPI_ADR_SPACE_GSBUS
,
435 &acpi_i2c_space_handler
);
437 status
= acpi_bus_get_private_data(handle
, (void **)&data
);
438 if (ACPI_SUCCESS(status
))
441 acpi_bus_detach_private_data(handle
);
443 #else /* CONFIG_ACPI_I2C_OPREGION */
444 static inline void acpi_i2c_remove_space_handler(struct i2c_adapter
*adapter
)
447 static inline int acpi_i2c_install_space_handler(struct i2c_adapter
*adapter
)
449 #endif /* CONFIG_ACPI_I2C_OPREGION */
451 /* ------------------------------------------------------------------------- */
453 static const struct i2c_device_id
*i2c_match_id(const struct i2c_device_id
*id
,
454 const struct i2c_client
*client
)
456 while (id
->name
[0]) {
457 if (strcmp(client
->name
, id
->name
) == 0)
464 static int i2c_device_match(struct device
*dev
, struct device_driver
*drv
)
466 struct i2c_client
*client
= i2c_verify_client(dev
);
467 struct i2c_driver
*driver
;
472 /* Attempt an OF style match */
473 if (of_driver_match_device(dev
, drv
))
476 /* Then ACPI style match */
477 if (acpi_driver_match_device(dev
, drv
))
480 driver
= to_i2c_driver(drv
);
481 /* match on an id table if there is one */
482 if (driver
->id_table
)
483 return i2c_match_id(driver
->id_table
, client
) != NULL
;
489 /* uevent helps with hotplug: modprobe -q $(MODALIAS) */
490 static int i2c_device_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
492 struct i2c_client
*client
= to_i2c_client(dev
);
495 rc
= acpi_device_uevent_modalias(dev
, env
);
499 if (add_uevent_var(env
, "MODALIAS=%s%s",
500 I2C_MODULE_PREFIX
, client
->name
))
502 dev_dbg(dev
, "uevent\n");
506 /* i2c bus recovery routines */
507 static int get_scl_gpio_value(struct i2c_adapter
*adap
)
509 return gpio_get_value(adap
->bus_recovery_info
->scl_gpio
);
512 static void set_scl_gpio_value(struct i2c_adapter
*adap
, int val
)
514 gpio_set_value(adap
->bus_recovery_info
->scl_gpio
, val
);
517 static int get_sda_gpio_value(struct i2c_adapter
*adap
)
519 return gpio_get_value(adap
->bus_recovery_info
->sda_gpio
);
522 static int i2c_get_gpios_for_recovery(struct i2c_adapter
*adap
)
524 struct i2c_bus_recovery_info
*bri
= adap
->bus_recovery_info
;
525 struct device
*dev
= &adap
->dev
;
528 ret
= gpio_request_one(bri
->scl_gpio
, GPIOF_OPEN_DRAIN
|
529 GPIOF_OUT_INIT_HIGH
, "i2c-scl");
531 dev_warn(dev
, "Can't get SCL gpio: %d\n", bri
->scl_gpio
);
536 if (gpio_request_one(bri
->sda_gpio
, GPIOF_IN
, "i2c-sda")) {
537 /* work without SDA polling */
538 dev_warn(dev
, "Can't get SDA gpio: %d. Not using SDA polling\n",
547 static void i2c_put_gpios_for_recovery(struct i2c_adapter
*adap
)
549 struct i2c_bus_recovery_info
*bri
= adap
->bus_recovery_info
;
552 gpio_free(bri
->sda_gpio
);
554 gpio_free(bri
->scl_gpio
);
558 * We are generating clock pulses. ndelay() determines durating of clk pulses.
559 * We will generate clock with rate 100 KHz and so duration of both clock levels
560 * is: delay in ns = (10^6 / 100) / 2
562 #define RECOVERY_NDELAY 5000
563 #define RECOVERY_CLK_CNT 9
565 static int i2c_generic_recovery(struct i2c_adapter
*adap
)
567 struct i2c_bus_recovery_info
*bri
= adap
->bus_recovery_info
;
568 int i
= 0, val
= 1, ret
= 0;
570 if (bri
->prepare_recovery
)
571 bri
->prepare_recovery(adap
);
573 bri
->set_scl(adap
, val
);
574 ndelay(RECOVERY_NDELAY
);
577 * By this time SCL is high, as we need to give 9 falling-rising edges
579 while (i
++ < RECOVERY_CLK_CNT
* 2) {
581 /* Break if SDA is high */
582 if (bri
->get_sda
&& bri
->get_sda(adap
))
584 /* SCL shouldn't be low here */
585 if (!bri
->get_scl(adap
)) {
587 "SCL is stuck low, exit recovery\n");
594 bri
->set_scl(adap
, val
);
595 ndelay(RECOVERY_NDELAY
);
598 if (bri
->unprepare_recovery
)
599 bri
->unprepare_recovery(adap
);
604 int i2c_generic_scl_recovery(struct i2c_adapter
*adap
)
606 return i2c_generic_recovery(adap
);
608 EXPORT_SYMBOL_GPL(i2c_generic_scl_recovery
);
610 int i2c_generic_gpio_recovery(struct i2c_adapter
*adap
)
614 ret
= i2c_get_gpios_for_recovery(adap
);
618 ret
= i2c_generic_recovery(adap
);
619 i2c_put_gpios_for_recovery(adap
);
623 EXPORT_SYMBOL_GPL(i2c_generic_gpio_recovery
);
625 int i2c_recover_bus(struct i2c_adapter
*adap
)
627 if (!adap
->bus_recovery_info
)
630 dev_dbg(&adap
->dev
, "Trying i2c bus recovery\n");
631 return adap
->bus_recovery_info
->recover_bus(adap
);
633 EXPORT_SYMBOL_GPL(i2c_recover_bus
);
635 static int i2c_device_probe(struct device
*dev
)
637 struct i2c_client
*client
= i2c_verify_client(dev
);
638 struct i2c_driver
*driver
;
648 irq
= of_irq_get(dev
->of_node
, 0);
649 else if (ACPI_COMPANION(dev
))
650 irq
= acpi_dev_gpio_irq_get(ACPI_COMPANION(dev
), 0);
652 if (irq
== -EPROBE_DEFER
)
660 driver
= to_i2c_driver(dev
->driver
);
661 if (!driver
->probe
|| !driver
->id_table
)
664 if (!device_can_wakeup(&client
->dev
))
665 device_init_wakeup(&client
->dev
,
666 client
->flags
& I2C_CLIENT_WAKE
);
667 dev_dbg(dev
, "probe\n");
669 status
= of_clk_set_defaults(dev
->of_node
, false);
673 status
= dev_pm_domain_attach(&client
->dev
, true);
674 if (status
!= -EPROBE_DEFER
) {
675 status
= driver
->probe(client
, i2c_match_id(driver
->id_table
,
678 dev_pm_domain_detach(&client
->dev
, true);
684 static int i2c_device_remove(struct device
*dev
)
686 struct i2c_client
*client
= i2c_verify_client(dev
);
687 struct i2c_driver
*driver
;
690 if (!client
|| !dev
->driver
)
693 driver
= to_i2c_driver(dev
->driver
);
694 if (driver
->remove
) {
695 dev_dbg(dev
, "remove\n");
696 status
= driver
->remove(client
);
699 dev_pm_domain_detach(&client
->dev
, true);
703 static void i2c_device_shutdown(struct device
*dev
)
705 struct i2c_client
*client
= i2c_verify_client(dev
);
706 struct i2c_driver
*driver
;
708 if (!client
|| !dev
->driver
)
710 driver
= to_i2c_driver(dev
->driver
);
711 if (driver
->shutdown
)
712 driver
->shutdown(client
);
715 static void i2c_client_dev_release(struct device
*dev
)
717 kfree(to_i2c_client(dev
));
721 show_name(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
723 return sprintf(buf
, "%s\n", dev
->type
== &i2c_client_type
?
724 to_i2c_client(dev
)->name
: to_i2c_adapter(dev
)->name
);
726 static DEVICE_ATTR(name
, S_IRUGO
, show_name
, NULL
);
729 show_modalias(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
731 struct i2c_client
*client
= to_i2c_client(dev
);
734 len
= acpi_device_modalias(dev
, buf
, PAGE_SIZE
-1);
738 return sprintf(buf
, "%s%s\n", I2C_MODULE_PREFIX
, client
->name
);
740 static DEVICE_ATTR(modalias
, S_IRUGO
, show_modalias
, NULL
);
742 static struct attribute
*i2c_dev_attrs
[] = {
744 /* modalias helps coldplug: modprobe $(cat .../modalias) */
745 &dev_attr_modalias
.attr
,
748 ATTRIBUTE_GROUPS(i2c_dev
);
750 struct bus_type i2c_bus_type
= {
752 .match
= i2c_device_match
,
753 .probe
= i2c_device_probe
,
754 .remove
= i2c_device_remove
,
755 .shutdown
= i2c_device_shutdown
,
757 EXPORT_SYMBOL_GPL(i2c_bus_type
);
759 static struct device_type i2c_client_type
= {
760 .groups
= i2c_dev_groups
,
761 .uevent
= i2c_device_uevent
,
762 .release
= i2c_client_dev_release
,
767 * i2c_verify_client - return parameter as i2c_client, or NULL
768 * @dev: device, probably from some driver model iterator
770 * When traversing the driver model tree, perhaps using driver model
771 * iterators like @device_for_each_child(), you can't assume very much
772 * about the nodes you find. Use this function to avoid oopses caused
773 * by wrongly treating some non-I2C device as an i2c_client.
775 struct i2c_client
*i2c_verify_client(struct device
*dev
)
777 return (dev
->type
== &i2c_client_type
)
781 EXPORT_SYMBOL(i2c_verify_client
);
784 /* Return a unique address which takes the flags of the client into account */
785 static unsigned short i2c_encode_flags_to_addr(struct i2c_client
*client
)
787 unsigned short addr
= client
->addr
;
789 /* For some client flags, add an arbitrary offset to avoid collisions */
790 if (client
->flags
& I2C_CLIENT_TEN
)
791 addr
|= I2C_ADDR_OFFSET_TEN_BIT
;
793 if (client
->flags
& I2C_CLIENT_SLAVE
)
794 addr
|= I2C_ADDR_OFFSET_SLAVE
;
799 /* This is a permissive address validity check, I2C address map constraints
800 * are purposely not enforced, except for the general call address. */
801 static int i2c_check_client_addr_validity(const struct i2c_client
*client
)
803 if (client
->flags
& I2C_CLIENT_TEN
) {
804 /* 10-bit address, all values are valid */
805 if (client
->addr
> 0x3ff)
808 /* 7-bit address, reject the general call address */
809 if (client
->addr
== 0x00 || client
->addr
> 0x7f)
815 /* And this is a strict address validity check, used when probing. If a
816 * device uses a reserved address, then it shouldn't be probed. 7-bit
817 * addressing is assumed, 10-bit address devices are rare and should be
818 * explicitly enumerated. */
819 static int i2c_check_addr_validity(unsigned short addr
)
822 * Reserved addresses per I2C specification:
823 * 0x00 General call address / START byte
825 * 0x02 Reserved for different bus format
826 * 0x03 Reserved for future purposes
827 * 0x04-0x07 Hs-mode master code
828 * 0x78-0x7b 10-bit slave addressing
829 * 0x7c-0x7f Reserved for future purposes
831 if (addr
< 0x08 || addr
> 0x77)
836 static int __i2c_check_addr_busy(struct device
*dev
, void *addrp
)
838 struct i2c_client
*client
= i2c_verify_client(dev
);
839 int addr
= *(int *)addrp
;
841 if (client
&& client
->addr
== addr
)
846 /* walk up mux tree */
847 static int i2c_check_mux_parents(struct i2c_adapter
*adapter
, int addr
)
849 struct i2c_adapter
*parent
= i2c_parent_is_i2c_adapter(adapter
);
852 result
= device_for_each_child(&adapter
->dev
, &addr
,
853 __i2c_check_addr_busy
);
855 if (!result
&& parent
)
856 result
= i2c_check_mux_parents(parent
, addr
);
861 /* recurse down mux tree */
862 static int i2c_check_mux_children(struct device
*dev
, void *addrp
)
866 if (dev
->type
== &i2c_adapter_type
)
867 result
= device_for_each_child(dev
, addrp
,
868 i2c_check_mux_children
);
870 result
= __i2c_check_addr_busy(dev
, addrp
);
875 static int i2c_check_addr_busy(struct i2c_adapter
*adapter
, int addr
)
877 struct i2c_adapter
*parent
= i2c_parent_is_i2c_adapter(adapter
);
881 result
= i2c_check_mux_parents(parent
, addr
);
884 result
= device_for_each_child(&adapter
->dev
, &addr
,
885 i2c_check_mux_children
);
891 * i2c_lock_adapter - Get exclusive access to an I2C bus segment
892 * @adapter: Target I2C bus segment
894 void i2c_lock_adapter(struct i2c_adapter
*adapter
)
896 struct i2c_adapter
*parent
= i2c_parent_is_i2c_adapter(adapter
);
899 i2c_lock_adapter(parent
);
901 rt_mutex_lock(&adapter
->bus_lock
);
903 EXPORT_SYMBOL_GPL(i2c_lock_adapter
);
906 * i2c_trylock_adapter - Try to get exclusive access to an I2C bus segment
907 * @adapter: Target I2C bus segment
909 static int i2c_trylock_adapter(struct i2c_adapter
*adapter
)
911 struct i2c_adapter
*parent
= i2c_parent_is_i2c_adapter(adapter
);
914 return i2c_trylock_adapter(parent
);
916 return rt_mutex_trylock(&adapter
->bus_lock
);
920 * i2c_unlock_adapter - Release exclusive access to an I2C bus segment
921 * @adapter: Target I2C bus segment
923 void i2c_unlock_adapter(struct i2c_adapter
*adapter
)
925 struct i2c_adapter
*parent
= i2c_parent_is_i2c_adapter(adapter
);
928 i2c_unlock_adapter(parent
);
930 rt_mutex_unlock(&adapter
->bus_lock
);
932 EXPORT_SYMBOL_GPL(i2c_unlock_adapter
);
934 static void i2c_dev_set_name(struct i2c_adapter
*adap
,
935 struct i2c_client
*client
)
937 struct acpi_device
*adev
= ACPI_COMPANION(&client
->dev
);
940 dev_set_name(&client
->dev
, "i2c-%s", acpi_dev_name(adev
));
944 dev_set_name(&client
->dev
, "%d-%04x", i2c_adapter_id(adap
),
945 i2c_encode_flags_to_addr(client
));
949 * i2c_new_device - instantiate an i2c device
950 * @adap: the adapter managing the device
951 * @info: describes one I2C device; bus_num is ignored
954 * Create an i2c device. Binding is handled through driver model
955 * probe()/remove() methods. A driver may be bound to this device when we
956 * return from this function, or any later moment (e.g. maybe hotplugging will
957 * load the driver module). This call is not appropriate for use by mainboard
958 * initialization logic, which usually runs during an arch_initcall() long
959 * before any i2c_adapter could exist.
961 * This returns the new i2c client, which may be saved for later use with
962 * i2c_unregister_device(); or NULL to indicate an error.
965 i2c_new_device(struct i2c_adapter
*adap
, struct i2c_board_info
const *info
)
967 struct i2c_client
*client
;
970 client
= kzalloc(sizeof *client
, GFP_KERNEL
);
974 client
->adapter
= adap
;
976 client
->dev
.platform_data
= info
->platform_data
;
979 client
->dev
.archdata
= *info
->archdata
;
981 client
->flags
= info
->flags
;
982 client
->addr
= info
->addr
;
983 client
->irq
= info
->irq
;
985 strlcpy(client
->name
, info
->type
, sizeof(client
->name
));
987 /* Check for address validity */
988 status
= i2c_check_client_addr_validity(client
);
990 dev_err(&adap
->dev
, "Invalid %d-bit I2C address 0x%02hx\n",
991 client
->flags
& I2C_CLIENT_TEN
? 10 : 7, client
->addr
);
995 /* Check for address business */
996 status
= i2c_check_addr_busy(adap
, client
->addr
);
1000 client
->dev
.parent
= &client
->adapter
->dev
;
1001 client
->dev
.bus
= &i2c_bus_type
;
1002 client
->dev
.type
= &i2c_client_type
;
1003 client
->dev
.of_node
= info
->of_node
;
1004 client
->dev
.fwnode
= info
->fwnode
;
1006 i2c_dev_set_name(adap
, client
);
1007 status
= device_register(&client
->dev
);
1011 dev_dbg(&adap
->dev
, "client [%s] registered with bus id %s\n",
1012 client
->name
, dev_name(&client
->dev
));
1017 dev_err(&adap
->dev
, "Failed to register i2c client %s at 0x%02x "
1018 "(%d)\n", client
->name
, client
->addr
, status
);
1023 EXPORT_SYMBOL_GPL(i2c_new_device
);
1027 * i2c_unregister_device - reverse effect of i2c_new_device()
1028 * @client: value returned from i2c_new_device()
1029 * Context: can sleep
1031 void i2c_unregister_device(struct i2c_client
*client
)
1033 if (client
->dev
.of_node
)
1034 of_node_clear_flag(client
->dev
.of_node
, OF_POPULATED
);
1035 device_unregister(&client
->dev
);
1037 EXPORT_SYMBOL_GPL(i2c_unregister_device
);
1040 static const struct i2c_device_id dummy_id
[] = {
1045 static int dummy_probe(struct i2c_client
*client
,
1046 const struct i2c_device_id
*id
)
1051 static int dummy_remove(struct i2c_client
*client
)
1056 static struct i2c_driver dummy_driver
= {
1057 .driver
.name
= "dummy",
1058 .probe
= dummy_probe
,
1059 .remove
= dummy_remove
,
1060 .id_table
= dummy_id
,
1064 * i2c_new_dummy - return a new i2c device bound to a dummy driver
1065 * @adapter: the adapter managing the device
1066 * @address: seven bit address to be used
1067 * Context: can sleep
1069 * This returns an I2C client bound to the "dummy" driver, intended for use
1070 * with devices that consume multiple addresses. Examples of such chips
1071 * include various EEPROMS (like 24c04 and 24c08 models).
1073 * These dummy devices have two main uses. First, most I2C and SMBus calls
1074 * except i2c_transfer() need a client handle; the dummy will be that handle.
1075 * And second, this prevents the specified address from being bound to a
1078 * This returns the new i2c client, which should be saved for later use with
1079 * i2c_unregister_device(); or NULL to indicate an error.
1081 struct i2c_client
*i2c_new_dummy(struct i2c_adapter
*adapter
, u16 address
)
1083 struct i2c_board_info info
= {
1084 I2C_BOARD_INFO("dummy", address
),
1087 return i2c_new_device(adapter
, &info
);
1089 EXPORT_SYMBOL_GPL(i2c_new_dummy
);
1091 /* ------------------------------------------------------------------------- */
1093 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
1095 static void i2c_adapter_dev_release(struct device
*dev
)
1097 struct i2c_adapter
*adap
= to_i2c_adapter(dev
);
1098 complete(&adap
->dev_released
);
1102 * This function is only needed for mutex_lock_nested, so it is never
1103 * called unless locking correctness checking is enabled. Thus we
1104 * make it inline to avoid a compiler warning. That's what gcc ends up
1107 static inline unsigned int i2c_adapter_depth(struct i2c_adapter
*adapter
)
1109 unsigned int depth
= 0;
1111 while ((adapter
= i2c_parent_is_i2c_adapter(adapter
)))
1118 * Let users instantiate I2C devices through sysfs. This can be used when
1119 * platform initialization code doesn't contain the proper data for
1120 * whatever reason. Also useful for drivers that do device detection and
1121 * detection fails, either because the device uses an unexpected address,
1122 * or this is a compatible device with different ID register values.
1124 * Parameter checking may look overzealous, but we really don't want
1125 * the user to provide incorrect parameters.
1128 i2c_sysfs_new_device(struct device
*dev
, struct device_attribute
*attr
,
1129 const char *buf
, size_t count
)
1131 struct i2c_adapter
*adap
= to_i2c_adapter(dev
);
1132 struct i2c_board_info info
;
1133 struct i2c_client
*client
;
1137 memset(&info
, 0, sizeof(struct i2c_board_info
));
1139 blank
= strchr(buf
, ' ');
1141 dev_err(dev
, "%s: Missing parameters\n", "new_device");
1144 if (blank
- buf
> I2C_NAME_SIZE
- 1) {
1145 dev_err(dev
, "%s: Invalid device name\n", "new_device");
1148 memcpy(info
.type
, buf
, blank
- buf
);
1150 /* Parse remaining parameters, reject extra parameters */
1151 res
= sscanf(++blank
, "%hi%c", &info
.addr
, &end
);
1153 dev_err(dev
, "%s: Can't parse I2C address\n", "new_device");
1156 if (res
> 1 && end
!= '\n') {
1157 dev_err(dev
, "%s: Extra parameters\n", "new_device");
1161 client
= i2c_new_device(adap
, &info
);
1165 /* Keep track of the added device */
1166 mutex_lock(&adap
->userspace_clients_lock
);
1167 list_add_tail(&client
->detected
, &adap
->userspace_clients
);
1168 mutex_unlock(&adap
->userspace_clients_lock
);
1169 dev_info(dev
, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
1170 info
.type
, info
.addr
);
1174 static DEVICE_ATTR(new_device
, S_IWUSR
, NULL
, i2c_sysfs_new_device
);
1177 * And of course let the users delete the devices they instantiated, if
1178 * they got it wrong. This interface can only be used to delete devices
1179 * instantiated by i2c_sysfs_new_device above. This guarantees that we
1180 * don't delete devices to which some kernel code still has references.
1182 * Parameter checking may look overzealous, but we really don't want
1183 * the user to delete the wrong device.
1186 i2c_sysfs_delete_device(struct device
*dev
, struct device_attribute
*attr
,
1187 const char *buf
, size_t count
)
1189 struct i2c_adapter
*adap
= to_i2c_adapter(dev
);
1190 struct i2c_client
*client
, *next
;
1191 unsigned short addr
;
1195 /* Parse parameters, reject extra parameters */
1196 res
= sscanf(buf
, "%hi%c", &addr
, &end
);
1198 dev_err(dev
, "%s: Can't parse I2C address\n", "delete_device");
1201 if (res
> 1 && end
!= '\n') {
1202 dev_err(dev
, "%s: Extra parameters\n", "delete_device");
1206 /* Make sure the device was added through sysfs */
1208 mutex_lock_nested(&adap
->userspace_clients_lock
,
1209 i2c_adapter_depth(adap
));
1210 list_for_each_entry_safe(client
, next
, &adap
->userspace_clients
,
1212 if (client
->addr
== addr
) {
1213 dev_info(dev
, "%s: Deleting device %s at 0x%02hx\n",
1214 "delete_device", client
->name
, client
->addr
);
1216 list_del(&client
->detected
);
1217 i2c_unregister_device(client
);
1222 mutex_unlock(&adap
->userspace_clients_lock
);
1225 dev_err(dev
, "%s: Can't find device in list\n",
1229 static DEVICE_ATTR_IGNORE_LOCKDEP(delete_device
, S_IWUSR
, NULL
,
1230 i2c_sysfs_delete_device
);
1232 static struct attribute
*i2c_adapter_attrs
[] = {
1233 &dev_attr_name
.attr
,
1234 &dev_attr_new_device
.attr
,
1235 &dev_attr_delete_device
.attr
,
1238 ATTRIBUTE_GROUPS(i2c_adapter
);
1240 struct device_type i2c_adapter_type
= {
1241 .groups
= i2c_adapter_groups
,
1242 .release
= i2c_adapter_dev_release
,
1244 EXPORT_SYMBOL_GPL(i2c_adapter_type
);
1247 * i2c_verify_adapter - return parameter as i2c_adapter or NULL
1248 * @dev: device, probably from some driver model iterator
1250 * When traversing the driver model tree, perhaps using driver model
1251 * iterators like @device_for_each_child(), you can't assume very much
1252 * about the nodes you find. Use this function to avoid oopses caused
1253 * by wrongly treating some non-I2C device as an i2c_adapter.
1255 struct i2c_adapter
*i2c_verify_adapter(struct device
*dev
)
1257 return (dev
->type
== &i2c_adapter_type
)
1258 ? to_i2c_adapter(dev
)
1261 EXPORT_SYMBOL(i2c_verify_adapter
);
1263 #ifdef CONFIG_I2C_COMPAT
1264 static struct class_compat
*i2c_adapter_compat_class
;
1267 static void i2c_scan_static_board_info(struct i2c_adapter
*adapter
)
1269 struct i2c_devinfo
*devinfo
;
1271 down_read(&__i2c_board_lock
);
1272 list_for_each_entry(devinfo
, &__i2c_board_list
, list
) {
1273 if (devinfo
->busnum
== adapter
->nr
1274 && !i2c_new_device(adapter
,
1275 &devinfo
->board_info
))
1276 dev_err(&adapter
->dev
,
1277 "Can't create device at 0x%02x\n",
1278 devinfo
->board_info
.addr
);
1280 up_read(&__i2c_board_lock
);
1283 /* OF support code */
1285 #if IS_ENABLED(CONFIG_OF)
1286 static struct i2c_client
*of_i2c_register_device(struct i2c_adapter
*adap
,
1287 struct device_node
*node
)
1289 struct i2c_client
*result
;
1290 struct i2c_board_info info
= {};
1291 struct dev_archdata dev_ad
= {};
1295 dev_dbg(&adap
->dev
, "of_i2c: register %s\n", node
->full_name
);
1297 if (of_modalias_node(node
, info
.type
, sizeof(info
.type
)) < 0) {
1298 dev_err(&adap
->dev
, "of_i2c: modalias failure on %s\n",
1300 return ERR_PTR(-EINVAL
);
1303 addr
= of_get_property(node
, "reg", &len
);
1304 if (!addr
|| (len
< sizeof(*addr
))) {
1305 dev_err(&adap
->dev
, "of_i2c: invalid reg on %s\n",
1307 return ERR_PTR(-EINVAL
);
1310 info
.addr
= be32_to_cpup(addr
);
1311 if (info
.addr
> (1 << 10) - 1) {
1312 dev_err(&adap
->dev
, "of_i2c: invalid addr=%x on %s\n",
1313 info
.addr
, node
->full_name
);
1314 return ERR_PTR(-EINVAL
);
1317 info
.of_node
= of_node_get(node
);
1318 info
.archdata
= &dev_ad
;
1320 if (of_get_property(node
, "wakeup-source", NULL
))
1321 info
.flags
|= I2C_CLIENT_WAKE
;
1323 result
= i2c_new_device(adap
, &info
);
1324 if (result
== NULL
) {
1325 dev_err(&adap
->dev
, "of_i2c: Failure registering %s\n",
1328 return ERR_PTR(-EINVAL
);
1333 static void of_i2c_register_devices(struct i2c_adapter
*adap
)
1335 struct device_node
*node
;
1337 /* Only register child devices if the adapter has a node pointer set */
1338 if (!adap
->dev
.of_node
)
1341 dev_dbg(&adap
->dev
, "of_i2c: walking child nodes\n");
1343 for_each_available_child_of_node(adap
->dev
.of_node
, node
) {
1344 if (of_node_test_and_set_flag(node
, OF_POPULATED
))
1346 of_i2c_register_device(adap
, node
);
1350 static int of_dev_node_match(struct device
*dev
, void *data
)
1352 return dev
->of_node
== data
;
1355 /* must call put_device() when done with returned i2c_client device */
1356 struct i2c_client
*of_find_i2c_device_by_node(struct device_node
*node
)
1359 struct i2c_client
*client
;
1361 dev
= bus_find_device(&i2c_bus_type
, NULL
, node
, of_dev_node_match
);
1365 client
= i2c_verify_client(dev
);
1371 EXPORT_SYMBOL(of_find_i2c_device_by_node
);
1373 /* must call put_device() when done with returned i2c_adapter device */
1374 struct i2c_adapter
*of_find_i2c_adapter_by_node(struct device_node
*node
)
1377 struct i2c_adapter
*adapter
;
1379 dev
= bus_find_device(&i2c_bus_type
, NULL
, node
, of_dev_node_match
);
1383 adapter
= i2c_verify_adapter(dev
);
1389 EXPORT_SYMBOL(of_find_i2c_adapter_by_node
);
1391 /* must call i2c_put_adapter() when done with returned i2c_adapter device */
1392 struct i2c_adapter
*of_get_i2c_adapter_by_node(struct device_node
*node
)
1394 struct i2c_adapter
*adapter
;
1396 adapter
= of_find_i2c_adapter_by_node(node
);
1400 if (!try_module_get(adapter
->owner
)) {
1401 put_device(&adapter
->dev
);
1407 EXPORT_SYMBOL(of_get_i2c_adapter_by_node
);
1409 static void of_i2c_register_devices(struct i2c_adapter
*adap
) { }
1410 #endif /* CONFIG_OF */
1412 static int i2c_do_add_adapter(struct i2c_driver
*driver
,
1413 struct i2c_adapter
*adap
)
1415 /* Detect supported devices on that bus, and instantiate them */
1416 i2c_detect(adap
, driver
);
1418 /* Let legacy drivers scan this bus for matching devices */
1419 if (driver
->attach_adapter
) {
1420 dev_warn(&adap
->dev
, "%s: attach_adapter method is deprecated\n",
1421 driver
->driver
.name
);
1422 dev_warn(&adap
->dev
, "Please use another way to instantiate "
1423 "your i2c_client\n");
1424 /* We ignore the return code; if it fails, too bad */
1425 driver
->attach_adapter(adap
);
1430 static int __process_new_adapter(struct device_driver
*d
, void *data
)
1432 return i2c_do_add_adapter(to_i2c_driver(d
), data
);
1435 static int i2c_register_adapter(struct i2c_adapter
*adap
)
1439 /* Can't register until after driver model init */
1440 if (unlikely(WARN_ON(!i2c_bus_type
.p
))) {
1446 if (unlikely(adap
->name
[0] == '\0')) {
1447 pr_err("i2c-core: Attempt to register an adapter with "
1451 if (unlikely(!adap
->algo
)) {
1452 pr_err("i2c-core: Attempt to register adapter '%s' with "
1453 "no algo!\n", adap
->name
);
1457 rt_mutex_init(&adap
->bus_lock
);
1458 mutex_init(&adap
->userspace_clients_lock
);
1459 INIT_LIST_HEAD(&adap
->userspace_clients
);
1461 /* Set default timeout to 1 second if not already set */
1462 if (adap
->timeout
== 0)
1465 dev_set_name(&adap
->dev
, "i2c-%d", adap
->nr
);
1466 adap
->dev
.bus
= &i2c_bus_type
;
1467 adap
->dev
.type
= &i2c_adapter_type
;
1468 res
= device_register(&adap
->dev
);
1472 dev_dbg(&adap
->dev
, "adapter [%s] registered\n", adap
->name
);
1474 pm_runtime_no_callbacks(&adap
->dev
);
1476 #ifdef CONFIG_I2C_COMPAT
1477 res
= class_compat_create_link(i2c_adapter_compat_class
, &adap
->dev
,
1480 dev_warn(&adap
->dev
,
1481 "Failed to create compatibility class link\n");
1484 /* bus recovery specific initialization */
1485 if (adap
->bus_recovery_info
) {
1486 struct i2c_bus_recovery_info
*bri
= adap
->bus_recovery_info
;
1488 if (!bri
->recover_bus
) {
1489 dev_err(&adap
->dev
, "No recover_bus() found, not using recovery\n");
1490 adap
->bus_recovery_info
= NULL
;
1494 /* Generic GPIO recovery */
1495 if (bri
->recover_bus
== i2c_generic_gpio_recovery
) {
1496 if (!gpio_is_valid(bri
->scl_gpio
)) {
1497 dev_err(&adap
->dev
, "Invalid SCL gpio, not using recovery\n");
1498 adap
->bus_recovery_info
= NULL
;
1502 if (gpio_is_valid(bri
->sda_gpio
))
1503 bri
->get_sda
= get_sda_gpio_value
;
1505 bri
->get_sda
= NULL
;
1507 bri
->get_scl
= get_scl_gpio_value
;
1508 bri
->set_scl
= set_scl_gpio_value
;
1509 } else if (!bri
->set_scl
|| !bri
->get_scl
) {
1510 /* Generic SCL recovery */
1511 dev_err(&adap
->dev
, "No {get|set}_gpio() found, not using recovery\n");
1512 adap
->bus_recovery_info
= NULL
;
1517 /* create pre-declared device nodes */
1518 of_i2c_register_devices(adap
);
1519 acpi_i2c_register_devices(adap
);
1520 acpi_i2c_install_space_handler(adap
);
1522 if (adap
->nr
< __i2c_first_dynamic_bus_num
)
1523 i2c_scan_static_board_info(adap
);
1525 /* Notify drivers */
1526 mutex_lock(&core_lock
);
1527 bus_for_each_drv(&i2c_bus_type
, NULL
, adap
, __process_new_adapter
);
1528 mutex_unlock(&core_lock
);
1533 mutex_lock(&core_lock
);
1534 idr_remove(&i2c_adapter_idr
, adap
->nr
);
1535 mutex_unlock(&core_lock
);
1540 * __i2c_add_numbered_adapter - i2c_add_numbered_adapter where nr is never -1
1541 * @adap: the adapter to register (with adap->nr initialized)
1542 * Context: can sleep
1544 * See i2c_add_numbered_adapter() for details.
1546 static int __i2c_add_numbered_adapter(struct i2c_adapter
*adap
)
1550 mutex_lock(&core_lock
);
1551 id
= idr_alloc(&i2c_adapter_idr
, adap
, adap
->nr
, adap
->nr
+ 1,
1553 mutex_unlock(&core_lock
);
1555 return id
== -ENOSPC
? -EBUSY
: id
;
1557 return i2c_register_adapter(adap
);
1561 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
1562 * @adapter: the adapter to add
1563 * Context: can sleep
1565 * This routine is used to declare an I2C adapter when its bus number
1566 * doesn't matter or when its bus number is specified by an dt alias.
1567 * Examples of bases when the bus number doesn't matter: I2C adapters
1568 * dynamically added by USB links or PCI plugin cards.
1570 * When this returns zero, a new bus number was allocated and stored
1571 * in adap->nr, and the specified adapter became available for clients.
1572 * Otherwise, a negative errno value is returned.
1574 int i2c_add_adapter(struct i2c_adapter
*adapter
)
1576 struct device
*dev
= &adapter
->dev
;
1580 id
= of_alias_get_id(dev
->of_node
, "i2c");
1583 return __i2c_add_numbered_adapter(adapter
);
1587 mutex_lock(&core_lock
);
1588 id
= idr_alloc(&i2c_adapter_idr
, adapter
,
1589 __i2c_first_dynamic_bus_num
, 0, GFP_KERNEL
);
1590 mutex_unlock(&core_lock
);
1596 return i2c_register_adapter(adapter
);
1598 EXPORT_SYMBOL(i2c_add_adapter
);
1601 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
1602 * @adap: the adapter to register (with adap->nr initialized)
1603 * Context: can sleep
1605 * This routine is used to declare an I2C adapter when its bus number
1606 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
1607 * or otherwise built in to the system's mainboard, and where i2c_board_info
1608 * is used to properly configure I2C devices.
1610 * If the requested bus number is set to -1, then this function will behave
1611 * identically to i2c_add_adapter, and will dynamically assign a bus number.
1613 * If no devices have pre-been declared for this bus, then be sure to
1614 * register the adapter before any dynamically allocated ones. Otherwise
1615 * the required bus ID may not be available.
1617 * When this returns zero, the specified adapter became available for
1618 * clients using the bus number provided in adap->nr. Also, the table
1619 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
1620 * and the appropriate driver model device nodes are created. Otherwise, a
1621 * negative errno value is returned.
1623 int i2c_add_numbered_adapter(struct i2c_adapter
*adap
)
1625 if (adap
->nr
== -1) /* -1 means dynamically assign bus id */
1626 return i2c_add_adapter(adap
);
1628 return __i2c_add_numbered_adapter(adap
);
1630 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter
);
1632 static void i2c_do_del_adapter(struct i2c_driver
*driver
,
1633 struct i2c_adapter
*adapter
)
1635 struct i2c_client
*client
, *_n
;
1637 /* Remove the devices we created ourselves as the result of hardware
1638 * probing (using a driver's detect method) */
1639 list_for_each_entry_safe(client
, _n
, &driver
->clients
, detected
) {
1640 if (client
->adapter
== adapter
) {
1641 dev_dbg(&adapter
->dev
, "Removing %s at 0x%x\n",
1642 client
->name
, client
->addr
);
1643 list_del(&client
->detected
);
1644 i2c_unregister_device(client
);
1649 static int __unregister_client(struct device
*dev
, void *dummy
)
1651 struct i2c_client
*client
= i2c_verify_client(dev
);
1652 if (client
&& strcmp(client
->name
, "dummy"))
1653 i2c_unregister_device(client
);
1657 static int __unregister_dummy(struct device
*dev
, void *dummy
)
1659 struct i2c_client
*client
= i2c_verify_client(dev
);
1661 i2c_unregister_device(client
);
1665 static int __process_removed_adapter(struct device_driver
*d
, void *data
)
1667 i2c_do_del_adapter(to_i2c_driver(d
), data
);
1672 * i2c_del_adapter - unregister I2C adapter
1673 * @adap: the adapter being unregistered
1674 * Context: can sleep
1676 * This unregisters an I2C adapter which was previously registered
1677 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
1679 void i2c_del_adapter(struct i2c_adapter
*adap
)
1681 struct i2c_adapter
*found
;
1682 struct i2c_client
*client
, *next
;
1684 /* First make sure that this adapter was ever added */
1685 mutex_lock(&core_lock
);
1686 found
= idr_find(&i2c_adapter_idr
, adap
->nr
);
1687 mutex_unlock(&core_lock
);
1688 if (found
!= adap
) {
1689 pr_debug("i2c-core: attempting to delete unregistered "
1690 "adapter [%s]\n", adap
->name
);
1694 acpi_i2c_remove_space_handler(adap
);
1695 /* Tell drivers about this removal */
1696 mutex_lock(&core_lock
);
1697 bus_for_each_drv(&i2c_bus_type
, NULL
, adap
,
1698 __process_removed_adapter
);
1699 mutex_unlock(&core_lock
);
1701 /* Remove devices instantiated from sysfs */
1702 mutex_lock_nested(&adap
->userspace_clients_lock
,
1703 i2c_adapter_depth(adap
));
1704 list_for_each_entry_safe(client
, next
, &adap
->userspace_clients
,
1706 dev_dbg(&adap
->dev
, "Removing %s at 0x%x\n", client
->name
,
1708 list_del(&client
->detected
);
1709 i2c_unregister_device(client
);
1711 mutex_unlock(&adap
->userspace_clients_lock
);
1713 /* Detach any active clients. This can't fail, thus we do not
1714 * check the returned value. This is a two-pass process, because
1715 * we can't remove the dummy devices during the first pass: they
1716 * could have been instantiated by real devices wishing to clean
1717 * them up properly, so we give them a chance to do that first. */
1718 device_for_each_child(&adap
->dev
, NULL
, __unregister_client
);
1719 device_for_each_child(&adap
->dev
, NULL
, __unregister_dummy
);
1721 #ifdef CONFIG_I2C_COMPAT
1722 class_compat_remove_link(i2c_adapter_compat_class
, &adap
->dev
,
1726 /* device name is gone after device_unregister */
1727 dev_dbg(&adap
->dev
, "adapter [%s] unregistered\n", adap
->name
);
1729 /* wait until all references to the device are gone
1731 * FIXME: This is old code and should ideally be replaced by an
1732 * alternative which results in decoupling the lifetime of the struct
1733 * device from the i2c_adapter, like spi or netdev do. Any solution
1734 * should be thoroughly tested with DEBUG_KOBJECT_RELEASE enabled!
1736 init_completion(&adap
->dev_released
);
1737 device_unregister(&adap
->dev
);
1738 wait_for_completion(&adap
->dev_released
);
1741 mutex_lock(&core_lock
);
1742 idr_remove(&i2c_adapter_idr
, adap
->nr
);
1743 mutex_unlock(&core_lock
);
1745 /* Clear the device structure in case this adapter is ever going to be
1747 memset(&adap
->dev
, 0, sizeof(adap
->dev
));
1749 EXPORT_SYMBOL(i2c_del_adapter
);
1751 /* ------------------------------------------------------------------------- */
1753 int i2c_for_each_dev(void *data
, int (*fn
)(struct device
*, void *))
1757 mutex_lock(&core_lock
);
1758 res
= bus_for_each_dev(&i2c_bus_type
, NULL
, data
, fn
);
1759 mutex_unlock(&core_lock
);
1763 EXPORT_SYMBOL_GPL(i2c_for_each_dev
);
1765 static int __process_new_driver(struct device
*dev
, void *data
)
1767 if (dev
->type
!= &i2c_adapter_type
)
1769 return i2c_do_add_adapter(data
, to_i2c_adapter(dev
));
1773 * An i2c_driver is used with one or more i2c_client (device) nodes to access
1774 * i2c slave chips, on a bus instance associated with some i2c_adapter.
1777 int i2c_register_driver(struct module
*owner
, struct i2c_driver
*driver
)
1781 /* Can't register until after driver model init */
1782 if (unlikely(WARN_ON(!i2c_bus_type
.p
)))
1785 /* add the driver to the list of i2c drivers in the driver core */
1786 driver
->driver
.owner
= owner
;
1787 driver
->driver
.bus
= &i2c_bus_type
;
1789 /* When registration returns, the driver core
1790 * will have called probe() for all matching-but-unbound devices.
1792 res
= driver_register(&driver
->driver
);
1796 pr_debug("i2c-core: driver [%s] registered\n", driver
->driver
.name
);
1798 INIT_LIST_HEAD(&driver
->clients
);
1799 /* Walk the adapters that are already present */
1800 i2c_for_each_dev(driver
, __process_new_driver
);
1804 EXPORT_SYMBOL(i2c_register_driver
);
1806 static int __process_removed_driver(struct device
*dev
, void *data
)
1808 if (dev
->type
== &i2c_adapter_type
)
1809 i2c_do_del_adapter(data
, to_i2c_adapter(dev
));
1814 * i2c_del_driver - unregister I2C driver
1815 * @driver: the driver being unregistered
1816 * Context: can sleep
1818 void i2c_del_driver(struct i2c_driver
*driver
)
1820 i2c_for_each_dev(driver
, __process_removed_driver
);
1822 driver_unregister(&driver
->driver
);
1823 pr_debug("i2c-core: driver [%s] unregistered\n", driver
->driver
.name
);
1825 EXPORT_SYMBOL(i2c_del_driver
);
1827 /* ------------------------------------------------------------------------- */
1830 * i2c_use_client - increments the reference count of the i2c client structure
1831 * @client: the client being referenced
1833 * Each live reference to a client should be refcounted. The driver model does
1834 * that automatically as part of driver binding, so that most drivers don't
1835 * need to do this explicitly: they hold a reference until they're unbound
1838 * A pointer to the client with the incremented reference counter is returned.
1840 struct i2c_client
*i2c_use_client(struct i2c_client
*client
)
1842 if (client
&& get_device(&client
->dev
))
1846 EXPORT_SYMBOL(i2c_use_client
);
1849 * i2c_release_client - release a use of the i2c client structure
1850 * @client: the client being no longer referenced
1852 * Must be called when a user of a client is finished with it.
1854 void i2c_release_client(struct i2c_client
*client
)
1857 put_device(&client
->dev
);
1859 EXPORT_SYMBOL(i2c_release_client
);
1861 struct i2c_cmd_arg
{
1866 static int i2c_cmd(struct device
*dev
, void *_arg
)
1868 struct i2c_client
*client
= i2c_verify_client(dev
);
1869 struct i2c_cmd_arg
*arg
= _arg
;
1870 struct i2c_driver
*driver
;
1872 if (!client
|| !client
->dev
.driver
)
1875 driver
= to_i2c_driver(client
->dev
.driver
);
1876 if (driver
->command
)
1877 driver
->command(client
, arg
->cmd
, arg
->arg
);
1881 void i2c_clients_command(struct i2c_adapter
*adap
, unsigned int cmd
, void *arg
)
1883 struct i2c_cmd_arg cmd_arg
;
1887 device_for_each_child(&adap
->dev
, &cmd_arg
, i2c_cmd
);
1889 EXPORT_SYMBOL(i2c_clients_command
);
1891 #if IS_ENABLED(CONFIG_OF_DYNAMIC)
1892 static int of_i2c_notify(struct notifier_block
*nb
, unsigned long action
,
1895 struct of_reconfig_data
*rd
= arg
;
1896 struct i2c_adapter
*adap
;
1897 struct i2c_client
*client
;
1899 switch (of_reconfig_get_state_change(action
, rd
)) {
1900 case OF_RECONFIG_CHANGE_ADD
:
1901 adap
= of_find_i2c_adapter_by_node(rd
->dn
->parent
);
1903 return NOTIFY_OK
; /* not for us */
1905 if (of_node_test_and_set_flag(rd
->dn
, OF_POPULATED
)) {
1906 put_device(&adap
->dev
);
1910 client
= of_i2c_register_device(adap
, rd
->dn
);
1911 put_device(&adap
->dev
);
1913 if (IS_ERR(client
)) {
1914 pr_err("%s: failed to create for '%s'\n",
1915 __func__
, rd
->dn
->full_name
);
1916 return notifier_from_errno(PTR_ERR(client
));
1919 case OF_RECONFIG_CHANGE_REMOVE
:
1920 /* already depopulated? */
1921 if (!of_node_check_flag(rd
->dn
, OF_POPULATED
))
1924 /* find our device by node */
1925 client
= of_find_i2c_device_by_node(rd
->dn
);
1927 return NOTIFY_OK
; /* no? not meant for us */
1929 /* unregister takes one ref away */
1930 i2c_unregister_device(client
);
1932 /* and put the reference of the find */
1933 put_device(&client
->dev
);
1939 static struct notifier_block i2c_of_notifier
= {
1940 .notifier_call
= of_i2c_notify
,
1943 extern struct notifier_block i2c_of_notifier
;
1944 #endif /* CONFIG_OF_DYNAMIC */
1946 static int __init
i2c_init(void)
1950 retval
= of_alias_get_highest_id("i2c");
1952 down_write(&__i2c_board_lock
);
1953 if (retval
>= __i2c_first_dynamic_bus_num
)
1954 __i2c_first_dynamic_bus_num
= retval
+ 1;
1955 up_write(&__i2c_board_lock
);
1957 retval
= bus_register(&i2c_bus_type
);
1960 #ifdef CONFIG_I2C_COMPAT
1961 i2c_adapter_compat_class
= class_compat_register("i2c-adapter");
1962 if (!i2c_adapter_compat_class
) {
1967 retval
= i2c_add_driver(&dummy_driver
);
1971 if (IS_ENABLED(CONFIG_OF_DYNAMIC
))
1972 WARN_ON(of_reconfig_notifier_register(&i2c_of_notifier
));
1977 #ifdef CONFIG_I2C_COMPAT
1978 class_compat_unregister(i2c_adapter_compat_class
);
1981 bus_unregister(&i2c_bus_type
);
1985 static void __exit
i2c_exit(void)
1987 if (IS_ENABLED(CONFIG_OF_DYNAMIC
))
1988 WARN_ON(of_reconfig_notifier_unregister(&i2c_of_notifier
));
1989 i2c_del_driver(&dummy_driver
);
1990 #ifdef CONFIG_I2C_COMPAT
1991 class_compat_unregister(i2c_adapter_compat_class
);
1993 bus_unregister(&i2c_bus_type
);
1994 tracepoint_synchronize_unregister();
1997 /* We must initialize early, because some subsystems register i2c drivers
1998 * in subsys_initcall() code, but are linked (and initialized) before i2c.
2000 postcore_initcall(i2c_init
);
2001 module_exit(i2c_exit
);
2003 /* ----------------------------------------------------
2004 * the functional interface to the i2c busses.
2005 * ----------------------------------------------------
2008 /* Check if val is exceeding the quirk IFF quirk is non 0 */
2009 #define i2c_quirk_exceeded(val, quirk) ((quirk) && ((val) > (quirk)))
2011 static int i2c_quirk_error(struct i2c_adapter
*adap
, struct i2c_msg
*msg
, char *err_msg
)
2013 dev_err_ratelimited(&adap
->dev
, "adapter quirk: %s (addr 0x%04x, size %u, %s)\n",
2014 err_msg
, msg
->addr
, msg
->len
,
2015 msg
->flags
& I2C_M_RD
? "read" : "write");
2019 static int i2c_check_for_quirks(struct i2c_adapter
*adap
, struct i2c_msg
*msgs
, int num
)
2021 const struct i2c_adapter_quirks
*q
= adap
->quirks
;
2022 int max_num
= q
->max_num_msgs
, i
;
2023 bool do_len_check
= true;
2025 if (q
->flags
& I2C_AQ_COMB
) {
2028 /* special checks for combined messages */
2030 if (q
->flags
& I2C_AQ_COMB_WRITE_FIRST
&& msgs
[0].flags
& I2C_M_RD
)
2031 return i2c_quirk_error(adap
, &msgs
[0], "1st comb msg must be write");
2033 if (q
->flags
& I2C_AQ_COMB_READ_SECOND
&& !(msgs
[1].flags
& I2C_M_RD
))
2034 return i2c_quirk_error(adap
, &msgs
[1], "2nd comb msg must be read");
2036 if (q
->flags
& I2C_AQ_COMB_SAME_ADDR
&& msgs
[0].addr
!= msgs
[1].addr
)
2037 return i2c_quirk_error(adap
, &msgs
[0], "comb msg only to same addr");
2039 if (i2c_quirk_exceeded(msgs
[0].len
, q
->max_comb_1st_msg_len
))
2040 return i2c_quirk_error(adap
, &msgs
[0], "msg too long");
2042 if (i2c_quirk_exceeded(msgs
[1].len
, q
->max_comb_2nd_msg_len
))
2043 return i2c_quirk_error(adap
, &msgs
[1], "msg too long");
2045 do_len_check
= false;
2049 if (i2c_quirk_exceeded(num
, max_num
))
2050 return i2c_quirk_error(adap
, &msgs
[0], "too many messages");
2052 for (i
= 0; i
< num
; i
++) {
2053 u16 len
= msgs
[i
].len
;
2055 if (msgs
[i
].flags
& I2C_M_RD
) {
2056 if (do_len_check
&& i2c_quirk_exceeded(len
, q
->max_read_len
))
2057 return i2c_quirk_error(adap
, &msgs
[i
], "msg too long");
2059 if (do_len_check
&& i2c_quirk_exceeded(len
, q
->max_write_len
))
2060 return i2c_quirk_error(adap
, &msgs
[i
], "msg too long");
2068 * __i2c_transfer - unlocked flavor of i2c_transfer
2069 * @adap: Handle to I2C bus
2070 * @msgs: One or more messages to execute before STOP is issued to
2071 * terminate the operation; each message begins with a START.
2072 * @num: Number of messages to be executed.
2074 * Returns negative errno, else the number of messages executed.
2076 * Adapter lock must be held when calling this function. No debug logging
2077 * takes place. adap->algo->master_xfer existence isn't checked.
2079 int __i2c_transfer(struct i2c_adapter
*adap
, struct i2c_msg
*msgs
, int num
)
2081 unsigned long orig_jiffies
;
2084 if (adap
->quirks
&& i2c_check_for_quirks(adap
, msgs
, num
))
2087 /* i2c_trace_msg gets enabled when tracepoint i2c_transfer gets
2088 * enabled. This is an efficient way of keeping the for-loop from
2089 * being executed when not needed.
2091 if (static_key_false(&i2c_trace_msg
)) {
2093 for (i
= 0; i
< num
; i
++)
2094 if (msgs
[i
].flags
& I2C_M_RD
)
2095 trace_i2c_read(adap
, &msgs
[i
], i
);
2097 trace_i2c_write(adap
, &msgs
[i
], i
);
2100 /* Retry automatically on arbitration loss */
2101 orig_jiffies
= jiffies
;
2102 for (ret
= 0, try = 0; try <= adap
->retries
; try++) {
2103 ret
= adap
->algo
->master_xfer(adap
, msgs
, num
);
2106 if (time_after(jiffies
, orig_jiffies
+ adap
->timeout
))
2110 if (static_key_false(&i2c_trace_msg
)) {
2112 for (i
= 0; i
< ret
; i
++)
2113 if (msgs
[i
].flags
& I2C_M_RD
)
2114 trace_i2c_reply(adap
, &msgs
[i
], i
);
2115 trace_i2c_result(adap
, i
, ret
);
2120 EXPORT_SYMBOL(__i2c_transfer
);
2123 * i2c_transfer - execute a single or combined I2C message
2124 * @adap: Handle to I2C bus
2125 * @msgs: One or more messages to execute before STOP is issued to
2126 * terminate the operation; each message begins with a START.
2127 * @num: Number of messages to be executed.
2129 * Returns negative errno, else the number of messages executed.
2131 * Note that there is no requirement that each message be sent to
2132 * the same slave address, although that is the most common model.
2134 int i2c_transfer(struct i2c_adapter
*adap
, struct i2c_msg
*msgs
, int num
)
2138 /* REVISIT the fault reporting model here is weak:
2140 * - When we get an error after receiving N bytes from a slave,
2141 * there is no way to report "N".
2143 * - When we get a NAK after transmitting N bytes to a slave,
2144 * there is no way to report "N" ... or to let the master
2145 * continue executing the rest of this combined message, if
2146 * that's the appropriate response.
2148 * - When for example "num" is two and we successfully complete
2149 * the first message but get an error part way through the
2150 * second, it's unclear whether that should be reported as
2151 * one (discarding status on the second message) or errno
2152 * (discarding status on the first one).
2155 if (adap
->algo
->master_xfer
) {
2157 for (ret
= 0; ret
< num
; ret
++) {
2158 dev_dbg(&adap
->dev
, "master_xfer[%d] %c, addr=0x%02x, "
2159 "len=%d%s\n", ret
, (msgs
[ret
].flags
& I2C_M_RD
)
2160 ? 'R' : 'W', msgs
[ret
].addr
, msgs
[ret
].len
,
2161 (msgs
[ret
].flags
& I2C_M_RECV_LEN
) ? "+" : "");
2165 if (in_atomic() || irqs_disabled()) {
2166 ret
= i2c_trylock_adapter(adap
);
2168 /* I2C activity is ongoing. */
2171 i2c_lock_adapter(adap
);
2174 ret
= __i2c_transfer(adap
, msgs
, num
);
2175 i2c_unlock_adapter(adap
);
2179 dev_dbg(&adap
->dev
, "I2C level transfers not supported\n");
2183 EXPORT_SYMBOL(i2c_transfer
);
2186 * i2c_master_send - issue a single I2C message in master transmit mode
2187 * @client: Handle to slave device
2188 * @buf: Data that will be written to the slave
2189 * @count: How many bytes to write, must be less than 64k since msg.len is u16
2191 * Returns negative errno, or else the number of bytes written.
2193 int i2c_master_send(const struct i2c_client
*client
, const char *buf
, int count
)
2196 struct i2c_adapter
*adap
= client
->adapter
;
2199 msg
.addr
= client
->addr
;
2200 msg
.flags
= client
->flags
& I2C_M_TEN
;
2202 msg
.buf
= (char *)buf
;
2204 ret
= i2c_transfer(adap
, &msg
, 1);
2207 * If everything went ok (i.e. 1 msg transmitted), return #bytes
2208 * transmitted, else error code.
2210 return (ret
== 1) ? count
: ret
;
2212 EXPORT_SYMBOL(i2c_master_send
);
2215 * i2c_master_recv - issue a single I2C message in master receive mode
2216 * @client: Handle to slave device
2217 * @buf: Where to store data read from slave
2218 * @count: How many bytes to read, must be less than 64k since msg.len is u16
2220 * Returns negative errno, or else the number of bytes read.
2222 int i2c_master_recv(const struct i2c_client
*client
, char *buf
, int count
)
2224 struct i2c_adapter
*adap
= client
->adapter
;
2228 msg
.addr
= client
->addr
;
2229 msg
.flags
= client
->flags
& I2C_M_TEN
;
2230 msg
.flags
|= I2C_M_RD
;
2234 ret
= i2c_transfer(adap
, &msg
, 1);
2237 * If everything went ok (i.e. 1 msg received), return #bytes received,
2240 return (ret
== 1) ? count
: ret
;
2242 EXPORT_SYMBOL(i2c_master_recv
);
2244 /* ----------------------------------------------------
2245 * the i2c address scanning function
2246 * Will not work for 10-bit addresses!
2247 * ----------------------------------------------------
2251 * Legacy default probe function, mostly relevant for SMBus. The default
2252 * probe method is a quick write, but it is known to corrupt the 24RF08
2253 * EEPROMs due to a state machine bug, and could also irreversibly
2254 * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
2255 * we use a short byte read instead. Also, some bus drivers don't implement
2256 * quick write, so we fallback to a byte read in that case too.
2257 * On x86, there is another special case for FSC hardware monitoring chips,
2258 * which want regular byte reads (address 0x73.) Fortunately, these are the
2259 * only known chips using this I2C address on PC hardware.
2260 * Returns 1 if probe succeeded, 0 if not.
2262 static int i2c_default_probe(struct i2c_adapter
*adap
, unsigned short addr
)
2265 union i2c_smbus_data dummy
;
2268 if (addr
== 0x73 && (adap
->class & I2C_CLASS_HWMON
)
2269 && i2c_check_functionality(adap
, I2C_FUNC_SMBUS_READ_BYTE_DATA
))
2270 err
= i2c_smbus_xfer(adap
, addr
, 0, I2C_SMBUS_READ
, 0,
2271 I2C_SMBUS_BYTE_DATA
, &dummy
);
2274 if (!((addr
& ~0x07) == 0x30 || (addr
& ~0x0f) == 0x50)
2275 && i2c_check_functionality(adap
, I2C_FUNC_SMBUS_QUICK
))
2276 err
= i2c_smbus_xfer(adap
, addr
, 0, I2C_SMBUS_WRITE
, 0,
2277 I2C_SMBUS_QUICK
, NULL
);
2278 else if (i2c_check_functionality(adap
, I2C_FUNC_SMBUS_READ_BYTE
))
2279 err
= i2c_smbus_xfer(adap
, addr
, 0, I2C_SMBUS_READ
, 0,
2280 I2C_SMBUS_BYTE
, &dummy
);
2282 dev_warn(&adap
->dev
, "No suitable probing method supported for address 0x%02X\n",
2290 static int i2c_detect_address(struct i2c_client
*temp_client
,
2291 struct i2c_driver
*driver
)
2293 struct i2c_board_info info
;
2294 struct i2c_adapter
*adapter
= temp_client
->adapter
;
2295 int addr
= temp_client
->addr
;
2298 /* Make sure the address is valid */
2299 err
= i2c_check_addr_validity(addr
);
2301 dev_warn(&adapter
->dev
, "Invalid probe address 0x%02x\n",
2306 /* Skip if already in use */
2307 if (i2c_check_addr_busy(adapter
, addr
))
2310 /* Make sure there is something at this address */
2311 if (!i2c_default_probe(adapter
, addr
))
2314 /* Finally call the custom detection function */
2315 memset(&info
, 0, sizeof(struct i2c_board_info
));
2317 err
= driver
->detect(temp_client
, &info
);
2319 /* -ENODEV is returned if the detection fails. We catch it
2320 here as this isn't an error. */
2321 return err
== -ENODEV
? 0 : err
;
2324 /* Consistency check */
2325 if (info
.type
[0] == '\0') {
2326 dev_err(&adapter
->dev
, "%s detection function provided "
2327 "no name for 0x%x\n", driver
->driver
.name
,
2330 struct i2c_client
*client
;
2332 /* Detection succeeded, instantiate the device */
2333 if (adapter
->class & I2C_CLASS_DEPRECATED
)
2334 dev_warn(&adapter
->dev
,
2335 "This adapter will soon drop class based instantiation of devices. "
2336 "Please make sure client 0x%02x gets instantiated by other means. "
2337 "Check 'Documentation/i2c/instantiating-devices' for details.\n",
2340 dev_dbg(&adapter
->dev
, "Creating %s at 0x%02x\n",
2341 info
.type
, info
.addr
);
2342 client
= i2c_new_device(adapter
, &info
);
2344 list_add_tail(&client
->detected
, &driver
->clients
);
2346 dev_err(&adapter
->dev
, "Failed creating %s at 0x%02x\n",
2347 info
.type
, info
.addr
);
2352 static int i2c_detect(struct i2c_adapter
*adapter
, struct i2c_driver
*driver
)
2354 const unsigned short *address_list
;
2355 struct i2c_client
*temp_client
;
2357 int adap_id
= i2c_adapter_id(adapter
);
2359 address_list
= driver
->address_list
;
2360 if (!driver
->detect
|| !address_list
)
2363 /* Warn that the adapter lost class based instantiation */
2364 if (adapter
->class == I2C_CLASS_DEPRECATED
) {
2365 dev_dbg(&adapter
->dev
,
2366 "This adapter dropped support for I2C classes and "
2367 "won't auto-detect %s devices anymore. If you need it, check "
2368 "'Documentation/i2c/instantiating-devices' for alternatives.\n",
2369 driver
->driver
.name
);
2373 /* Stop here if the classes do not match */
2374 if (!(adapter
->class & driver
->class))
2377 /* Set up a temporary client to help detect callback */
2378 temp_client
= kzalloc(sizeof(struct i2c_client
), GFP_KERNEL
);
2381 temp_client
->adapter
= adapter
;
2383 for (i
= 0; address_list
[i
] != I2C_CLIENT_END
; i
+= 1) {
2384 dev_dbg(&adapter
->dev
, "found normal entry for adapter %d, "
2385 "addr 0x%02x\n", adap_id
, address_list
[i
]);
2386 temp_client
->addr
= address_list
[i
];
2387 err
= i2c_detect_address(temp_client
, driver
);
2396 int i2c_probe_func_quick_read(struct i2c_adapter
*adap
, unsigned short addr
)
2398 return i2c_smbus_xfer(adap
, addr
, 0, I2C_SMBUS_READ
, 0,
2399 I2C_SMBUS_QUICK
, NULL
) >= 0;
2401 EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read
);
2404 i2c_new_probed_device(struct i2c_adapter
*adap
,
2405 struct i2c_board_info
*info
,
2406 unsigned short const *addr_list
,
2407 int (*probe
)(struct i2c_adapter
*, unsigned short addr
))
2412 probe
= i2c_default_probe
;
2414 for (i
= 0; addr_list
[i
] != I2C_CLIENT_END
; i
++) {
2415 /* Check address validity */
2416 if (i2c_check_addr_validity(addr_list
[i
]) < 0) {
2417 dev_warn(&adap
->dev
, "Invalid 7-bit address "
2418 "0x%02x\n", addr_list
[i
]);
2422 /* Check address availability */
2423 if (i2c_check_addr_busy(adap
, addr_list
[i
])) {
2424 dev_dbg(&adap
->dev
, "Address 0x%02x already in "
2425 "use, not probing\n", addr_list
[i
]);
2429 /* Test address responsiveness */
2430 if (probe(adap
, addr_list
[i
]))
2434 if (addr_list
[i
] == I2C_CLIENT_END
) {
2435 dev_dbg(&adap
->dev
, "Probing failed, no device found\n");
2439 info
->addr
= addr_list
[i
];
2440 return i2c_new_device(adap
, info
);
2442 EXPORT_SYMBOL_GPL(i2c_new_probed_device
);
2444 struct i2c_adapter
*i2c_get_adapter(int nr
)
2446 struct i2c_adapter
*adapter
;
2448 mutex_lock(&core_lock
);
2449 adapter
= idr_find(&i2c_adapter_idr
, nr
);
2453 if (try_module_get(adapter
->owner
))
2454 get_device(&adapter
->dev
);
2459 mutex_unlock(&core_lock
);
2462 EXPORT_SYMBOL(i2c_get_adapter
);
2464 void i2c_put_adapter(struct i2c_adapter
*adap
)
2469 put_device(&adap
->dev
);
2470 module_put(adap
->owner
);
2472 EXPORT_SYMBOL(i2c_put_adapter
);
2474 /* The SMBus parts */
2476 #define POLY (0x1070U << 3)
2477 static u8
crc8(u16 data
)
2481 for (i
= 0; i
< 8; i
++) {
2486 return (u8
)(data
>> 8);
2489 /* Incremental CRC8 over count bytes in the array pointed to by p */
2490 static u8
i2c_smbus_pec(u8 crc
, u8
*p
, size_t count
)
2494 for (i
= 0; i
< count
; i
++)
2495 crc
= crc8((crc
^ p
[i
]) << 8);
2499 /* Assume a 7-bit address, which is reasonable for SMBus */
2500 static u8
i2c_smbus_msg_pec(u8 pec
, struct i2c_msg
*msg
)
2502 /* The address will be sent first */
2503 u8 addr
= (msg
->addr
<< 1) | !!(msg
->flags
& I2C_M_RD
);
2504 pec
= i2c_smbus_pec(pec
, &addr
, 1);
2506 /* The data buffer follows */
2507 return i2c_smbus_pec(pec
, msg
->buf
, msg
->len
);
2510 /* Used for write only transactions */
2511 static inline void i2c_smbus_add_pec(struct i2c_msg
*msg
)
2513 msg
->buf
[msg
->len
] = i2c_smbus_msg_pec(0, msg
);
2517 /* Return <0 on CRC error
2518 If there was a write before this read (most cases) we need to take the
2519 partial CRC from the write part into account.
2520 Note that this function does modify the message (we need to decrease the
2521 message length to hide the CRC byte from the caller). */
2522 static int i2c_smbus_check_pec(u8 cpec
, struct i2c_msg
*msg
)
2524 u8 rpec
= msg
->buf
[--msg
->len
];
2525 cpec
= i2c_smbus_msg_pec(cpec
, msg
);
2528 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
2536 * i2c_smbus_read_byte - SMBus "receive byte" protocol
2537 * @client: Handle to slave device
2539 * This executes the SMBus "receive byte" protocol, returning negative errno
2540 * else the byte received from the device.
2542 s32
i2c_smbus_read_byte(const struct i2c_client
*client
)
2544 union i2c_smbus_data data
;
2547 status
= i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
2549 I2C_SMBUS_BYTE
, &data
);
2550 return (status
< 0) ? status
: data
.byte
;
2552 EXPORT_SYMBOL(i2c_smbus_read_byte
);
2555 * i2c_smbus_write_byte - SMBus "send byte" protocol
2556 * @client: Handle to slave device
2557 * @value: Byte to be sent
2559 * This executes the SMBus "send byte" protocol, returning negative errno
2560 * else zero on success.
2562 s32
i2c_smbus_write_byte(const struct i2c_client
*client
, u8 value
)
2564 return i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
2565 I2C_SMBUS_WRITE
, value
, I2C_SMBUS_BYTE
, NULL
);
2567 EXPORT_SYMBOL(i2c_smbus_write_byte
);
2570 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
2571 * @client: Handle to slave device
2572 * @command: Byte interpreted by slave
2574 * This executes the SMBus "read byte" protocol, returning negative errno
2575 * else a data byte received from the device.
2577 s32
i2c_smbus_read_byte_data(const struct i2c_client
*client
, u8 command
)
2579 union i2c_smbus_data data
;
2582 status
= i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
2583 I2C_SMBUS_READ
, command
,
2584 I2C_SMBUS_BYTE_DATA
, &data
);
2585 return (status
< 0) ? status
: data
.byte
;
2587 EXPORT_SYMBOL(i2c_smbus_read_byte_data
);
2590 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
2591 * @client: Handle to slave device
2592 * @command: Byte interpreted by slave
2593 * @value: Byte being written
2595 * This executes the SMBus "write byte" protocol, returning negative errno
2596 * else zero on success.
2598 s32
i2c_smbus_write_byte_data(const struct i2c_client
*client
, u8 command
,
2601 union i2c_smbus_data data
;
2603 return i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
2604 I2C_SMBUS_WRITE
, command
,
2605 I2C_SMBUS_BYTE_DATA
, &data
);
2607 EXPORT_SYMBOL(i2c_smbus_write_byte_data
);
2610 * i2c_smbus_read_word_data - SMBus "read word" protocol
2611 * @client: Handle to slave device
2612 * @command: Byte interpreted by slave
2614 * This executes the SMBus "read word" protocol, returning negative errno
2615 * else a 16-bit unsigned "word" received from the device.
2617 s32
i2c_smbus_read_word_data(const struct i2c_client
*client
, u8 command
)
2619 union i2c_smbus_data data
;
2622 status
= i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
2623 I2C_SMBUS_READ
, command
,
2624 I2C_SMBUS_WORD_DATA
, &data
);
2625 return (status
< 0) ? status
: data
.word
;
2627 EXPORT_SYMBOL(i2c_smbus_read_word_data
);
2630 * i2c_smbus_write_word_data - SMBus "write word" protocol
2631 * @client: Handle to slave device
2632 * @command: Byte interpreted by slave
2633 * @value: 16-bit "word" being written
2635 * This executes the SMBus "write word" protocol, returning negative errno
2636 * else zero on success.
2638 s32
i2c_smbus_write_word_data(const struct i2c_client
*client
, u8 command
,
2641 union i2c_smbus_data data
;
2643 return i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
2644 I2C_SMBUS_WRITE
, command
,
2645 I2C_SMBUS_WORD_DATA
, &data
);
2647 EXPORT_SYMBOL(i2c_smbus_write_word_data
);
2650 * i2c_smbus_read_block_data - SMBus "block read" protocol
2651 * @client: Handle to slave device
2652 * @command: Byte interpreted by slave
2653 * @values: Byte array into which data will be read; big enough to hold
2654 * the data returned by the slave. SMBus allows at most 32 bytes.
2656 * This executes the SMBus "block read" protocol, returning negative errno
2657 * else the number of data bytes in the slave's response.
2659 * Note that using this function requires that the client's adapter support
2660 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
2661 * support this; its emulation through I2C messaging relies on a specific
2662 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
2664 s32
i2c_smbus_read_block_data(const struct i2c_client
*client
, u8 command
,
2667 union i2c_smbus_data data
;
2670 status
= i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
2671 I2C_SMBUS_READ
, command
,
2672 I2C_SMBUS_BLOCK_DATA
, &data
);
2676 memcpy(values
, &data
.block
[1], data
.block
[0]);
2677 return data
.block
[0];
2679 EXPORT_SYMBOL(i2c_smbus_read_block_data
);
2682 * i2c_smbus_write_block_data - SMBus "block write" protocol
2683 * @client: Handle to slave device
2684 * @command: Byte interpreted by slave
2685 * @length: Size of data block; SMBus allows at most 32 bytes
2686 * @values: Byte array which will be written.
2688 * This executes the SMBus "block write" protocol, returning negative errno
2689 * else zero on success.
2691 s32
i2c_smbus_write_block_data(const struct i2c_client
*client
, u8 command
,
2692 u8 length
, const u8
*values
)
2694 union i2c_smbus_data data
;
2696 if (length
> I2C_SMBUS_BLOCK_MAX
)
2697 length
= I2C_SMBUS_BLOCK_MAX
;
2698 data
.block
[0] = length
;
2699 memcpy(&data
.block
[1], values
, length
);
2700 return i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
2701 I2C_SMBUS_WRITE
, command
,
2702 I2C_SMBUS_BLOCK_DATA
, &data
);
2704 EXPORT_SYMBOL(i2c_smbus_write_block_data
);
2706 /* Returns the number of read bytes */
2707 s32
i2c_smbus_read_i2c_block_data(const struct i2c_client
*client
, u8 command
,
2708 u8 length
, u8
*values
)
2710 union i2c_smbus_data data
;
2713 if (length
> I2C_SMBUS_BLOCK_MAX
)
2714 length
= I2C_SMBUS_BLOCK_MAX
;
2715 data
.block
[0] = length
;
2716 status
= i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
2717 I2C_SMBUS_READ
, command
,
2718 I2C_SMBUS_I2C_BLOCK_DATA
, &data
);
2722 memcpy(values
, &data
.block
[1], data
.block
[0]);
2723 return data
.block
[0];
2725 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data
);
2727 s32
i2c_smbus_write_i2c_block_data(const struct i2c_client
*client
, u8 command
,
2728 u8 length
, const u8
*values
)
2730 union i2c_smbus_data data
;
2732 if (length
> I2C_SMBUS_BLOCK_MAX
)
2733 length
= I2C_SMBUS_BLOCK_MAX
;
2734 data
.block
[0] = length
;
2735 memcpy(data
.block
+ 1, values
, length
);
2736 return i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
2737 I2C_SMBUS_WRITE
, command
,
2738 I2C_SMBUS_I2C_BLOCK_DATA
, &data
);
2740 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data
);
2742 /* Simulate a SMBus command using the i2c protocol
2743 No checking of parameters is done! */
2744 static s32
i2c_smbus_xfer_emulated(struct i2c_adapter
*adapter
, u16 addr
,
2745 unsigned short flags
,
2746 char read_write
, u8 command
, int size
,
2747 union i2c_smbus_data
*data
)
2749 /* So we need to generate a series of msgs. In the case of writing, we
2750 need to use only one message; when reading, we need two. We initialize
2751 most things with sane defaults, to keep the code below somewhat
2753 unsigned char msgbuf0
[I2C_SMBUS_BLOCK_MAX
+3];
2754 unsigned char msgbuf1
[I2C_SMBUS_BLOCK_MAX
+2];
2755 int num
= read_write
== I2C_SMBUS_READ
? 2 : 1;
2759 struct i2c_msg msg
[2] = {
2767 .flags
= flags
| I2C_M_RD
,
2773 msgbuf0
[0] = command
;
2775 case I2C_SMBUS_QUICK
:
2777 /* Special case: The read/write field is used as data */
2778 msg
[0].flags
= flags
| (read_write
== I2C_SMBUS_READ
?
2782 case I2C_SMBUS_BYTE
:
2783 if (read_write
== I2C_SMBUS_READ
) {
2784 /* Special case: only a read! */
2785 msg
[0].flags
= I2C_M_RD
| flags
;
2789 case I2C_SMBUS_BYTE_DATA
:
2790 if (read_write
== I2C_SMBUS_READ
)
2794 msgbuf0
[1] = data
->byte
;
2797 case I2C_SMBUS_WORD_DATA
:
2798 if (read_write
== I2C_SMBUS_READ
)
2802 msgbuf0
[1] = data
->word
& 0xff;
2803 msgbuf0
[2] = data
->word
>> 8;
2806 case I2C_SMBUS_PROC_CALL
:
2807 num
= 2; /* Special case */
2808 read_write
= I2C_SMBUS_READ
;
2811 msgbuf0
[1] = data
->word
& 0xff;
2812 msgbuf0
[2] = data
->word
>> 8;
2814 case I2C_SMBUS_BLOCK_DATA
:
2815 if (read_write
== I2C_SMBUS_READ
) {
2816 msg
[1].flags
|= I2C_M_RECV_LEN
;
2817 msg
[1].len
= 1; /* block length will be added by
2818 the underlying bus driver */
2820 msg
[0].len
= data
->block
[0] + 2;
2821 if (msg
[0].len
> I2C_SMBUS_BLOCK_MAX
+ 2) {
2822 dev_err(&adapter
->dev
,
2823 "Invalid block write size %d\n",
2827 for (i
= 1; i
< msg
[0].len
; i
++)
2828 msgbuf0
[i
] = data
->block
[i
-1];
2831 case I2C_SMBUS_BLOCK_PROC_CALL
:
2832 num
= 2; /* Another special case */
2833 read_write
= I2C_SMBUS_READ
;
2834 if (data
->block
[0] > I2C_SMBUS_BLOCK_MAX
) {
2835 dev_err(&adapter
->dev
,
2836 "Invalid block write size %d\n",
2840 msg
[0].len
= data
->block
[0] + 2;
2841 for (i
= 1; i
< msg
[0].len
; i
++)
2842 msgbuf0
[i
] = data
->block
[i
-1];
2843 msg
[1].flags
|= I2C_M_RECV_LEN
;
2844 msg
[1].len
= 1; /* block length will be added by
2845 the underlying bus driver */
2847 case I2C_SMBUS_I2C_BLOCK_DATA
:
2848 if (read_write
== I2C_SMBUS_READ
) {
2849 msg
[1].len
= data
->block
[0];
2851 msg
[0].len
= data
->block
[0] + 1;
2852 if (msg
[0].len
> I2C_SMBUS_BLOCK_MAX
+ 1) {
2853 dev_err(&adapter
->dev
,
2854 "Invalid block write size %d\n",
2858 for (i
= 1; i
<= data
->block
[0]; i
++)
2859 msgbuf0
[i
] = data
->block
[i
];
2863 dev_err(&adapter
->dev
, "Unsupported transaction %d\n", size
);
2867 i
= ((flags
& I2C_CLIENT_PEC
) && size
!= I2C_SMBUS_QUICK
2868 && size
!= I2C_SMBUS_I2C_BLOCK_DATA
);
2870 /* Compute PEC if first message is a write */
2871 if (!(msg
[0].flags
& I2C_M_RD
)) {
2872 if (num
== 1) /* Write only */
2873 i2c_smbus_add_pec(&msg
[0]);
2874 else /* Write followed by read */
2875 partial_pec
= i2c_smbus_msg_pec(0, &msg
[0]);
2877 /* Ask for PEC if last message is a read */
2878 if (msg
[num
-1].flags
& I2C_M_RD
)
2882 status
= i2c_transfer(adapter
, msg
, num
);
2886 /* Check PEC if last message is a read */
2887 if (i
&& (msg
[num
-1].flags
& I2C_M_RD
)) {
2888 status
= i2c_smbus_check_pec(partial_pec
, &msg
[num
-1]);
2893 if (read_write
== I2C_SMBUS_READ
)
2895 case I2C_SMBUS_BYTE
:
2896 data
->byte
= msgbuf0
[0];
2898 case I2C_SMBUS_BYTE_DATA
:
2899 data
->byte
= msgbuf1
[0];
2901 case I2C_SMBUS_WORD_DATA
:
2902 case I2C_SMBUS_PROC_CALL
:
2903 data
->word
= msgbuf1
[0] | (msgbuf1
[1] << 8);
2905 case I2C_SMBUS_I2C_BLOCK_DATA
:
2906 for (i
= 0; i
< data
->block
[0]; i
++)
2907 data
->block
[i
+1] = msgbuf1
[i
];
2909 case I2C_SMBUS_BLOCK_DATA
:
2910 case I2C_SMBUS_BLOCK_PROC_CALL
:
2911 for (i
= 0; i
< msgbuf1
[0] + 1; i
++)
2912 data
->block
[i
] = msgbuf1
[i
];
2919 * i2c_smbus_xfer - execute SMBus protocol operations
2920 * @adapter: Handle to I2C bus
2921 * @addr: Address of SMBus slave on that bus
2922 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
2923 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
2924 * @command: Byte interpreted by slave, for protocols which use such bytes
2925 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
2926 * @data: Data to be read or written
2928 * This executes an SMBus protocol operation, and returns a negative
2929 * errno code else zero on success.
2931 s32
i2c_smbus_xfer(struct i2c_adapter
*adapter
, u16 addr
, unsigned short flags
,
2932 char read_write
, u8 command
, int protocol
,
2933 union i2c_smbus_data
*data
)
2935 unsigned long orig_jiffies
;
2939 /* If enabled, the following two tracepoints are conditional on
2940 * read_write and protocol.
2942 trace_smbus_write(adapter
, addr
, flags
, read_write
,
2943 command
, protocol
, data
);
2944 trace_smbus_read(adapter
, addr
, flags
, read_write
,
2947 flags
&= I2C_M_TEN
| I2C_CLIENT_PEC
| I2C_CLIENT_SCCB
;
2949 if (adapter
->algo
->smbus_xfer
) {
2950 i2c_lock_adapter(adapter
);
2952 /* Retry automatically on arbitration loss */
2953 orig_jiffies
= jiffies
;
2954 for (res
= 0, try = 0; try <= adapter
->retries
; try++) {
2955 res
= adapter
->algo
->smbus_xfer(adapter
, addr
, flags
,
2956 read_write
, command
,
2960 if (time_after(jiffies
,
2961 orig_jiffies
+ adapter
->timeout
))
2964 i2c_unlock_adapter(adapter
);
2966 if (res
!= -EOPNOTSUPP
|| !adapter
->algo
->master_xfer
)
2969 * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
2970 * implement native support for the SMBus operation.
2974 res
= i2c_smbus_xfer_emulated(adapter
, addr
, flags
, read_write
,
2975 command
, protocol
, data
);
2978 /* If enabled, the reply tracepoint is conditional on read_write. */
2979 trace_smbus_reply(adapter
, addr
, flags
, read_write
,
2980 command
, protocol
, data
);
2981 trace_smbus_result(adapter
, addr
, flags
, read_write
,
2982 command
, protocol
, res
);
2986 EXPORT_SYMBOL(i2c_smbus_xfer
);
2988 #if IS_ENABLED(CONFIG_I2C_SLAVE)
2989 int i2c_slave_register(struct i2c_client
*client
, i2c_slave_cb_t slave_cb
)
2993 if (!client
|| !slave_cb
) {
2994 WARN(1, "insufficent data\n");
2998 if (!(client
->flags
& I2C_CLIENT_TEN
)) {
2999 /* Enforce stricter address checking */
3000 ret
= i2c_check_addr_validity(client
->addr
);
3002 dev_err(&client
->dev
, "%s: invalid address\n", __func__
);
3007 if (!client
->adapter
->algo
->reg_slave
) {
3008 dev_err(&client
->dev
, "%s: not supported by adapter\n", __func__
);
3012 client
->slave_cb
= slave_cb
;
3014 i2c_lock_adapter(client
->adapter
);
3015 ret
= client
->adapter
->algo
->reg_slave(client
);
3016 i2c_unlock_adapter(client
->adapter
);
3019 client
->slave_cb
= NULL
;
3020 dev_err(&client
->dev
, "%s: adapter returned error %d\n", __func__
, ret
);
3025 EXPORT_SYMBOL_GPL(i2c_slave_register
);
3027 int i2c_slave_unregister(struct i2c_client
*client
)
3031 if (!client
->adapter
->algo
->unreg_slave
) {
3032 dev_err(&client
->dev
, "%s: not supported by adapter\n", __func__
);
3036 i2c_lock_adapter(client
->adapter
);
3037 ret
= client
->adapter
->algo
->unreg_slave(client
);
3038 i2c_unlock_adapter(client
->adapter
);
3041 client
->slave_cb
= NULL
;
3043 dev_err(&client
->dev
, "%s: adapter returned error %d\n", __func__
, ret
);
3047 EXPORT_SYMBOL_GPL(i2c_slave_unregister
);
3050 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
3051 MODULE_DESCRIPTION("I2C-Bus main module");
3052 MODULE_LICENSE("GPL");