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 * Let users instantiate I2C devices through sysfs. This can be used when
641 * platform initialization code doesn't contain the proper data for
642 * whatever reason. Also useful for drivers that do device detection and
643 * detection fails, either because the device uses an unexpected address,
644 * or this is a compatible device with different ID register values.
646 * Parameter checking may look overzealous, but we really don't want
647 * the user to provide incorrect parameters.
650 i2c_sysfs_new_device(struct device
*dev
, struct device_attribute
*attr
,
651 const char *buf
, size_t count
)
653 struct i2c_adapter
*adap
= to_i2c_adapter(dev
);
654 struct i2c_board_info info
;
655 struct i2c_client
*client
;
659 memset(&info
, 0, sizeof(struct i2c_board_info
));
661 blank
= strchr(buf
, ' ');
663 dev_err(dev
, "%s: Missing parameters\n", "new_device");
666 if (blank
- buf
> I2C_NAME_SIZE
- 1) {
667 dev_err(dev
, "%s: Invalid device name\n", "new_device");
670 memcpy(info
.type
, buf
, blank
- buf
);
672 /* Parse remaining parameters, reject extra parameters */
673 res
= sscanf(++blank
, "%hi%c", &info
.addr
, &end
);
675 dev_err(dev
, "%s: Can't parse I2C address\n", "new_device");
678 if (res
> 1 && end
!= '\n') {
679 dev_err(dev
, "%s: Extra parameters\n", "new_device");
683 client
= i2c_new_device(adap
, &info
);
687 /* Keep track of the added device */
688 mutex_lock(&adap
->userspace_clients_lock
);
689 list_add_tail(&client
->detected
, &adap
->userspace_clients
);
690 mutex_unlock(&adap
->userspace_clients_lock
);
691 dev_info(dev
, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
692 info
.type
, info
.addr
);
698 * And of course let the users delete the devices they instantiated, if
699 * they got it wrong. This interface can only be used to delete devices
700 * instantiated by i2c_sysfs_new_device above. This guarantees that we
701 * don't delete devices to which some kernel code still has references.
703 * Parameter checking may look overzealous, but we really don't want
704 * the user to delete the wrong device.
707 i2c_sysfs_delete_device(struct device
*dev
, struct device_attribute
*attr
,
708 const char *buf
, size_t count
)
710 struct i2c_adapter
*adap
= to_i2c_adapter(dev
);
711 struct i2c_client
*client
, *next
;
716 /* Parse parameters, reject extra parameters */
717 res
= sscanf(buf
, "%hi%c", &addr
, &end
);
719 dev_err(dev
, "%s: Can't parse I2C address\n", "delete_device");
722 if (res
> 1 && end
!= '\n') {
723 dev_err(dev
, "%s: Extra parameters\n", "delete_device");
727 /* Make sure the device was added through sysfs */
729 mutex_lock(&adap
->userspace_clients_lock
);
730 list_for_each_entry_safe(client
, next
, &adap
->userspace_clients
,
732 if (client
->addr
== addr
) {
733 dev_info(dev
, "%s: Deleting device %s at 0x%02hx\n",
734 "delete_device", client
->name
, client
->addr
);
736 list_del(&client
->detected
);
737 i2c_unregister_device(client
);
742 mutex_unlock(&adap
->userspace_clients_lock
);
745 dev_err(dev
, "%s: Can't find device in list\n",
750 static DEVICE_ATTR(new_device
, S_IWUSR
, NULL
, i2c_sysfs_new_device
);
751 static DEVICE_ATTR(delete_device
, S_IWUSR
, NULL
, i2c_sysfs_delete_device
);
753 static struct attribute
*i2c_adapter_attrs
[] = {
755 &dev_attr_new_device
.attr
,
756 &dev_attr_delete_device
.attr
,
760 static struct attribute_group i2c_adapter_attr_group
= {
761 .attrs
= i2c_adapter_attrs
,
764 static const struct attribute_group
*i2c_adapter_attr_groups
[] = {
765 &i2c_adapter_attr_group
,
769 struct device_type i2c_adapter_type
= {
770 .groups
= i2c_adapter_attr_groups
,
771 .release
= i2c_adapter_dev_release
,
773 EXPORT_SYMBOL_GPL(i2c_adapter_type
);
775 #ifdef CONFIG_I2C_COMPAT
776 static struct class_compat
*i2c_adapter_compat_class
;
779 static void i2c_scan_static_board_info(struct i2c_adapter
*adapter
)
781 struct i2c_devinfo
*devinfo
;
783 down_read(&__i2c_board_lock
);
784 list_for_each_entry(devinfo
, &__i2c_board_list
, list
) {
785 if (devinfo
->busnum
== adapter
->nr
786 && !i2c_new_device(adapter
,
787 &devinfo
->board_info
))
788 dev_err(&adapter
->dev
,
789 "Can't create device at 0x%02x\n",
790 devinfo
->board_info
.addr
);
792 up_read(&__i2c_board_lock
);
795 static int i2c_do_add_adapter(struct i2c_driver
*driver
,
796 struct i2c_adapter
*adap
)
798 /* Detect supported devices on that bus, and instantiate them */
799 i2c_detect(adap
, driver
);
801 /* Let legacy drivers scan this bus for matching devices */
802 if (driver
->attach_adapter
) {
803 dev_warn(&adap
->dev
, "%s: attach_adapter method is deprecated\n",
804 driver
->driver
.name
);
805 dev_warn(&adap
->dev
, "Please use another way to instantiate "
806 "your i2c_client\n");
807 /* We ignore the return code; if it fails, too bad */
808 driver
->attach_adapter(adap
);
813 static int __process_new_adapter(struct device_driver
*d
, void *data
)
815 return i2c_do_add_adapter(to_i2c_driver(d
), data
);
818 static int i2c_register_adapter(struct i2c_adapter
*adap
)
822 /* Can't register until after driver model init */
823 if (unlikely(WARN_ON(!i2c_bus_type
.p
))) {
829 if (unlikely(adap
->name
[0] == '\0')) {
830 pr_err("i2c-core: Attempt to register an adapter with "
834 if (unlikely(!adap
->algo
)) {
835 pr_err("i2c-core: Attempt to register adapter '%s' with "
836 "no algo!\n", adap
->name
);
840 rt_mutex_init(&adap
->bus_lock
);
841 mutex_init(&adap
->userspace_clients_lock
);
842 INIT_LIST_HEAD(&adap
->userspace_clients
);
844 /* Set default timeout to 1 second if not already set */
845 if (adap
->timeout
== 0)
848 dev_set_name(&adap
->dev
, "i2c-%d", adap
->nr
);
849 adap
->dev
.bus
= &i2c_bus_type
;
850 adap
->dev
.type
= &i2c_adapter_type
;
851 res
= device_register(&adap
->dev
);
855 dev_dbg(&adap
->dev
, "adapter [%s] registered\n", adap
->name
);
857 #ifdef CONFIG_I2C_COMPAT
858 res
= class_compat_create_link(i2c_adapter_compat_class
, &adap
->dev
,
862 "Failed to create compatibility class link\n");
865 /* create pre-declared device nodes */
866 if (adap
->nr
< __i2c_first_dynamic_bus_num
)
867 i2c_scan_static_board_info(adap
);
870 mutex_lock(&core_lock
);
871 bus_for_each_drv(&i2c_bus_type
, NULL
, adap
, __process_new_adapter
);
872 mutex_unlock(&core_lock
);
877 mutex_lock(&core_lock
);
878 idr_remove(&i2c_adapter_idr
, adap
->nr
);
879 mutex_unlock(&core_lock
);
884 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
885 * @adapter: the adapter to add
888 * This routine is used to declare an I2C adapter when its bus number
889 * doesn't matter. Examples: for I2C adapters dynamically added by
890 * USB links or PCI plugin cards.
892 * When this returns zero, a new bus number was allocated and stored
893 * in adap->nr, and the specified adapter became available for clients.
894 * Otherwise, a negative errno value is returned.
896 int i2c_add_adapter(struct i2c_adapter
*adapter
)
901 if (idr_pre_get(&i2c_adapter_idr
, GFP_KERNEL
) == 0)
904 mutex_lock(&core_lock
);
905 /* "above" here means "above or equal to", sigh */
906 res
= idr_get_new_above(&i2c_adapter_idr
, adapter
,
907 __i2c_first_dynamic_bus_num
, &id
);
908 mutex_unlock(&core_lock
);
917 return i2c_register_adapter(adapter
);
919 EXPORT_SYMBOL(i2c_add_adapter
);
922 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
923 * @adap: the adapter to register (with adap->nr initialized)
926 * This routine is used to declare an I2C adapter when its bus number
927 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
928 * or otherwise built in to the system's mainboard, and where i2c_board_info
929 * is used to properly configure I2C devices.
931 * If the requested bus number is set to -1, then this function will behave
932 * identically to i2c_add_adapter, and will dynamically assign a bus number.
934 * If no devices have pre-been declared for this bus, then be sure to
935 * register the adapter before any dynamically allocated ones. Otherwise
936 * the required bus ID may not be available.
938 * When this returns zero, the specified adapter became available for
939 * clients using the bus number provided in adap->nr. Also, the table
940 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
941 * and the appropriate driver model device nodes are created. Otherwise, a
942 * negative errno value is returned.
944 int i2c_add_numbered_adapter(struct i2c_adapter
*adap
)
949 if (adap
->nr
== -1) /* -1 means dynamically assign bus id */
950 return i2c_add_adapter(adap
);
951 if (adap
->nr
& ~MAX_ID_MASK
)
955 if (idr_pre_get(&i2c_adapter_idr
, GFP_KERNEL
) == 0)
958 mutex_lock(&core_lock
);
959 /* "above" here means "above or equal to", sigh;
960 * we need the "equal to" result to force the result
962 status
= idr_get_new_above(&i2c_adapter_idr
, adap
, adap
->nr
, &id
);
963 if (status
== 0 && id
!= adap
->nr
) {
965 idr_remove(&i2c_adapter_idr
, id
);
967 mutex_unlock(&core_lock
);
968 if (status
== -EAGAIN
)
972 status
= i2c_register_adapter(adap
);
975 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter
);
977 static int i2c_do_del_adapter(struct i2c_driver
*driver
,
978 struct i2c_adapter
*adapter
)
980 struct i2c_client
*client
, *_n
;
983 /* Remove the devices we created ourselves as the result of hardware
984 * probing (using a driver's detect method) */
985 list_for_each_entry_safe(client
, _n
, &driver
->clients
, detected
) {
986 if (client
->adapter
== adapter
) {
987 dev_dbg(&adapter
->dev
, "Removing %s at 0x%x\n",
988 client
->name
, client
->addr
);
989 list_del(&client
->detected
);
990 i2c_unregister_device(client
);
994 if (!driver
->detach_adapter
)
996 dev_warn(&adapter
->dev
, "%s: detach_adapter method is deprecated\n",
997 driver
->driver
.name
);
998 res
= driver
->detach_adapter(adapter
);
1000 dev_err(&adapter
->dev
, "detach_adapter failed (%d) "
1001 "for driver [%s]\n", res
, driver
->driver
.name
);
1005 static int __unregister_client(struct device
*dev
, void *dummy
)
1007 struct i2c_client
*client
= i2c_verify_client(dev
);
1008 if (client
&& strcmp(client
->name
, "dummy"))
1009 i2c_unregister_device(client
);
1013 static int __unregister_dummy(struct device
*dev
, void *dummy
)
1015 struct i2c_client
*client
= i2c_verify_client(dev
);
1017 i2c_unregister_device(client
);
1021 static int __process_removed_adapter(struct device_driver
*d
, void *data
)
1023 return i2c_do_del_adapter(to_i2c_driver(d
), data
);
1027 * i2c_del_adapter - unregister I2C adapter
1028 * @adap: the adapter being unregistered
1029 * Context: can sleep
1031 * This unregisters an I2C adapter which was previously registered
1032 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
1034 int i2c_del_adapter(struct i2c_adapter
*adap
)
1037 struct i2c_adapter
*found
;
1038 struct i2c_client
*client
, *next
;
1040 /* First make sure that this adapter was ever added */
1041 mutex_lock(&core_lock
);
1042 found
= idr_find(&i2c_adapter_idr
, adap
->nr
);
1043 mutex_unlock(&core_lock
);
1044 if (found
!= adap
) {
1045 pr_debug("i2c-core: attempting to delete unregistered "
1046 "adapter [%s]\n", adap
->name
);
1050 /* Tell drivers about this removal */
1051 mutex_lock(&core_lock
);
1052 res
= bus_for_each_drv(&i2c_bus_type
, NULL
, adap
,
1053 __process_removed_adapter
);
1054 mutex_unlock(&core_lock
);
1058 /* Remove devices instantiated from sysfs */
1059 mutex_lock(&adap
->userspace_clients_lock
);
1060 list_for_each_entry_safe(client
, next
, &adap
->userspace_clients
,
1062 dev_dbg(&adap
->dev
, "Removing %s at 0x%x\n", client
->name
,
1064 list_del(&client
->detected
);
1065 i2c_unregister_device(client
);
1067 mutex_unlock(&adap
->userspace_clients_lock
);
1069 /* Detach any active clients. This can't fail, thus we do not
1070 * check the returned value. This is a two-pass process, because
1071 * we can't remove the dummy devices during the first pass: they
1072 * could have been instantiated by real devices wishing to clean
1073 * them up properly, so we give them a chance to do that first. */
1074 res
= device_for_each_child(&adap
->dev
, NULL
, __unregister_client
);
1075 res
= device_for_each_child(&adap
->dev
, NULL
, __unregister_dummy
);
1077 #ifdef CONFIG_I2C_COMPAT
1078 class_compat_remove_link(i2c_adapter_compat_class
, &adap
->dev
,
1082 /* device name is gone after device_unregister */
1083 dev_dbg(&adap
->dev
, "adapter [%s] unregistered\n", adap
->name
);
1085 /* clean up the sysfs representation */
1086 init_completion(&adap
->dev_released
);
1087 device_unregister(&adap
->dev
);
1089 /* wait for sysfs to drop all references */
1090 wait_for_completion(&adap
->dev_released
);
1093 mutex_lock(&core_lock
);
1094 idr_remove(&i2c_adapter_idr
, adap
->nr
);
1095 mutex_unlock(&core_lock
);
1097 /* Clear the device structure in case this adapter is ever going to be
1099 memset(&adap
->dev
, 0, sizeof(adap
->dev
));
1103 EXPORT_SYMBOL(i2c_del_adapter
);
1106 /* ------------------------------------------------------------------------- */
1108 int i2c_for_each_dev(void *data
, int (*fn
)(struct device
*, void *))
1112 mutex_lock(&core_lock
);
1113 res
= bus_for_each_dev(&i2c_bus_type
, NULL
, data
, fn
);
1114 mutex_unlock(&core_lock
);
1118 EXPORT_SYMBOL_GPL(i2c_for_each_dev
);
1120 static int __process_new_driver(struct device
*dev
, void *data
)
1122 if (dev
->type
!= &i2c_adapter_type
)
1124 return i2c_do_add_adapter(data
, to_i2c_adapter(dev
));
1128 * An i2c_driver is used with one or more i2c_client (device) nodes to access
1129 * i2c slave chips, on a bus instance associated with some i2c_adapter.
1132 int i2c_register_driver(struct module
*owner
, struct i2c_driver
*driver
)
1136 /* Can't register until after driver model init */
1137 if (unlikely(WARN_ON(!i2c_bus_type
.p
)))
1140 /* add the driver to the list of i2c drivers in the driver core */
1141 driver
->driver
.owner
= owner
;
1142 driver
->driver
.bus
= &i2c_bus_type
;
1144 /* When registration returns, the driver core
1145 * will have called probe() for all matching-but-unbound devices.
1147 res
= driver_register(&driver
->driver
);
1151 /* Drivers should switch to dev_pm_ops instead. */
1152 if (driver
->suspend
)
1153 pr_warn("i2c-core: driver [%s] using legacy suspend method\n",
1154 driver
->driver
.name
);
1156 pr_warn("i2c-core: driver [%s] using legacy resume method\n",
1157 driver
->driver
.name
);
1159 pr_debug("i2c-core: driver [%s] registered\n", driver
->driver
.name
);
1161 INIT_LIST_HEAD(&driver
->clients
);
1162 /* Walk the adapters that are already present */
1163 i2c_for_each_dev(driver
, __process_new_driver
);
1167 EXPORT_SYMBOL(i2c_register_driver
);
1169 static int __process_removed_driver(struct device
*dev
, void *data
)
1171 if (dev
->type
!= &i2c_adapter_type
)
1173 return i2c_do_del_adapter(data
, to_i2c_adapter(dev
));
1177 * i2c_del_driver - unregister I2C driver
1178 * @driver: the driver being unregistered
1179 * Context: can sleep
1181 void i2c_del_driver(struct i2c_driver
*driver
)
1183 i2c_for_each_dev(driver
, __process_removed_driver
);
1185 driver_unregister(&driver
->driver
);
1186 pr_debug("i2c-core: driver [%s] unregistered\n", driver
->driver
.name
);
1188 EXPORT_SYMBOL(i2c_del_driver
);
1190 /* ------------------------------------------------------------------------- */
1193 * i2c_use_client - increments the reference count of the i2c client structure
1194 * @client: the client being referenced
1196 * Each live reference to a client should be refcounted. The driver model does
1197 * that automatically as part of driver binding, so that most drivers don't
1198 * need to do this explicitly: they hold a reference until they're unbound
1201 * A pointer to the client with the incremented reference counter is returned.
1203 struct i2c_client
*i2c_use_client(struct i2c_client
*client
)
1205 if (client
&& get_device(&client
->dev
))
1209 EXPORT_SYMBOL(i2c_use_client
);
1212 * i2c_release_client - release a use of the i2c client structure
1213 * @client: the client being no longer referenced
1215 * Must be called when a user of a client is finished with it.
1217 void i2c_release_client(struct i2c_client
*client
)
1220 put_device(&client
->dev
);
1222 EXPORT_SYMBOL(i2c_release_client
);
1224 struct i2c_cmd_arg
{
1229 static int i2c_cmd(struct device
*dev
, void *_arg
)
1231 struct i2c_client
*client
= i2c_verify_client(dev
);
1232 struct i2c_cmd_arg
*arg
= _arg
;
1234 if (client
&& client
->driver
&& client
->driver
->command
)
1235 client
->driver
->command(client
, arg
->cmd
, arg
->arg
);
1239 void i2c_clients_command(struct i2c_adapter
*adap
, unsigned int cmd
, void *arg
)
1241 struct i2c_cmd_arg cmd_arg
;
1245 device_for_each_child(&adap
->dev
, &cmd_arg
, i2c_cmd
);
1247 EXPORT_SYMBOL(i2c_clients_command
);
1249 static int __init
i2c_init(void)
1253 retval
= bus_register(&i2c_bus_type
);
1256 #ifdef CONFIG_I2C_COMPAT
1257 i2c_adapter_compat_class
= class_compat_register("i2c-adapter");
1258 if (!i2c_adapter_compat_class
) {
1263 retval
= i2c_add_driver(&dummy_driver
);
1269 #ifdef CONFIG_I2C_COMPAT
1270 class_compat_unregister(i2c_adapter_compat_class
);
1273 bus_unregister(&i2c_bus_type
);
1277 static void __exit
i2c_exit(void)
1279 i2c_del_driver(&dummy_driver
);
1280 #ifdef CONFIG_I2C_COMPAT
1281 class_compat_unregister(i2c_adapter_compat_class
);
1283 bus_unregister(&i2c_bus_type
);
1286 /* We must initialize early, because some subsystems register i2c drivers
1287 * in subsys_initcall() code, but are linked (and initialized) before i2c.
1289 postcore_initcall(i2c_init
);
1290 module_exit(i2c_exit
);
1292 /* ----------------------------------------------------
1293 * the functional interface to the i2c busses.
1294 * ----------------------------------------------------
1298 * __i2c_transfer - unlocked flavor of i2c_transfer
1299 * @adap: Handle to I2C bus
1300 * @msgs: One or more messages to execute before STOP is issued to
1301 * terminate the operation; each message begins with a START.
1302 * @num: Number of messages to be executed.
1304 * Returns negative errno, else the number of messages executed.
1306 * Adapter lock must be held when calling this function. No debug logging
1307 * takes place. adap->algo->master_xfer existence isn't checked.
1309 int __i2c_transfer(struct i2c_adapter
*adap
, struct i2c_msg
*msgs
, int num
)
1311 unsigned long orig_jiffies
;
1314 /* Retry automatically on arbitration loss */
1315 orig_jiffies
= jiffies
;
1316 for (ret
= 0, try = 0; try <= adap
->retries
; try++) {
1317 ret
= adap
->algo
->master_xfer(adap
, msgs
, num
);
1320 if (time_after(jiffies
, orig_jiffies
+ adap
->timeout
))
1326 EXPORT_SYMBOL(__i2c_transfer
);
1329 * i2c_transfer - execute a single or combined I2C message
1330 * @adap: Handle to I2C bus
1331 * @msgs: One or more messages to execute before STOP is issued to
1332 * terminate the operation; each message begins with a START.
1333 * @num: Number of messages to be executed.
1335 * Returns negative errno, else the number of messages executed.
1337 * Note that there is no requirement that each message be sent to
1338 * the same slave address, although that is the most common model.
1340 int i2c_transfer(struct i2c_adapter
*adap
, struct i2c_msg
*msgs
, int num
)
1344 /* REVISIT the fault reporting model here is weak:
1346 * - When we get an error after receiving N bytes from a slave,
1347 * there is no way to report "N".
1349 * - When we get a NAK after transmitting N bytes to a slave,
1350 * there is no way to report "N" ... or to let the master
1351 * continue executing the rest of this combined message, if
1352 * that's the appropriate response.
1354 * - When for example "num" is two and we successfully complete
1355 * the first message but get an error part way through the
1356 * second, it's unclear whether that should be reported as
1357 * one (discarding status on the second message) or errno
1358 * (discarding status on the first one).
1361 if (adap
->algo
->master_xfer
) {
1363 for (ret
= 0; ret
< num
; ret
++) {
1364 dev_dbg(&adap
->dev
, "master_xfer[%d] %c, addr=0x%02x, "
1365 "len=%d%s\n", ret
, (msgs
[ret
].flags
& I2C_M_RD
)
1366 ? 'R' : 'W', msgs
[ret
].addr
, msgs
[ret
].len
,
1367 (msgs
[ret
].flags
& I2C_M_RECV_LEN
) ? "+" : "");
1371 if (in_atomic() || irqs_disabled()) {
1372 ret
= i2c_trylock_adapter(adap
);
1374 /* I2C activity is ongoing. */
1377 i2c_lock_adapter(adap
);
1380 ret
= __i2c_transfer(adap
, msgs
, num
);
1381 i2c_unlock_adapter(adap
);
1385 dev_dbg(&adap
->dev
, "I2C level transfers not supported\n");
1389 EXPORT_SYMBOL(i2c_transfer
);
1392 * i2c_master_send - issue a single I2C message in master transmit mode
1393 * @client: Handle to slave device
1394 * @buf: Data that will be written to the slave
1395 * @count: How many bytes to write, must be less than 64k since msg.len is u16
1397 * Returns negative errno, or else the number of bytes written.
1399 int i2c_master_send(const struct i2c_client
*client
, const char *buf
, int count
)
1402 struct i2c_adapter
*adap
= client
->adapter
;
1405 msg
.addr
= client
->addr
;
1406 msg
.flags
= client
->flags
& I2C_M_TEN
;
1408 msg
.buf
= (char *)buf
;
1410 ret
= i2c_transfer(adap
, &msg
, 1);
1413 * If everything went ok (i.e. 1 msg transmitted), return #bytes
1414 * transmitted, else error code.
1416 return (ret
== 1) ? count
: ret
;
1418 EXPORT_SYMBOL(i2c_master_send
);
1421 * i2c_master_recv - issue a single I2C message in master receive mode
1422 * @client: Handle to slave device
1423 * @buf: Where to store data read from slave
1424 * @count: How many bytes to read, must be less than 64k since msg.len is u16
1426 * Returns negative errno, or else the number of bytes read.
1428 int i2c_master_recv(const struct i2c_client
*client
, char *buf
, int count
)
1430 struct i2c_adapter
*adap
= client
->adapter
;
1434 msg
.addr
= client
->addr
;
1435 msg
.flags
= client
->flags
& I2C_M_TEN
;
1436 msg
.flags
|= I2C_M_RD
;
1440 ret
= i2c_transfer(adap
, &msg
, 1);
1443 * If everything went ok (i.e. 1 msg received), return #bytes received,
1446 return (ret
== 1) ? count
: ret
;
1448 EXPORT_SYMBOL(i2c_master_recv
);
1450 /* ----------------------------------------------------
1451 * the i2c address scanning function
1452 * Will not work for 10-bit addresses!
1453 * ----------------------------------------------------
1457 * Legacy default probe function, mostly relevant for SMBus. The default
1458 * probe method is a quick write, but it is known to corrupt the 24RF08
1459 * EEPROMs due to a state machine bug, and could also irreversibly
1460 * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
1461 * we use a short byte read instead. Also, some bus drivers don't implement
1462 * quick write, so we fallback to a byte read in that case too.
1463 * On x86, there is another special case for FSC hardware monitoring chips,
1464 * which want regular byte reads (address 0x73.) Fortunately, these are the
1465 * only known chips using this I2C address on PC hardware.
1466 * Returns 1 if probe succeeded, 0 if not.
1468 static int i2c_default_probe(struct i2c_adapter
*adap
, unsigned short addr
)
1471 union i2c_smbus_data dummy
;
1474 if (addr
== 0x73 && (adap
->class & I2C_CLASS_HWMON
)
1475 && i2c_check_functionality(adap
, I2C_FUNC_SMBUS_READ_BYTE_DATA
))
1476 err
= i2c_smbus_xfer(adap
, addr
, 0, I2C_SMBUS_READ
, 0,
1477 I2C_SMBUS_BYTE_DATA
, &dummy
);
1480 if (!((addr
& ~0x07) == 0x30 || (addr
& ~0x0f) == 0x50)
1481 && i2c_check_functionality(adap
, I2C_FUNC_SMBUS_QUICK
))
1482 err
= i2c_smbus_xfer(adap
, addr
, 0, I2C_SMBUS_WRITE
, 0,
1483 I2C_SMBUS_QUICK
, NULL
);
1484 else if (i2c_check_functionality(adap
, I2C_FUNC_SMBUS_READ_BYTE
))
1485 err
= i2c_smbus_xfer(adap
, addr
, 0, I2C_SMBUS_READ
, 0,
1486 I2C_SMBUS_BYTE
, &dummy
);
1488 dev_warn(&adap
->dev
, "No suitable probing method supported\n");
1495 static int i2c_detect_address(struct i2c_client
*temp_client
,
1496 struct i2c_driver
*driver
)
1498 struct i2c_board_info info
;
1499 struct i2c_adapter
*adapter
= temp_client
->adapter
;
1500 int addr
= temp_client
->addr
;
1503 /* Make sure the address is valid */
1504 err
= i2c_check_addr_validity(addr
);
1506 dev_warn(&adapter
->dev
, "Invalid probe address 0x%02x\n",
1511 /* Skip if already in use */
1512 if (i2c_check_addr_busy(adapter
, addr
))
1515 /* Make sure there is something at this address */
1516 if (!i2c_default_probe(adapter
, addr
))
1519 /* Finally call the custom detection function */
1520 memset(&info
, 0, sizeof(struct i2c_board_info
));
1522 err
= driver
->detect(temp_client
, &info
);
1524 /* -ENODEV is returned if the detection fails. We catch it
1525 here as this isn't an error. */
1526 return err
== -ENODEV
? 0 : err
;
1529 /* Consistency check */
1530 if (info
.type
[0] == '\0') {
1531 dev_err(&adapter
->dev
, "%s detection function provided "
1532 "no name for 0x%x\n", driver
->driver
.name
,
1535 struct i2c_client
*client
;
1537 /* Detection succeeded, instantiate the device */
1538 dev_dbg(&adapter
->dev
, "Creating %s at 0x%02x\n",
1539 info
.type
, info
.addr
);
1540 client
= i2c_new_device(adapter
, &info
);
1542 list_add_tail(&client
->detected
, &driver
->clients
);
1544 dev_err(&adapter
->dev
, "Failed creating %s at 0x%02x\n",
1545 info
.type
, info
.addr
);
1550 static int i2c_detect(struct i2c_adapter
*adapter
, struct i2c_driver
*driver
)
1552 const unsigned short *address_list
;
1553 struct i2c_client
*temp_client
;
1555 int adap_id
= i2c_adapter_id(adapter
);
1557 address_list
= driver
->address_list
;
1558 if (!driver
->detect
|| !address_list
)
1561 /* Stop here if the classes do not match */
1562 if (!(adapter
->class & driver
->class))
1565 /* Set up a temporary client to help detect callback */
1566 temp_client
= kzalloc(sizeof(struct i2c_client
), GFP_KERNEL
);
1569 temp_client
->adapter
= adapter
;
1571 for (i
= 0; address_list
[i
] != I2C_CLIENT_END
; i
+= 1) {
1572 dev_dbg(&adapter
->dev
, "found normal entry for adapter %d, "
1573 "addr 0x%02x\n", adap_id
, address_list
[i
]);
1574 temp_client
->addr
= address_list
[i
];
1575 err
= i2c_detect_address(temp_client
, driver
);
1584 int i2c_probe_func_quick_read(struct i2c_adapter
*adap
, unsigned short addr
)
1586 return i2c_smbus_xfer(adap
, addr
, 0, I2C_SMBUS_READ
, 0,
1587 I2C_SMBUS_QUICK
, NULL
) >= 0;
1589 EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read
);
1592 i2c_new_probed_device(struct i2c_adapter
*adap
,
1593 struct i2c_board_info
*info
,
1594 unsigned short const *addr_list
,
1595 int (*probe
)(struct i2c_adapter
*, unsigned short addr
))
1600 probe
= i2c_default_probe
;
1602 for (i
= 0; addr_list
[i
] != I2C_CLIENT_END
; i
++) {
1603 /* Check address validity */
1604 if (i2c_check_addr_validity(addr_list
[i
]) < 0) {
1605 dev_warn(&adap
->dev
, "Invalid 7-bit address "
1606 "0x%02x\n", addr_list
[i
]);
1610 /* Check address availability */
1611 if (i2c_check_addr_busy(adap
, addr_list
[i
])) {
1612 dev_dbg(&adap
->dev
, "Address 0x%02x already in "
1613 "use, not probing\n", addr_list
[i
]);
1617 /* Test address responsiveness */
1618 if (probe(adap
, addr_list
[i
]))
1622 if (addr_list
[i
] == I2C_CLIENT_END
) {
1623 dev_dbg(&adap
->dev
, "Probing failed, no device found\n");
1627 info
->addr
= addr_list
[i
];
1628 return i2c_new_device(adap
, info
);
1630 EXPORT_SYMBOL_GPL(i2c_new_probed_device
);
1632 struct i2c_adapter
*i2c_get_adapter(int nr
)
1634 struct i2c_adapter
*adapter
;
1636 mutex_lock(&core_lock
);
1637 adapter
= idr_find(&i2c_adapter_idr
, nr
);
1638 if (adapter
&& !try_module_get(adapter
->owner
))
1641 mutex_unlock(&core_lock
);
1644 EXPORT_SYMBOL(i2c_get_adapter
);
1646 void i2c_put_adapter(struct i2c_adapter
*adap
)
1648 module_put(adap
->owner
);
1650 EXPORT_SYMBOL(i2c_put_adapter
);
1652 /* The SMBus parts */
1654 #define POLY (0x1070U << 3)
1655 static u8
crc8(u16 data
)
1659 for (i
= 0; i
< 8; i
++) {
1664 return (u8
)(data
>> 8);
1667 /* Incremental CRC8 over count bytes in the array pointed to by p */
1668 static u8
i2c_smbus_pec(u8 crc
, u8
*p
, size_t count
)
1672 for (i
= 0; i
< count
; i
++)
1673 crc
= crc8((crc
^ p
[i
]) << 8);
1677 /* Assume a 7-bit address, which is reasonable for SMBus */
1678 static u8
i2c_smbus_msg_pec(u8 pec
, struct i2c_msg
*msg
)
1680 /* The address will be sent first */
1681 u8 addr
= (msg
->addr
<< 1) | !!(msg
->flags
& I2C_M_RD
);
1682 pec
= i2c_smbus_pec(pec
, &addr
, 1);
1684 /* The data buffer follows */
1685 return i2c_smbus_pec(pec
, msg
->buf
, msg
->len
);
1688 /* Used for write only transactions */
1689 static inline void i2c_smbus_add_pec(struct i2c_msg
*msg
)
1691 msg
->buf
[msg
->len
] = i2c_smbus_msg_pec(0, msg
);
1695 /* Return <0 on CRC error
1696 If there was a write before this read (most cases) we need to take the
1697 partial CRC from the write part into account.
1698 Note that this function does modify the message (we need to decrease the
1699 message length to hide the CRC byte from the caller). */
1700 static int i2c_smbus_check_pec(u8 cpec
, struct i2c_msg
*msg
)
1702 u8 rpec
= msg
->buf
[--msg
->len
];
1703 cpec
= i2c_smbus_msg_pec(cpec
, msg
);
1706 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1714 * i2c_smbus_read_byte - SMBus "receive byte" protocol
1715 * @client: Handle to slave device
1717 * This executes the SMBus "receive byte" protocol, returning negative errno
1718 * else the byte received from the device.
1720 s32
i2c_smbus_read_byte(const struct i2c_client
*client
)
1722 union i2c_smbus_data data
;
1725 status
= i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1727 I2C_SMBUS_BYTE
, &data
);
1728 return (status
< 0) ? status
: data
.byte
;
1730 EXPORT_SYMBOL(i2c_smbus_read_byte
);
1733 * i2c_smbus_write_byte - SMBus "send byte" protocol
1734 * @client: Handle to slave device
1735 * @value: Byte to be sent
1737 * This executes the SMBus "send byte" protocol, returning negative errno
1738 * else zero on success.
1740 s32
i2c_smbus_write_byte(const struct i2c_client
*client
, u8 value
)
1742 return i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1743 I2C_SMBUS_WRITE
, value
, I2C_SMBUS_BYTE
, NULL
);
1745 EXPORT_SYMBOL(i2c_smbus_write_byte
);
1748 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
1749 * @client: Handle to slave device
1750 * @command: Byte interpreted by slave
1752 * This executes the SMBus "read byte" protocol, returning negative errno
1753 * else a data byte received from the device.
1755 s32
i2c_smbus_read_byte_data(const struct i2c_client
*client
, u8 command
)
1757 union i2c_smbus_data data
;
1760 status
= i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1761 I2C_SMBUS_READ
, command
,
1762 I2C_SMBUS_BYTE_DATA
, &data
);
1763 return (status
< 0) ? status
: data
.byte
;
1765 EXPORT_SYMBOL(i2c_smbus_read_byte_data
);
1768 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
1769 * @client: Handle to slave device
1770 * @command: Byte interpreted by slave
1771 * @value: Byte being written
1773 * This executes the SMBus "write byte" protocol, returning negative errno
1774 * else zero on success.
1776 s32
i2c_smbus_write_byte_data(const struct i2c_client
*client
, u8 command
,
1779 union i2c_smbus_data data
;
1781 return i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1782 I2C_SMBUS_WRITE
, command
,
1783 I2C_SMBUS_BYTE_DATA
, &data
);
1785 EXPORT_SYMBOL(i2c_smbus_write_byte_data
);
1788 * i2c_smbus_read_word_data - SMBus "read word" protocol
1789 * @client: Handle to slave device
1790 * @command: Byte interpreted by slave
1792 * This executes the SMBus "read word" protocol, returning negative errno
1793 * else a 16-bit unsigned "word" received from the device.
1795 s32
i2c_smbus_read_word_data(const struct i2c_client
*client
, u8 command
)
1797 union i2c_smbus_data data
;
1800 status
= i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1801 I2C_SMBUS_READ
, command
,
1802 I2C_SMBUS_WORD_DATA
, &data
);
1803 return (status
< 0) ? status
: data
.word
;
1805 EXPORT_SYMBOL(i2c_smbus_read_word_data
);
1808 * i2c_smbus_write_word_data - SMBus "write word" protocol
1809 * @client: Handle to slave device
1810 * @command: Byte interpreted by slave
1811 * @value: 16-bit "word" being written
1813 * This executes the SMBus "write word" protocol, returning negative errno
1814 * else zero on success.
1816 s32
i2c_smbus_write_word_data(const struct i2c_client
*client
, u8 command
,
1819 union i2c_smbus_data data
;
1821 return i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1822 I2C_SMBUS_WRITE
, command
,
1823 I2C_SMBUS_WORD_DATA
, &data
);
1825 EXPORT_SYMBOL(i2c_smbus_write_word_data
);
1828 * i2c_smbus_process_call - SMBus "process call" protocol
1829 * @client: Handle to slave device
1830 * @command: Byte interpreted by slave
1831 * @value: 16-bit "word" being written
1833 * This executes the SMBus "process call" protocol, returning negative errno
1834 * else a 16-bit unsigned "word" received from the device.
1836 s32
i2c_smbus_process_call(const struct i2c_client
*client
, u8 command
,
1839 union i2c_smbus_data data
;
1843 status
= i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1844 I2C_SMBUS_WRITE
, command
,
1845 I2C_SMBUS_PROC_CALL
, &data
);
1846 return (status
< 0) ? status
: data
.word
;
1848 EXPORT_SYMBOL(i2c_smbus_process_call
);
1851 * i2c_smbus_read_block_data - SMBus "block read" protocol
1852 * @client: Handle to slave device
1853 * @command: Byte interpreted by slave
1854 * @values: Byte array into which data will be read; big enough to hold
1855 * the data returned by the slave. SMBus allows at most 32 bytes.
1857 * This executes the SMBus "block read" protocol, returning negative errno
1858 * else the number of data bytes in the slave's response.
1860 * Note that using this function requires that the client's adapter support
1861 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
1862 * support this; its emulation through I2C messaging relies on a specific
1863 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
1865 s32
i2c_smbus_read_block_data(const struct i2c_client
*client
, u8 command
,
1868 union i2c_smbus_data data
;
1871 status
= i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1872 I2C_SMBUS_READ
, command
,
1873 I2C_SMBUS_BLOCK_DATA
, &data
);
1877 memcpy(values
, &data
.block
[1], data
.block
[0]);
1878 return data
.block
[0];
1880 EXPORT_SYMBOL(i2c_smbus_read_block_data
);
1883 * i2c_smbus_write_block_data - SMBus "block write" protocol
1884 * @client: Handle to slave device
1885 * @command: Byte interpreted by slave
1886 * @length: Size of data block; SMBus allows at most 32 bytes
1887 * @values: Byte array which will be written.
1889 * This executes the SMBus "block write" protocol, returning negative errno
1890 * else zero on success.
1892 s32
i2c_smbus_write_block_data(const struct i2c_client
*client
, u8 command
,
1893 u8 length
, const u8
*values
)
1895 union i2c_smbus_data data
;
1897 if (length
> I2C_SMBUS_BLOCK_MAX
)
1898 length
= I2C_SMBUS_BLOCK_MAX
;
1899 data
.block
[0] = length
;
1900 memcpy(&data
.block
[1], values
, length
);
1901 return i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1902 I2C_SMBUS_WRITE
, command
,
1903 I2C_SMBUS_BLOCK_DATA
, &data
);
1905 EXPORT_SYMBOL(i2c_smbus_write_block_data
);
1907 /* Returns the number of read bytes */
1908 s32
i2c_smbus_read_i2c_block_data(const struct i2c_client
*client
, u8 command
,
1909 u8 length
, u8
*values
)
1911 union i2c_smbus_data data
;
1914 if (length
> I2C_SMBUS_BLOCK_MAX
)
1915 length
= I2C_SMBUS_BLOCK_MAX
;
1916 data
.block
[0] = length
;
1917 status
= i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1918 I2C_SMBUS_READ
, command
,
1919 I2C_SMBUS_I2C_BLOCK_DATA
, &data
);
1923 memcpy(values
, &data
.block
[1], data
.block
[0]);
1924 return data
.block
[0];
1926 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data
);
1928 s32
i2c_smbus_write_i2c_block_data(const struct i2c_client
*client
, u8 command
,
1929 u8 length
, const u8
*values
)
1931 union i2c_smbus_data data
;
1933 if (length
> I2C_SMBUS_BLOCK_MAX
)
1934 length
= I2C_SMBUS_BLOCK_MAX
;
1935 data
.block
[0] = length
;
1936 memcpy(data
.block
+ 1, values
, length
);
1937 return i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1938 I2C_SMBUS_WRITE
, command
,
1939 I2C_SMBUS_I2C_BLOCK_DATA
, &data
);
1941 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data
);
1943 /* Simulate a SMBus command using the i2c protocol
1944 No checking of parameters is done! */
1945 static s32
i2c_smbus_xfer_emulated(struct i2c_adapter
*adapter
, u16 addr
,
1946 unsigned short flags
,
1947 char read_write
, u8 command
, int size
,
1948 union i2c_smbus_data
*data
)
1950 /* So we need to generate a series of msgs. In the case of writing, we
1951 need to use only one message; when reading, we need two. We initialize
1952 most things with sane defaults, to keep the code below somewhat
1954 unsigned char msgbuf0
[I2C_SMBUS_BLOCK_MAX
+3];
1955 unsigned char msgbuf1
[I2C_SMBUS_BLOCK_MAX
+2];
1956 int num
= read_write
== I2C_SMBUS_READ
? 2 : 1;
1957 struct i2c_msg msg
[2] = { { addr
, flags
, 1, msgbuf0
},
1958 { addr
, flags
| I2C_M_RD
, 0, msgbuf1
}
1964 msgbuf0
[0] = command
;
1966 case I2C_SMBUS_QUICK
:
1968 /* Special case: The read/write field is used as data */
1969 msg
[0].flags
= flags
| (read_write
== I2C_SMBUS_READ
?
1973 case I2C_SMBUS_BYTE
:
1974 if (read_write
== I2C_SMBUS_READ
) {
1975 /* Special case: only a read! */
1976 msg
[0].flags
= I2C_M_RD
| flags
;
1980 case I2C_SMBUS_BYTE_DATA
:
1981 if (read_write
== I2C_SMBUS_READ
)
1985 msgbuf0
[1] = data
->byte
;
1988 case I2C_SMBUS_WORD_DATA
:
1989 if (read_write
== I2C_SMBUS_READ
)
1993 msgbuf0
[1] = data
->word
& 0xff;
1994 msgbuf0
[2] = data
->word
>> 8;
1997 case I2C_SMBUS_PROC_CALL
:
1998 num
= 2; /* Special case */
1999 read_write
= I2C_SMBUS_READ
;
2002 msgbuf0
[1] = data
->word
& 0xff;
2003 msgbuf0
[2] = data
->word
>> 8;
2005 case I2C_SMBUS_BLOCK_DATA
:
2006 if (read_write
== I2C_SMBUS_READ
) {
2007 msg
[1].flags
|= I2C_M_RECV_LEN
;
2008 msg
[1].len
= 1; /* block length will be added by
2009 the underlying bus driver */
2011 msg
[0].len
= data
->block
[0] + 2;
2012 if (msg
[0].len
> I2C_SMBUS_BLOCK_MAX
+ 2) {
2013 dev_err(&adapter
->dev
,
2014 "Invalid block write size %d\n",
2018 for (i
= 1; i
< msg
[0].len
; i
++)
2019 msgbuf0
[i
] = data
->block
[i
-1];
2022 case I2C_SMBUS_BLOCK_PROC_CALL
:
2023 num
= 2; /* Another special case */
2024 read_write
= I2C_SMBUS_READ
;
2025 if (data
->block
[0] > I2C_SMBUS_BLOCK_MAX
) {
2026 dev_err(&adapter
->dev
,
2027 "Invalid block write size %d\n",
2031 msg
[0].len
= data
->block
[0] + 2;
2032 for (i
= 1; i
< msg
[0].len
; i
++)
2033 msgbuf0
[i
] = data
->block
[i
-1];
2034 msg
[1].flags
|= I2C_M_RECV_LEN
;
2035 msg
[1].len
= 1; /* block length will be added by
2036 the underlying bus driver */
2038 case I2C_SMBUS_I2C_BLOCK_DATA
:
2039 if (read_write
== I2C_SMBUS_READ
) {
2040 msg
[1].len
= data
->block
[0];
2042 msg
[0].len
= data
->block
[0] + 1;
2043 if (msg
[0].len
> I2C_SMBUS_BLOCK_MAX
+ 1) {
2044 dev_err(&adapter
->dev
,
2045 "Invalid block write size %d\n",
2049 for (i
= 1; i
<= data
->block
[0]; i
++)
2050 msgbuf0
[i
] = data
->block
[i
];
2054 dev_err(&adapter
->dev
, "Unsupported transaction %d\n", size
);
2058 i
= ((flags
& I2C_CLIENT_PEC
) && size
!= I2C_SMBUS_QUICK
2059 && size
!= I2C_SMBUS_I2C_BLOCK_DATA
);
2061 /* Compute PEC if first message is a write */
2062 if (!(msg
[0].flags
& I2C_M_RD
)) {
2063 if (num
== 1) /* Write only */
2064 i2c_smbus_add_pec(&msg
[0]);
2065 else /* Write followed by read */
2066 partial_pec
= i2c_smbus_msg_pec(0, &msg
[0]);
2068 /* Ask for PEC if last message is a read */
2069 if (msg
[num
-1].flags
& I2C_M_RD
)
2073 status
= i2c_transfer(adapter
, msg
, num
);
2077 /* Check PEC if last message is a read */
2078 if (i
&& (msg
[num
-1].flags
& I2C_M_RD
)) {
2079 status
= i2c_smbus_check_pec(partial_pec
, &msg
[num
-1]);
2084 if (read_write
== I2C_SMBUS_READ
)
2086 case I2C_SMBUS_BYTE
:
2087 data
->byte
= msgbuf0
[0];
2089 case I2C_SMBUS_BYTE_DATA
:
2090 data
->byte
= msgbuf1
[0];
2092 case I2C_SMBUS_WORD_DATA
:
2093 case I2C_SMBUS_PROC_CALL
:
2094 data
->word
= msgbuf1
[0] | (msgbuf1
[1] << 8);
2096 case I2C_SMBUS_I2C_BLOCK_DATA
:
2097 for (i
= 0; i
< data
->block
[0]; i
++)
2098 data
->block
[i
+1] = msgbuf1
[i
];
2100 case I2C_SMBUS_BLOCK_DATA
:
2101 case I2C_SMBUS_BLOCK_PROC_CALL
:
2102 for (i
= 0; i
< msgbuf1
[0] + 1; i
++)
2103 data
->block
[i
] = msgbuf1
[i
];
2110 * i2c_smbus_xfer - execute SMBus protocol operations
2111 * @adapter: Handle to I2C bus
2112 * @addr: Address of SMBus slave on that bus
2113 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
2114 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
2115 * @command: Byte interpreted by slave, for protocols which use such bytes
2116 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
2117 * @data: Data to be read or written
2119 * This executes an SMBus protocol operation, and returns a negative
2120 * errno code else zero on success.
2122 s32
i2c_smbus_xfer(struct i2c_adapter
*adapter
, u16 addr
, unsigned short flags
,
2123 char read_write
, u8 command
, int protocol
,
2124 union i2c_smbus_data
*data
)
2126 unsigned long orig_jiffies
;
2130 flags
&= I2C_M_TEN
| I2C_CLIENT_PEC
;
2132 if (adapter
->algo
->smbus_xfer
) {
2133 i2c_lock_adapter(adapter
);
2135 /* Retry automatically on arbitration loss */
2136 orig_jiffies
= jiffies
;
2137 for (res
= 0, try = 0; try <= adapter
->retries
; try++) {
2138 res
= adapter
->algo
->smbus_xfer(adapter
, addr
, flags
,
2139 read_write
, command
,
2143 if (time_after(jiffies
,
2144 orig_jiffies
+ adapter
->timeout
))
2147 i2c_unlock_adapter(adapter
);
2149 res
= i2c_smbus_xfer_emulated(adapter
, addr
, flags
, read_write
,
2150 command
, protocol
, data
);
2154 EXPORT_SYMBOL(i2c_smbus_xfer
);
2156 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
2157 MODULE_DESCRIPTION("I2C-Bus main module");
2158 MODULE_LICENSE("GPL");