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 <asm/uaccess.h>
47 /* core_lock protects i2c_adapter_idr, and guarantees
48 that device detection, deletion of detected devices, and attach_adapter
49 and detach_adapter calls are serialized */
50 static DEFINE_MUTEX(core_lock
);
51 static DEFINE_IDR(i2c_adapter_idr
);
53 static struct device_type i2c_client_type
;
54 static int i2c_detect(struct i2c_adapter
*adapter
, struct i2c_driver
*driver
);
56 /* ------------------------------------------------------------------------- */
58 static const struct i2c_device_id
*i2c_match_id(const struct i2c_device_id
*id
,
59 const struct i2c_client
*client
)
62 if (strcmp(client
->name
, id
->name
) == 0)
69 static int i2c_device_match(struct device
*dev
, struct device_driver
*drv
)
71 struct i2c_client
*client
= i2c_verify_client(dev
);
72 struct i2c_driver
*driver
;
77 /* Attempt an OF style match */
78 if (of_driver_match_device(dev
, drv
))
81 driver
= to_i2c_driver(drv
);
82 /* match on an id table if there is one */
84 return i2c_match_id(driver
->id_table
, client
) != NULL
;
91 /* uevent helps with hotplug: modprobe -q $(MODALIAS) */
92 static int i2c_device_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
94 struct i2c_client
*client
= to_i2c_client(dev
);
96 if (add_uevent_var(env
, "MODALIAS=%s%s",
97 I2C_MODULE_PREFIX
, client
->name
))
99 dev_dbg(dev
, "uevent\n");
104 #define i2c_device_uevent NULL
105 #endif /* CONFIG_HOTPLUG */
107 static int i2c_device_probe(struct device
*dev
)
109 struct i2c_client
*client
= i2c_verify_client(dev
);
110 struct i2c_driver
*driver
;
116 driver
= to_i2c_driver(dev
->driver
);
117 if (!driver
->probe
|| !driver
->id_table
)
119 client
->driver
= driver
;
120 if (!device_can_wakeup(&client
->dev
))
121 device_init_wakeup(&client
->dev
,
122 client
->flags
& I2C_CLIENT_WAKE
);
123 dev_dbg(dev
, "probe\n");
125 status
= driver
->probe(client
, i2c_match_id(driver
->id_table
, client
));
127 client
->driver
= NULL
;
128 i2c_set_clientdata(client
, NULL
);
133 static int i2c_device_remove(struct device
*dev
)
135 struct i2c_client
*client
= i2c_verify_client(dev
);
136 struct i2c_driver
*driver
;
139 if (!client
|| !dev
->driver
)
142 driver
= to_i2c_driver(dev
->driver
);
143 if (driver
->remove
) {
144 dev_dbg(dev
, "remove\n");
145 status
= driver
->remove(client
);
151 client
->driver
= NULL
;
152 i2c_set_clientdata(client
, NULL
);
157 static void i2c_device_shutdown(struct device
*dev
)
159 struct i2c_client
*client
= i2c_verify_client(dev
);
160 struct i2c_driver
*driver
;
162 if (!client
|| !dev
->driver
)
164 driver
= to_i2c_driver(dev
->driver
);
165 if (driver
->shutdown
)
166 driver
->shutdown(client
);
169 #ifdef CONFIG_PM_SLEEP
170 static int i2c_legacy_suspend(struct device
*dev
, pm_message_t mesg
)
172 struct i2c_client
*client
= i2c_verify_client(dev
);
173 struct i2c_driver
*driver
;
175 if (!client
|| !dev
->driver
)
177 driver
= to_i2c_driver(dev
->driver
);
178 if (!driver
->suspend
)
180 return driver
->suspend(client
, mesg
);
183 static int i2c_legacy_resume(struct device
*dev
)
185 struct i2c_client
*client
= i2c_verify_client(dev
);
186 struct i2c_driver
*driver
;
188 if (!client
|| !dev
->driver
)
190 driver
= to_i2c_driver(dev
->driver
);
193 return driver
->resume(client
);
196 static int i2c_device_pm_suspend(struct device
*dev
)
198 const struct dev_pm_ops
*pm
= dev
->driver
? dev
->driver
->pm
: NULL
;
201 return pm_generic_suspend(dev
);
203 return i2c_legacy_suspend(dev
, PMSG_SUSPEND
);
206 static int i2c_device_pm_resume(struct device
*dev
)
208 const struct dev_pm_ops
*pm
= dev
->driver
? dev
->driver
->pm
: NULL
;
211 return pm_generic_resume(dev
);
213 return i2c_legacy_resume(dev
);
216 static int i2c_device_pm_freeze(struct device
*dev
)
218 const struct dev_pm_ops
*pm
= dev
->driver
? dev
->driver
->pm
: NULL
;
221 return pm_generic_freeze(dev
);
223 return i2c_legacy_suspend(dev
, PMSG_FREEZE
);
226 static int i2c_device_pm_thaw(struct device
*dev
)
228 const struct dev_pm_ops
*pm
= dev
->driver
? dev
->driver
->pm
: NULL
;
231 return pm_generic_thaw(dev
);
233 return i2c_legacy_resume(dev
);
236 static int i2c_device_pm_poweroff(struct device
*dev
)
238 const struct dev_pm_ops
*pm
= dev
->driver
? dev
->driver
->pm
: NULL
;
241 return pm_generic_poweroff(dev
);
243 return i2c_legacy_suspend(dev
, PMSG_HIBERNATE
);
246 static int i2c_device_pm_restore(struct device
*dev
)
248 const struct dev_pm_ops
*pm
= dev
->driver
? dev
->driver
->pm
: NULL
;
251 return pm_generic_restore(dev
);
253 return i2c_legacy_resume(dev
);
255 #else /* !CONFIG_PM_SLEEP */
256 #define i2c_device_pm_suspend NULL
257 #define i2c_device_pm_resume NULL
258 #define i2c_device_pm_freeze NULL
259 #define i2c_device_pm_thaw NULL
260 #define i2c_device_pm_poweroff NULL
261 #define i2c_device_pm_restore NULL
262 #endif /* !CONFIG_PM_SLEEP */
264 static void i2c_client_dev_release(struct device
*dev
)
266 kfree(to_i2c_client(dev
));
270 show_name(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
272 return sprintf(buf
, "%s\n", dev
->type
== &i2c_client_type
?
273 to_i2c_client(dev
)->name
: to_i2c_adapter(dev
)->name
);
277 show_modalias(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
279 struct i2c_client
*client
= to_i2c_client(dev
);
280 return sprintf(buf
, "%s%s\n", I2C_MODULE_PREFIX
, client
->name
);
283 static DEVICE_ATTR(name
, S_IRUGO
, show_name
, NULL
);
284 static DEVICE_ATTR(modalias
, S_IRUGO
, show_modalias
, NULL
);
286 static struct attribute
*i2c_dev_attrs
[] = {
288 /* modalias helps coldplug: modprobe $(cat .../modalias) */
289 &dev_attr_modalias
.attr
,
293 static struct attribute_group i2c_dev_attr_group
= {
294 .attrs
= i2c_dev_attrs
,
297 static const struct attribute_group
*i2c_dev_attr_groups
[] = {
302 static const struct dev_pm_ops i2c_device_pm_ops
= {
303 .suspend
= i2c_device_pm_suspend
,
304 .resume
= i2c_device_pm_resume
,
305 .freeze
= i2c_device_pm_freeze
,
306 .thaw
= i2c_device_pm_thaw
,
307 .poweroff
= i2c_device_pm_poweroff
,
308 .restore
= i2c_device_pm_restore
,
310 pm_generic_runtime_suspend
,
311 pm_generic_runtime_resume
,
312 pm_generic_runtime_idle
316 struct bus_type i2c_bus_type
= {
318 .match
= i2c_device_match
,
319 .probe
= i2c_device_probe
,
320 .remove
= i2c_device_remove
,
321 .shutdown
= i2c_device_shutdown
,
322 .pm
= &i2c_device_pm_ops
,
324 EXPORT_SYMBOL_GPL(i2c_bus_type
);
326 static struct device_type i2c_client_type
= {
327 .groups
= i2c_dev_attr_groups
,
328 .uevent
= i2c_device_uevent
,
329 .release
= i2c_client_dev_release
,
334 * i2c_verify_client - return parameter as i2c_client, or NULL
335 * @dev: device, probably from some driver model iterator
337 * When traversing the driver model tree, perhaps using driver model
338 * iterators like @device_for_each_child(), you can't assume very much
339 * about the nodes you find. Use this function to avoid oopses caused
340 * by wrongly treating some non-I2C device as an i2c_client.
342 struct i2c_client
*i2c_verify_client(struct device
*dev
)
344 return (dev
->type
== &i2c_client_type
)
348 EXPORT_SYMBOL(i2c_verify_client
);
351 /* This is a permissive address validity check, I2C address map constraints
352 * are purposely not enforced, except for the general call address. */
353 static int i2c_check_client_addr_validity(const struct i2c_client
*client
)
355 if (client
->flags
& I2C_CLIENT_TEN
) {
356 /* 10-bit address, all values are valid */
357 if (client
->addr
> 0x3ff)
360 /* 7-bit address, reject the general call address */
361 if (client
->addr
== 0x00 || client
->addr
> 0x7f)
367 /* And this is a strict address validity check, used when probing. If a
368 * device uses a reserved address, then it shouldn't be probed. 7-bit
369 * addressing is assumed, 10-bit address devices are rare and should be
370 * explicitly enumerated. */
371 static int i2c_check_addr_validity(unsigned short addr
)
374 * Reserved addresses per I2C specification:
375 * 0x00 General call address / START byte
377 * 0x02 Reserved for different bus format
378 * 0x03 Reserved for future purposes
379 * 0x04-0x07 Hs-mode master code
380 * 0x78-0x7b 10-bit slave addressing
381 * 0x7c-0x7f Reserved for future purposes
383 if (addr
< 0x08 || addr
> 0x77)
388 static int __i2c_check_addr_busy(struct device
*dev
, void *addrp
)
390 struct i2c_client
*client
= i2c_verify_client(dev
);
391 int addr
= *(int *)addrp
;
393 if (client
&& client
->addr
== addr
)
398 /* walk up mux tree */
399 static int i2c_check_mux_parents(struct i2c_adapter
*adapter
, int addr
)
401 struct i2c_adapter
*parent
= i2c_parent_is_i2c_adapter(adapter
);
404 result
= device_for_each_child(&adapter
->dev
, &addr
,
405 __i2c_check_addr_busy
);
407 if (!result
&& parent
)
408 result
= i2c_check_mux_parents(parent
, addr
);
413 /* recurse down mux tree */
414 static int i2c_check_mux_children(struct device
*dev
, void *addrp
)
418 if (dev
->type
== &i2c_adapter_type
)
419 result
= device_for_each_child(dev
, addrp
,
420 i2c_check_mux_children
);
422 result
= __i2c_check_addr_busy(dev
, addrp
);
427 static int i2c_check_addr_busy(struct i2c_adapter
*adapter
, int addr
)
429 struct i2c_adapter
*parent
= i2c_parent_is_i2c_adapter(adapter
);
433 result
= i2c_check_mux_parents(parent
, addr
);
436 result
= device_for_each_child(&adapter
->dev
, &addr
,
437 i2c_check_mux_children
);
443 * i2c_lock_adapter - Get exclusive access to an I2C bus segment
444 * @adapter: Target I2C bus segment
446 void i2c_lock_adapter(struct i2c_adapter
*adapter
)
448 struct i2c_adapter
*parent
= i2c_parent_is_i2c_adapter(adapter
);
451 i2c_lock_adapter(parent
);
453 rt_mutex_lock(&adapter
->bus_lock
);
455 EXPORT_SYMBOL_GPL(i2c_lock_adapter
);
458 * i2c_trylock_adapter - Try to get exclusive access to an I2C bus segment
459 * @adapter: Target I2C bus segment
461 static int i2c_trylock_adapter(struct i2c_adapter
*adapter
)
463 struct i2c_adapter
*parent
= i2c_parent_is_i2c_adapter(adapter
);
466 return i2c_trylock_adapter(parent
);
468 return rt_mutex_trylock(&adapter
->bus_lock
);
472 * i2c_unlock_adapter - Release exclusive access to an I2C bus segment
473 * @adapter: Target I2C bus segment
475 void i2c_unlock_adapter(struct i2c_adapter
*adapter
)
477 struct i2c_adapter
*parent
= i2c_parent_is_i2c_adapter(adapter
);
480 i2c_unlock_adapter(parent
);
482 rt_mutex_unlock(&adapter
->bus_lock
);
484 EXPORT_SYMBOL_GPL(i2c_unlock_adapter
);
487 * i2c_new_device - instantiate an i2c device
488 * @adap: the adapter managing the device
489 * @info: describes one I2C device; bus_num is ignored
492 * Create an i2c device. Binding is handled through driver model
493 * probe()/remove() methods. A driver may be bound to this device when we
494 * return from this function, or any later moment (e.g. maybe hotplugging will
495 * load the driver module). This call is not appropriate for use by mainboard
496 * initialization logic, which usually runs during an arch_initcall() long
497 * before any i2c_adapter could exist.
499 * This returns the new i2c client, which may be saved for later use with
500 * i2c_unregister_device(); or NULL to indicate an error.
503 i2c_new_device(struct i2c_adapter
*adap
, struct i2c_board_info
const *info
)
505 struct i2c_client
*client
;
508 client
= kzalloc(sizeof *client
, GFP_KERNEL
);
512 client
->adapter
= adap
;
514 client
->dev
.platform_data
= info
->platform_data
;
517 client
->dev
.archdata
= *info
->archdata
;
519 client
->flags
= info
->flags
;
520 client
->addr
= info
->addr
;
521 client
->irq
= info
->irq
;
523 strlcpy(client
->name
, info
->type
, sizeof(client
->name
));
525 /* Check for address validity */
526 status
= i2c_check_client_addr_validity(client
);
528 dev_err(&adap
->dev
, "Invalid %d-bit I2C address 0x%02hx\n",
529 client
->flags
& I2C_CLIENT_TEN
? 10 : 7, client
->addr
);
533 /* Check for address business */
534 status
= i2c_check_addr_busy(adap
, client
->addr
);
538 client
->dev
.parent
= &client
->adapter
->dev
;
539 client
->dev
.bus
= &i2c_bus_type
;
540 client
->dev
.type
= &i2c_client_type
;
541 client
->dev
.of_node
= info
->of_node
;
543 /* For 10-bit clients, add an arbitrary offset to avoid collisions */
544 dev_set_name(&client
->dev
, "%d-%04x", i2c_adapter_id(adap
),
545 client
->addr
| ((client
->flags
& I2C_CLIENT_TEN
)
547 status
= device_register(&client
->dev
);
551 dev_dbg(&adap
->dev
, "client [%s] registered with bus id %s\n",
552 client
->name
, dev_name(&client
->dev
));
557 dev_err(&adap
->dev
, "Failed to register i2c client %s at 0x%02x "
558 "(%d)\n", client
->name
, client
->addr
, status
);
563 EXPORT_SYMBOL_GPL(i2c_new_device
);
567 * i2c_unregister_device - reverse effect of i2c_new_device()
568 * @client: value returned from i2c_new_device()
571 void i2c_unregister_device(struct i2c_client
*client
)
573 device_unregister(&client
->dev
);
575 EXPORT_SYMBOL_GPL(i2c_unregister_device
);
578 static const struct i2c_device_id dummy_id
[] = {
583 static int dummy_probe(struct i2c_client
*client
,
584 const struct i2c_device_id
*id
)
589 static int dummy_remove(struct i2c_client
*client
)
594 static struct i2c_driver dummy_driver
= {
595 .driver
.name
= "dummy",
596 .probe
= dummy_probe
,
597 .remove
= dummy_remove
,
598 .id_table
= dummy_id
,
602 * i2c_new_dummy - return a new i2c device bound to a dummy driver
603 * @adapter: the adapter managing the device
604 * @address: seven bit address to be used
607 * This returns an I2C client bound to the "dummy" driver, intended for use
608 * with devices that consume multiple addresses. Examples of such chips
609 * include various EEPROMS (like 24c04 and 24c08 models).
611 * These dummy devices have two main uses. First, most I2C and SMBus calls
612 * except i2c_transfer() need a client handle; the dummy will be that handle.
613 * And second, this prevents the specified address from being bound to a
616 * This returns the new i2c client, which should be saved for later use with
617 * i2c_unregister_device(); or NULL to indicate an error.
619 struct i2c_client
*i2c_new_dummy(struct i2c_adapter
*adapter
, u16 address
)
621 struct i2c_board_info info
= {
622 I2C_BOARD_INFO("dummy", address
),
625 return i2c_new_device(adapter
, &info
);
627 EXPORT_SYMBOL_GPL(i2c_new_dummy
);
629 /* ------------------------------------------------------------------------- */
631 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
633 static void i2c_adapter_dev_release(struct device
*dev
)
635 struct i2c_adapter
*adap
= to_i2c_adapter(dev
);
636 complete(&adap
->dev_released
);
640 * This function is only needed for mutex_lock_nested, so it is never
641 * called unless locking correctness checking is enabled. Thus we
642 * make it inline to avoid a compiler warning. That's what gcc ends up
645 static inline unsigned int i2c_adapter_depth(struct i2c_adapter
*adapter
)
647 unsigned int depth
= 0;
649 while ((adapter
= i2c_parent_is_i2c_adapter(adapter
)))
656 * Let users instantiate I2C devices through sysfs. This can be used when
657 * platform initialization code doesn't contain the proper data for
658 * whatever reason. Also useful for drivers that do device detection and
659 * detection fails, either because the device uses an unexpected address,
660 * or this is a compatible device with different ID register values.
662 * Parameter checking may look overzealous, but we really don't want
663 * the user to provide incorrect parameters.
666 i2c_sysfs_new_device(struct device
*dev
, struct device_attribute
*attr
,
667 const char *buf
, size_t count
)
669 struct i2c_adapter
*adap
= to_i2c_adapter(dev
);
670 struct i2c_board_info info
;
671 struct i2c_client
*client
;
675 memset(&info
, 0, sizeof(struct i2c_board_info
));
677 blank
= strchr(buf
, ' ');
679 dev_err(dev
, "%s: Missing parameters\n", "new_device");
682 if (blank
- buf
> I2C_NAME_SIZE
- 1) {
683 dev_err(dev
, "%s: Invalid device name\n", "new_device");
686 memcpy(info
.type
, buf
, blank
- buf
);
688 /* Parse remaining parameters, reject extra parameters */
689 res
= sscanf(++blank
, "%hi%c", &info
.addr
, &end
);
691 dev_err(dev
, "%s: Can't parse I2C address\n", "new_device");
694 if (res
> 1 && end
!= '\n') {
695 dev_err(dev
, "%s: Extra parameters\n", "new_device");
699 client
= i2c_new_device(adap
, &info
);
703 /* Keep track of the added device */
704 mutex_lock(&adap
->userspace_clients_lock
);
705 list_add_tail(&client
->detected
, &adap
->userspace_clients
);
706 mutex_unlock(&adap
->userspace_clients_lock
);
707 dev_info(dev
, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
708 info
.type
, info
.addr
);
714 * And of course let the users delete the devices they instantiated, if
715 * they got it wrong. This interface can only be used to delete devices
716 * instantiated by i2c_sysfs_new_device above. This guarantees that we
717 * don't delete devices to which some kernel code still has references.
719 * Parameter checking may look overzealous, but we really don't want
720 * the user to delete the wrong device.
723 i2c_sysfs_delete_device(struct device
*dev
, struct device_attribute
*attr
,
724 const char *buf
, size_t count
)
726 struct i2c_adapter
*adap
= to_i2c_adapter(dev
);
727 struct i2c_client
*client
, *next
;
732 /* Parse parameters, reject extra parameters */
733 res
= sscanf(buf
, "%hi%c", &addr
, &end
);
735 dev_err(dev
, "%s: Can't parse I2C address\n", "delete_device");
738 if (res
> 1 && end
!= '\n') {
739 dev_err(dev
, "%s: Extra parameters\n", "delete_device");
743 /* Make sure the device was added through sysfs */
745 mutex_lock_nested(&adap
->userspace_clients_lock
,
746 i2c_adapter_depth(adap
));
747 list_for_each_entry_safe(client
, next
, &adap
->userspace_clients
,
749 if (client
->addr
== addr
) {
750 dev_info(dev
, "%s: Deleting device %s at 0x%02hx\n",
751 "delete_device", client
->name
, client
->addr
);
753 list_del(&client
->detected
);
754 i2c_unregister_device(client
);
759 mutex_unlock(&adap
->userspace_clients_lock
);
762 dev_err(dev
, "%s: Can't find device in list\n",
767 static DEVICE_ATTR(new_device
, S_IWUSR
, NULL
, i2c_sysfs_new_device
);
768 static DEVICE_ATTR(delete_device
, S_IWUSR
, NULL
, i2c_sysfs_delete_device
);
770 static struct attribute
*i2c_adapter_attrs
[] = {
772 &dev_attr_new_device
.attr
,
773 &dev_attr_delete_device
.attr
,
777 static struct attribute_group i2c_adapter_attr_group
= {
778 .attrs
= i2c_adapter_attrs
,
781 static const struct attribute_group
*i2c_adapter_attr_groups
[] = {
782 &i2c_adapter_attr_group
,
786 struct device_type i2c_adapter_type
= {
787 .groups
= i2c_adapter_attr_groups
,
788 .release
= i2c_adapter_dev_release
,
790 EXPORT_SYMBOL_GPL(i2c_adapter_type
);
793 * i2c_verify_adapter - return parameter as i2c_adapter or NULL
794 * @dev: device, probably from some driver model iterator
796 * When traversing the driver model tree, perhaps using driver model
797 * iterators like @device_for_each_child(), you can't assume very much
798 * about the nodes you find. Use this function to avoid oopses caused
799 * by wrongly treating some non-I2C device as an i2c_adapter.
801 struct i2c_adapter
*i2c_verify_adapter(struct device
*dev
)
803 return (dev
->type
== &i2c_adapter_type
)
804 ? to_i2c_adapter(dev
)
807 EXPORT_SYMBOL(i2c_verify_adapter
);
809 #ifdef CONFIG_I2C_COMPAT
810 static struct class_compat
*i2c_adapter_compat_class
;
813 static void i2c_scan_static_board_info(struct i2c_adapter
*adapter
)
815 struct i2c_devinfo
*devinfo
;
817 down_read(&__i2c_board_lock
);
818 list_for_each_entry(devinfo
, &__i2c_board_list
, list
) {
819 if (devinfo
->busnum
== adapter
->nr
820 && !i2c_new_device(adapter
,
821 &devinfo
->board_info
))
822 dev_err(&adapter
->dev
,
823 "Can't create device at 0x%02x\n",
824 devinfo
->board_info
.addr
);
826 up_read(&__i2c_board_lock
);
829 static int i2c_do_add_adapter(struct i2c_driver
*driver
,
830 struct i2c_adapter
*adap
)
832 /* Detect supported devices on that bus, and instantiate them */
833 i2c_detect(adap
, driver
);
835 /* Let legacy drivers scan this bus for matching devices */
836 if (driver
->attach_adapter
) {
837 dev_warn(&adap
->dev
, "%s: attach_adapter method is deprecated\n",
838 driver
->driver
.name
);
839 dev_warn(&adap
->dev
, "Please use another way to instantiate "
840 "your i2c_client\n");
841 /* We ignore the return code; if it fails, too bad */
842 driver
->attach_adapter(adap
);
847 static int __process_new_adapter(struct device_driver
*d
, void *data
)
849 return i2c_do_add_adapter(to_i2c_driver(d
), data
);
852 static int i2c_register_adapter(struct i2c_adapter
*adap
)
856 /* Can't register until after driver model init */
857 if (unlikely(WARN_ON(!i2c_bus_type
.p
))) {
863 if (unlikely(adap
->name
[0] == '\0')) {
864 pr_err("i2c-core: Attempt to register an adapter with "
868 if (unlikely(!adap
->algo
)) {
869 pr_err("i2c-core: Attempt to register adapter '%s' with "
870 "no algo!\n", adap
->name
);
874 rt_mutex_init(&adap
->bus_lock
);
875 mutex_init(&adap
->userspace_clients_lock
);
876 INIT_LIST_HEAD(&adap
->userspace_clients
);
878 /* Set default timeout to 1 second if not already set */
879 if (adap
->timeout
== 0)
882 dev_set_name(&adap
->dev
, "i2c-%d", adap
->nr
);
883 adap
->dev
.bus
= &i2c_bus_type
;
884 adap
->dev
.type
= &i2c_adapter_type
;
885 res
= device_register(&adap
->dev
);
889 dev_dbg(&adap
->dev
, "adapter [%s] registered\n", adap
->name
);
891 #ifdef CONFIG_I2C_COMPAT
892 res
= class_compat_create_link(i2c_adapter_compat_class
, &adap
->dev
,
896 "Failed to create compatibility class link\n");
899 /* create pre-declared device nodes */
900 if (adap
->nr
< __i2c_first_dynamic_bus_num
)
901 i2c_scan_static_board_info(adap
);
904 mutex_lock(&core_lock
);
905 bus_for_each_drv(&i2c_bus_type
, NULL
, adap
, __process_new_adapter
);
906 mutex_unlock(&core_lock
);
911 mutex_lock(&core_lock
);
912 idr_remove(&i2c_adapter_idr
, adap
->nr
);
913 mutex_unlock(&core_lock
);
918 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
919 * @adapter: the adapter to add
922 * This routine is used to declare an I2C adapter when its bus number
923 * doesn't matter. Examples: for I2C adapters dynamically added by
924 * USB links or PCI plugin cards.
926 * When this returns zero, a new bus number was allocated and stored
927 * in adap->nr, and the specified adapter became available for clients.
928 * Otherwise, a negative errno value is returned.
930 int i2c_add_adapter(struct i2c_adapter
*adapter
)
935 if (idr_pre_get(&i2c_adapter_idr
, GFP_KERNEL
) == 0)
938 mutex_lock(&core_lock
);
939 /* "above" here means "above or equal to", sigh */
940 res
= idr_get_new_above(&i2c_adapter_idr
, adapter
,
941 __i2c_first_dynamic_bus_num
, &id
);
942 mutex_unlock(&core_lock
);
951 return i2c_register_adapter(adapter
);
953 EXPORT_SYMBOL(i2c_add_adapter
);
956 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
957 * @adap: the adapter to register (with adap->nr initialized)
960 * This routine is used to declare an I2C adapter when its bus number
961 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
962 * or otherwise built in to the system's mainboard, and where i2c_board_info
963 * is used to properly configure I2C devices.
965 * If the requested bus number is set to -1, then this function will behave
966 * identically to i2c_add_adapter, and will dynamically assign a bus number.
968 * If no devices have pre-been declared for this bus, then be sure to
969 * register the adapter before any dynamically allocated ones. Otherwise
970 * the required bus ID may not be available.
972 * When this returns zero, the specified adapter became available for
973 * clients using the bus number provided in adap->nr. Also, the table
974 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
975 * and the appropriate driver model device nodes are created. Otherwise, a
976 * negative errno value is returned.
978 int i2c_add_numbered_adapter(struct i2c_adapter
*adap
)
983 if (adap
->nr
== -1) /* -1 means dynamically assign bus id */
984 return i2c_add_adapter(adap
);
985 if (adap
->nr
& ~MAX_IDR_MASK
)
989 if (idr_pre_get(&i2c_adapter_idr
, GFP_KERNEL
) == 0)
992 mutex_lock(&core_lock
);
993 /* "above" here means "above or equal to", sigh;
994 * we need the "equal to" result to force the result
996 status
= idr_get_new_above(&i2c_adapter_idr
, adap
, adap
->nr
, &id
);
997 if (status
== 0 && id
!= adap
->nr
) {
999 idr_remove(&i2c_adapter_idr
, id
);
1001 mutex_unlock(&core_lock
);
1002 if (status
== -EAGAIN
)
1006 status
= i2c_register_adapter(adap
);
1009 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter
);
1011 static int i2c_do_del_adapter(struct i2c_driver
*driver
,
1012 struct i2c_adapter
*adapter
)
1014 struct i2c_client
*client
, *_n
;
1017 /* Remove the devices we created ourselves as the result of hardware
1018 * probing (using a driver's detect method) */
1019 list_for_each_entry_safe(client
, _n
, &driver
->clients
, detected
) {
1020 if (client
->adapter
== adapter
) {
1021 dev_dbg(&adapter
->dev
, "Removing %s at 0x%x\n",
1022 client
->name
, client
->addr
);
1023 list_del(&client
->detected
);
1024 i2c_unregister_device(client
);
1028 if (!driver
->detach_adapter
)
1030 dev_warn(&adapter
->dev
, "%s: detach_adapter method is deprecated\n",
1031 driver
->driver
.name
);
1032 res
= driver
->detach_adapter(adapter
);
1034 dev_err(&adapter
->dev
, "detach_adapter failed (%d) "
1035 "for driver [%s]\n", res
, driver
->driver
.name
);
1039 static int __unregister_client(struct device
*dev
, void *dummy
)
1041 struct i2c_client
*client
= i2c_verify_client(dev
);
1042 if (client
&& strcmp(client
->name
, "dummy"))
1043 i2c_unregister_device(client
);
1047 static int __unregister_dummy(struct device
*dev
, void *dummy
)
1049 struct i2c_client
*client
= i2c_verify_client(dev
);
1051 i2c_unregister_device(client
);
1055 static int __process_removed_adapter(struct device_driver
*d
, void *data
)
1057 return i2c_do_del_adapter(to_i2c_driver(d
), data
);
1061 * i2c_del_adapter - unregister I2C adapter
1062 * @adap: the adapter being unregistered
1063 * Context: can sleep
1065 * This unregisters an I2C adapter which was previously registered
1066 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
1068 int i2c_del_adapter(struct i2c_adapter
*adap
)
1071 struct i2c_adapter
*found
;
1072 struct i2c_client
*client
, *next
;
1074 /* First make sure that this adapter was ever added */
1075 mutex_lock(&core_lock
);
1076 found
= idr_find(&i2c_adapter_idr
, adap
->nr
);
1077 mutex_unlock(&core_lock
);
1078 if (found
!= adap
) {
1079 pr_debug("i2c-core: attempting to delete unregistered "
1080 "adapter [%s]\n", adap
->name
);
1084 /* Tell drivers about this removal */
1085 mutex_lock(&core_lock
);
1086 res
= bus_for_each_drv(&i2c_bus_type
, NULL
, adap
,
1087 __process_removed_adapter
);
1088 mutex_unlock(&core_lock
);
1092 /* Remove devices instantiated from sysfs */
1093 mutex_lock_nested(&adap
->userspace_clients_lock
,
1094 i2c_adapter_depth(adap
));
1095 list_for_each_entry_safe(client
, next
, &adap
->userspace_clients
,
1097 dev_dbg(&adap
->dev
, "Removing %s at 0x%x\n", client
->name
,
1099 list_del(&client
->detected
);
1100 i2c_unregister_device(client
);
1102 mutex_unlock(&adap
->userspace_clients_lock
);
1104 /* Detach any active clients. This can't fail, thus we do not
1105 * check the returned value. This is a two-pass process, because
1106 * we can't remove the dummy devices during the first pass: they
1107 * could have been instantiated by real devices wishing to clean
1108 * them up properly, so we give them a chance to do that first. */
1109 res
= device_for_each_child(&adap
->dev
, NULL
, __unregister_client
);
1110 res
= device_for_each_child(&adap
->dev
, NULL
, __unregister_dummy
);
1112 #ifdef CONFIG_I2C_COMPAT
1113 class_compat_remove_link(i2c_adapter_compat_class
, &adap
->dev
,
1117 /* device name is gone after device_unregister */
1118 dev_dbg(&adap
->dev
, "adapter [%s] unregistered\n", adap
->name
);
1120 /* clean up the sysfs representation */
1121 init_completion(&adap
->dev_released
);
1122 device_unregister(&adap
->dev
);
1124 /* wait for sysfs to drop all references */
1125 wait_for_completion(&adap
->dev_released
);
1128 mutex_lock(&core_lock
);
1129 idr_remove(&i2c_adapter_idr
, adap
->nr
);
1130 mutex_unlock(&core_lock
);
1132 /* Clear the device structure in case this adapter is ever going to be
1134 memset(&adap
->dev
, 0, sizeof(adap
->dev
));
1138 EXPORT_SYMBOL(i2c_del_adapter
);
1141 /* ------------------------------------------------------------------------- */
1143 int i2c_for_each_dev(void *data
, int (*fn
)(struct device
*, void *))
1147 mutex_lock(&core_lock
);
1148 res
= bus_for_each_dev(&i2c_bus_type
, NULL
, data
, fn
);
1149 mutex_unlock(&core_lock
);
1153 EXPORT_SYMBOL_GPL(i2c_for_each_dev
);
1155 static int __process_new_driver(struct device
*dev
, void *data
)
1157 if (dev
->type
!= &i2c_adapter_type
)
1159 return i2c_do_add_adapter(data
, to_i2c_adapter(dev
));
1163 * An i2c_driver is used with one or more i2c_client (device) nodes to access
1164 * i2c slave chips, on a bus instance associated with some i2c_adapter.
1167 int i2c_register_driver(struct module
*owner
, struct i2c_driver
*driver
)
1171 /* Can't register until after driver model init */
1172 if (unlikely(WARN_ON(!i2c_bus_type
.p
)))
1175 /* add the driver to the list of i2c drivers in the driver core */
1176 driver
->driver
.owner
= owner
;
1177 driver
->driver
.bus
= &i2c_bus_type
;
1179 /* When registration returns, the driver core
1180 * will have called probe() for all matching-but-unbound devices.
1182 res
= driver_register(&driver
->driver
);
1186 /* Drivers should switch to dev_pm_ops instead. */
1187 if (driver
->suspend
)
1188 pr_warn("i2c-core: driver [%s] using legacy suspend method\n",
1189 driver
->driver
.name
);
1191 pr_warn("i2c-core: driver [%s] using legacy resume method\n",
1192 driver
->driver
.name
);
1194 pr_debug("i2c-core: driver [%s] registered\n", driver
->driver
.name
);
1196 INIT_LIST_HEAD(&driver
->clients
);
1197 /* Walk the adapters that are already present */
1198 i2c_for_each_dev(driver
, __process_new_driver
);
1202 EXPORT_SYMBOL(i2c_register_driver
);
1204 static int __process_removed_driver(struct device
*dev
, void *data
)
1206 if (dev
->type
!= &i2c_adapter_type
)
1208 return i2c_do_del_adapter(data
, to_i2c_adapter(dev
));
1212 * i2c_del_driver - unregister I2C driver
1213 * @driver: the driver being unregistered
1214 * Context: can sleep
1216 void i2c_del_driver(struct i2c_driver
*driver
)
1218 i2c_for_each_dev(driver
, __process_removed_driver
);
1220 driver_unregister(&driver
->driver
);
1221 pr_debug("i2c-core: driver [%s] unregistered\n", driver
->driver
.name
);
1223 EXPORT_SYMBOL(i2c_del_driver
);
1225 /* ------------------------------------------------------------------------- */
1228 * i2c_use_client - increments the reference count of the i2c client structure
1229 * @client: the client being referenced
1231 * Each live reference to a client should be refcounted. The driver model does
1232 * that automatically as part of driver binding, so that most drivers don't
1233 * need to do this explicitly: they hold a reference until they're unbound
1236 * A pointer to the client with the incremented reference counter is returned.
1238 struct i2c_client
*i2c_use_client(struct i2c_client
*client
)
1240 if (client
&& get_device(&client
->dev
))
1244 EXPORT_SYMBOL(i2c_use_client
);
1247 * i2c_release_client - release a use of the i2c client structure
1248 * @client: the client being no longer referenced
1250 * Must be called when a user of a client is finished with it.
1252 void i2c_release_client(struct i2c_client
*client
)
1255 put_device(&client
->dev
);
1257 EXPORT_SYMBOL(i2c_release_client
);
1259 struct i2c_cmd_arg
{
1264 static int i2c_cmd(struct device
*dev
, void *_arg
)
1266 struct i2c_client
*client
= i2c_verify_client(dev
);
1267 struct i2c_cmd_arg
*arg
= _arg
;
1269 if (client
&& client
->driver
&& client
->driver
->command
)
1270 client
->driver
->command(client
, arg
->cmd
, arg
->arg
);
1274 void i2c_clients_command(struct i2c_adapter
*adap
, unsigned int cmd
, void *arg
)
1276 struct i2c_cmd_arg cmd_arg
;
1280 device_for_each_child(&adap
->dev
, &cmd_arg
, i2c_cmd
);
1282 EXPORT_SYMBOL(i2c_clients_command
);
1284 static int __init
i2c_init(void)
1288 retval
= bus_register(&i2c_bus_type
);
1291 #ifdef CONFIG_I2C_COMPAT
1292 i2c_adapter_compat_class
= class_compat_register("i2c-adapter");
1293 if (!i2c_adapter_compat_class
) {
1298 retval
= i2c_add_driver(&dummy_driver
);
1304 #ifdef CONFIG_I2C_COMPAT
1305 class_compat_unregister(i2c_adapter_compat_class
);
1308 bus_unregister(&i2c_bus_type
);
1312 static void __exit
i2c_exit(void)
1314 i2c_del_driver(&dummy_driver
);
1315 #ifdef CONFIG_I2C_COMPAT
1316 class_compat_unregister(i2c_adapter_compat_class
);
1318 bus_unregister(&i2c_bus_type
);
1321 /* We must initialize early, because some subsystems register i2c drivers
1322 * in subsys_initcall() code, but are linked (and initialized) before i2c.
1324 postcore_initcall(i2c_init
);
1325 module_exit(i2c_exit
);
1327 /* ----------------------------------------------------
1328 * the functional interface to the i2c busses.
1329 * ----------------------------------------------------
1333 * __i2c_transfer - unlocked flavor of i2c_transfer
1334 * @adap: Handle to I2C bus
1335 * @msgs: One or more messages to execute before STOP is issued to
1336 * terminate the operation; each message begins with a START.
1337 * @num: Number of messages to be executed.
1339 * Returns negative errno, else the number of messages executed.
1341 * Adapter lock must be held when calling this function. No debug logging
1342 * takes place. adap->algo->master_xfer existence isn't checked.
1344 int __i2c_transfer(struct i2c_adapter
*adap
, struct i2c_msg
*msgs
, int num
)
1346 unsigned long orig_jiffies
;
1349 /* Retry automatically on arbitration loss */
1350 orig_jiffies
= jiffies
;
1351 for (ret
= 0, try = 0; try <= adap
->retries
; try++) {
1352 ret
= adap
->algo
->master_xfer(adap
, msgs
, num
);
1355 if (time_after(jiffies
, orig_jiffies
+ adap
->timeout
))
1361 EXPORT_SYMBOL(__i2c_transfer
);
1364 * i2c_transfer - execute a single or combined I2C message
1365 * @adap: Handle to I2C bus
1366 * @msgs: One or more messages to execute before STOP is issued to
1367 * terminate the operation; each message begins with a START.
1368 * @num: Number of messages to be executed.
1370 * Returns negative errno, else the number of messages executed.
1372 * Note that there is no requirement that each message be sent to
1373 * the same slave address, although that is the most common model.
1375 int i2c_transfer(struct i2c_adapter
*adap
, struct i2c_msg
*msgs
, int num
)
1379 /* REVISIT the fault reporting model here is weak:
1381 * - When we get an error after receiving N bytes from a slave,
1382 * there is no way to report "N".
1384 * - When we get a NAK after transmitting N bytes to a slave,
1385 * there is no way to report "N" ... or to let the master
1386 * continue executing the rest of this combined message, if
1387 * that's the appropriate response.
1389 * - When for example "num" is two and we successfully complete
1390 * the first message but get an error part way through the
1391 * second, it's unclear whether that should be reported as
1392 * one (discarding status on the second message) or errno
1393 * (discarding status on the first one).
1396 if (adap
->algo
->master_xfer
) {
1398 for (ret
= 0; ret
< num
; ret
++) {
1399 dev_dbg(&adap
->dev
, "master_xfer[%d] %c, addr=0x%02x, "
1400 "len=%d%s\n", ret
, (msgs
[ret
].flags
& I2C_M_RD
)
1401 ? 'R' : 'W', msgs
[ret
].addr
, msgs
[ret
].len
,
1402 (msgs
[ret
].flags
& I2C_M_RECV_LEN
) ? "+" : "");
1406 if (in_atomic() || irqs_disabled()) {
1407 ret
= i2c_trylock_adapter(adap
);
1409 /* I2C activity is ongoing. */
1412 i2c_lock_adapter(adap
);
1415 ret
= __i2c_transfer(adap
, msgs
, num
);
1416 i2c_unlock_adapter(adap
);
1420 dev_dbg(&adap
->dev
, "I2C level transfers not supported\n");
1424 EXPORT_SYMBOL(i2c_transfer
);
1427 * i2c_master_send - issue a single I2C message in master transmit mode
1428 * @client: Handle to slave device
1429 * @buf: Data that will be written to the slave
1430 * @count: How many bytes to write, must be less than 64k since msg.len is u16
1432 * Returns negative errno, or else the number of bytes written.
1434 int i2c_master_send(const struct i2c_client
*client
, const char *buf
, int count
)
1437 struct i2c_adapter
*adap
= client
->adapter
;
1440 msg
.addr
= client
->addr
;
1441 msg
.flags
= client
->flags
& I2C_M_TEN
;
1443 msg
.buf
= (char *)buf
;
1445 ret
= i2c_transfer(adap
, &msg
, 1);
1448 * If everything went ok (i.e. 1 msg transmitted), return #bytes
1449 * transmitted, else error code.
1451 return (ret
== 1) ? count
: ret
;
1453 EXPORT_SYMBOL(i2c_master_send
);
1456 * i2c_master_recv - issue a single I2C message in master receive mode
1457 * @client: Handle to slave device
1458 * @buf: Where to store data read from slave
1459 * @count: How many bytes to read, must be less than 64k since msg.len is u16
1461 * Returns negative errno, or else the number of bytes read.
1463 int i2c_master_recv(const struct i2c_client
*client
, char *buf
, int count
)
1465 struct i2c_adapter
*adap
= client
->adapter
;
1469 msg
.addr
= client
->addr
;
1470 msg
.flags
= client
->flags
& I2C_M_TEN
;
1471 msg
.flags
|= I2C_M_RD
;
1475 ret
= i2c_transfer(adap
, &msg
, 1);
1478 * If everything went ok (i.e. 1 msg received), return #bytes received,
1481 return (ret
== 1) ? count
: ret
;
1483 EXPORT_SYMBOL(i2c_master_recv
);
1485 /* ----------------------------------------------------
1486 * the i2c address scanning function
1487 * Will not work for 10-bit addresses!
1488 * ----------------------------------------------------
1492 * Legacy default probe function, mostly relevant for SMBus. The default
1493 * probe method is a quick write, but it is known to corrupt the 24RF08
1494 * EEPROMs due to a state machine bug, and could also irreversibly
1495 * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
1496 * we use a short byte read instead. Also, some bus drivers don't implement
1497 * quick write, so we fallback to a byte read in that case too.
1498 * On x86, there is another special case for FSC hardware monitoring chips,
1499 * which want regular byte reads (address 0x73.) Fortunately, these are the
1500 * only known chips using this I2C address on PC hardware.
1501 * Returns 1 if probe succeeded, 0 if not.
1503 static int i2c_default_probe(struct i2c_adapter
*adap
, unsigned short addr
)
1506 union i2c_smbus_data dummy
;
1509 if (addr
== 0x73 && (adap
->class & I2C_CLASS_HWMON
)
1510 && i2c_check_functionality(adap
, I2C_FUNC_SMBUS_READ_BYTE_DATA
))
1511 err
= i2c_smbus_xfer(adap
, addr
, 0, I2C_SMBUS_READ
, 0,
1512 I2C_SMBUS_BYTE_DATA
, &dummy
);
1515 if (!((addr
& ~0x07) == 0x30 || (addr
& ~0x0f) == 0x50)
1516 && i2c_check_functionality(adap
, I2C_FUNC_SMBUS_QUICK
))
1517 err
= i2c_smbus_xfer(adap
, addr
, 0, I2C_SMBUS_WRITE
, 0,
1518 I2C_SMBUS_QUICK
, NULL
);
1519 else if (i2c_check_functionality(adap
, I2C_FUNC_SMBUS_READ_BYTE
))
1520 err
= i2c_smbus_xfer(adap
, addr
, 0, I2C_SMBUS_READ
, 0,
1521 I2C_SMBUS_BYTE
, &dummy
);
1523 dev_warn(&adap
->dev
, "No suitable probing method supported\n");
1530 static int i2c_detect_address(struct i2c_client
*temp_client
,
1531 struct i2c_driver
*driver
)
1533 struct i2c_board_info info
;
1534 struct i2c_adapter
*adapter
= temp_client
->adapter
;
1535 int addr
= temp_client
->addr
;
1538 /* Make sure the address is valid */
1539 err
= i2c_check_addr_validity(addr
);
1541 dev_warn(&adapter
->dev
, "Invalid probe address 0x%02x\n",
1546 /* Skip if already in use */
1547 if (i2c_check_addr_busy(adapter
, addr
))
1550 /* Make sure there is something at this address */
1551 if (!i2c_default_probe(adapter
, addr
))
1554 /* Finally call the custom detection function */
1555 memset(&info
, 0, sizeof(struct i2c_board_info
));
1557 err
= driver
->detect(temp_client
, &info
);
1559 /* -ENODEV is returned if the detection fails. We catch it
1560 here as this isn't an error. */
1561 return err
== -ENODEV
? 0 : err
;
1564 /* Consistency check */
1565 if (info
.type
[0] == '\0') {
1566 dev_err(&adapter
->dev
, "%s detection function provided "
1567 "no name for 0x%x\n", driver
->driver
.name
,
1570 struct i2c_client
*client
;
1572 /* Detection succeeded, instantiate the device */
1573 dev_dbg(&adapter
->dev
, "Creating %s at 0x%02x\n",
1574 info
.type
, info
.addr
);
1575 client
= i2c_new_device(adapter
, &info
);
1577 list_add_tail(&client
->detected
, &driver
->clients
);
1579 dev_err(&adapter
->dev
, "Failed creating %s at 0x%02x\n",
1580 info
.type
, info
.addr
);
1585 static int i2c_detect(struct i2c_adapter
*adapter
, struct i2c_driver
*driver
)
1587 const unsigned short *address_list
;
1588 struct i2c_client
*temp_client
;
1590 int adap_id
= i2c_adapter_id(adapter
);
1592 address_list
= driver
->address_list
;
1593 if (!driver
->detect
|| !address_list
)
1596 /* Stop here if the classes do not match */
1597 if (!(adapter
->class & driver
->class))
1600 /* Set up a temporary client to help detect callback */
1601 temp_client
= kzalloc(sizeof(struct i2c_client
), GFP_KERNEL
);
1604 temp_client
->adapter
= adapter
;
1606 for (i
= 0; address_list
[i
] != I2C_CLIENT_END
; i
+= 1) {
1607 dev_dbg(&adapter
->dev
, "found normal entry for adapter %d, "
1608 "addr 0x%02x\n", adap_id
, address_list
[i
]);
1609 temp_client
->addr
= address_list
[i
];
1610 err
= i2c_detect_address(temp_client
, driver
);
1619 int i2c_probe_func_quick_read(struct i2c_adapter
*adap
, unsigned short addr
)
1621 return i2c_smbus_xfer(adap
, addr
, 0, I2C_SMBUS_READ
, 0,
1622 I2C_SMBUS_QUICK
, NULL
) >= 0;
1624 EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read
);
1627 i2c_new_probed_device(struct i2c_adapter
*adap
,
1628 struct i2c_board_info
*info
,
1629 unsigned short const *addr_list
,
1630 int (*probe
)(struct i2c_adapter
*, unsigned short addr
))
1635 probe
= i2c_default_probe
;
1637 for (i
= 0; addr_list
[i
] != I2C_CLIENT_END
; i
++) {
1638 /* Check address validity */
1639 if (i2c_check_addr_validity(addr_list
[i
]) < 0) {
1640 dev_warn(&adap
->dev
, "Invalid 7-bit address "
1641 "0x%02x\n", addr_list
[i
]);
1645 /* Check address availability */
1646 if (i2c_check_addr_busy(adap
, addr_list
[i
])) {
1647 dev_dbg(&adap
->dev
, "Address 0x%02x already in "
1648 "use, not probing\n", addr_list
[i
]);
1652 /* Test address responsiveness */
1653 if (probe(adap
, addr_list
[i
]))
1657 if (addr_list
[i
] == I2C_CLIENT_END
) {
1658 dev_dbg(&adap
->dev
, "Probing failed, no device found\n");
1662 info
->addr
= addr_list
[i
];
1663 return i2c_new_device(adap
, info
);
1665 EXPORT_SYMBOL_GPL(i2c_new_probed_device
);
1667 struct i2c_adapter
*i2c_get_adapter(int nr
)
1669 struct i2c_adapter
*adapter
;
1671 mutex_lock(&core_lock
);
1672 adapter
= idr_find(&i2c_adapter_idr
, nr
);
1673 if (adapter
&& !try_module_get(adapter
->owner
))
1676 mutex_unlock(&core_lock
);
1679 EXPORT_SYMBOL(i2c_get_adapter
);
1681 void i2c_put_adapter(struct i2c_adapter
*adap
)
1683 module_put(adap
->owner
);
1685 EXPORT_SYMBOL(i2c_put_adapter
);
1687 /* The SMBus parts */
1689 #define POLY (0x1070U << 3)
1690 static u8
crc8(u16 data
)
1694 for (i
= 0; i
< 8; i
++) {
1699 return (u8
)(data
>> 8);
1702 /* Incremental CRC8 over count bytes in the array pointed to by p */
1703 static u8
i2c_smbus_pec(u8 crc
, u8
*p
, size_t count
)
1707 for (i
= 0; i
< count
; i
++)
1708 crc
= crc8((crc
^ p
[i
]) << 8);
1712 /* Assume a 7-bit address, which is reasonable for SMBus */
1713 static u8
i2c_smbus_msg_pec(u8 pec
, struct i2c_msg
*msg
)
1715 /* The address will be sent first */
1716 u8 addr
= (msg
->addr
<< 1) | !!(msg
->flags
& I2C_M_RD
);
1717 pec
= i2c_smbus_pec(pec
, &addr
, 1);
1719 /* The data buffer follows */
1720 return i2c_smbus_pec(pec
, msg
->buf
, msg
->len
);
1723 /* Used for write only transactions */
1724 static inline void i2c_smbus_add_pec(struct i2c_msg
*msg
)
1726 msg
->buf
[msg
->len
] = i2c_smbus_msg_pec(0, msg
);
1730 /* Return <0 on CRC error
1731 If there was a write before this read (most cases) we need to take the
1732 partial CRC from the write part into account.
1733 Note that this function does modify the message (we need to decrease the
1734 message length to hide the CRC byte from the caller). */
1735 static int i2c_smbus_check_pec(u8 cpec
, struct i2c_msg
*msg
)
1737 u8 rpec
= msg
->buf
[--msg
->len
];
1738 cpec
= i2c_smbus_msg_pec(cpec
, msg
);
1741 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1749 * i2c_smbus_read_byte - SMBus "receive byte" protocol
1750 * @client: Handle to slave device
1752 * This executes the SMBus "receive byte" protocol, returning negative errno
1753 * else the byte received from the device.
1755 s32
i2c_smbus_read_byte(const struct i2c_client
*client
)
1757 union i2c_smbus_data data
;
1760 status
= i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1762 I2C_SMBUS_BYTE
, &data
);
1763 return (status
< 0) ? status
: data
.byte
;
1765 EXPORT_SYMBOL(i2c_smbus_read_byte
);
1768 * i2c_smbus_write_byte - SMBus "send byte" protocol
1769 * @client: Handle to slave device
1770 * @value: Byte to be sent
1772 * This executes the SMBus "send byte" protocol, returning negative errno
1773 * else zero on success.
1775 s32
i2c_smbus_write_byte(const struct i2c_client
*client
, u8 value
)
1777 return i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1778 I2C_SMBUS_WRITE
, value
, I2C_SMBUS_BYTE
, NULL
);
1780 EXPORT_SYMBOL(i2c_smbus_write_byte
);
1783 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
1784 * @client: Handle to slave device
1785 * @command: Byte interpreted by slave
1787 * This executes the SMBus "read byte" protocol, returning negative errno
1788 * else a data byte received from the device.
1790 s32
i2c_smbus_read_byte_data(const struct i2c_client
*client
, u8 command
)
1792 union i2c_smbus_data data
;
1795 status
= i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1796 I2C_SMBUS_READ
, command
,
1797 I2C_SMBUS_BYTE_DATA
, &data
);
1798 return (status
< 0) ? status
: data
.byte
;
1800 EXPORT_SYMBOL(i2c_smbus_read_byte_data
);
1803 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
1804 * @client: Handle to slave device
1805 * @command: Byte interpreted by slave
1806 * @value: Byte being written
1808 * This executes the SMBus "write byte" protocol, returning negative errno
1809 * else zero on success.
1811 s32
i2c_smbus_write_byte_data(const struct i2c_client
*client
, u8 command
,
1814 union i2c_smbus_data data
;
1816 return i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1817 I2C_SMBUS_WRITE
, command
,
1818 I2C_SMBUS_BYTE_DATA
, &data
);
1820 EXPORT_SYMBOL(i2c_smbus_write_byte_data
);
1823 * i2c_smbus_read_word_data - SMBus "read word" protocol
1824 * @client: Handle to slave device
1825 * @command: Byte interpreted by slave
1827 * This executes the SMBus "read word" protocol, returning negative errno
1828 * else a 16-bit unsigned "word" received from the device.
1830 s32
i2c_smbus_read_word_data(const struct i2c_client
*client
, u8 command
)
1832 union i2c_smbus_data data
;
1835 status
= i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1836 I2C_SMBUS_READ
, command
,
1837 I2C_SMBUS_WORD_DATA
, &data
);
1838 return (status
< 0) ? status
: data
.word
;
1840 EXPORT_SYMBOL(i2c_smbus_read_word_data
);
1843 * i2c_smbus_write_word_data - SMBus "write word" protocol
1844 * @client: Handle to slave device
1845 * @command: Byte interpreted by slave
1846 * @value: 16-bit "word" being written
1848 * This executes the SMBus "write word" protocol, returning negative errno
1849 * else zero on success.
1851 s32
i2c_smbus_write_word_data(const struct i2c_client
*client
, u8 command
,
1854 union i2c_smbus_data data
;
1856 return i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1857 I2C_SMBUS_WRITE
, command
,
1858 I2C_SMBUS_WORD_DATA
, &data
);
1860 EXPORT_SYMBOL(i2c_smbus_write_word_data
);
1863 * i2c_smbus_process_call - SMBus "process call" protocol
1864 * @client: Handle to slave device
1865 * @command: Byte interpreted by slave
1866 * @value: 16-bit "word" being written
1868 * This executes the SMBus "process call" protocol, returning negative errno
1869 * else a 16-bit unsigned "word" received from the device.
1871 s32
i2c_smbus_process_call(const struct i2c_client
*client
, u8 command
,
1874 union i2c_smbus_data data
;
1878 status
= i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1879 I2C_SMBUS_WRITE
, command
,
1880 I2C_SMBUS_PROC_CALL
, &data
);
1881 return (status
< 0) ? status
: data
.word
;
1883 EXPORT_SYMBOL(i2c_smbus_process_call
);
1886 * i2c_smbus_read_block_data - SMBus "block read" protocol
1887 * @client: Handle to slave device
1888 * @command: Byte interpreted by slave
1889 * @values: Byte array into which data will be read; big enough to hold
1890 * the data returned by the slave. SMBus allows at most 32 bytes.
1892 * This executes the SMBus "block read" protocol, returning negative errno
1893 * else the number of data bytes in the slave's response.
1895 * Note that using this function requires that the client's adapter support
1896 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
1897 * support this; its emulation through I2C messaging relies on a specific
1898 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
1900 s32
i2c_smbus_read_block_data(const struct i2c_client
*client
, u8 command
,
1903 union i2c_smbus_data data
;
1906 status
= i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1907 I2C_SMBUS_READ
, command
,
1908 I2C_SMBUS_BLOCK_DATA
, &data
);
1912 memcpy(values
, &data
.block
[1], data
.block
[0]);
1913 return data
.block
[0];
1915 EXPORT_SYMBOL(i2c_smbus_read_block_data
);
1918 * i2c_smbus_write_block_data - SMBus "block write" protocol
1919 * @client: Handle to slave device
1920 * @command: Byte interpreted by slave
1921 * @length: Size of data block; SMBus allows at most 32 bytes
1922 * @values: Byte array which will be written.
1924 * This executes the SMBus "block write" protocol, returning negative errno
1925 * else zero on success.
1927 s32
i2c_smbus_write_block_data(const struct i2c_client
*client
, u8 command
,
1928 u8 length
, const u8
*values
)
1930 union i2c_smbus_data data
;
1932 if (length
> I2C_SMBUS_BLOCK_MAX
)
1933 length
= I2C_SMBUS_BLOCK_MAX
;
1934 data
.block
[0] = length
;
1935 memcpy(&data
.block
[1], values
, length
);
1936 return i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1937 I2C_SMBUS_WRITE
, command
,
1938 I2C_SMBUS_BLOCK_DATA
, &data
);
1940 EXPORT_SYMBOL(i2c_smbus_write_block_data
);
1942 /* Returns the number of read bytes */
1943 s32
i2c_smbus_read_i2c_block_data(const struct i2c_client
*client
, u8 command
,
1944 u8 length
, u8
*values
)
1946 union i2c_smbus_data data
;
1949 if (length
> I2C_SMBUS_BLOCK_MAX
)
1950 length
= I2C_SMBUS_BLOCK_MAX
;
1951 data
.block
[0] = length
;
1952 status
= i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1953 I2C_SMBUS_READ
, command
,
1954 I2C_SMBUS_I2C_BLOCK_DATA
, &data
);
1958 memcpy(values
, &data
.block
[1], data
.block
[0]);
1959 return data
.block
[0];
1961 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data
);
1963 s32
i2c_smbus_write_i2c_block_data(const struct i2c_client
*client
, u8 command
,
1964 u8 length
, const u8
*values
)
1966 union i2c_smbus_data data
;
1968 if (length
> I2C_SMBUS_BLOCK_MAX
)
1969 length
= I2C_SMBUS_BLOCK_MAX
;
1970 data
.block
[0] = length
;
1971 memcpy(data
.block
+ 1, values
, length
);
1972 return i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1973 I2C_SMBUS_WRITE
, command
,
1974 I2C_SMBUS_I2C_BLOCK_DATA
, &data
);
1976 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data
);
1978 /* Simulate a SMBus command using the i2c protocol
1979 No checking of parameters is done! */
1980 static s32
i2c_smbus_xfer_emulated(struct i2c_adapter
*adapter
, u16 addr
,
1981 unsigned short flags
,
1982 char read_write
, u8 command
, int size
,
1983 union i2c_smbus_data
*data
)
1985 /* So we need to generate a series of msgs. In the case of writing, we
1986 need to use only one message; when reading, we need two. We initialize
1987 most things with sane defaults, to keep the code below somewhat
1989 unsigned char msgbuf0
[I2C_SMBUS_BLOCK_MAX
+3];
1990 unsigned char msgbuf1
[I2C_SMBUS_BLOCK_MAX
+2];
1991 int num
= read_write
== I2C_SMBUS_READ
? 2 : 1;
1995 struct i2c_msg msg
[2] = {
2003 .flags
= flags
| I2C_M_RD
,
2009 msgbuf0
[0] = command
;
2011 case I2C_SMBUS_QUICK
:
2013 /* Special case: The read/write field is used as data */
2014 msg
[0].flags
= flags
| (read_write
== I2C_SMBUS_READ
?
2018 case I2C_SMBUS_BYTE
:
2019 if (read_write
== I2C_SMBUS_READ
) {
2020 /* Special case: only a read! */
2021 msg
[0].flags
= I2C_M_RD
| flags
;
2025 case I2C_SMBUS_BYTE_DATA
:
2026 if (read_write
== I2C_SMBUS_READ
)
2030 msgbuf0
[1] = data
->byte
;
2033 case I2C_SMBUS_WORD_DATA
:
2034 if (read_write
== I2C_SMBUS_READ
)
2038 msgbuf0
[1] = data
->word
& 0xff;
2039 msgbuf0
[2] = data
->word
>> 8;
2042 case I2C_SMBUS_PROC_CALL
:
2043 num
= 2; /* Special case */
2044 read_write
= I2C_SMBUS_READ
;
2047 msgbuf0
[1] = data
->word
& 0xff;
2048 msgbuf0
[2] = data
->word
>> 8;
2050 case I2C_SMBUS_BLOCK_DATA
:
2051 if (read_write
== I2C_SMBUS_READ
) {
2052 msg
[1].flags
|= I2C_M_RECV_LEN
;
2053 msg
[1].len
= 1; /* block length will be added by
2054 the underlying bus driver */
2056 msg
[0].len
= data
->block
[0] + 2;
2057 if (msg
[0].len
> I2C_SMBUS_BLOCK_MAX
+ 2) {
2058 dev_err(&adapter
->dev
,
2059 "Invalid block write size %d\n",
2063 for (i
= 1; i
< msg
[0].len
; i
++)
2064 msgbuf0
[i
] = data
->block
[i
-1];
2067 case I2C_SMBUS_BLOCK_PROC_CALL
:
2068 num
= 2; /* Another special case */
2069 read_write
= I2C_SMBUS_READ
;
2070 if (data
->block
[0] > I2C_SMBUS_BLOCK_MAX
) {
2071 dev_err(&adapter
->dev
,
2072 "Invalid block write size %d\n",
2076 msg
[0].len
= data
->block
[0] + 2;
2077 for (i
= 1; i
< msg
[0].len
; i
++)
2078 msgbuf0
[i
] = data
->block
[i
-1];
2079 msg
[1].flags
|= I2C_M_RECV_LEN
;
2080 msg
[1].len
= 1; /* block length will be added by
2081 the underlying bus driver */
2083 case I2C_SMBUS_I2C_BLOCK_DATA
:
2084 if (read_write
== I2C_SMBUS_READ
) {
2085 msg
[1].len
= data
->block
[0];
2087 msg
[0].len
= data
->block
[0] + 1;
2088 if (msg
[0].len
> I2C_SMBUS_BLOCK_MAX
+ 1) {
2089 dev_err(&adapter
->dev
,
2090 "Invalid block write size %d\n",
2094 for (i
= 1; i
<= data
->block
[0]; i
++)
2095 msgbuf0
[i
] = data
->block
[i
];
2099 dev_err(&adapter
->dev
, "Unsupported transaction %d\n", size
);
2103 i
= ((flags
& I2C_CLIENT_PEC
) && size
!= I2C_SMBUS_QUICK
2104 && size
!= I2C_SMBUS_I2C_BLOCK_DATA
);
2106 /* Compute PEC if first message is a write */
2107 if (!(msg
[0].flags
& I2C_M_RD
)) {
2108 if (num
== 1) /* Write only */
2109 i2c_smbus_add_pec(&msg
[0]);
2110 else /* Write followed by read */
2111 partial_pec
= i2c_smbus_msg_pec(0, &msg
[0]);
2113 /* Ask for PEC if last message is a read */
2114 if (msg
[num
-1].flags
& I2C_M_RD
)
2118 status
= i2c_transfer(adapter
, msg
, num
);
2122 /* Check PEC if last message is a read */
2123 if (i
&& (msg
[num
-1].flags
& I2C_M_RD
)) {
2124 status
= i2c_smbus_check_pec(partial_pec
, &msg
[num
-1]);
2129 if (read_write
== I2C_SMBUS_READ
)
2131 case I2C_SMBUS_BYTE
:
2132 data
->byte
= msgbuf0
[0];
2134 case I2C_SMBUS_BYTE_DATA
:
2135 data
->byte
= msgbuf1
[0];
2137 case I2C_SMBUS_WORD_DATA
:
2138 case I2C_SMBUS_PROC_CALL
:
2139 data
->word
= msgbuf1
[0] | (msgbuf1
[1] << 8);
2141 case I2C_SMBUS_I2C_BLOCK_DATA
:
2142 for (i
= 0; i
< data
->block
[0]; i
++)
2143 data
->block
[i
+1] = msgbuf1
[i
];
2145 case I2C_SMBUS_BLOCK_DATA
:
2146 case I2C_SMBUS_BLOCK_PROC_CALL
:
2147 for (i
= 0; i
< msgbuf1
[0] + 1; i
++)
2148 data
->block
[i
] = msgbuf1
[i
];
2155 * i2c_smbus_xfer - execute SMBus protocol operations
2156 * @adapter: Handle to I2C bus
2157 * @addr: Address of SMBus slave on that bus
2158 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
2159 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
2160 * @command: Byte interpreted by slave, for protocols which use such bytes
2161 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
2162 * @data: Data to be read or written
2164 * This executes an SMBus protocol operation, and returns a negative
2165 * errno code else zero on success.
2167 s32
i2c_smbus_xfer(struct i2c_adapter
*adapter
, u16 addr
, unsigned short flags
,
2168 char read_write
, u8 command
, int protocol
,
2169 union i2c_smbus_data
*data
)
2171 unsigned long orig_jiffies
;
2175 flags
&= I2C_M_TEN
| I2C_CLIENT_PEC
| I2C_CLIENT_SCCB
;
2177 if (adapter
->algo
->smbus_xfer
) {
2178 i2c_lock_adapter(adapter
);
2180 /* Retry automatically on arbitration loss */
2181 orig_jiffies
= jiffies
;
2182 for (res
= 0, try = 0; try <= adapter
->retries
; try++) {
2183 res
= adapter
->algo
->smbus_xfer(adapter
, addr
, flags
,
2184 read_write
, command
,
2188 if (time_after(jiffies
,
2189 orig_jiffies
+ adapter
->timeout
))
2192 i2c_unlock_adapter(adapter
);
2194 if (res
!= -EOPNOTSUPP
|| !adapter
->algo
->master_xfer
)
2197 * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
2198 * implement native support for the SMBus operation.
2202 return i2c_smbus_xfer_emulated(adapter
, addr
, flags
, read_write
,
2203 command
, protocol
, data
);
2205 EXPORT_SYMBOL(i2c_smbus_xfer
);
2207 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
2208 MODULE_DESCRIPTION("I2C-Bus main module");
2209 MODULE_LICENSE("GPL");