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., 675 Mass Ave, Cambridge, MA 02139, USA. */
18 /* ------------------------------------------------------------------------- */
20 /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi>.
21 All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl>
22 SMBus 2.0 support by Mark Studebaker <mdsxyz123@yahoo.com> and
23 Jean Delvare <khali@linux-fr.org> */
25 #include <linux/module.h>
26 #include <linux/kernel.h>
27 #include <linux/errno.h>
28 #include <linux/slab.h>
29 #include <linux/i2c.h>
30 #include <linux/init.h>
31 #include <linux/idr.h>
32 #include <linux/seq_file.h>
33 #include <linux/platform_device.h>
34 #include <linux/mutex.h>
35 #include <linux/completion.h>
36 #include <linux/hardirq.h>
37 #include <linux/irqflags.h>
38 #include <asm/uaccess.h>
39 #include <asm/semaphore.h>
44 static DEFINE_MUTEX(core_lock
);
45 static DEFINE_IDR(i2c_adapter_idr
);
47 #define is_newstyle_driver(d) ((d)->probe || (d)->remove)
49 /* ------------------------------------------------------------------------- */
51 static int i2c_device_match(struct device
*dev
, struct device_driver
*drv
)
53 struct i2c_client
*client
= to_i2c_client(dev
);
54 struct i2c_driver
*driver
= to_i2c_driver(drv
);
56 /* make legacy i2c drivers bypass driver model probing entirely;
57 * such drivers scan each i2c adapter/bus themselves.
59 if (!is_newstyle_driver(driver
))
62 /* new style drivers use the same kind of driver matching policy
63 * as platform devices or SPI: compare device and driver IDs.
65 return strcmp(client
->driver_name
, drv
->name
) == 0;
70 /* uevent helps with hotplug: modprobe -q $(MODALIAS) */
71 static int i2c_device_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
73 struct i2c_client
*client
= to_i2c_client(dev
);
75 /* by definition, legacy drivers can't hotplug */
76 if (dev
->driver
|| !client
->driver_name
)
79 if (add_uevent_var(env
, "MODALIAS=%s", client
->driver_name
))
81 dev_dbg(dev
, "uevent\n");
86 #define i2c_device_uevent NULL
87 #endif /* CONFIG_HOTPLUG */
89 static int i2c_device_probe(struct device
*dev
)
91 struct i2c_client
*client
= to_i2c_client(dev
);
92 struct i2c_driver
*driver
= to_i2c_driver(dev
->driver
);
96 client
->driver
= driver
;
97 dev_dbg(dev
, "probe\n");
98 return driver
->probe(client
);
101 static int i2c_device_remove(struct device
*dev
)
103 struct i2c_client
*client
= to_i2c_client(dev
);
104 struct i2c_driver
*driver
;
110 driver
= to_i2c_driver(dev
->driver
);
111 if (driver
->remove
) {
112 dev_dbg(dev
, "remove\n");
113 status
= driver
->remove(client
);
119 client
->driver
= NULL
;
123 static void i2c_device_shutdown(struct device
*dev
)
125 struct i2c_driver
*driver
;
129 driver
= to_i2c_driver(dev
->driver
);
130 if (driver
->shutdown
)
131 driver
->shutdown(to_i2c_client(dev
));
134 static int i2c_device_suspend(struct device
* dev
, pm_message_t mesg
)
136 struct i2c_driver
*driver
;
140 driver
= to_i2c_driver(dev
->driver
);
141 if (!driver
->suspend
)
143 return driver
->suspend(to_i2c_client(dev
), mesg
);
146 static int i2c_device_resume(struct device
* dev
)
148 struct i2c_driver
*driver
;
152 driver
= to_i2c_driver(dev
->driver
);
155 return driver
->resume(to_i2c_client(dev
));
158 static void i2c_client_release(struct device
*dev
)
160 struct i2c_client
*client
= to_i2c_client(dev
);
161 complete(&client
->released
);
164 static void i2c_client_dev_release(struct device
*dev
)
166 kfree(to_i2c_client(dev
));
169 static ssize_t
show_client_name(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
171 struct i2c_client
*client
= to_i2c_client(dev
);
172 return sprintf(buf
, "%s\n", client
->name
);
175 static ssize_t
show_modalias(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
177 struct i2c_client
*client
= to_i2c_client(dev
);
178 return client
->driver_name
179 ? sprintf(buf
, "%s\n", client
->driver_name
)
183 static struct device_attribute i2c_dev_attrs
[] = {
184 __ATTR(name
, S_IRUGO
, show_client_name
, NULL
),
185 /* modalias helps coldplug: modprobe $(cat .../modalias) */
186 __ATTR(modalias
, S_IRUGO
, show_modalias
, NULL
),
190 static struct bus_type i2c_bus_type
= {
192 .dev_attrs
= i2c_dev_attrs
,
193 .match
= i2c_device_match
,
194 .uevent
= i2c_device_uevent
,
195 .probe
= i2c_device_probe
,
196 .remove
= i2c_device_remove
,
197 .shutdown
= i2c_device_shutdown
,
198 .suspend
= i2c_device_suspend
,
199 .resume
= i2c_device_resume
,
204 * i2c_verify_client - return parameter as i2c_client, or NULL
205 * @dev: device, probably from some driver model iterator
207 * When traversing the driver model tree, perhaps using driver model
208 * iterators like @device_for_each_child(), you can't assume very much
209 * about the nodes you find. Use this function to avoid oopses caused
210 * by wrongly treating some non-I2C device as an i2c_client.
212 struct i2c_client
*i2c_verify_client(struct device
*dev
)
214 return (dev
->bus
== &i2c_bus_type
)
218 EXPORT_SYMBOL(i2c_verify_client
);
222 * i2c_new_device - instantiate an i2c device for use with a new style driver
223 * @adap: the adapter managing the device
224 * @info: describes one I2C device; bus_num is ignored
227 * Create a device to work with a new style i2c driver, where binding is
228 * handled through driver model probe()/remove() methods. This call is not
229 * appropriate for use by mainboad initialization logic, which usually runs
230 * during an arch_initcall() long before any i2c_adapter could exist.
232 * This returns the new i2c client, which may be saved for later use with
233 * i2c_unregister_device(); or NULL to indicate an error.
236 i2c_new_device(struct i2c_adapter
*adap
, struct i2c_board_info
const *info
)
238 struct i2c_client
*client
;
241 client
= kzalloc(sizeof *client
, GFP_KERNEL
);
245 client
->adapter
= adap
;
247 client
->dev
.platform_data
= info
->platform_data
;
248 device_init_wakeup(&client
->dev
, info
->flags
& I2C_CLIENT_WAKE
);
250 client
->flags
= info
->flags
& ~I2C_CLIENT_WAKE
;
251 client
->addr
= info
->addr
;
252 client
->irq
= info
->irq
;
254 strlcpy(client
->driver_name
, info
->driver_name
,
255 sizeof(client
->driver_name
));
256 strlcpy(client
->name
, info
->type
, sizeof(client
->name
));
258 /* a new style driver may be bound to this device when we
259 * return from this function, or any later moment (e.g. maybe
260 * hotplugging will load the driver module). and the device
261 * refcount model is the standard driver model one.
263 status
= i2c_attach_client(client
);
270 EXPORT_SYMBOL_GPL(i2c_new_device
);
274 * i2c_unregister_device - reverse effect of i2c_new_device()
275 * @client: value returned from i2c_new_device()
278 void i2c_unregister_device(struct i2c_client
*client
)
280 struct i2c_adapter
*adapter
= client
->adapter
;
281 struct i2c_driver
*driver
= client
->driver
;
283 if (driver
&& !is_newstyle_driver(driver
)) {
284 dev_err(&client
->dev
, "can't unregister devices "
285 "with legacy drivers\n");
290 mutex_lock(&adapter
->clist_lock
);
291 list_del(&client
->list
);
292 mutex_unlock(&adapter
->clist_lock
);
294 device_unregister(&client
->dev
);
296 EXPORT_SYMBOL_GPL(i2c_unregister_device
);
299 /* ------------------------------------------------------------------------- */
301 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
303 static void i2c_adapter_dev_release(struct device
*dev
)
305 struct i2c_adapter
*adap
= to_i2c_adapter(dev
);
306 complete(&adap
->dev_released
);
310 show_adapter_name(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
312 struct i2c_adapter
*adap
= to_i2c_adapter(dev
);
313 return sprintf(buf
, "%s\n", adap
->name
);
316 static struct device_attribute i2c_adapter_attrs
[] = {
317 __ATTR(name
, S_IRUGO
, show_adapter_name
, NULL
),
321 static struct class i2c_adapter_class
= {
322 .owner
= THIS_MODULE
,
323 .name
= "i2c-adapter",
324 .dev_attrs
= i2c_adapter_attrs
,
327 static void i2c_scan_static_board_info(struct i2c_adapter
*adapter
)
329 struct i2c_devinfo
*devinfo
;
331 mutex_lock(&__i2c_board_lock
);
332 list_for_each_entry(devinfo
, &__i2c_board_list
, list
) {
333 if (devinfo
->busnum
== adapter
->nr
334 && !i2c_new_device(adapter
,
335 &devinfo
->board_info
))
336 printk(KERN_ERR
"i2c-core: can't create i2c%d-%04x\n",
337 i2c_adapter_id(adapter
),
338 devinfo
->board_info
.addr
);
340 mutex_unlock(&__i2c_board_lock
);
343 static int i2c_do_add_adapter(struct device_driver
*d
, void *data
)
345 struct i2c_driver
*driver
= to_i2c_driver(d
);
346 struct i2c_adapter
*adap
= data
;
348 if (driver
->attach_adapter
) {
349 /* We ignore the return code; if it fails, too bad */
350 driver
->attach_adapter(adap
);
355 static int i2c_register_adapter(struct i2c_adapter
*adap
)
359 mutex_init(&adap
->bus_lock
);
360 mutex_init(&adap
->clist_lock
);
361 INIT_LIST_HEAD(&adap
->clients
);
363 mutex_lock(&core_lock
);
365 /* Add the adapter to the driver core.
366 * If the parent pointer is not set up,
367 * we add this adapter to the host bus.
369 if (adap
->dev
.parent
== NULL
) {
370 adap
->dev
.parent
= &platform_bus
;
371 pr_debug("I2C adapter driver [%s] forgot to specify "
372 "physical device\n", adap
->name
);
374 sprintf(adap
->dev
.bus_id
, "i2c-%d", adap
->nr
);
375 adap
->dev
.release
= &i2c_adapter_dev_release
;
376 adap
->dev
.class = &i2c_adapter_class
;
377 res
= device_register(&adap
->dev
);
381 dev_dbg(&adap
->dev
, "adapter [%s] registered\n", adap
->name
);
383 /* create pre-declared device nodes for new-style drivers */
384 if (adap
->nr
< __i2c_first_dynamic_bus_num
)
385 i2c_scan_static_board_info(adap
);
387 /* let legacy drivers scan this bus for matching devices */
388 dummy
= bus_for_each_drv(&i2c_bus_type
, NULL
, adap
,
392 mutex_unlock(&core_lock
);
396 idr_remove(&i2c_adapter_idr
, adap
->nr
);
401 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
402 * @adapter: the adapter to add
405 * This routine is used to declare an I2C adapter when its bus number
406 * doesn't matter. Examples: for I2C adapters dynamically added by
407 * USB links or PCI plugin cards.
409 * When this returns zero, a new bus number was allocated and stored
410 * in adap->nr, and the specified adapter became available for clients.
411 * Otherwise, a negative errno value is returned.
413 int i2c_add_adapter(struct i2c_adapter
*adapter
)
418 if (idr_pre_get(&i2c_adapter_idr
, GFP_KERNEL
) == 0)
421 mutex_lock(&core_lock
);
422 /* "above" here means "above or equal to", sigh */
423 res
= idr_get_new_above(&i2c_adapter_idr
, adapter
,
424 __i2c_first_dynamic_bus_num
, &id
);
425 mutex_unlock(&core_lock
);
434 return i2c_register_adapter(adapter
);
436 EXPORT_SYMBOL(i2c_add_adapter
);
439 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
440 * @adap: the adapter to register (with adap->nr initialized)
443 * This routine is used to declare an I2C adapter when its bus number
444 * matters. Example: for I2C adapters from system-on-chip CPUs, or
445 * otherwise built in to the system's mainboard, and where i2c_board_info
446 * is used to properly configure I2C devices.
448 * If no devices have pre-been declared for this bus, then be sure to
449 * register the adapter before any dynamically allocated ones. Otherwise
450 * the required bus ID may not be available.
452 * When this returns zero, the specified adapter became available for
453 * clients using the bus number provided in adap->nr. Also, the table
454 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
455 * and the appropriate driver model device nodes are created. Otherwise, a
456 * negative errno value is returned.
458 int i2c_add_numbered_adapter(struct i2c_adapter
*adap
)
463 if (adap
->nr
& ~MAX_ID_MASK
)
467 if (idr_pre_get(&i2c_adapter_idr
, GFP_KERNEL
) == 0)
470 mutex_lock(&core_lock
);
471 /* "above" here means "above or equal to", sigh;
472 * we need the "equal to" result to force the result
474 status
= idr_get_new_above(&i2c_adapter_idr
, adap
, adap
->nr
, &id
);
475 if (status
== 0 && id
!= adap
->nr
) {
477 idr_remove(&i2c_adapter_idr
, id
);
479 mutex_unlock(&core_lock
);
480 if (status
== -EAGAIN
)
484 status
= i2c_register_adapter(adap
);
487 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter
);
489 static int i2c_do_del_adapter(struct device_driver
*d
, void *data
)
491 struct i2c_driver
*driver
= to_i2c_driver(d
);
492 struct i2c_adapter
*adapter
= data
;
495 if (!driver
->detach_adapter
)
497 res
= driver
->detach_adapter(adapter
);
499 dev_err(&adapter
->dev
, "detach_adapter failed (%d) "
500 "for driver [%s]\n", res
, driver
->driver
.name
);
505 * i2c_del_adapter - unregister I2C adapter
506 * @adap: the adapter being unregistered
509 * This unregisters an I2C adapter which was previously registered
510 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
512 int i2c_del_adapter(struct i2c_adapter
*adap
)
514 struct list_head
*item
, *_n
;
515 struct i2c_client
*client
;
518 mutex_lock(&core_lock
);
520 /* First make sure that this adapter was ever added */
521 if (idr_find(&i2c_adapter_idr
, adap
->nr
) != adap
) {
522 pr_debug("i2c-core: attempting to delete unregistered "
523 "adapter [%s]\n", adap
->name
);
528 /* Tell drivers about this removal */
529 res
= bus_for_each_drv(&i2c_bus_type
, NULL
, adap
,
534 /* detach any active clients. This must be done first, because
535 * it can fail; in which case we give up. */
536 list_for_each_safe(item
, _n
, &adap
->clients
) {
537 struct i2c_driver
*driver
;
539 client
= list_entry(item
, struct i2c_client
, list
);
540 driver
= client
->driver
;
542 /* new style, follow standard driver model */
543 if (!driver
|| is_newstyle_driver(driver
)) {
544 i2c_unregister_device(client
);
548 /* legacy drivers create and remove clients themselves */
549 if ((res
= driver
->detach_client(client
))) {
550 dev_err(&adap
->dev
, "detach_client failed for client "
551 "[%s] at address 0x%02x\n", client
->name
,
557 /* clean up the sysfs representation */
558 init_completion(&adap
->dev_released
);
559 device_unregister(&adap
->dev
);
561 /* wait for sysfs to drop all references */
562 wait_for_completion(&adap
->dev_released
);
565 idr_remove(&i2c_adapter_idr
, adap
->nr
);
567 dev_dbg(&adap
->dev
, "adapter [%s] unregistered\n", adap
->name
);
570 mutex_unlock(&core_lock
);
573 EXPORT_SYMBOL(i2c_del_adapter
);
576 /* ------------------------------------------------------------------------- */
579 * An i2c_driver is used with one or more i2c_client (device) nodes to access
580 * i2c slave chips, on a bus instance associated with some i2c_adapter. There
581 * are two models for binding the driver to its device: "new style" drivers
582 * follow the standard Linux driver model and just respond to probe() calls
583 * issued if the driver core sees they match(); "legacy" drivers create device
587 int i2c_register_driver(struct module
*owner
, struct i2c_driver
*driver
)
591 /* new style driver methods can't mix with legacy ones */
592 if (is_newstyle_driver(driver
)) {
593 if (driver
->attach_adapter
|| driver
->detach_adapter
594 || driver
->detach_client
) {
596 "i2c-core: driver [%s] is confused\n",
597 driver
->driver
.name
);
602 /* add the driver to the list of i2c drivers in the driver core */
603 driver
->driver
.owner
= owner
;
604 driver
->driver
.bus
= &i2c_bus_type
;
606 /* for new style drivers, when registration returns the driver core
607 * will have called probe() for all matching-but-unbound devices.
609 res
= driver_register(&driver
->driver
);
613 mutex_lock(&core_lock
);
615 pr_debug("i2c-core: driver [%s] registered\n", driver
->driver
.name
);
617 /* legacy drivers scan i2c busses directly */
618 if (driver
->attach_adapter
) {
619 struct i2c_adapter
*adapter
;
621 down(&i2c_adapter_class
.sem
);
622 list_for_each_entry(adapter
, &i2c_adapter_class
.devices
,
624 driver
->attach_adapter(adapter
);
626 up(&i2c_adapter_class
.sem
);
629 mutex_unlock(&core_lock
);
632 EXPORT_SYMBOL(i2c_register_driver
);
635 * i2c_del_driver - unregister I2C driver
636 * @driver: the driver being unregistered
639 void i2c_del_driver(struct i2c_driver
*driver
)
641 struct list_head
*item2
, *_n
;
642 struct i2c_client
*client
;
643 struct i2c_adapter
*adap
;
645 mutex_lock(&core_lock
);
647 /* new-style driver? */
648 if (is_newstyle_driver(driver
))
651 /* Have a look at each adapter, if clients of this driver are still
652 * attached. If so, detach them to be able to kill the driver
655 down(&i2c_adapter_class
.sem
);
656 list_for_each_entry(adap
, &i2c_adapter_class
.devices
, dev
.node
) {
657 if (driver
->detach_adapter
) {
658 if (driver
->detach_adapter(adap
)) {
659 dev_err(&adap
->dev
, "detach_adapter failed "
661 driver
->driver
.name
);
664 list_for_each_safe(item2
, _n
, &adap
->clients
) {
665 client
= list_entry(item2
, struct i2c_client
, list
);
666 if (client
->driver
!= driver
)
668 dev_dbg(&adap
->dev
, "detaching client [%s] "
669 "at 0x%02x\n", client
->name
,
671 if (driver
->detach_client(client
)) {
672 dev_err(&adap
->dev
, "detach_client "
673 "failed for client [%s] at "
674 "0x%02x\n", client
->name
,
680 up(&i2c_adapter_class
.sem
);
683 driver_unregister(&driver
->driver
);
684 pr_debug("i2c-core: driver [%s] unregistered\n", driver
->driver
.name
);
686 mutex_unlock(&core_lock
);
688 EXPORT_SYMBOL(i2c_del_driver
);
690 /* ------------------------------------------------------------------------- */
692 static int __i2c_check_addr(struct device
*dev
, void *addrp
)
694 struct i2c_client
*client
= i2c_verify_client(dev
);
695 int addr
= *(int *)addrp
;
697 if (client
&& client
->addr
== addr
)
702 static int i2c_check_addr(struct i2c_adapter
*adapter
, int addr
)
704 return device_for_each_child(&adapter
->dev
, &addr
, __i2c_check_addr
);
707 int i2c_attach_client(struct i2c_client
*client
)
709 struct i2c_adapter
*adapter
= client
->adapter
;
712 client
->dev
.parent
= &client
->adapter
->dev
;
713 client
->dev
.bus
= &i2c_bus_type
;
716 client
->dev
.driver
= &client
->driver
->driver
;
718 if (client
->driver
&& !is_newstyle_driver(client
->driver
)) {
719 client
->dev
.release
= i2c_client_release
;
720 client
->dev
.uevent_suppress
= 1;
722 client
->dev
.release
= i2c_client_dev_release
;
724 snprintf(&client
->dev
.bus_id
[0], sizeof(client
->dev
.bus_id
),
725 "%d-%04x", i2c_adapter_id(adapter
), client
->addr
);
726 res
= device_register(&client
->dev
);
730 mutex_lock(&adapter
->clist_lock
);
731 list_add_tail(&client
->list
, &adapter
->clients
);
732 mutex_unlock(&adapter
->clist_lock
);
734 dev_dbg(&adapter
->dev
, "client [%s] registered with bus id %s\n",
735 client
->name
, client
->dev
.bus_id
);
737 if (adapter
->client_register
) {
738 if (adapter
->client_register(client
)) {
739 dev_dbg(&adapter
->dev
, "client_register "
740 "failed for client [%s] at 0x%02x\n",
741 client
->name
, client
->addr
);
748 dev_err(&adapter
->dev
, "Failed to attach i2c client %s at 0x%02x "
749 "(%d)\n", client
->name
, client
->addr
, res
);
752 EXPORT_SYMBOL(i2c_attach_client
);
754 int i2c_detach_client(struct i2c_client
*client
)
756 struct i2c_adapter
*adapter
= client
->adapter
;
759 if (adapter
->client_unregister
) {
760 res
= adapter
->client_unregister(client
);
762 dev_err(&client
->dev
,
763 "client_unregister [%s] failed, "
764 "client not detached\n", client
->name
);
769 mutex_lock(&adapter
->clist_lock
);
770 list_del(&client
->list
);
771 mutex_unlock(&adapter
->clist_lock
);
773 init_completion(&client
->released
);
774 device_unregister(&client
->dev
);
775 wait_for_completion(&client
->released
);
780 EXPORT_SYMBOL(i2c_detach_client
);
783 * i2c_use_client - increments the reference count of the i2c client structure
784 * @client: the client being referenced
786 * Each live reference to a client should be refcounted. The driver model does
787 * that automatically as part of driver binding, so that most drivers don't
788 * need to do this explicitly: they hold a reference until they're unbound
791 * A pointer to the client with the incremented reference counter is returned.
793 struct i2c_client
*i2c_use_client(struct i2c_client
*client
)
795 get_device(&client
->dev
);
798 EXPORT_SYMBOL(i2c_use_client
);
801 * i2c_release_client - release a use of the i2c client structure
802 * @client: the client being no longer referenced
804 * Must be called when a user of a client is finished with it.
806 void i2c_release_client(struct i2c_client
*client
)
808 put_device(&client
->dev
);
810 EXPORT_SYMBOL(i2c_release_client
);
817 static int i2c_cmd(struct device
*dev
, void *_arg
)
819 struct i2c_client
*client
= i2c_verify_client(dev
);
820 struct i2c_cmd_arg
*arg
= _arg
;
822 if (client
&& client
->driver
&& client
->driver
->command
)
823 client
->driver
->command(client
, arg
->cmd
, arg
->arg
);
827 void i2c_clients_command(struct i2c_adapter
*adap
, unsigned int cmd
, void *arg
)
829 struct i2c_cmd_arg cmd_arg
;
833 device_for_each_child(&adap
->dev
, &cmd_arg
, i2c_cmd
);
835 EXPORT_SYMBOL(i2c_clients_command
);
837 static int __init
i2c_init(void)
841 retval
= bus_register(&i2c_bus_type
);
844 return class_register(&i2c_adapter_class
);
847 static void __exit
i2c_exit(void)
849 class_unregister(&i2c_adapter_class
);
850 bus_unregister(&i2c_bus_type
);
853 subsys_initcall(i2c_init
);
854 module_exit(i2c_exit
);
856 /* ----------------------------------------------------
857 * the functional interface to the i2c busses.
858 * ----------------------------------------------------
861 int i2c_transfer(struct i2c_adapter
* adap
, struct i2c_msg
*msgs
, int num
)
865 if (adap
->algo
->master_xfer
) {
867 for (ret
= 0; ret
< num
; ret
++) {
868 dev_dbg(&adap
->dev
, "master_xfer[%d] %c, addr=0x%02x, "
869 "len=%d%s\n", ret
, (msgs
[ret
].flags
& I2C_M_RD
)
870 ? 'R' : 'W', msgs
[ret
].addr
, msgs
[ret
].len
,
871 (msgs
[ret
].flags
& I2C_M_RECV_LEN
) ? "+" : "");
875 if (in_atomic() || irqs_disabled()) {
876 ret
= mutex_trylock(&adap
->bus_lock
);
878 /* I2C activity is ongoing. */
881 mutex_lock_nested(&adap
->bus_lock
, adap
->level
);
884 ret
= adap
->algo
->master_xfer(adap
,msgs
,num
);
885 mutex_unlock(&adap
->bus_lock
);
889 dev_dbg(&adap
->dev
, "I2C level transfers not supported\n");
893 EXPORT_SYMBOL(i2c_transfer
);
895 int i2c_master_send(struct i2c_client
*client
,const char *buf
,int count
)
898 struct i2c_adapter
*adap
=client
->adapter
;
901 msg
.addr
= client
->addr
;
902 msg
.flags
= client
->flags
& I2C_M_TEN
;
904 msg
.buf
= (char *)buf
;
906 ret
= i2c_transfer(adap
, &msg
, 1);
908 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
909 transmitted, else error code. */
910 return (ret
== 1) ? count
: ret
;
912 EXPORT_SYMBOL(i2c_master_send
);
914 int i2c_master_recv(struct i2c_client
*client
, char *buf
,int count
)
916 struct i2c_adapter
*adap
=client
->adapter
;
920 msg
.addr
= client
->addr
;
921 msg
.flags
= client
->flags
& I2C_M_TEN
;
922 msg
.flags
|= I2C_M_RD
;
926 ret
= i2c_transfer(adap
, &msg
, 1);
928 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
929 transmitted, else error code. */
930 return (ret
== 1) ? count
: ret
;
932 EXPORT_SYMBOL(i2c_master_recv
);
934 /* ----------------------------------------------------
935 * the i2c address scanning function
936 * Will not work for 10-bit addresses!
937 * ----------------------------------------------------
939 static int i2c_probe_address(struct i2c_adapter
*adapter
, int addr
, int kind
,
940 int (*found_proc
) (struct i2c_adapter
*, int, int))
944 /* Make sure the address is valid */
945 if (addr
< 0x03 || addr
> 0x77) {
946 dev_warn(&adapter
->dev
, "Invalid probe address 0x%02x\n",
951 /* Skip if already in use */
952 if (i2c_check_addr(adapter
, addr
))
955 /* Make sure there is something at this address, unless forced */
957 if (i2c_smbus_xfer(adapter
, addr
, 0, 0, 0,
958 I2C_SMBUS_QUICK
, NULL
) < 0)
961 /* prevent 24RF08 corruption */
962 if ((addr
& ~0x0f) == 0x50)
963 i2c_smbus_xfer(adapter
, addr
, 0, 0, 0,
964 I2C_SMBUS_QUICK
, NULL
);
967 /* Finally call the custom detection function */
968 err
= found_proc(adapter
, addr
, kind
);
969 /* -ENODEV can be returned if there is a chip at the given address
970 but it isn't supported by this chip driver. We catch it here as
971 this isn't an error. */
976 dev_warn(&adapter
->dev
, "Client creation failed at 0x%x (%d)\n",
981 int i2c_probe(struct i2c_adapter
*adapter
,
982 const struct i2c_client_address_data
*address_data
,
983 int (*found_proc
) (struct i2c_adapter
*, int, int))
986 int adap_id
= i2c_adapter_id(adapter
);
988 /* Force entries are done first, and are not affected by ignore
990 if (address_data
->forces
) {
991 const unsigned short * const *forces
= address_data
->forces
;
994 for (kind
= 0; forces
[kind
]; kind
++) {
995 for (i
= 0; forces
[kind
][i
] != I2C_CLIENT_END
;
997 if (forces
[kind
][i
] == adap_id
998 || forces
[kind
][i
] == ANY_I2C_BUS
) {
999 dev_dbg(&adapter
->dev
, "found force "
1000 "parameter for adapter %d, "
1001 "addr 0x%02x, kind %d\n",
1002 adap_id
, forces
[kind
][i
+ 1],
1004 err
= i2c_probe_address(adapter
,
1005 forces
[kind
][i
+ 1],
1014 /* Stop here if we can't use SMBUS_QUICK */
1015 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_QUICK
)) {
1016 if (address_data
->probe
[0] == I2C_CLIENT_END
1017 && address_data
->normal_i2c
[0] == I2C_CLIENT_END
)
1020 dev_warn(&adapter
->dev
, "SMBus Quick command not supported, "
1021 "can't probe for chips\n");
1025 /* Probe entries are done second, and are not affected by ignore
1027 for (i
= 0; address_data
->probe
[i
] != I2C_CLIENT_END
; i
+= 2) {
1028 if (address_data
->probe
[i
] == adap_id
1029 || address_data
->probe
[i
] == ANY_I2C_BUS
) {
1030 dev_dbg(&adapter
->dev
, "found probe parameter for "
1031 "adapter %d, addr 0x%02x\n", adap_id
,
1032 address_data
->probe
[i
+ 1]);
1033 err
= i2c_probe_address(adapter
,
1034 address_data
->probe
[i
+ 1],
1041 /* Normal entries are done last, unless shadowed by an ignore entry */
1042 for (i
= 0; address_data
->normal_i2c
[i
] != I2C_CLIENT_END
; i
+= 1) {
1046 for (j
= 0; address_data
->ignore
[j
] != I2C_CLIENT_END
;
1048 if ((address_data
->ignore
[j
] == adap_id
||
1049 address_data
->ignore
[j
] == ANY_I2C_BUS
)
1050 && address_data
->ignore
[j
+ 1]
1051 == address_data
->normal_i2c
[i
]) {
1052 dev_dbg(&adapter
->dev
, "found ignore "
1053 "parameter for adapter %d, "
1054 "addr 0x%02x\n", adap_id
,
1055 address_data
->ignore
[j
+ 1]);
1063 dev_dbg(&adapter
->dev
, "found normal entry for adapter %d, "
1064 "addr 0x%02x\n", adap_id
,
1065 address_data
->normal_i2c
[i
]);
1066 err
= i2c_probe_address(adapter
, address_data
->normal_i2c
[i
],
1074 EXPORT_SYMBOL(i2c_probe
);
1077 i2c_new_probed_device(struct i2c_adapter
*adap
,
1078 struct i2c_board_info
*info
,
1079 unsigned short const *addr_list
)
1083 /* Stop here if the bus doesn't support probing */
1084 if (!i2c_check_functionality(adap
, I2C_FUNC_SMBUS_READ_BYTE
)) {
1085 dev_err(&adap
->dev
, "Probing not supported\n");
1089 for (i
= 0; addr_list
[i
] != I2C_CLIENT_END
; i
++) {
1090 /* Check address validity */
1091 if (addr_list
[i
] < 0x03 || addr_list
[i
] > 0x77) {
1092 dev_warn(&adap
->dev
, "Invalid 7-bit address "
1093 "0x%02x\n", addr_list
[i
]);
1097 /* Check address availability */
1098 if (i2c_check_addr(adap
, addr_list
[i
])) {
1099 dev_dbg(&adap
->dev
, "Address 0x%02x already in "
1100 "use, not probing\n", addr_list
[i
]);
1104 /* Test address responsiveness
1105 The default probe method is a quick write, but it is known
1106 to corrupt the 24RF08 EEPROMs due to a state machine bug,
1107 and could also irreversibly write-protect some EEPROMs, so
1108 for address ranges 0x30-0x37 and 0x50-0x5f, we use a byte
1109 read instead. Also, some bus drivers don't implement
1110 quick write, so we fallback to a byte read it that case
1112 if ((addr_list
[i
] & ~0x07) == 0x30
1113 || (addr_list
[i
] & ~0x0f) == 0x50
1114 || !i2c_check_functionality(adap
, I2C_FUNC_SMBUS_QUICK
)) {
1115 if (i2c_smbus_xfer(adap
, addr_list
[i
], 0,
1117 I2C_SMBUS_BYTE
, NULL
) >= 0)
1120 if (i2c_smbus_xfer(adap
, addr_list
[i
], 0,
1122 I2C_SMBUS_QUICK
, NULL
) >= 0)
1127 if (addr_list
[i
] == I2C_CLIENT_END
) {
1128 dev_dbg(&adap
->dev
, "Probing failed, no device found\n");
1132 info
->addr
= addr_list
[i
];
1133 return i2c_new_device(adap
, info
);
1135 EXPORT_SYMBOL_GPL(i2c_new_probed_device
);
1137 struct i2c_adapter
* i2c_get_adapter(int id
)
1139 struct i2c_adapter
*adapter
;
1141 mutex_lock(&core_lock
);
1142 adapter
= (struct i2c_adapter
*)idr_find(&i2c_adapter_idr
, id
);
1143 if (adapter
&& !try_module_get(adapter
->owner
))
1146 mutex_unlock(&core_lock
);
1149 EXPORT_SYMBOL(i2c_get_adapter
);
1151 void i2c_put_adapter(struct i2c_adapter
*adap
)
1153 module_put(adap
->owner
);
1155 EXPORT_SYMBOL(i2c_put_adapter
);
1157 /* The SMBus parts */
1159 #define POLY (0x1070U << 3)
1165 for(i
= 0; i
< 8; i
++) {
1170 return (u8
)(data
>> 8);
1173 /* Incremental CRC8 over count bytes in the array pointed to by p */
1174 static u8
i2c_smbus_pec(u8 crc
, u8
*p
, size_t count
)
1178 for(i
= 0; i
< count
; i
++)
1179 crc
= crc8((crc
^ p
[i
]) << 8);
1183 /* Assume a 7-bit address, which is reasonable for SMBus */
1184 static u8
i2c_smbus_msg_pec(u8 pec
, struct i2c_msg
*msg
)
1186 /* The address will be sent first */
1187 u8 addr
= (msg
->addr
<< 1) | !!(msg
->flags
& I2C_M_RD
);
1188 pec
= i2c_smbus_pec(pec
, &addr
, 1);
1190 /* The data buffer follows */
1191 return i2c_smbus_pec(pec
, msg
->buf
, msg
->len
);
1194 /* Used for write only transactions */
1195 static inline void i2c_smbus_add_pec(struct i2c_msg
*msg
)
1197 msg
->buf
[msg
->len
] = i2c_smbus_msg_pec(0, msg
);
1201 /* Return <0 on CRC error
1202 If there was a write before this read (most cases) we need to take the
1203 partial CRC from the write part into account.
1204 Note that this function does modify the message (we need to decrease the
1205 message length to hide the CRC byte from the caller). */
1206 static int i2c_smbus_check_pec(u8 cpec
, struct i2c_msg
*msg
)
1208 u8 rpec
= msg
->buf
[--msg
->len
];
1209 cpec
= i2c_smbus_msg_pec(cpec
, msg
);
1212 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1219 s32
i2c_smbus_write_quick(struct i2c_client
*client
, u8 value
)
1221 return i2c_smbus_xfer(client
->adapter
,client
->addr
,client
->flags
,
1222 value
,0,I2C_SMBUS_QUICK
,NULL
);
1224 EXPORT_SYMBOL(i2c_smbus_write_quick
);
1226 s32
i2c_smbus_read_byte(struct i2c_client
*client
)
1228 union i2c_smbus_data data
;
1229 if (i2c_smbus_xfer(client
->adapter
,client
->addr
,client
->flags
,
1230 I2C_SMBUS_READ
,0,I2C_SMBUS_BYTE
, &data
))
1235 EXPORT_SYMBOL(i2c_smbus_read_byte
);
1237 s32
i2c_smbus_write_byte(struct i2c_client
*client
, u8 value
)
1239 return i2c_smbus_xfer(client
->adapter
,client
->addr
,client
->flags
,
1240 I2C_SMBUS_WRITE
, value
, I2C_SMBUS_BYTE
, NULL
);
1242 EXPORT_SYMBOL(i2c_smbus_write_byte
);
1244 s32
i2c_smbus_read_byte_data(struct i2c_client
*client
, u8 command
)
1246 union i2c_smbus_data data
;
1247 if (i2c_smbus_xfer(client
->adapter
,client
->addr
,client
->flags
,
1248 I2C_SMBUS_READ
,command
, I2C_SMBUS_BYTE_DATA
,&data
))
1253 EXPORT_SYMBOL(i2c_smbus_read_byte_data
);
1255 s32
i2c_smbus_write_byte_data(struct i2c_client
*client
, u8 command
, u8 value
)
1257 union i2c_smbus_data data
;
1259 return i2c_smbus_xfer(client
->adapter
,client
->addr
,client
->flags
,
1260 I2C_SMBUS_WRITE
,command
,
1261 I2C_SMBUS_BYTE_DATA
,&data
);
1263 EXPORT_SYMBOL(i2c_smbus_write_byte_data
);
1265 s32
i2c_smbus_read_word_data(struct i2c_client
*client
, u8 command
)
1267 union i2c_smbus_data data
;
1268 if (i2c_smbus_xfer(client
->adapter
,client
->addr
,client
->flags
,
1269 I2C_SMBUS_READ
,command
, I2C_SMBUS_WORD_DATA
, &data
))
1274 EXPORT_SYMBOL(i2c_smbus_read_word_data
);
1276 s32
i2c_smbus_write_word_data(struct i2c_client
*client
, u8 command
, u16 value
)
1278 union i2c_smbus_data data
;
1280 return i2c_smbus_xfer(client
->adapter
,client
->addr
,client
->flags
,
1281 I2C_SMBUS_WRITE
,command
,
1282 I2C_SMBUS_WORD_DATA
,&data
);
1284 EXPORT_SYMBOL(i2c_smbus_write_word_data
);
1287 * i2c_smbus_read_block_data - SMBus block read request
1288 * @client: Handle to slave device
1289 * @command: Command byte issued to let the slave know what data should
1291 * @values: Byte array into which data will be read; big enough to hold
1292 * the data returned by the slave. SMBus allows at most 32 bytes.
1294 * Returns the number of bytes read in the slave's response, else a
1295 * negative number to indicate some kind of error.
1297 * Note that using this function requires that the client's adapter support
1298 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
1299 * support this; its emulation through I2C messaging relies on a specific
1300 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
1302 s32
i2c_smbus_read_block_data(struct i2c_client
*client
, u8 command
,
1305 union i2c_smbus_data data
;
1307 if (i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1308 I2C_SMBUS_READ
, command
,
1309 I2C_SMBUS_BLOCK_DATA
, &data
))
1312 memcpy(values
, &data
.block
[1], data
.block
[0]);
1313 return data
.block
[0];
1315 EXPORT_SYMBOL(i2c_smbus_read_block_data
);
1317 s32
i2c_smbus_write_block_data(struct i2c_client
*client
, u8 command
,
1318 u8 length
, const u8
*values
)
1320 union i2c_smbus_data data
;
1322 if (length
> I2C_SMBUS_BLOCK_MAX
)
1323 length
= I2C_SMBUS_BLOCK_MAX
;
1324 data
.block
[0] = length
;
1325 memcpy(&data
.block
[1], values
, length
);
1326 return i2c_smbus_xfer(client
->adapter
,client
->addr
,client
->flags
,
1327 I2C_SMBUS_WRITE
,command
,
1328 I2C_SMBUS_BLOCK_DATA
,&data
);
1330 EXPORT_SYMBOL(i2c_smbus_write_block_data
);
1332 /* Returns the number of read bytes */
1333 s32
i2c_smbus_read_i2c_block_data(struct i2c_client
*client
, u8 command
,
1334 u8 length
, u8
*values
)
1336 union i2c_smbus_data data
;
1338 if (length
> I2C_SMBUS_BLOCK_MAX
)
1339 length
= I2C_SMBUS_BLOCK_MAX
;
1340 data
.block
[0] = length
;
1341 if (i2c_smbus_xfer(client
->adapter
,client
->addr
,client
->flags
,
1342 I2C_SMBUS_READ
,command
,
1343 I2C_SMBUS_I2C_BLOCK_DATA
,&data
))
1346 memcpy(values
, &data
.block
[1], data
.block
[0]);
1347 return data
.block
[0];
1349 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data
);
1351 s32
i2c_smbus_write_i2c_block_data(struct i2c_client
*client
, u8 command
,
1352 u8 length
, const u8
*values
)
1354 union i2c_smbus_data data
;
1356 if (length
> I2C_SMBUS_BLOCK_MAX
)
1357 length
= I2C_SMBUS_BLOCK_MAX
;
1358 data
.block
[0] = length
;
1359 memcpy(data
.block
+ 1, values
, length
);
1360 return i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1361 I2C_SMBUS_WRITE
, command
,
1362 I2C_SMBUS_I2C_BLOCK_DATA
, &data
);
1364 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data
);
1366 /* Simulate a SMBus command using the i2c protocol
1367 No checking of parameters is done! */
1368 static s32
i2c_smbus_xfer_emulated(struct i2c_adapter
* adapter
, u16 addr
,
1369 unsigned short flags
,
1370 char read_write
, u8 command
, int size
,
1371 union i2c_smbus_data
* data
)
1373 /* So we need to generate a series of msgs. In the case of writing, we
1374 need to use only one message; when reading, we need two. We initialize
1375 most things with sane defaults, to keep the code below somewhat
1377 unsigned char msgbuf0
[I2C_SMBUS_BLOCK_MAX
+3];
1378 unsigned char msgbuf1
[I2C_SMBUS_BLOCK_MAX
+2];
1379 int num
= read_write
== I2C_SMBUS_READ
?2:1;
1380 struct i2c_msg msg
[2] = { { addr
, flags
, 1, msgbuf0
},
1381 { addr
, flags
| I2C_M_RD
, 0, msgbuf1
}
1386 msgbuf0
[0] = command
;
1388 case I2C_SMBUS_QUICK
:
1390 /* Special case: The read/write field is used as data */
1391 msg
[0].flags
= flags
| (read_write
==I2C_SMBUS_READ
)?I2C_M_RD
:0;
1394 case I2C_SMBUS_BYTE
:
1395 if (read_write
== I2C_SMBUS_READ
) {
1396 /* Special case: only a read! */
1397 msg
[0].flags
= I2C_M_RD
| flags
;
1401 case I2C_SMBUS_BYTE_DATA
:
1402 if (read_write
== I2C_SMBUS_READ
)
1406 msgbuf0
[1] = data
->byte
;
1409 case I2C_SMBUS_WORD_DATA
:
1410 if (read_write
== I2C_SMBUS_READ
)
1414 msgbuf0
[1] = data
->word
& 0xff;
1415 msgbuf0
[2] = data
->word
>> 8;
1418 case I2C_SMBUS_PROC_CALL
:
1419 num
= 2; /* Special case */
1420 read_write
= I2C_SMBUS_READ
;
1423 msgbuf0
[1] = data
->word
& 0xff;
1424 msgbuf0
[2] = data
->word
>> 8;
1426 case I2C_SMBUS_BLOCK_DATA
:
1427 if (read_write
== I2C_SMBUS_READ
) {
1428 msg
[1].flags
|= I2C_M_RECV_LEN
;
1429 msg
[1].len
= 1; /* block length will be added by
1430 the underlying bus driver */
1432 msg
[0].len
= data
->block
[0] + 2;
1433 if (msg
[0].len
> I2C_SMBUS_BLOCK_MAX
+ 2) {
1434 dev_err(&adapter
->dev
, "smbus_access called with "
1435 "invalid block write size (%d)\n",
1439 for (i
= 1; i
< msg
[0].len
; i
++)
1440 msgbuf0
[i
] = data
->block
[i
-1];
1443 case I2C_SMBUS_BLOCK_PROC_CALL
:
1444 num
= 2; /* Another special case */
1445 read_write
= I2C_SMBUS_READ
;
1446 if (data
->block
[0] > I2C_SMBUS_BLOCK_MAX
) {
1447 dev_err(&adapter
->dev
, "%s called with invalid "
1448 "block proc call size (%d)\n", __FUNCTION__
,
1452 msg
[0].len
= data
->block
[0] + 2;
1453 for (i
= 1; i
< msg
[0].len
; i
++)
1454 msgbuf0
[i
] = data
->block
[i
-1];
1455 msg
[1].flags
|= I2C_M_RECV_LEN
;
1456 msg
[1].len
= 1; /* block length will be added by
1457 the underlying bus driver */
1459 case I2C_SMBUS_I2C_BLOCK_DATA
:
1460 if (read_write
== I2C_SMBUS_READ
) {
1461 msg
[1].len
= data
->block
[0];
1463 msg
[0].len
= data
->block
[0] + 1;
1464 if (msg
[0].len
> I2C_SMBUS_BLOCK_MAX
+ 1) {
1465 dev_err(&adapter
->dev
, "i2c_smbus_xfer_emulated called with "
1466 "invalid block write size (%d)\n",
1470 for (i
= 1; i
<= data
->block
[0]; i
++)
1471 msgbuf0
[i
] = data
->block
[i
];
1475 dev_err(&adapter
->dev
, "smbus_access called with invalid size (%d)\n",
1480 i
= ((flags
& I2C_CLIENT_PEC
) && size
!= I2C_SMBUS_QUICK
1481 && size
!= I2C_SMBUS_I2C_BLOCK_DATA
);
1483 /* Compute PEC if first message is a write */
1484 if (!(msg
[0].flags
& I2C_M_RD
)) {
1485 if (num
== 1) /* Write only */
1486 i2c_smbus_add_pec(&msg
[0]);
1487 else /* Write followed by read */
1488 partial_pec
= i2c_smbus_msg_pec(0, &msg
[0]);
1490 /* Ask for PEC if last message is a read */
1491 if (msg
[num
-1].flags
& I2C_M_RD
)
1495 if (i2c_transfer(adapter
, msg
, num
) < 0)
1498 /* Check PEC if last message is a read */
1499 if (i
&& (msg
[num
-1].flags
& I2C_M_RD
)) {
1500 if (i2c_smbus_check_pec(partial_pec
, &msg
[num
-1]) < 0)
1504 if (read_write
== I2C_SMBUS_READ
)
1506 case I2C_SMBUS_BYTE
:
1507 data
->byte
= msgbuf0
[0];
1509 case I2C_SMBUS_BYTE_DATA
:
1510 data
->byte
= msgbuf1
[0];
1512 case I2C_SMBUS_WORD_DATA
:
1513 case I2C_SMBUS_PROC_CALL
:
1514 data
->word
= msgbuf1
[0] | (msgbuf1
[1] << 8);
1516 case I2C_SMBUS_I2C_BLOCK_DATA
:
1517 for (i
= 0; i
< data
->block
[0]; i
++)
1518 data
->block
[i
+1] = msgbuf1
[i
];
1520 case I2C_SMBUS_BLOCK_DATA
:
1521 case I2C_SMBUS_BLOCK_PROC_CALL
:
1522 for (i
= 0; i
< msgbuf1
[0] + 1; i
++)
1523 data
->block
[i
] = msgbuf1
[i
];
1530 s32
i2c_smbus_xfer(struct i2c_adapter
* adapter
, u16 addr
, unsigned short flags
,
1531 char read_write
, u8 command
, int size
,
1532 union i2c_smbus_data
* data
)
1536 flags
&= I2C_M_TEN
| I2C_CLIENT_PEC
;
1538 if (adapter
->algo
->smbus_xfer
) {
1539 mutex_lock(&adapter
->bus_lock
);
1540 res
= adapter
->algo
->smbus_xfer(adapter
,addr
,flags
,read_write
,
1542 mutex_unlock(&adapter
->bus_lock
);
1544 res
= i2c_smbus_xfer_emulated(adapter
,addr
,flags
,read_write
,
1549 EXPORT_SYMBOL(i2c_smbus_xfer
);
1551 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
1552 MODULE_DESCRIPTION("I2C-Bus main module");
1553 MODULE_LICENSE("GPL");