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.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
19 /* ------------------------------------------------------------------------- */
21 /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi>.
22 All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl>
23 SMBus 2.0 support by Mark Studebaker <mdsxyz123@yahoo.com> and
24 Jean Delvare <khali@linux-fr.org>
25 Mux support by Rodolfo Giometti <giometti@enneenne.com> and
26 Michael Lawnick <michael.lawnick.ext@nsn.com> */
28 #include <linux/module.h>
29 #include <linux/kernel.h>
30 #include <linux/errno.h>
31 #include <linux/slab.h>
32 #include <linux/i2c.h>
33 #include <linux/init.h>
34 #include <linux/idr.h>
35 #include <linux/mutex.h>
36 #include <linux/of_device.h>
37 #include <linux/completion.h>
38 #include <linux/hardirq.h>
39 #include <linux/irqflags.h>
40 #include <linux/rwsem.h>
41 #include <linux/pm_runtime.h>
42 #include <linux/acpi.h>
43 #include <asm/uaccess.h>
48 /* core_lock protects i2c_adapter_idr, and guarantees
49 that device detection, deletion of detected devices, and attach_adapter
50 and detach_adapter calls are serialized */
51 static DEFINE_MUTEX(core_lock
);
52 static DEFINE_IDR(i2c_adapter_idr
);
54 static struct device_type i2c_client_type
;
55 static int i2c_detect(struct i2c_adapter
*adapter
, struct i2c_driver
*driver
);
57 /* ------------------------------------------------------------------------- */
59 static const struct i2c_device_id
*i2c_match_id(const struct i2c_device_id
*id
,
60 const struct i2c_client
*client
)
63 if (strcmp(client
->name
, id
->name
) == 0)
70 static int i2c_device_match(struct device
*dev
, struct device_driver
*drv
)
72 struct i2c_client
*client
= i2c_verify_client(dev
);
73 struct i2c_driver
*driver
;
78 /* Attempt an OF style match */
79 if (of_driver_match_device(dev
, drv
))
82 /* Then ACPI style match */
83 if (acpi_driver_match_device(dev
, drv
))
86 driver
= to_i2c_driver(drv
);
87 /* match on an id table if there is one */
89 return i2c_match_id(driver
->id_table
, client
) != NULL
;
96 /* uevent helps with hotplug: modprobe -q $(MODALIAS) */
97 static int i2c_device_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
99 struct i2c_client
*client
= to_i2c_client(dev
);
101 if (add_uevent_var(env
, "MODALIAS=%s%s",
102 I2C_MODULE_PREFIX
, client
->name
))
104 dev_dbg(dev
, "uevent\n");
109 #define i2c_device_uevent NULL
110 #endif /* CONFIG_HOTPLUG */
112 static int i2c_device_probe(struct device
*dev
)
114 struct i2c_client
*client
= i2c_verify_client(dev
);
115 struct i2c_driver
*driver
;
121 driver
= to_i2c_driver(dev
->driver
);
122 if (!driver
->probe
|| !driver
->id_table
)
124 client
->driver
= driver
;
125 if (!device_can_wakeup(&client
->dev
))
126 device_init_wakeup(&client
->dev
,
127 client
->flags
& I2C_CLIENT_WAKE
);
128 dev_dbg(dev
, "probe\n");
130 status
= driver
->probe(client
, i2c_match_id(driver
->id_table
, client
));
132 client
->driver
= NULL
;
133 i2c_set_clientdata(client
, NULL
);
138 static int i2c_device_remove(struct device
*dev
)
140 struct i2c_client
*client
= i2c_verify_client(dev
);
141 struct i2c_driver
*driver
;
144 if (!client
|| !dev
->driver
)
147 driver
= to_i2c_driver(dev
->driver
);
148 if (driver
->remove
) {
149 dev_dbg(dev
, "remove\n");
150 status
= driver
->remove(client
);
156 client
->driver
= NULL
;
157 i2c_set_clientdata(client
, NULL
);
162 static void i2c_device_shutdown(struct device
*dev
)
164 struct i2c_client
*client
= i2c_verify_client(dev
);
165 struct i2c_driver
*driver
;
167 if (!client
|| !dev
->driver
)
169 driver
= to_i2c_driver(dev
->driver
);
170 if (driver
->shutdown
)
171 driver
->shutdown(client
);
174 #ifdef CONFIG_PM_SLEEP
175 static int i2c_legacy_suspend(struct device
*dev
, pm_message_t mesg
)
177 struct i2c_client
*client
= i2c_verify_client(dev
);
178 struct i2c_driver
*driver
;
180 if (!client
|| !dev
->driver
)
182 driver
= to_i2c_driver(dev
->driver
);
183 if (!driver
->suspend
)
185 return driver
->suspend(client
, mesg
);
188 static int i2c_legacy_resume(struct device
*dev
)
190 struct i2c_client
*client
= i2c_verify_client(dev
);
191 struct i2c_driver
*driver
;
193 if (!client
|| !dev
->driver
)
195 driver
= to_i2c_driver(dev
->driver
);
198 return driver
->resume(client
);
201 static int i2c_device_pm_suspend(struct device
*dev
)
203 const struct dev_pm_ops
*pm
= dev
->driver
? dev
->driver
->pm
: NULL
;
206 return pm_generic_suspend(dev
);
208 return i2c_legacy_suspend(dev
, PMSG_SUSPEND
);
211 static int i2c_device_pm_resume(struct device
*dev
)
213 const struct dev_pm_ops
*pm
= dev
->driver
? dev
->driver
->pm
: NULL
;
216 return pm_generic_resume(dev
);
218 return i2c_legacy_resume(dev
);
221 static int i2c_device_pm_freeze(struct device
*dev
)
223 const struct dev_pm_ops
*pm
= dev
->driver
? dev
->driver
->pm
: NULL
;
226 return pm_generic_freeze(dev
);
228 return i2c_legacy_suspend(dev
, PMSG_FREEZE
);
231 static int i2c_device_pm_thaw(struct device
*dev
)
233 const struct dev_pm_ops
*pm
= dev
->driver
? dev
->driver
->pm
: NULL
;
236 return pm_generic_thaw(dev
);
238 return i2c_legacy_resume(dev
);
241 static int i2c_device_pm_poweroff(struct device
*dev
)
243 const struct dev_pm_ops
*pm
= dev
->driver
? dev
->driver
->pm
: NULL
;
246 return pm_generic_poweroff(dev
);
248 return i2c_legacy_suspend(dev
, PMSG_HIBERNATE
);
251 static int i2c_device_pm_restore(struct device
*dev
)
253 const struct dev_pm_ops
*pm
= dev
->driver
? dev
->driver
->pm
: NULL
;
256 return pm_generic_restore(dev
);
258 return i2c_legacy_resume(dev
);
260 #else /* !CONFIG_PM_SLEEP */
261 #define i2c_device_pm_suspend NULL
262 #define i2c_device_pm_resume NULL
263 #define i2c_device_pm_freeze NULL
264 #define i2c_device_pm_thaw NULL
265 #define i2c_device_pm_poweroff NULL
266 #define i2c_device_pm_restore NULL
267 #endif /* !CONFIG_PM_SLEEP */
269 static void i2c_client_dev_release(struct device
*dev
)
271 kfree(to_i2c_client(dev
));
275 show_name(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
277 return sprintf(buf
, "%s\n", dev
->type
== &i2c_client_type
?
278 to_i2c_client(dev
)->name
: to_i2c_adapter(dev
)->name
);
282 show_modalias(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
284 struct i2c_client
*client
= to_i2c_client(dev
);
285 return sprintf(buf
, "%s%s\n", I2C_MODULE_PREFIX
, client
->name
);
288 static DEVICE_ATTR(name
, S_IRUGO
, show_name
, NULL
);
289 static DEVICE_ATTR(modalias
, S_IRUGO
, show_modalias
, NULL
);
291 static struct attribute
*i2c_dev_attrs
[] = {
293 /* modalias helps coldplug: modprobe $(cat .../modalias) */
294 &dev_attr_modalias
.attr
,
298 static struct attribute_group i2c_dev_attr_group
= {
299 .attrs
= i2c_dev_attrs
,
302 static const struct attribute_group
*i2c_dev_attr_groups
[] = {
307 static const struct dev_pm_ops i2c_device_pm_ops
= {
308 .suspend
= i2c_device_pm_suspend
,
309 .resume
= i2c_device_pm_resume
,
310 .freeze
= i2c_device_pm_freeze
,
311 .thaw
= i2c_device_pm_thaw
,
312 .poweroff
= i2c_device_pm_poweroff
,
313 .restore
= i2c_device_pm_restore
,
315 pm_generic_runtime_suspend
,
316 pm_generic_runtime_resume
,
317 pm_generic_runtime_idle
321 struct bus_type i2c_bus_type
= {
323 .match
= i2c_device_match
,
324 .probe
= i2c_device_probe
,
325 .remove
= i2c_device_remove
,
326 .shutdown
= i2c_device_shutdown
,
327 .pm
= &i2c_device_pm_ops
,
329 EXPORT_SYMBOL_GPL(i2c_bus_type
);
331 static struct device_type i2c_client_type
= {
332 .groups
= i2c_dev_attr_groups
,
333 .uevent
= i2c_device_uevent
,
334 .release
= i2c_client_dev_release
,
339 * i2c_verify_client - return parameter as i2c_client, or NULL
340 * @dev: device, probably from some driver model iterator
342 * When traversing the driver model tree, perhaps using driver model
343 * iterators like @device_for_each_child(), you can't assume very much
344 * about the nodes you find. Use this function to avoid oopses caused
345 * by wrongly treating some non-I2C device as an i2c_client.
347 struct i2c_client
*i2c_verify_client(struct device
*dev
)
349 return (dev
->type
== &i2c_client_type
)
353 EXPORT_SYMBOL(i2c_verify_client
);
356 /* This is a permissive address validity check, I2C address map constraints
357 * are purposely not enforced, except for the general call address. */
358 static int i2c_check_client_addr_validity(const struct i2c_client
*client
)
360 if (client
->flags
& I2C_CLIENT_TEN
) {
361 /* 10-bit address, all values are valid */
362 if (client
->addr
> 0x3ff)
365 /* 7-bit address, reject the general call address */
366 if (client
->addr
== 0x00 || client
->addr
> 0x7f)
372 /* And this is a strict address validity check, used when probing. If a
373 * device uses a reserved address, then it shouldn't be probed. 7-bit
374 * addressing is assumed, 10-bit address devices are rare and should be
375 * explicitly enumerated. */
376 static int i2c_check_addr_validity(unsigned short addr
)
379 * Reserved addresses per I2C specification:
380 * 0x00 General call address / START byte
382 * 0x02 Reserved for different bus format
383 * 0x03 Reserved for future purposes
384 * 0x04-0x07 Hs-mode master code
385 * 0x78-0x7b 10-bit slave addressing
386 * 0x7c-0x7f Reserved for future purposes
388 if (addr
< 0x08 || addr
> 0x77)
393 static int __i2c_check_addr_busy(struct device
*dev
, void *addrp
)
395 struct i2c_client
*client
= i2c_verify_client(dev
);
396 int addr
= *(int *)addrp
;
398 if (client
&& client
->addr
== addr
)
403 /* walk up mux tree */
404 static int i2c_check_mux_parents(struct i2c_adapter
*adapter
, int addr
)
406 struct i2c_adapter
*parent
= i2c_parent_is_i2c_adapter(adapter
);
409 result
= device_for_each_child(&adapter
->dev
, &addr
,
410 __i2c_check_addr_busy
);
412 if (!result
&& parent
)
413 result
= i2c_check_mux_parents(parent
, addr
);
418 /* recurse down mux tree */
419 static int i2c_check_mux_children(struct device
*dev
, void *addrp
)
423 if (dev
->type
== &i2c_adapter_type
)
424 result
= device_for_each_child(dev
, addrp
,
425 i2c_check_mux_children
);
427 result
= __i2c_check_addr_busy(dev
, addrp
);
432 static int i2c_check_addr_busy(struct i2c_adapter
*adapter
, int addr
)
434 struct i2c_adapter
*parent
= i2c_parent_is_i2c_adapter(adapter
);
438 result
= i2c_check_mux_parents(parent
, addr
);
441 result
= device_for_each_child(&adapter
->dev
, &addr
,
442 i2c_check_mux_children
);
448 * i2c_lock_adapter - Get exclusive access to an I2C bus segment
449 * @adapter: Target I2C bus segment
451 void i2c_lock_adapter(struct i2c_adapter
*adapter
)
453 struct i2c_adapter
*parent
= i2c_parent_is_i2c_adapter(adapter
);
456 i2c_lock_adapter(parent
);
458 rt_mutex_lock(&adapter
->bus_lock
);
460 EXPORT_SYMBOL_GPL(i2c_lock_adapter
);
463 * i2c_trylock_adapter - Try to get exclusive access to an I2C bus segment
464 * @adapter: Target I2C bus segment
466 static int i2c_trylock_adapter(struct i2c_adapter
*adapter
)
468 struct i2c_adapter
*parent
= i2c_parent_is_i2c_adapter(adapter
);
471 return i2c_trylock_adapter(parent
);
473 return rt_mutex_trylock(&adapter
->bus_lock
);
477 * i2c_unlock_adapter - Release exclusive access to an I2C bus segment
478 * @adapter: Target I2C bus segment
480 void i2c_unlock_adapter(struct i2c_adapter
*adapter
)
482 struct i2c_adapter
*parent
= i2c_parent_is_i2c_adapter(adapter
);
485 i2c_unlock_adapter(parent
);
487 rt_mutex_unlock(&adapter
->bus_lock
);
489 EXPORT_SYMBOL_GPL(i2c_unlock_adapter
);
492 * i2c_new_device - instantiate an i2c device
493 * @adap: the adapter managing the device
494 * @info: describes one I2C device; bus_num is ignored
497 * Create an i2c device. Binding is handled through driver model
498 * probe()/remove() methods. A driver may be bound to this device when we
499 * return from this function, or any later moment (e.g. maybe hotplugging will
500 * load the driver module). This call is not appropriate for use by mainboard
501 * initialization logic, which usually runs during an arch_initcall() long
502 * before any i2c_adapter could exist.
504 * This returns the new i2c client, which may be saved for later use with
505 * i2c_unregister_device(); or NULL to indicate an error.
508 i2c_new_device(struct i2c_adapter
*adap
, struct i2c_board_info
const *info
)
510 struct i2c_client
*client
;
513 client
= kzalloc(sizeof *client
, GFP_KERNEL
);
517 client
->adapter
= adap
;
519 client
->dev
.platform_data
= info
->platform_data
;
522 client
->dev
.archdata
= *info
->archdata
;
524 client
->flags
= info
->flags
;
525 client
->addr
= info
->addr
;
526 client
->irq
= info
->irq
;
528 strlcpy(client
->name
, info
->type
, sizeof(client
->name
));
530 /* Check for address validity */
531 status
= i2c_check_client_addr_validity(client
);
533 dev_err(&adap
->dev
, "Invalid %d-bit I2C address 0x%02hx\n",
534 client
->flags
& I2C_CLIENT_TEN
? 10 : 7, client
->addr
);
538 /* Check for address business */
539 status
= i2c_check_addr_busy(adap
, client
->addr
);
543 client
->dev
.parent
= &client
->adapter
->dev
;
544 client
->dev
.bus
= &i2c_bus_type
;
545 client
->dev
.type
= &i2c_client_type
;
546 client
->dev
.of_node
= info
->of_node
;
547 ACPI_HANDLE_SET(&client
->dev
, info
->acpi_node
.handle
);
549 /* For 10-bit clients, add an arbitrary offset to avoid collisions */
550 dev_set_name(&client
->dev
, "%d-%04x", i2c_adapter_id(adap
),
551 client
->addr
| ((client
->flags
& I2C_CLIENT_TEN
)
553 status
= device_register(&client
->dev
);
557 dev_dbg(&adap
->dev
, "client [%s] registered with bus id %s\n",
558 client
->name
, dev_name(&client
->dev
));
563 dev_err(&adap
->dev
, "Failed to register i2c client %s at 0x%02x "
564 "(%d)\n", client
->name
, client
->addr
, status
);
569 EXPORT_SYMBOL_GPL(i2c_new_device
);
573 * i2c_unregister_device - reverse effect of i2c_new_device()
574 * @client: value returned from i2c_new_device()
577 void i2c_unregister_device(struct i2c_client
*client
)
579 device_unregister(&client
->dev
);
581 EXPORT_SYMBOL_GPL(i2c_unregister_device
);
584 static const struct i2c_device_id dummy_id
[] = {
589 static int dummy_probe(struct i2c_client
*client
,
590 const struct i2c_device_id
*id
)
595 static int dummy_remove(struct i2c_client
*client
)
600 static struct i2c_driver dummy_driver
= {
601 .driver
.name
= "dummy",
602 .probe
= dummy_probe
,
603 .remove
= dummy_remove
,
604 .id_table
= dummy_id
,
608 * i2c_new_dummy - return a new i2c device bound to a dummy driver
609 * @adapter: the adapter managing the device
610 * @address: seven bit address to be used
613 * This returns an I2C client bound to the "dummy" driver, intended for use
614 * with devices that consume multiple addresses. Examples of such chips
615 * include various EEPROMS (like 24c04 and 24c08 models).
617 * These dummy devices have two main uses. First, most I2C and SMBus calls
618 * except i2c_transfer() need a client handle; the dummy will be that handle.
619 * And second, this prevents the specified address from being bound to a
622 * This returns the new i2c client, which should be saved for later use with
623 * i2c_unregister_device(); or NULL to indicate an error.
625 struct i2c_client
*i2c_new_dummy(struct i2c_adapter
*adapter
, u16 address
)
627 struct i2c_board_info info
= {
628 I2C_BOARD_INFO("dummy", address
),
631 return i2c_new_device(adapter
, &info
);
633 EXPORT_SYMBOL_GPL(i2c_new_dummy
);
635 /* ------------------------------------------------------------------------- */
637 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
639 static void i2c_adapter_dev_release(struct device
*dev
)
641 struct i2c_adapter
*adap
= to_i2c_adapter(dev
);
642 complete(&adap
->dev_released
);
646 * This function is only needed for mutex_lock_nested, so it is never
647 * called unless locking correctness checking is enabled. Thus we
648 * make it inline to avoid a compiler warning. That's what gcc ends up
651 static inline unsigned int i2c_adapter_depth(struct i2c_adapter
*adapter
)
653 unsigned int depth
= 0;
655 while ((adapter
= i2c_parent_is_i2c_adapter(adapter
)))
662 * Let users instantiate I2C devices through sysfs. This can be used when
663 * platform initialization code doesn't contain the proper data for
664 * whatever reason. Also useful for drivers that do device detection and
665 * detection fails, either because the device uses an unexpected address,
666 * or this is a compatible device with different ID register values.
668 * Parameter checking may look overzealous, but we really don't want
669 * the user to provide incorrect parameters.
672 i2c_sysfs_new_device(struct device
*dev
, struct device_attribute
*attr
,
673 const char *buf
, size_t count
)
675 struct i2c_adapter
*adap
= to_i2c_adapter(dev
);
676 struct i2c_board_info info
;
677 struct i2c_client
*client
;
681 memset(&info
, 0, sizeof(struct i2c_board_info
));
683 blank
= strchr(buf
, ' ');
685 dev_err(dev
, "%s: Missing parameters\n", "new_device");
688 if (blank
- buf
> I2C_NAME_SIZE
- 1) {
689 dev_err(dev
, "%s: Invalid device name\n", "new_device");
692 memcpy(info
.type
, buf
, blank
- buf
);
694 /* Parse remaining parameters, reject extra parameters */
695 res
= sscanf(++blank
, "%hi%c", &info
.addr
, &end
);
697 dev_err(dev
, "%s: Can't parse I2C address\n", "new_device");
700 if (res
> 1 && end
!= '\n') {
701 dev_err(dev
, "%s: Extra parameters\n", "new_device");
705 client
= i2c_new_device(adap
, &info
);
709 /* Keep track of the added device */
710 mutex_lock(&adap
->userspace_clients_lock
);
711 list_add_tail(&client
->detected
, &adap
->userspace_clients
);
712 mutex_unlock(&adap
->userspace_clients_lock
);
713 dev_info(dev
, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
714 info
.type
, info
.addr
);
720 * And of course let the users delete the devices they instantiated, if
721 * they got it wrong. This interface can only be used to delete devices
722 * instantiated by i2c_sysfs_new_device above. This guarantees that we
723 * don't delete devices to which some kernel code still has references.
725 * Parameter checking may look overzealous, but we really don't want
726 * the user to delete the wrong device.
729 i2c_sysfs_delete_device(struct device
*dev
, struct device_attribute
*attr
,
730 const char *buf
, size_t count
)
732 struct i2c_adapter
*adap
= to_i2c_adapter(dev
);
733 struct i2c_client
*client
, *next
;
738 /* Parse parameters, reject extra parameters */
739 res
= sscanf(buf
, "%hi%c", &addr
, &end
);
741 dev_err(dev
, "%s: Can't parse I2C address\n", "delete_device");
744 if (res
> 1 && end
!= '\n') {
745 dev_err(dev
, "%s: Extra parameters\n", "delete_device");
749 /* Make sure the device was added through sysfs */
751 mutex_lock_nested(&adap
->userspace_clients_lock
,
752 i2c_adapter_depth(adap
));
753 list_for_each_entry_safe(client
, next
, &adap
->userspace_clients
,
755 if (client
->addr
== addr
) {
756 dev_info(dev
, "%s: Deleting device %s at 0x%02hx\n",
757 "delete_device", client
->name
, client
->addr
);
759 list_del(&client
->detected
);
760 i2c_unregister_device(client
);
765 mutex_unlock(&adap
->userspace_clients_lock
);
768 dev_err(dev
, "%s: Can't find device in list\n",
773 static DEVICE_ATTR(new_device
, S_IWUSR
, NULL
, i2c_sysfs_new_device
);
774 static DEVICE_ATTR(delete_device
, S_IWUSR
, NULL
, i2c_sysfs_delete_device
);
776 static struct attribute
*i2c_adapter_attrs
[] = {
778 &dev_attr_new_device
.attr
,
779 &dev_attr_delete_device
.attr
,
783 static struct attribute_group i2c_adapter_attr_group
= {
784 .attrs
= i2c_adapter_attrs
,
787 static const struct attribute_group
*i2c_adapter_attr_groups
[] = {
788 &i2c_adapter_attr_group
,
792 struct device_type i2c_adapter_type
= {
793 .groups
= i2c_adapter_attr_groups
,
794 .release
= i2c_adapter_dev_release
,
796 EXPORT_SYMBOL_GPL(i2c_adapter_type
);
799 * i2c_verify_adapter - return parameter as i2c_adapter or NULL
800 * @dev: device, probably from some driver model iterator
802 * When traversing the driver model tree, perhaps using driver model
803 * iterators like @device_for_each_child(), you can't assume very much
804 * about the nodes you find. Use this function to avoid oopses caused
805 * by wrongly treating some non-I2C device as an i2c_adapter.
807 struct i2c_adapter
*i2c_verify_adapter(struct device
*dev
)
809 return (dev
->type
== &i2c_adapter_type
)
810 ? to_i2c_adapter(dev
)
813 EXPORT_SYMBOL(i2c_verify_adapter
);
815 #ifdef CONFIG_I2C_COMPAT
816 static struct class_compat
*i2c_adapter_compat_class
;
819 static void i2c_scan_static_board_info(struct i2c_adapter
*adapter
)
821 struct i2c_devinfo
*devinfo
;
823 down_read(&__i2c_board_lock
);
824 list_for_each_entry(devinfo
, &__i2c_board_list
, list
) {
825 if (devinfo
->busnum
== adapter
->nr
826 && !i2c_new_device(adapter
,
827 &devinfo
->board_info
))
828 dev_err(&adapter
->dev
,
829 "Can't create device at 0x%02x\n",
830 devinfo
->board_info
.addr
);
832 up_read(&__i2c_board_lock
);
835 static int i2c_do_add_adapter(struct i2c_driver
*driver
,
836 struct i2c_adapter
*adap
)
838 /* Detect supported devices on that bus, and instantiate them */
839 i2c_detect(adap
, driver
);
841 /* Let legacy drivers scan this bus for matching devices */
842 if (driver
->attach_adapter
) {
843 dev_warn(&adap
->dev
, "%s: attach_adapter method is deprecated\n",
844 driver
->driver
.name
);
845 dev_warn(&adap
->dev
, "Please use another way to instantiate "
846 "your i2c_client\n");
847 /* We ignore the return code; if it fails, too bad */
848 driver
->attach_adapter(adap
);
853 static int __process_new_adapter(struct device_driver
*d
, void *data
)
855 return i2c_do_add_adapter(to_i2c_driver(d
), data
);
858 static int i2c_register_adapter(struct i2c_adapter
*adap
)
862 /* Can't register until after driver model init */
863 if (unlikely(WARN_ON(!i2c_bus_type
.p
))) {
869 if (unlikely(adap
->name
[0] == '\0')) {
870 pr_err("i2c-core: Attempt to register an adapter with "
874 if (unlikely(!adap
->algo
)) {
875 pr_err("i2c-core: Attempt to register adapter '%s' with "
876 "no algo!\n", adap
->name
);
880 rt_mutex_init(&adap
->bus_lock
);
881 mutex_init(&adap
->userspace_clients_lock
);
882 INIT_LIST_HEAD(&adap
->userspace_clients
);
884 /* Set default timeout to 1 second if not already set */
885 if (adap
->timeout
== 0)
888 dev_set_name(&adap
->dev
, "i2c-%d", adap
->nr
);
889 adap
->dev
.bus
= &i2c_bus_type
;
890 adap
->dev
.type
= &i2c_adapter_type
;
891 res
= device_register(&adap
->dev
);
895 dev_dbg(&adap
->dev
, "adapter [%s] registered\n", adap
->name
);
897 #ifdef CONFIG_I2C_COMPAT
898 res
= class_compat_create_link(i2c_adapter_compat_class
, &adap
->dev
,
902 "Failed to create compatibility class link\n");
905 /* create pre-declared device nodes */
906 if (adap
->nr
< __i2c_first_dynamic_bus_num
)
907 i2c_scan_static_board_info(adap
);
910 mutex_lock(&core_lock
);
911 bus_for_each_drv(&i2c_bus_type
, NULL
, adap
, __process_new_adapter
);
912 mutex_unlock(&core_lock
);
917 mutex_lock(&core_lock
);
918 idr_remove(&i2c_adapter_idr
, adap
->nr
);
919 mutex_unlock(&core_lock
);
924 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
925 * @adapter: the adapter to add
928 * This routine is used to declare an I2C adapter when its bus number
929 * doesn't matter. Examples: for I2C adapters dynamically added by
930 * USB links or PCI plugin cards.
932 * When this returns zero, a new bus number was allocated and stored
933 * in adap->nr, and the specified adapter became available for clients.
934 * Otherwise, a negative errno value is returned.
936 int i2c_add_adapter(struct i2c_adapter
*adapter
)
941 if (idr_pre_get(&i2c_adapter_idr
, GFP_KERNEL
) == 0)
944 mutex_lock(&core_lock
);
945 /* "above" here means "above or equal to", sigh */
946 res
= idr_get_new_above(&i2c_adapter_idr
, adapter
,
947 __i2c_first_dynamic_bus_num
, &id
);
948 mutex_unlock(&core_lock
);
957 return i2c_register_adapter(adapter
);
959 EXPORT_SYMBOL(i2c_add_adapter
);
962 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
963 * @adap: the adapter to register (with adap->nr initialized)
966 * This routine is used to declare an I2C adapter when its bus number
967 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
968 * or otherwise built in to the system's mainboard, and where i2c_board_info
969 * is used to properly configure I2C devices.
971 * If the requested bus number is set to -1, then this function will behave
972 * identically to i2c_add_adapter, and will dynamically assign a bus number.
974 * If no devices have pre-been declared for this bus, then be sure to
975 * register the adapter before any dynamically allocated ones. Otherwise
976 * the required bus ID may not be available.
978 * When this returns zero, the specified adapter became available for
979 * clients using the bus number provided in adap->nr. Also, the table
980 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
981 * and the appropriate driver model device nodes are created. Otherwise, a
982 * negative errno value is returned.
984 int i2c_add_numbered_adapter(struct i2c_adapter
*adap
)
989 if (adap
->nr
== -1) /* -1 means dynamically assign bus id */
990 return i2c_add_adapter(adap
);
991 if (adap
->nr
& ~MAX_IDR_MASK
)
995 if (idr_pre_get(&i2c_adapter_idr
, GFP_KERNEL
) == 0)
998 mutex_lock(&core_lock
);
999 /* "above" here means "above or equal to", sigh;
1000 * we need the "equal to" result to force the result
1002 status
= idr_get_new_above(&i2c_adapter_idr
, adap
, adap
->nr
, &id
);
1003 if (status
== 0 && id
!= adap
->nr
) {
1005 idr_remove(&i2c_adapter_idr
, id
);
1007 mutex_unlock(&core_lock
);
1008 if (status
== -EAGAIN
)
1012 status
= i2c_register_adapter(adap
);
1015 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter
);
1017 static int i2c_do_del_adapter(struct i2c_driver
*driver
,
1018 struct i2c_adapter
*adapter
)
1020 struct i2c_client
*client
, *_n
;
1023 /* Remove the devices we created ourselves as the result of hardware
1024 * probing (using a driver's detect method) */
1025 list_for_each_entry_safe(client
, _n
, &driver
->clients
, detected
) {
1026 if (client
->adapter
== adapter
) {
1027 dev_dbg(&adapter
->dev
, "Removing %s at 0x%x\n",
1028 client
->name
, client
->addr
);
1029 list_del(&client
->detected
);
1030 i2c_unregister_device(client
);
1034 if (!driver
->detach_adapter
)
1036 dev_warn(&adapter
->dev
, "%s: detach_adapter method is deprecated\n",
1037 driver
->driver
.name
);
1038 res
= driver
->detach_adapter(adapter
);
1040 dev_err(&adapter
->dev
, "detach_adapter failed (%d) "
1041 "for driver [%s]\n", res
, driver
->driver
.name
);
1045 static int __unregister_client(struct device
*dev
, void *dummy
)
1047 struct i2c_client
*client
= i2c_verify_client(dev
);
1048 if (client
&& strcmp(client
->name
, "dummy"))
1049 i2c_unregister_device(client
);
1053 static int __unregister_dummy(struct device
*dev
, void *dummy
)
1055 struct i2c_client
*client
= i2c_verify_client(dev
);
1057 i2c_unregister_device(client
);
1061 static int __process_removed_adapter(struct device_driver
*d
, void *data
)
1063 return i2c_do_del_adapter(to_i2c_driver(d
), data
);
1067 * i2c_del_adapter - unregister I2C adapter
1068 * @adap: the adapter being unregistered
1069 * Context: can sleep
1071 * This unregisters an I2C adapter which was previously registered
1072 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
1074 int i2c_del_adapter(struct i2c_adapter
*adap
)
1077 struct i2c_adapter
*found
;
1078 struct i2c_client
*client
, *next
;
1080 /* First make sure that this adapter was ever added */
1081 mutex_lock(&core_lock
);
1082 found
= idr_find(&i2c_adapter_idr
, adap
->nr
);
1083 mutex_unlock(&core_lock
);
1084 if (found
!= adap
) {
1085 pr_debug("i2c-core: attempting to delete unregistered "
1086 "adapter [%s]\n", adap
->name
);
1090 /* Tell drivers about this removal */
1091 mutex_lock(&core_lock
);
1092 res
= bus_for_each_drv(&i2c_bus_type
, NULL
, adap
,
1093 __process_removed_adapter
);
1094 mutex_unlock(&core_lock
);
1098 /* Remove devices instantiated from sysfs */
1099 mutex_lock_nested(&adap
->userspace_clients_lock
,
1100 i2c_adapter_depth(adap
));
1101 list_for_each_entry_safe(client
, next
, &adap
->userspace_clients
,
1103 dev_dbg(&adap
->dev
, "Removing %s at 0x%x\n", client
->name
,
1105 list_del(&client
->detected
);
1106 i2c_unregister_device(client
);
1108 mutex_unlock(&adap
->userspace_clients_lock
);
1110 /* Detach any active clients. This can't fail, thus we do not
1111 * check the returned value. This is a two-pass process, because
1112 * we can't remove the dummy devices during the first pass: they
1113 * could have been instantiated by real devices wishing to clean
1114 * them up properly, so we give them a chance to do that first. */
1115 res
= device_for_each_child(&adap
->dev
, NULL
, __unregister_client
);
1116 res
= device_for_each_child(&adap
->dev
, NULL
, __unregister_dummy
);
1118 #ifdef CONFIG_I2C_COMPAT
1119 class_compat_remove_link(i2c_adapter_compat_class
, &adap
->dev
,
1123 /* device name is gone after device_unregister */
1124 dev_dbg(&adap
->dev
, "adapter [%s] unregistered\n", adap
->name
);
1126 /* clean up the sysfs representation */
1127 init_completion(&adap
->dev_released
);
1128 device_unregister(&adap
->dev
);
1130 /* wait for sysfs to drop all references */
1131 wait_for_completion(&adap
->dev_released
);
1134 mutex_lock(&core_lock
);
1135 idr_remove(&i2c_adapter_idr
, adap
->nr
);
1136 mutex_unlock(&core_lock
);
1138 /* Clear the device structure in case this adapter is ever going to be
1140 memset(&adap
->dev
, 0, sizeof(adap
->dev
));
1144 EXPORT_SYMBOL(i2c_del_adapter
);
1147 /* ------------------------------------------------------------------------- */
1149 int i2c_for_each_dev(void *data
, int (*fn
)(struct device
*, void *))
1153 mutex_lock(&core_lock
);
1154 res
= bus_for_each_dev(&i2c_bus_type
, NULL
, data
, fn
);
1155 mutex_unlock(&core_lock
);
1159 EXPORT_SYMBOL_GPL(i2c_for_each_dev
);
1161 static int __process_new_driver(struct device
*dev
, void *data
)
1163 if (dev
->type
!= &i2c_adapter_type
)
1165 return i2c_do_add_adapter(data
, to_i2c_adapter(dev
));
1169 * An i2c_driver is used with one or more i2c_client (device) nodes to access
1170 * i2c slave chips, on a bus instance associated with some i2c_adapter.
1173 int i2c_register_driver(struct module
*owner
, struct i2c_driver
*driver
)
1177 /* Can't register until after driver model init */
1178 if (unlikely(WARN_ON(!i2c_bus_type
.p
)))
1181 /* add the driver to the list of i2c drivers in the driver core */
1182 driver
->driver
.owner
= owner
;
1183 driver
->driver
.bus
= &i2c_bus_type
;
1185 /* When registration returns, the driver core
1186 * will have called probe() for all matching-but-unbound devices.
1188 res
= driver_register(&driver
->driver
);
1192 /* Drivers should switch to dev_pm_ops instead. */
1193 if (driver
->suspend
)
1194 pr_warn("i2c-core: driver [%s] using legacy suspend method\n",
1195 driver
->driver
.name
);
1197 pr_warn("i2c-core: driver [%s] using legacy resume method\n",
1198 driver
->driver
.name
);
1200 pr_debug("i2c-core: driver [%s] registered\n", driver
->driver
.name
);
1202 INIT_LIST_HEAD(&driver
->clients
);
1203 /* Walk the adapters that are already present */
1204 i2c_for_each_dev(driver
, __process_new_driver
);
1208 EXPORT_SYMBOL(i2c_register_driver
);
1210 static int __process_removed_driver(struct device
*dev
, void *data
)
1212 if (dev
->type
!= &i2c_adapter_type
)
1214 return i2c_do_del_adapter(data
, to_i2c_adapter(dev
));
1218 * i2c_del_driver - unregister I2C driver
1219 * @driver: the driver being unregistered
1220 * Context: can sleep
1222 void i2c_del_driver(struct i2c_driver
*driver
)
1224 i2c_for_each_dev(driver
, __process_removed_driver
);
1226 driver_unregister(&driver
->driver
);
1227 pr_debug("i2c-core: driver [%s] unregistered\n", driver
->driver
.name
);
1229 EXPORT_SYMBOL(i2c_del_driver
);
1231 /* ------------------------------------------------------------------------- */
1234 * i2c_use_client - increments the reference count of the i2c client structure
1235 * @client: the client being referenced
1237 * Each live reference to a client should be refcounted. The driver model does
1238 * that automatically as part of driver binding, so that most drivers don't
1239 * need to do this explicitly: they hold a reference until they're unbound
1242 * A pointer to the client with the incremented reference counter is returned.
1244 struct i2c_client
*i2c_use_client(struct i2c_client
*client
)
1246 if (client
&& get_device(&client
->dev
))
1250 EXPORT_SYMBOL(i2c_use_client
);
1253 * i2c_release_client - release a use of the i2c client structure
1254 * @client: the client being no longer referenced
1256 * Must be called when a user of a client is finished with it.
1258 void i2c_release_client(struct i2c_client
*client
)
1261 put_device(&client
->dev
);
1263 EXPORT_SYMBOL(i2c_release_client
);
1265 struct i2c_cmd_arg
{
1270 static int i2c_cmd(struct device
*dev
, void *_arg
)
1272 struct i2c_client
*client
= i2c_verify_client(dev
);
1273 struct i2c_cmd_arg
*arg
= _arg
;
1275 if (client
&& client
->driver
&& client
->driver
->command
)
1276 client
->driver
->command(client
, arg
->cmd
, arg
->arg
);
1280 void i2c_clients_command(struct i2c_adapter
*adap
, unsigned int cmd
, void *arg
)
1282 struct i2c_cmd_arg cmd_arg
;
1286 device_for_each_child(&adap
->dev
, &cmd_arg
, i2c_cmd
);
1288 EXPORT_SYMBOL(i2c_clients_command
);
1290 static int __init
i2c_init(void)
1294 retval
= bus_register(&i2c_bus_type
);
1297 #ifdef CONFIG_I2C_COMPAT
1298 i2c_adapter_compat_class
= class_compat_register("i2c-adapter");
1299 if (!i2c_adapter_compat_class
) {
1304 retval
= i2c_add_driver(&dummy_driver
);
1310 #ifdef CONFIG_I2C_COMPAT
1311 class_compat_unregister(i2c_adapter_compat_class
);
1314 bus_unregister(&i2c_bus_type
);
1318 static void __exit
i2c_exit(void)
1320 i2c_del_driver(&dummy_driver
);
1321 #ifdef CONFIG_I2C_COMPAT
1322 class_compat_unregister(i2c_adapter_compat_class
);
1324 bus_unregister(&i2c_bus_type
);
1327 /* We must initialize early, because some subsystems register i2c drivers
1328 * in subsys_initcall() code, but are linked (and initialized) before i2c.
1330 postcore_initcall(i2c_init
);
1331 module_exit(i2c_exit
);
1333 /* ----------------------------------------------------
1334 * the functional interface to the i2c busses.
1335 * ----------------------------------------------------
1339 * __i2c_transfer - unlocked flavor of i2c_transfer
1340 * @adap: Handle to I2C bus
1341 * @msgs: One or more messages to execute before STOP is issued to
1342 * terminate the operation; each message begins with a START.
1343 * @num: Number of messages to be executed.
1345 * Returns negative errno, else the number of messages executed.
1347 * Adapter lock must be held when calling this function. No debug logging
1348 * takes place. adap->algo->master_xfer existence isn't checked.
1350 int __i2c_transfer(struct i2c_adapter
*adap
, struct i2c_msg
*msgs
, int num
)
1352 unsigned long orig_jiffies
;
1355 /* Retry automatically on arbitration loss */
1356 orig_jiffies
= jiffies
;
1357 for (ret
= 0, try = 0; try <= adap
->retries
; try++) {
1358 ret
= adap
->algo
->master_xfer(adap
, msgs
, num
);
1361 if (time_after(jiffies
, orig_jiffies
+ adap
->timeout
))
1367 EXPORT_SYMBOL(__i2c_transfer
);
1370 * i2c_transfer - execute a single or combined I2C message
1371 * @adap: Handle to I2C bus
1372 * @msgs: One or more messages to execute before STOP is issued to
1373 * terminate the operation; each message begins with a START.
1374 * @num: Number of messages to be executed.
1376 * Returns negative errno, else the number of messages executed.
1378 * Note that there is no requirement that each message be sent to
1379 * the same slave address, although that is the most common model.
1381 int i2c_transfer(struct i2c_adapter
*adap
, struct i2c_msg
*msgs
, int num
)
1385 /* REVISIT the fault reporting model here is weak:
1387 * - When we get an error after receiving N bytes from a slave,
1388 * there is no way to report "N".
1390 * - When we get a NAK after transmitting N bytes to a slave,
1391 * there is no way to report "N" ... or to let the master
1392 * continue executing the rest of this combined message, if
1393 * that's the appropriate response.
1395 * - When for example "num" is two and we successfully complete
1396 * the first message but get an error part way through the
1397 * second, it's unclear whether that should be reported as
1398 * one (discarding status on the second message) or errno
1399 * (discarding status on the first one).
1402 if (adap
->algo
->master_xfer
) {
1404 for (ret
= 0; ret
< num
; ret
++) {
1405 dev_dbg(&adap
->dev
, "master_xfer[%d] %c, addr=0x%02x, "
1406 "len=%d%s\n", ret
, (msgs
[ret
].flags
& I2C_M_RD
)
1407 ? 'R' : 'W', msgs
[ret
].addr
, msgs
[ret
].len
,
1408 (msgs
[ret
].flags
& I2C_M_RECV_LEN
) ? "+" : "");
1412 if (in_atomic() || irqs_disabled()) {
1413 ret
= i2c_trylock_adapter(adap
);
1415 /* I2C activity is ongoing. */
1418 i2c_lock_adapter(adap
);
1421 ret
= __i2c_transfer(adap
, msgs
, num
);
1422 i2c_unlock_adapter(adap
);
1426 dev_dbg(&adap
->dev
, "I2C level transfers not supported\n");
1430 EXPORT_SYMBOL(i2c_transfer
);
1433 * i2c_master_send - issue a single I2C message in master transmit mode
1434 * @client: Handle to slave device
1435 * @buf: Data that will be written to the slave
1436 * @count: How many bytes to write, must be less than 64k since msg.len is u16
1438 * Returns negative errno, or else the number of bytes written.
1440 int i2c_master_send(const struct i2c_client
*client
, const char *buf
, int count
)
1443 struct i2c_adapter
*adap
= client
->adapter
;
1446 msg
.addr
= client
->addr
;
1447 msg
.flags
= client
->flags
& I2C_M_TEN
;
1449 msg
.buf
= (char *)buf
;
1451 ret
= i2c_transfer(adap
, &msg
, 1);
1454 * If everything went ok (i.e. 1 msg transmitted), return #bytes
1455 * transmitted, else error code.
1457 return (ret
== 1) ? count
: ret
;
1459 EXPORT_SYMBOL(i2c_master_send
);
1462 * i2c_master_recv - issue a single I2C message in master receive mode
1463 * @client: Handle to slave device
1464 * @buf: Where to store data read from slave
1465 * @count: How many bytes to read, must be less than 64k since msg.len is u16
1467 * Returns negative errno, or else the number of bytes read.
1469 int i2c_master_recv(const struct i2c_client
*client
, char *buf
, int count
)
1471 struct i2c_adapter
*adap
= client
->adapter
;
1475 msg
.addr
= client
->addr
;
1476 msg
.flags
= client
->flags
& I2C_M_TEN
;
1477 msg
.flags
|= I2C_M_RD
;
1481 ret
= i2c_transfer(adap
, &msg
, 1);
1484 * If everything went ok (i.e. 1 msg received), return #bytes received,
1487 return (ret
== 1) ? count
: ret
;
1489 EXPORT_SYMBOL(i2c_master_recv
);
1491 /* ----------------------------------------------------
1492 * the i2c address scanning function
1493 * Will not work for 10-bit addresses!
1494 * ----------------------------------------------------
1498 * Legacy default probe function, mostly relevant for SMBus. The default
1499 * probe method is a quick write, but it is known to corrupt the 24RF08
1500 * EEPROMs due to a state machine bug, and could also irreversibly
1501 * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
1502 * we use a short byte read instead. Also, some bus drivers don't implement
1503 * quick write, so we fallback to a byte read in that case too.
1504 * On x86, there is another special case for FSC hardware monitoring chips,
1505 * which want regular byte reads (address 0x73.) Fortunately, these are the
1506 * only known chips using this I2C address on PC hardware.
1507 * Returns 1 if probe succeeded, 0 if not.
1509 static int i2c_default_probe(struct i2c_adapter
*adap
, unsigned short addr
)
1512 union i2c_smbus_data dummy
;
1515 if (addr
== 0x73 && (adap
->class & I2C_CLASS_HWMON
)
1516 && i2c_check_functionality(adap
, I2C_FUNC_SMBUS_READ_BYTE_DATA
))
1517 err
= i2c_smbus_xfer(adap
, addr
, 0, I2C_SMBUS_READ
, 0,
1518 I2C_SMBUS_BYTE_DATA
, &dummy
);
1521 if (!((addr
& ~0x07) == 0x30 || (addr
& ~0x0f) == 0x50)
1522 && i2c_check_functionality(adap
, I2C_FUNC_SMBUS_QUICK
))
1523 err
= i2c_smbus_xfer(adap
, addr
, 0, I2C_SMBUS_WRITE
, 0,
1524 I2C_SMBUS_QUICK
, NULL
);
1525 else if (i2c_check_functionality(adap
, I2C_FUNC_SMBUS_READ_BYTE
))
1526 err
= i2c_smbus_xfer(adap
, addr
, 0, I2C_SMBUS_READ
, 0,
1527 I2C_SMBUS_BYTE
, &dummy
);
1529 dev_warn(&adap
->dev
, "No suitable probing method supported\n");
1536 static int i2c_detect_address(struct i2c_client
*temp_client
,
1537 struct i2c_driver
*driver
)
1539 struct i2c_board_info info
;
1540 struct i2c_adapter
*adapter
= temp_client
->adapter
;
1541 int addr
= temp_client
->addr
;
1544 /* Make sure the address is valid */
1545 err
= i2c_check_addr_validity(addr
);
1547 dev_warn(&adapter
->dev
, "Invalid probe address 0x%02x\n",
1552 /* Skip if already in use */
1553 if (i2c_check_addr_busy(adapter
, addr
))
1556 /* Make sure there is something at this address */
1557 if (!i2c_default_probe(adapter
, addr
))
1560 /* Finally call the custom detection function */
1561 memset(&info
, 0, sizeof(struct i2c_board_info
));
1563 err
= driver
->detect(temp_client
, &info
);
1565 /* -ENODEV is returned if the detection fails. We catch it
1566 here as this isn't an error. */
1567 return err
== -ENODEV
? 0 : err
;
1570 /* Consistency check */
1571 if (info
.type
[0] == '\0') {
1572 dev_err(&adapter
->dev
, "%s detection function provided "
1573 "no name for 0x%x\n", driver
->driver
.name
,
1576 struct i2c_client
*client
;
1578 /* Detection succeeded, instantiate the device */
1579 dev_dbg(&adapter
->dev
, "Creating %s at 0x%02x\n",
1580 info
.type
, info
.addr
);
1581 client
= i2c_new_device(adapter
, &info
);
1583 list_add_tail(&client
->detected
, &driver
->clients
);
1585 dev_err(&adapter
->dev
, "Failed creating %s at 0x%02x\n",
1586 info
.type
, info
.addr
);
1591 static int i2c_detect(struct i2c_adapter
*adapter
, struct i2c_driver
*driver
)
1593 const unsigned short *address_list
;
1594 struct i2c_client
*temp_client
;
1596 int adap_id
= i2c_adapter_id(adapter
);
1598 address_list
= driver
->address_list
;
1599 if (!driver
->detect
|| !address_list
)
1602 /* Stop here if the classes do not match */
1603 if (!(adapter
->class & driver
->class))
1606 /* Set up a temporary client to help detect callback */
1607 temp_client
= kzalloc(sizeof(struct i2c_client
), GFP_KERNEL
);
1610 temp_client
->adapter
= adapter
;
1612 for (i
= 0; address_list
[i
] != I2C_CLIENT_END
; i
+= 1) {
1613 dev_dbg(&adapter
->dev
, "found normal entry for adapter %d, "
1614 "addr 0x%02x\n", adap_id
, address_list
[i
]);
1615 temp_client
->addr
= address_list
[i
];
1616 err
= i2c_detect_address(temp_client
, driver
);
1625 int i2c_probe_func_quick_read(struct i2c_adapter
*adap
, unsigned short addr
)
1627 return i2c_smbus_xfer(adap
, addr
, 0, I2C_SMBUS_READ
, 0,
1628 I2C_SMBUS_QUICK
, NULL
) >= 0;
1630 EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read
);
1633 i2c_new_probed_device(struct i2c_adapter
*adap
,
1634 struct i2c_board_info
*info
,
1635 unsigned short const *addr_list
,
1636 int (*probe
)(struct i2c_adapter
*, unsigned short addr
))
1641 probe
= i2c_default_probe
;
1643 for (i
= 0; addr_list
[i
] != I2C_CLIENT_END
; i
++) {
1644 /* Check address validity */
1645 if (i2c_check_addr_validity(addr_list
[i
]) < 0) {
1646 dev_warn(&adap
->dev
, "Invalid 7-bit address "
1647 "0x%02x\n", addr_list
[i
]);
1651 /* Check address availability */
1652 if (i2c_check_addr_busy(adap
, addr_list
[i
])) {
1653 dev_dbg(&adap
->dev
, "Address 0x%02x already in "
1654 "use, not probing\n", addr_list
[i
]);
1658 /* Test address responsiveness */
1659 if (probe(adap
, addr_list
[i
]))
1663 if (addr_list
[i
] == I2C_CLIENT_END
) {
1664 dev_dbg(&adap
->dev
, "Probing failed, no device found\n");
1668 info
->addr
= addr_list
[i
];
1669 return i2c_new_device(adap
, info
);
1671 EXPORT_SYMBOL_GPL(i2c_new_probed_device
);
1673 struct i2c_adapter
*i2c_get_adapter(int nr
)
1675 struct i2c_adapter
*adapter
;
1677 mutex_lock(&core_lock
);
1678 adapter
= idr_find(&i2c_adapter_idr
, nr
);
1679 if (adapter
&& !try_module_get(adapter
->owner
))
1682 mutex_unlock(&core_lock
);
1685 EXPORT_SYMBOL(i2c_get_adapter
);
1687 void i2c_put_adapter(struct i2c_adapter
*adap
)
1689 module_put(adap
->owner
);
1691 EXPORT_SYMBOL(i2c_put_adapter
);
1693 /* The SMBus parts */
1695 #define POLY (0x1070U << 3)
1696 static u8
crc8(u16 data
)
1700 for (i
= 0; i
< 8; i
++) {
1705 return (u8
)(data
>> 8);
1708 /* Incremental CRC8 over count bytes in the array pointed to by p */
1709 static u8
i2c_smbus_pec(u8 crc
, u8
*p
, size_t count
)
1713 for (i
= 0; i
< count
; i
++)
1714 crc
= crc8((crc
^ p
[i
]) << 8);
1718 /* Assume a 7-bit address, which is reasonable for SMBus */
1719 static u8
i2c_smbus_msg_pec(u8 pec
, struct i2c_msg
*msg
)
1721 /* The address will be sent first */
1722 u8 addr
= (msg
->addr
<< 1) | !!(msg
->flags
& I2C_M_RD
);
1723 pec
= i2c_smbus_pec(pec
, &addr
, 1);
1725 /* The data buffer follows */
1726 return i2c_smbus_pec(pec
, msg
->buf
, msg
->len
);
1729 /* Used for write only transactions */
1730 static inline void i2c_smbus_add_pec(struct i2c_msg
*msg
)
1732 msg
->buf
[msg
->len
] = i2c_smbus_msg_pec(0, msg
);
1736 /* Return <0 on CRC error
1737 If there was a write before this read (most cases) we need to take the
1738 partial CRC from the write part into account.
1739 Note that this function does modify the message (we need to decrease the
1740 message length to hide the CRC byte from the caller). */
1741 static int i2c_smbus_check_pec(u8 cpec
, struct i2c_msg
*msg
)
1743 u8 rpec
= msg
->buf
[--msg
->len
];
1744 cpec
= i2c_smbus_msg_pec(cpec
, msg
);
1747 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1755 * i2c_smbus_read_byte - SMBus "receive byte" protocol
1756 * @client: Handle to slave device
1758 * This executes the SMBus "receive byte" protocol, returning negative errno
1759 * else the byte received from the device.
1761 s32
i2c_smbus_read_byte(const struct i2c_client
*client
)
1763 union i2c_smbus_data data
;
1766 status
= i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1768 I2C_SMBUS_BYTE
, &data
);
1769 return (status
< 0) ? status
: data
.byte
;
1771 EXPORT_SYMBOL(i2c_smbus_read_byte
);
1774 * i2c_smbus_write_byte - SMBus "send byte" protocol
1775 * @client: Handle to slave device
1776 * @value: Byte to be sent
1778 * This executes the SMBus "send byte" protocol, returning negative errno
1779 * else zero on success.
1781 s32
i2c_smbus_write_byte(const struct i2c_client
*client
, u8 value
)
1783 return i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1784 I2C_SMBUS_WRITE
, value
, I2C_SMBUS_BYTE
, NULL
);
1786 EXPORT_SYMBOL(i2c_smbus_write_byte
);
1789 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
1790 * @client: Handle to slave device
1791 * @command: Byte interpreted by slave
1793 * This executes the SMBus "read byte" protocol, returning negative errno
1794 * else a data byte received from the device.
1796 s32
i2c_smbus_read_byte_data(const struct i2c_client
*client
, u8 command
)
1798 union i2c_smbus_data data
;
1801 status
= i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1802 I2C_SMBUS_READ
, command
,
1803 I2C_SMBUS_BYTE_DATA
, &data
);
1804 return (status
< 0) ? status
: data
.byte
;
1806 EXPORT_SYMBOL(i2c_smbus_read_byte_data
);
1809 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
1810 * @client: Handle to slave device
1811 * @command: Byte interpreted by slave
1812 * @value: Byte being written
1814 * This executes the SMBus "write byte" protocol, returning negative errno
1815 * else zero on success.
1817 s32
i2c_smbus_write_byte_data(const struct i2c_client
*client
, u8 command
,
1820 union i2c_smbus_data data
;
1822 return i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1823 I2C_SMBUS_WRITE
, command
,
1824 I2C_SMBUS_BYTE_DATA
, &data
);
1826 EXPORT_SYMBOL(i2c_smbus_write_byte_data
);
1829 * i2c_smbus_read_word_data - SMBus "read word" protocol
1830 * @client: Handle to slave device
1831 * @command: Byte interpreted by slave
1833 * This executes the SMBus "read word" protocol, returning negative errno
1834 * else a 16-bit unsigned "word" received from the device.
1836 s32
i2c_smbus_read_word_data(const struct i2c_client
*client
, u8 command
)
1838 union i2c_smbus_data data
;
1841 status
= i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1842 I2C_SMBUS_READ
, command
,
1843 I2C_SMBUS_WORD_DATA
, &data
);
1844 return (status
< 0) ? status
: data
.word
;
1846 EXPORT_SYMBOL(i2c_smbus_read_word_data
);
1849 * i2c_smbus_write_word_data - SMBus "write word" protocol
1850 * @client: Handle to slave device
1851 * @command: Byte interpreted by slave
1852 * @value: 16-bit "word" being written
1854 * This executes the SMBus "write word" protocol, returning negative errno
1855 * else zero on success.
1857 s32
i2c_smbus_write_word_data(const struct i2c_client
*client
, u8 command
,
1860 union i2c_smbus_data data
;
1862 return i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1863 I2C_SMBUS_WRITE
, command
,
1864 I2C_SMBUS_WORD_DATA
, &data
);
1866 EXPORT_SYMBOL(i2c_smbus_write_word_data
);
1869 * i2c_smbus_process_call - SMBus "process call" protocol
1870 * @client: Handle to slave device
1871 * @command: Byte interpreted by slave
1872 * @value: 16-bit "word" being written
1874 * This executes the SMBus "process call" protocol, returning negative errno
1875 * else a 16-bit unsigned "word" received from the device.
1877 s32
i2c_smbus_process_call(const struct i2c_client
*client
, u8 command
,
1880 union i2c_smbus_data data
;
1884 status
= i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1885 I2C_SMBUS_WRITE
, command
,
1886 I2C_SMBUS_PROC_CALL
, &data
);
1887 return (status
< 0) ? status
: data
.word
;
1889 EXPORT_SYMBOL(i2c_smbus_process_call
);
1892 * i2c_smbus_read_block_data - SMBus "block read" protocol
1893 * @client: Handle to slave device
1894 * @command: Byte interpreted by slave
1895 * @values: Byte array into which data will be read; big enough to hold
1896 * the data returned by the slave. SMBus allows at most 32 bytes.
1898 * This executes the SMBus "block read" protocol, returning negative errno
1899 * else the number of data bytes in the slave's response.
1901 * Note that using this function requires that the client's adapter support
1902 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
1903 * support this; its emulation through I2C messaging relies on a specific
1904 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
1906 s32
i2c_smbus_read_block_data(const struct i2c_client
*client
, u8 command
,
1909 union i2c_smbus_data data
;
1912 status
= i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1913 I2C_SMBUS_READ
, command
,
1914 I2C_SMBUS_BLOCK_DATA
, &data
);
1918 memcpy(values
, &data
.block
[1], data
.block
[0]);
1919 return data
.block
[0];
1921 EXPORT_SYMBOL(i2c_smbus_read_block_data
);
1924 * i2c_smbus_write_block_data - SMBus "block write" protocol
1925 * @client: Handle to slave device
1926 * @command: Byte interpreted by slave
1927 * @length: Size of data block; SMBus allows at most 32 bytes
1928 * @values: Byte array which will be written.
1930 * This executes the SMBus "block write" protocol, returning negative errno
1931 * else zero on success.
1933 s32
i2c_smbus_write_block_data(const struct i2c_client
*client
, u8 command
,
1934 u8 length
, const u8
*values
)
1936 union i2c_smbus_data data
;
1938 if (length
> I2C_SMBUS_BLOCK_MAX
)
1939 length
= I2C_SMBUS_BLOCK_MAX
;
1940 data
.block
[0] = length
;
1941 memcpy(&data
.block
[1], values
, length
);
1942 return i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1943 I2C_SMBUS_WRITE
, command
,
1944 I2C_SMBUS_BLOCK_DATA
, &data
);
1946 EXPORT_SYMBOL(i2c_smbus_write_block_data
);
1948 /* Returns the number of read bytes */
1949 s32
i2c_smbus_read_i2c_block_data(const struct i2c_client
*client
, u8 command
,
1950 u8 length
, u8
*values
)
1952 union i2c_smbus_data data
;
1955 if (length
> I2C_SMBUS_BLOCK_MAX
)
1956 length
= I2C_SMBUS_BLOCK_MAX
;
1957 data
.block
[0] = length
;
1958 status
= i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1959 I2C_SMBUS_READ
, command
,
1960 I2C_SMBUS_I2C_BLOCK_DATA
, &data
);
1964 memcpy(values
, &data
.block
[1], data
.block
[0]);
1965 return data
.block
[0];
1967 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data
);
1969 s32
i2c_smbus_write_i2c_block_data(const struct i2c_client
*client
, u8 command
,
1970 u8 length
, const u8
*values
)
1972 union i2c_smbus_data data
;
1974 if (length
> I2C_SMBUS_BLOCK_MAX
)
1975 length
= I2C_SMBUS_BLOCK_MAX
;
1976 data
.block
[0] = length
;
1977 memcpy(data
.block
+ 1, values
, length
);
1978 return i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1979 I2C_SMBUS_WRITE
, command
,
1980 I2C_SMBUS_I2C_BLOCK_DATA
, &data
);
1982 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data
);
1984 /* Simulate a SMBus command using the i2c protocol
1985 No checking of parameters is done! */
1986 static s32
i2c_smbus_xfer_emulated(struct i2c_adapter
*adapter
, u16 addr
,
1987 unsigned short flags
,
1988 char read_write
, u8 command
, int size
,
1989 union i2c_smbus_data
*data
)
1991 /* So we need to generate a series of msgs. In the case of writing, we
1992 need to use only one message; when reading, we need two. We initialize
1993 most things with sane defaults, to keep the code below somewhat
1995 unsigned char msgbuf0
[I2C_SMBUS_BLOCK_MAX
+3];
1996 unsigned char msgbuf1
[I2C_SMBUS_BLOCK_MAX
+2];
1997 int num
= read_write
== I2C_SMBUS_READ
? 2 : 1;
2001 struct i2c_msg msg
[2] = {
2009 .flags
= flags
| I2C_M_RD
,
2015 msgbuf0
[0] = command
;
2017 case I2C_SMBUS_QUICK
:
2019 /* Special case: The read/write field is used as data */
2020 msg
[0].flags
= flags
| (read_write
== I2C_SMBUS_READ
?
2024 case I2C_SMBUS_BYTE
:
2025 if (read_write
== I2C_SMBUS_READ
) {
2026 /* Special case: only a read! */
2027 msg
[0].flags
= I2C_M_RD
| flags
;
2031 case I2C_SMBUS_BYTE_DATA
:
2032 if (read_write
== I2C_SMBUS_READ
)
2036 msgbuf0
[1] = data
->byte
;
2039 case I2C_SMBUS_WORD_DATA
:
2040 if (read_write
== I2C_SMBUS_READ
)
2044 msgbuf0
[1] = data
->word
& 0xff;
2045 msgbuf0
[2] = data
->word
>> 8;
2048 case I2C_SMBUS_PROC_CALL
:
2049 num
= 2; /* Special case */
2050 read_write
= I2C_SMBUS_READ
;
2053 msgbuf0
[1] = data
->word
& 0xff;
2054 msgbuf0
[2] = data
->word
>> 8;
2056 case I2C_SMBUS_BLOCK_DATA
:
2057 if (read_write
== I2C_SMBUS_READ
) {
2058 msg
[1].flags
|= I2C_M_RECV_LEN
;
2059 msg
[1].len
= 1; /* block length will be added by
2060 the underlying bus driver */
2062 msg
[0].len
= data
->block
[0] + 2;
2063 if (msg
[0].len
> I2C_SMBUS_BLOCK_MAX
+ 2) {
2064 dev_err(&adapter
->dev
,
2065 "Invalid block write size %d\n",
2069 for (i
= 1; i
< msg
[0].len
; i
++)
2070 msgbuf0
[i
] = data
->block
[i
-1];
2073 case I2C_SMBUS_BLOCK_PROC_CALL
:
2074 num
= 2; /* Another special case */
2075 read_write
= I2C_SMBUS_READ
;
2076 if (data
->block
[0] > I2C_SMBUS_BLOCK_MAX
) {
2077 dev_err(&adapter
->dev
,
2078 "Invalid block write size %d\n",
2082 msg
[0].len
= data
->block
[0] + 2;
2083 for (i
= 1; i
< msg
[0].len
; i
++)
2084 msgbuf0
[i
] = data
->block
[i
-1];
2085 msg
[1].flags
|= I2C_M_RECV_LEN
;
2086 msg
[1].len
= 1; /* block length will be added by
2087 the underlying bus driver */
2089 case I2C_SMBUS_I2C_BLOCK_DATA
:
2090 if (read_write
== I2C_SMBUS_READ
) {
2091 msg
[1].len
= data
->block
[0];
2093 msg
[0].len
= data
->block
[0] + 1;
2094 if (msg
[0].len
> I2C_SMBUS_BLOCK_MAX
+ 1) {
2095 dev_err(&adapter
->dev
,
2096 "Invalid block write size %d\n",
2100 for (i
= 1; i
<= data
->block
[0]; i
++)
2101 msgbuf0
[i
] = data
->block
[i
];
2105 dev_err(&adapter
->dev
, "Unsupported transaction %d\n", size
);
2109 i
= ((flags
& I2C_CLIENT_PEC
) && size
!= I2C_SMBUS_QUICK
2110 && size
!= I2C_SMBUS_I2C_BLOCK_DATA
);
2112 /* Compute PEC if first message is a write */
2113 if (!(msg
[0].flags
& I2C_M_RD
)) {
2114 if (num
== 1) /* Write only */
2115 i2c_smbus_add_pec(&msg
[0]);
2116 else /* Write followed by read */
2117 partial_pec
= i2c_smbus_msg_pec(0, &msg
[0]);
2119 /* Ask for PEC if last message is a read */
2120 if (msg
[num
-1].flags
& I2C_M_RD
)
2124 status
= i2c_transfer(adapter
, msg
, num
);
2128 /* Check PEC if last message is a read */
2129 if (i
&& (msg
[num
-1].flags
& I2C_M_RD
)) {
2130 status
= i2c_smbus_check_pec(partial_pec
, &msg
[num
-1]);
2135 if (read_write
== I2C_SMBUS_READ
)
2137 case I2C_SMBUS_BYTE
:
2138 data
->byte
= msgbuf0
[0];
2140 case I2C_SMBUS_BYTE_DATA
:
2141 data
->byte
= msgbuf1
[0];
2143 case I2C_SMBUS_WORD_DATA
:
2144 case I2C_SMBUS_PROC_CALL
:
2145 data
->word
= msgbuf1
[0] | (msgbuf1
[1] << 8);
2147 case I2C_SMBUS_I2C_BLOCK_DATA
:
2148 for (i
= 0; i
< data
->block
[0]; i
++)
2149 data
->block
[i
+1] = msgbuf1
[i
];
2151 case I2C_SMBUS_BLOCK_DATA
:
2152 case I2C_SMBUS_BLOCK_PROC_CALL
:
2153 for (i
= 0; i
< msgbuf1
[0] + 1; i
++)
2154 data
->block
[i
] = msgbuf1
[i
];
2161 * i2c_smbus_xfer - execute SMBus protocol operations
2162 * @adapter: Handle to I2C bus
2163 * @addr: Address of SMBus slave on that bus
2164 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
2165 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
2166 * @command: Byte interpreted by slave, for protocols which use such bytes
2167 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
2168 * @data: Data to be read or written
2170 * This executes an SMBus protocol operation, and returns a negative
2171 * errno code else zero on success.
2173 s32
i2c_smbus_xfer(struct i2c_adapter
*adapter
, u16 addr
, unsigned short flags
,
2174 char read_write
, u8 command
, int protocol
,
2175 union i2c_smbus_data
*data
)
2177 unsigned long orig_jiffies
;
2181 flags
&= I2C_M_TEN
| I2C_CLIENT_PEC
| I2C_CLIENT_SCCB
;
2183 if (adapter
->algo
->smbus_xfer
) {
2184 i2c_lock_adapter(adapter
);
2186 /* Retry automatically on arbitration loss */
2187 orig_jiffies
= jiffies
;
2188 for (res
= 0, try = 0; try <= adapter
->retries
; try++) {
2189 res
= adapter
->algo
->smbus_xfer(adapter
, addr
, flags
,
2190 read_write
, command
,
2194 if (time_after(jiffies
,
2195 orig_jiffies
+ adapter
->timeout
))
2198 i2c_unlock_adapter(adapter
);
2200 if (res
!= -EOPNOTSUPP
|| !adapter
->algo
->master_xfer
)
2203 * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
2204 * implement native support for the SMBus operation.
2208 return i2c_smbus_xfer_emulated(adapter
, addr
, flags
, read_write
,
2209 command
, protocol
, data
);
2211 EXPORT_SYMBOL(i2c_smbus_xfer
);
2213 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
2214 MODULE_DESCRIPTION("I2C-Bus main module");
2215 MODULE_LICENSE("GPL");