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/platform_device.h>
33 #include <linux/mutex.h>
34 #include <linux/completion.h>
35 #include <linux/hardirq.h>
36 #include <linux/irqflags.h>
37 #include <asm/uaccess.h>
42 static DEFINE_MUTEX(core_lock);
43 static DEFINE_IDR(i2c_adapter_idr);
45 #define is_newstyle_driver(d) ((d)->probe || (d)->remove)
47 /* ------------------------------------------------------------------------- */
49 static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
50 const struct i2c_client *client)
53 if (strcmp(client->name, id->name) == 0)
60 static int i2c_device_match(struct device *dev, struct device_driver *drv)
62 struct i2c_client *client = to_i2c_client(dev);
63 struct i2c_driver *driver = to_i2c_driver(drv);
65 /* make legacy i2c drivers bypass driver model probing entirely;
66 * such drivers scan each i2c adapter/bus themselves.
68 if (!is_newstyle_driver(driver))
71 /* match on an id table if there is one */
73 return i2c_match_id(driver->id_table, client) != NULL;
80 /* uevent helps with hotplug: modprobe -q $(MODALIAS) */
81 static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
83 struct i2c_client *client = to_i2c_client(dev);
85 /* by definition, legacy drivers can't hotplug */
89 if (add_uevent_var(env, "MODALIAS=%s%s",
90 I2C_MODULE_PREFIX, client->name))
92 dev_dbg(dev, "uevent\n");
97 #define i2c_device_uevent NULL
98 #endif /* CONFIG_HOTPLUG */
100 static int i2c_device_probe(struct device *dev)
102 struct i2c_client *client = to_i2c_client(dev);
103 struct i2c_driver *driver = to_i2c_driver(dev->driver);
104 const struct i2c_device_id *id;
109 client->driver = driver;
110 dev_dbg(dev, "probe\n");
112 if (driver->id_table)
113 id = i2c_match_id(driver->id_table, client);
116 status = driver->probe(client, id);
118 client->driver = NULL;
122 static int i2c_device_remove(struct device *dev)
124 struct i2c_client *client = to_i2c_client(dev);
125 struct i2c_driver *driver;
131 driver = to_i2c_driver(dev->driver);
132 if (driver->remove) {
133 dev_dbg(dev, "remove\n");
134 status = driver->remove(client);
140 client->driver = NULL;
144 static void i2c_device_shutdown(struct device *dev)
146 struct i2c_driver *driver;
150 driver = to_i2c_driver(dev->driver);
151 if (driver->shutdown)
152 driver->shutdown(to_i2c_client(dev));
155 static int i2c_device_suspend(struct device * dev, pm_message_t mesg)
157 struct i2c_driver *driver;
161 driver = to_i2c_driver(dev->driver);
162 if (!driver->suspend)
164 return driver->suspend(to_i2c_client(dev), mesg);
167 static int i2c_device_resume(struct device * dev)
169 struct i2c_driver *driver;
173 driver = to_i2c_driver(dev->driver);
176 return driver->resume(to_i2c_client(dev));
179 static void i2c_client_release(struct device *dev)
181 struct i2c_client *client = to_i2c_client(dev);
182 complete(&client->released);
185 static void i2c_client_dev_release(struct device *dev)
187 kfree(to_i2c_client(dev));
190 static ssize_t show_client_name(struct device *dev, struct device_attribute *attr, char *buf)
192 struct i2c_client *client = to_i2c_client(dev);
193 return sprintf(buf, "%s\n", client->name);
196 static ssize_t show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
198 struct i2c_client *client = to_i2c_client(dev);
199 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
202 static struct device_attribute i2c_dev_attrs[] = {
203 __ATTR(name, S_IRUGO, show_client_name, NULL),
204 /* modalias helps coldplug: modprobe $(cat .../modalias) */
205 __ATTR(modalias, S_IRUGO, show_modalias, NULL),
209 static struct bus_type i2c_bus_type = {
211 .dev_attrs = i2c_dev_attrs,
212 .match = i2c_device_match,
213 .uevent = i2c_device_uevent,
214 .probe = i2c_device_probe,
215 .remove = i2c_device_remove,
216 .shutdown = i2c_device_shutdown,
217 .suspend = i2c_device_suspend,
218 .resume = i2c_device_resume,
223 * i2c_verify_client - return parameter as i2c_client, or NULL
224 * @dev: device, probably from some driver model iterator
226 * When traversing the driver model tree, perhaps using driver model
227 * iterators like @device_for_each_child(), you can't assume very much
228 * about the nodes you find. Use this function to avoid oopses caused
229 * by wrongly treating some non-I2C device as an i2c_client.
231 struct i2c_client *i2c_verify_client(struct device *dev)
233 return (dev->bus == &i2c_bus_type)
237 EXPORT_SYMBOL(i2c_verify_client);
241 * i2c_new_device - instantiate an i2c device for use with a new style driver
242 * @adap: the adapter managing the device
243 * @info: describes one I2C device; bus_num is ignored
246 * Create a device to work with a new style i2c driver, where binding is
247 * handled through driver model probe()/remove() methods. This call is not
248 * appropriate for use by mainboad initialization logic, which usually runs
249 * during an arch_initcall() long before any i2c_adapter could exist.
251 * This returns the new i2c client, which may be saved for later use with
252 * i2c_unregister_device(); or NULL to indicate an error.
255 i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
257 struct i2c_client *client;
260 client = kzalloc(sizeof *client, GFP_KERNEL);
264 client->adapter = adap;
266 client->dev.platform_data = info->platform_data;
267 device_init_wakeup(&client->dev, info->flags & I2C_CLIENT_WAKE);
269 client->flags = info->flags & ~I2C_CLIENT_WAKE;
270 client->addr = info->addr;
271 client->irq = info->irq;
273 strlcpy(client->name, info->type, sizeof(client->name));
275 /* a new style driver may be bound to this device when we
276 * return from this function, or any later moment (e.g. maybe
277 * hotplugging will load the driver module). and the device
278 * refcount model is the standard driver model one.
280 status = i2c_attach_client(client);
287 EXPORT_SYMBOL_GPL(i2c_new_device);
291 * i2c_unregister_device - reverse effect of i2c_new_device()
292 * @client: value returned from i2c_new_device()
295 void i2c_unregister_device(struct i2c_client *client)
297 struct i2c_adapter *adapter = client->adapter;
298 struct i2c_driver *driver = client->driver;
300 if (driver && !is_newstyle_driver(driver)) {
301 dev_err(&client->dev, "can't unregister devices "
302 "with legacy drivers\n");
307 mutex_lock(&adapter->clist_lock);
308 list_del(&client->list);
309 mutex_unlock(&adapter->clist_lock);
311 device_unregister(&client->dev);
313 EXPORT_SYMBOL_GPL(i2c_unregister_device);
316 static const struct i2c_device_id dummy_id[] = {
321 static int dummy_probe(struct i2c_client *client,
322 const struct i2c_device_id *id)
327 static int dummy_remove(struct i2c_client *client)
332 static struct i2c_driver dummy_driver = {
333 .driver.name = "dummy",
334 .probe = dummy_probe,
335 .remove = dummy_remove,
336 .id_table = dummy_id,
340 * i2c_new_dummy - return a new i2c device bound to a dummy driver
341 * @adapter: the adapter managing the device
342 * @address: seven bit address to be used
345 * This returns an I2C client bound to the "dummy" driver, intended for use
346 * with devices that consume multiple addresses. Examples of such chips
347 * include various EEPROMS (like 24c04 and 24c08 models).
349 * These dummy devices have two main uses. First, most I2C and SMBus calls
350 * except i2c_transfer() need a client handle; the dummy will be that handle.
351 * And second, this prevents the specified address from being bound to a
354 * This returns the new i2c client, which should be saved for later use with
355 * i2c_unregister_device(); or NULL to indicate an error.
358 i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
360 struct i2c_board_info info = {
361 I2C_BOARD_INFO("dummy", address),
364 return i2c_new_device(adapter, &info);
366 EXPORT_SYMBOL_GPL(i2c_new_dummy);
368 /* ------------------------------------------------------------------------- */
370 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
372 static void i2c_adapter_dev_release(struct device *dev)
374 struct i2c_adapter *adap = to_i2c_adapter(dev);
375 complete(&adap->dev_released);
379 show_adapter_name(struct device *dev, struct device_attribute *attr, char *buf)
381 struct i2c_adapter *adap = to_i2c_adapter(dev);
382 return sprintf(buf, "%s\n", adap->name);
385 static struct device_attribute i2c_adapter_attrs[] = {
386 __ATTR(name, S_IRUGO, show_adapter_name, NULL),
390 static struct class i2c_adapter_class = {
391 .owner = THIS_MODULE,
392 .name = "i2c-adapter",
393 .dev_attrs = i2c_adapter_attrs,
396 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
398 struct i2c_devinfo *devinfo;
400 mutex_lock(&__i2c_board_lock);
401 list_for_each_entry(devinfo, &__i2c_board_list, list) {
402 if (devinfo->busnum == adapter->nr
403 && !i2c_new_device(adapter,
404 &devinfo->board_info))
405 printk(KERN_ERR "i2c-core: can't create i2c%d-%04x\n",
406 i2c_adapter_id(adapter),
407 devinfo->board_info.addr);
409 mutex_unlock(&__i2c_board_lock);
412 static int i2c_do_add_adapter(struct device_driver *d, void *data)
414 struct i2c_driver *driver = to_i2c_driver(d);
415 struct i2c_adapter *adap = data;
417 if (driver->attach_adapter) {
418 /* We ignore the return code; if it fails, too bad */
419 driver->attach_adapter(adap);
424 static int i2c_register_adapter(struct i2c_adapter *adap)
428 mutex_init(&adap->bus_lock);
429 mutex_init(&adap->clist_lock);
430 INIT_LIST_HEAD(&adap->clients);
432 mutex_lock(&core_lock);
434 /* Add the adapter to the driver core.
435 * If the parent pointer is not set up,
436 * we add this adapter to the host bus.
438 if (adap->dev.parent == NULL) {
439 adap->dev.parent = &platform_bus;
440 pr_debug("I2C adapter driver [%s] forgot to specify "
441 "physical device\n", adap->name);
443 sprintf(adap->dev.bus_id, "i2c-%d", adap->nr);
444 adap->dev.release = &i2c_adapter_dev_release;
445 adap->dev.class = &i2c_adapter_class;
446 res = device_register(&adap->dev);
450 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
452 /* create pre-declared device nodes for new-style drivers */
453 if (adap->nr < __i2c_first_dynamic_bus_num)
454 i2c_scan_static_board_info(adap);
456 /* let legacy drivers scan this bus for matching devices */
457 dummy = bus_for_each_drv(&i2c_bus_type, NULL, adap,
461 mutex_unlock(&core_lock);
465 idr_remove(&i2c_adapter_idr, adap->nr);
470 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
471 * @adapter: the adapter to add
474 * This routine is used to declare an I2C adapter when its bus number
475 * doesn't matter. Examples: for I2C adapters dynamically added by
476 * USB links or PCI plugin cards.
478 * When this returns zero, a new bus number was allocated and stored
479 * in adap->nr, and the specified adapter became available for clients.
480 * Otherwise, a negative errno value is returned.
482 int i2c_add_adapter(struct i2c_adapter *adapter)
487 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
490 mutex_lock(&core_lock);
491 /* "above" here means "above or equal to", sigh */
492 res = idr_get_new_above(&i2c_adapter_idr, adapter,
493 __i2c_first_dynamic_bus_num, &id);
494 mutex_unlock(&core_lock);
503 return i2c_register_adapter(adapter);
505 EXPORT_SYMBOL(i2c_add_adapter);
508 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
509 * @adap: the adapter to register (with adap->nr initialized)
512 * This routine is used to declare an I2C adapter when its bus number
513 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
514 * or otherwise built in to the system's mainboard, and where i2c_board_info
515 * is used to properly configure I2C devices.
517 * If no devices have pre-been declared for this bus, then be sure to
518 * register the adapter before any dynamically allocated ones. Otherwise
519 * the required bus ID may not be available.
521 * When this returns zero, the specified adapter became available for
522 * clients using the bus number provided in adap->nr. Also, the table
523 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
524 * and the appropriate driver model device nodes are created. Otherwise, a
525 * negative errno value is returned.
527 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
532 if (adap->nr & ~MAX_ID_MASK)
536 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
539 mutex_lock(&core_lock);
540 /* "above" here means "above or equal to", sigh;
541 * we need the "equal to" result to force the result
543 status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
544 if (status == 0 && id != adap->nr) {
546 idr_remove(&i2c_adapter_idr, id);
548 mutex_unlock(&core_lock);
549 if (status == -EAGAIN)
553 status = i2c_register_adapter(adap);
556 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
558 static int i2c_do_del_adapter(struct device_driver *d, void *data)
560 struct i2c_driver *driver = to_i2c_driver(d);
561 struct i2c_adapter *adapter = data;
564 if (!driver->detach_adapter)
566 res = driver->detach_adapter(adapter);
568 dev_err(&adapter->dev, "detach_adapter failed (%d) "
569 "for driver [%s]\n", res, driver->driver.name);
574 * i2c_del_adapter - unregister I2C adapter
575 * @adap: the adapter being unregistered
578 * This unregisters an I2C adapter which was previously registered
579 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
581 int i2c_del_adapter(struct i2c_adapter *adap)
583 struct i2c_client *client, *_n;
586 mutex_lock(&core_lock);
588 /* First make sure that this adapter was ever added */
589 if (idr_find(&i2c_adapter_idr, adap->nr) != adap) {
590 pr_debug("i2c-core: attempting to delete unregistered "
591 "adapter [%s]\n", adap->name);
596 /* Tell drivers about this removal */
597 res = bus_for_each_drv(&i2c_bus_type, NULL, adap,
602 /* detach any active clients. This must be done first, because
603 * it can fail; in which case we give up. */
604 list_for_each_entry_safe(client, _n, &adap->clients, list) {
605 struct i2c_driver *driver;
607 driver = client->driver;
609 /* new style, follow standard driver model */
610 if (!driver || is_newstyle_driver(driver)) {
611 i2c_unregister_device(client);
615 /* legacy drivers create and remove clients themselves */
616 if ((res = driver->detach_client(client))) {
617 dev_err(&adap->dev, "detach_client failed for client "
618 "[%s] at address 0x%02x\n", client->name,
624 /* clean up the sysfs representation */
625 init_completion(&adap->dev_released);
626 device_unregister(&adap->dev);
628 /* wait for sysfs to drop all references */
629 wait_for_completion(&adap->dev_released);
632 idr_remove(&i2c_adapter_idr, adap->nr);
634 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
637 mutex_unlock(&core_lock);
640 EXPORT_SYMBOL(i2c_del_adapter);
643 /* ------------------------------------------------------------------------- */
645 static int __attach_adapter(struct device *dev, void *data)
647 struct i2c_adapter *adapter = to_i2c_adapter(dev);
648 struct i2c_driver *driver = data;
650 driver->attach_adapter(adapter);
656 * An i2c_driver is used with one or more i2c_client (device) nodes to access
657 * i2c slave chips, on a bus instance associated with some i2c_adapter. There
658 * are two models for binding the driver to its device: "new style" drivers
659 * follow the standard Linux driver model and just respond to probe() calls
660 * issued if the driver core sees they match(); "legacy" drivers create device
664 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
668 /* new style driver methods can't mix with legacy ones */
669 if (is_newstyle_driver(driver)) {
670 if (driver->attach_adapter || driver->detach_adapter
671 || driver->detach_client) {
673 "i2c-core: driver [%s] is confused\n",
674 driver->driver.name);
679 /* add the driver to the list of i2c drivers in the driver core */
680 driver->driver.owner = owner;
681 driver->driver.bus = &i2c_bus_type;
683 /* for new style drivers, when registration returns the driver core
684 * will have called probe() for all matching-but-unbound devices.
686 res = driver_register(&driver->driver);
690 mutex_lock(&core_lock);
692 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
694 /* legacy drivers scan i2c busses directly */
695 if (driver->attach_adapter)
696 class_for_each_device(&i2c_adapter_class, driver,
699 mutex_unlock(&core_lock);
702 EXPORT_SYMBOL(i2c_register_driver);
704 static int __detach_adapter(struct device *dev, void *data)
706 struct i2c_adapter *adapter = to_i2c_adapter(dev);
707 struct i2c_driver *driver = data;
709 /* Have a look at each adapter, if clients of this driver are still
710 * attached. If so, detach them to be able to kill the driver
713 if (driver->detach_adapter) {
714 if (driver->detach_adapter(adapter))
715 dev_err(&adapter->dev,
716 "detach_adapter failed for driver [%s]\n",
717 driver->driver.name);
719 struct i2c_client *client, *_n;
721 list_for_each_entry_safe(client, _n, &adapter->clients, list) {
722 if (client->driver != driver)
724 dev_dbg(&adapter->dev,
725 "detaching client [%s] at 0x%02x\n",
726 client->name, client->addr);
727 if (driver->detach_client(client))
728 dev_err(&adapter->dev, "detach_client "
729 "failed for client [%s] at 0x%02x\n",
730 client->name, client->addr);
738 * i2c_del_driver - unregister I2C driver
739 * @driver: the driver being unregistered
742 void i2c_del_driver(struct i2c_driver *driver)
744 mutex_lock(&core_lock);
747 if (!is_newstyle_driver(driver))
748 class_for_each_device(&i2c_adapter_class, driver,
751 driver_unregister(&driver->driver);
752 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
754 mutex_unlock(&core_lock);
756 EXPORT_SYMBOL(i2c_del_driver);
758 /* ------------------------------------------------------------------------- */
760 static int __i2c_check_addr(struct device *dev, void *addrp)
762 struct i2c_client *client = i2c_verify_client(dev);
763 int addr = *(int *)addrp;
765 if (client && client->addr == addr)
770 static int i2c_check_addr(struct i2c_adapter *adapter, int addr)
772 return device_for_each_child(&adapter->dev, &addr, __i2c_check_addr);
775 int i2c_attach_client(struct i2c_client *client)
777 struct i2c_adapter *adapter = client->adapter;
780 client->dev.parent = &client->adapter->dev;
781 client->dev.bus = &i2c_bus_type;
784 client->dev.driver = &client->driver->driver;
786 if (client->driver && !is_newstyle_driver(client->driver)) {
787 client->dev.release = i2c_client_release;
788 client->dev.uevent_suppress = 1;
790 client->dev.release = i2c_client_dev_release;
792 snprintf(&client->dev.bus_id[0], sizeof(client->dev.bus_id),
793 "%d-%04x", i2c_adapter_id(adapter), client->addr);
794 res = device_register(&client->dev);
798 mutex_lock(&adapter->clist_lock);
799 list_add_tail(&client->list, &adapter->clients);
800 mutex_unlock(&adapter->clist_lock);
802 dev_dbg(&adapter->dev, "client [%s] registered with bus id %s\n",
803 client->name, client->dev.bus_id);
805 if (adapter->client_register) {
806 if (adapter->client_register(client)) {
807 dev_dbg(&adapter->dev, "client_register "
808 "failed for client [%s] at 0x%02x\n",
809 client->name, client->addr);
816 dev_err(&adapter->dev, "Failed to attach i2c client %s at 0x%02x "
817 "(%d)\n", client->name, client->addr, res);
820 EXPORT_SYMBOL(i2c_attach_client);
822 int i2c_detach_client(struct i2c_client *client)
824 struct i2c_adapter *adapter = client->adapter;
827 if (adapter->client_unregister) {
828 res = adapter->client_unregister(client);
830 dev_err(&client->dev,
831 "client_unregister [%s] failed, "
832 "client not detached\n", client->name);
837 mutex_lock(&adapter->clist_lock);
838 list_del(&client->list);
839 mutex_unlock(&adapter->clist_lock);
841 init_completion(&client->released);
842 device_unregister(&client->dev);
843 wait_for_completion(&client->released);
848 EXPORT_SYMBOL(i2c_detach_client);
851 * i2c_use_client - increments the reference count of the i2c client structure
852 * @client: the client being referenced
854 * Each live reference to a client should be refcounted. The driver model does
855 * that automatically as part of driver binding, so that most drivers don't
856 * need to do this explicitly: they hold a reference until they're unbound
859 * A pointer to the client with the incremented reference counter is returned.
861 struct i2c_client *i2c_use_client(struct i2c_client *client)
863 if (client && get_device(&client->dev))
867 EXPORT_SYMBOL(i2c_use_client);
870 * i2c_release_client - release a use of the i2c client structure
871 * @client: the client being no longer referenced
873 * Must be called when a user of a client is finished with it.
875 void i2c_release_client(struct i2c_client *client)
878 put_device(&client->dev);
880 EXPORT_SYMBOL(i2c_release_client);
887 static int i2c_cmd(struct device *dev, void *_arg)
889 struct i2c_client *client = i2c_verify_client(dev);
890 struct i2c_cmd_arg *arg = _arg;
892 if (client && client->driver && client->driver->command)
893 client->driver->command(client, arg->cmd, arg->arg);
897 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
899 struct i2c_cmd_arg cmd_arg;
903 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
905 EXPORT_SYMBOL(i2c_clients_command);
907 static int __init i2c_init(void)
911 retval = bus_register(&i2c_bus_type);
914 retval = class_register(&i2c_adapter_class);
917 retval = i2c_add_driver(&dummy_driver);
923 class_unregister(&i2c_adapter_class);
925 bus_unregister(&i2c_bus_type);
929 static void __exit i2c_exit(void)
931 i2c_del_driver(&dummy_driver);
932 class_unregister(&i2c_adapter_class);
933 bus_unregister(&i2c_bus_type);
936 subsys_initcall(i2c_init);
937 module_exit(i2c_exit);
939 /* ----------------------------------------------------
940 * the functional interface to the i2c busses.
941 * ----------------------------------------------------
945 * i2c_transfer - execute a single or combined I2C message
946 * @adap: Handle to I2C bus
947 * @msgs: One or more messages to execute before STOP is issued to
948 * terminate the operation; each message begins with a START.
949 * @num: Number of messages to be executed.
951 * Returns negative errno, else the number of messages executed.
953 * Note that there is no requirement that each message be sent to
954 * the same slave address, although that is the most common model.
956 int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num)
960 /* REVISIT the fault reporting model here is weak:
962 * - When we get an error after receiving N bytes from a slave,
963 * there is no way to report "N".
965 * - When we get a NAK after transmitting N bytes to a slave,
966 * there is no way to report "N" ... or to let the master
967 * continue executing the rest of this combined message, if
968 * that's the appropriate response.
970 * - When for example "num" is two and we successfully complete
971 * the first message but get an error part way through the
972 * second, it's unclear whether that should be reported as
973 * one (discarding status on the second message) or errno
974 * (discarding status on the first one).
977 if (adap->algo->master_xfer) {
979 for (ret = 0; ret < num; ret++) {
980 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
981 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
982 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
983 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
987 if (in_atomic() || irqs_disabled()) {
988 ret = mutex_trylock(&adap->bus_lock);
990 /* I2C activity is ongoing. */
993 mutex_lock_nested(&adap->bus_lock, adap->level);
996 ret = adap->algo->master_xfer(adap,msgs,num);
997 mutex_unlock(&adap->bus_lock);
1001 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
1005 EXPORT_SYMBOL(i2c_transfer);
1008 * i2c_master_send - issue a single I2C message in master transmit mode
1009 * @client: Handle to slave device
1010 * @buf: Data that will be written to the slave
1011 * @count: How many bytes to write
1013 * Returns negative errno, or else the number of bytes written.
1015 int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
1018 struct i2c_adapter *adap=client->adapter;
1021 msg.addr = client->addr;
1022 msg.flags = client->flags & I2C_M_TEN;
1024 msg.buf = (char *)buf;
1026 ret = i2c_transfer(adap, &msg, 1);
1028 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1029 transmitted, else error code. */
1030 return (ret == 1) ? count : ret;
1032 EXPORT_SYMBOL(i2c_master_send);
1035 * i2c_master_recv - issue a single I2C message in master receive mode
1036 * @client: Handle to slave device
1037 * @buf: Where to store data read from slave
1038 * @count: How many bytes to read
1040 * Returns negative errno, or else the number of bytes read.
1042 int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
1044 struct i2c_adapter *adap=client->adapter;
1048 msg.addr = client->addr;
1049 msg.flags = client->flags & I2C_M_TEN;
1050 msg.flags |= I2C_M_RD;
1054 ret = i2c_transfer(adap, &msg, 1);
1056 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1057 transmitted, else error code. */
1058 return (ret == 1) ? count : ret;
1060 EXPORT_SYMBOL(i2c_master_recv);
1062 /* ----------------------------------------------------
1063 * the i2c address scanning function
1064 * Will not work for 10-bit addresses!
1065 * ----------------------------------------------------
1067 static int i2c_probe_address(struct i2c_adapter *adapter, int addr, int kind,
1068 int (*found_proc) (struct i2c_adapter *, int, int))
1072 /* Make sure the address is valid */
1073 if (addr < 0x03 || addr > 0x77) {
1074 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1079 /* Skip if already in use */
1080 if (i2c_check_addr(adapter, addr))
1083 /* Make sure there is something at this address, unless forced */
1085 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1086 I2C_SMBUS_QUICK, NULL) < 0)
1089 /* prevent 24RF08 corruption */
1090 if ((addr & ~0x0f) == 0x50)
1091 i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1092 I2C_SMBUS_QUICK, NULL);
1095 /* Finally call the custom detection function */
1096 err = found_proc(adapter, addr, kind);
1097 /* -ENODEV can be returned if there is a chip at the given address
1098 but it isn't supported by this chip driver. We catch it here as
1099 this isn't an error. */
1104 dev_warn(&adapter->dev, "Client creation failed at 0x%x (%d)\n",
1109 int i2c_probe(struct i2c_adapter *adapter,
1110 const struct i2c_client_address_data *address_data,
1111 int (*found_proc) (struct i2c_adapter *, int, int))
1114 int adap_id = i2c_adapter_id(adapter);
1116 /* Force entries are done first, and are not affected by ignore
1118 if (address_data->forces) {
1119 const unsigned short * const *forces = address_data->forces;
1122 for (kind = 0; forces[kind]; kind++) {
1123 for (i = 0; forces[kind][i] != I2C_CLIENT_END;
1125 if (forces[kind][i] == adap_id
1126 || forces[kind][i] == ANY_I2C_BUS) {
1127 dev_dbg(&adapter->dev, "found force "
1128 "parameter for adapter %d, "
1129 "addr 0x%02x, kind %d\n",
1130 adap_id, forces[kind][i + 1],
1132 err = i2c_probe_address(adapter,
1133 forces[kind][i + 1],
1142 /* Stop here if we can't use SMBUS_QUICK */
1143 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
1144 if (address_data->probe[0] == I2C_CLIENT_END
1145 && address_data->normal_i2c[0] == I2C_CLIENT_END)
1148 dev_warn(&adapter->dev, "SMBus Quick command not supported, "
1149 "can't probe for chips\n");
1153 /* Probe entries are done second, and are not affected by ignore
1155 for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
1156 if (address_data->probe[i] == adap_id
1157 || address_data->probe[i] == ANY_I2C_BUS) {
1158 dev_dbg(&adapter->dev, "found probe parameter for "
1159 "adapter %d, addr 0x%02x\n", adap_id,
1160 address_data->probe[i + 1]);
1161 err = i2c_probe_address(adapter,
1162 address_data->probe[i + 1],
1169 /* Normal entries are done last, unless shadowed by an ignore entry */
1170 for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
1174 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
1176 if ((address_data->ignore[j] == adap_id ||
1177 address_data->ignore[j] == ANY_I2C_BUS)
1178 && address_data->ignore[j + 1]
1179 == address_data->normal_i2c[i]) {
1180 dev_dbg(&adapter->dev, "found ignore "
1181 "parameter for adapter %d, "
1182 "addr 0x%02x\n", adap_id,
1183 address_data->ignore[j + 1]);
1191 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1192 "addr 0x%02x\n", adap_id,
1193 address_data->normal_i2c[i]);
1194 err = i2c_probe_address(adapter, address_data->normal_i2c[i],
1202 EXPORT_SYMBOL(i2c_probe);
1205 i2c_new_probed_device(struct i2c_adapter *adap,
1206 struct i2c_board_info *info,
1207 unsigned short const *addr_list)
1211 /* Stop here if the bus doesn't support probing */
1212 if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE)) {
1213 dev_err(&adap->dev, "Probing not supported\n");
1217 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1218 /* Check address validity */
1219 if (addr_list[i] < 0x03 || addr_list[i] > 0x77) {
1220 dev_warn(&adap->dev, "Invalid 7-bit address "
1221 "0x%02x\n", addr_list[i]);
1225 /* Check address availability */
1226 if (i2c_check_addr(adap, addr_list[i])) {
1227 dev_dbg(&adap->dev, "Address 0x%02x already in "
1228 "use, not probing\n", addr_list[i]);
1232 /* Test address responsiveness
1233 The default probe method is a quick write, but it is known
1234 to corrupt the 24RF08 EEPROMs due to a state machine bug,
1235 and could also irreversibly write-protect some EEPROMs, so
1236 for address ranges 0x30-0x37 and 0x50-0x5f, we use a byte
1237 read instead. Also, some bus drivers don't implement
1238 quick write, so we fallback to a byte read it that case
1240 if ((addr_list[i] & ~0x07) == 0x30
1241 || (addr_list[i] & ~0x0f) == 0x50
1242 || !i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK)) {
1243 if (i2c_smbus_xfer(adap, addr_list[i], 0,
1245 I2C_SMBUS_BYTE, NULL) >= 0)
1248 if (i2c_smbus_xfer(adap, addr_list[i], 0,
1250 I2C_SMBUS_QUICK, NULL) >= 0)
1255 if (addr_list[i] == I2C_CLIENT_END) {
1256 dev_dbg(&adap->dev, "Probing failed, no device found\n");
1260 info->addr = addr_list[i];
1261 return i2c_new_device(adap, info);
1263 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1265 struct i2c_adapter* i2c_get_adapter(int id)
1267 struct i2c_adapter *adapter;
1269 mutex_lock(&core_lock);
1270 adapter = (struct i2c_adapter *)idr_find(&i2c_adapter_idr, id);
1271 if (adapter && !try_module_get(adapter->owner))
1274 mutex_unlock(&core_lock);
1277 EXPORT_SYMBOL(i2c_get_adapter);
1279 void i2c_put_adapter(struct i2c_adapter *adap)
1281 module_put(adap->owner);
1283 EXPORT_SYMBOL(i2c_put_adapter);
1285 /* The SMBus parts */
1287 #define POLY (0x1070U << 3)
1293 for(i = 0; i < 8; i++) {
1298 return (u8)(data >> 8);
1301 /* Incremental CRC8 over count bytes in the array pointed to by p */
1302 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
1306 for(i = 0; i < count; i++)
1307 crc = crc8((crc ^ p[i]) << 8);
1311 /* Assume a 7-bit address, which is reasonable for SMBus */
1312 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
1314 /* The address will be sent first */
1315 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1316 pec = i2c_smbus_pec(pec, &addr, 1);
1318 /* The data buffer follows */
1319 return i2c_smbus_pec(pec, msg->buf, msg->len);
1322 /* Used for write only transactions */
1323 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
1325 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1329 /* Return <0 on CRC error
1330 If there was a write before this read (most cases) we need to take the
1331 partial CRC from the write part into account.
1332 Note that this function does modify the message (we need to decrease the
1333 message length to hide the CRC byte from the caller). */
1334 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
1336 u8 rpec = msg->buf[--msg->len];
1337 cpec = i2c_smbus_msg_pec(cpec, msg);
1340 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1348 * i2c_smbus_read_byte - SMBus "receive byte" protocol
1349 * @client: Handle to slave device
1351 * This executes the SMBus "receive byte" protocol, returning negative errno
1352 * else the byte received from the device.
1354 s32 i2c_smbus_read_byte(struct i2c_client *client)
1356 union i2c_smbus_data data;
1359 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1361 I2C_SMBUS_BYTE, &data);
1362 return (status < 0) ? status : data.byte;
1364 EXPORT_SYMBOL(i2c_smbus_read_byte);
1367 * i2c_smbus_write_byte - SMBus "send byte" protocol
1368 * @client: Handle to slave device
1369 * @value: Byte to be sent
1371 * This executes the SMBus "send byte" protocol, returning negative errno
1372 * else zero on success.
1374 s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
1376 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1377 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
1379 EXPORT_SYMBOL(i2c_smbus_write_byte);
1382 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
1383 * @client: Handle to slave device
1384 * @command: Byte interpreted by slave
1386 * This executes the SMBus "read byte" protocol, returning negative errno
1387 * else a data byte received from the device.
1389 s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
1391 union i2c_smbus_data data;
1394 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1395 I2C_SMBUS_READ, command,
1396 I2C_SMBUS_BYTE_DATA, &data);
1397 return (status < 0) ? status : data.byte;
1399 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1402 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
1403 * @client: Handle to slave device
1404 * @command: Byte interpreted by slave
1405 * @value: Byte being written
1407 * This executes the SMBus "write byte" protocol, returning negative errno
1408 * else zero on success.
1410 s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
1412 union i2c_smbus_data data;
1414 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1415 I2C_SMBUS_WRITE,command,
1416 I2C_SMBUS_BYTE_DATA,&data);
1418 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1421 * i2c_smbus_read_word_data - SMBus "read word" protocol
1422 * @client: Handle to slave device
1423 * @command: Byte interpreted by slave
1425 * This executes the SMBus "read word" protocol, returning negative errno
1426 * else a 16-bit unsigned "word" received from the device.
1428 s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
1430 union i2c_smbus_data data;
1433 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1434 I2C_SMBUS_READ, command,
1435 I2C_SMBUS_WORD_DATA, &data);
1436 return (status < 0) ? status : data.word;
1438 EXPORT_SYMBOL(i2c_smbus_read_word_data);
1441 * i2c_smbus_write_word_data - SMBus "write word" protocol
1442 * @client: Handle to slave device
1443 * @command: Byte interpreted by slave
1444 * @value: 16-bit "word" being written
1446 * This executes the SMBus "write word" protocol, returning negative errno
1447 * else zero on success.
1449 s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
1451 union i2c_smbus_data data;
1453 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1454 I2C_SMBUS_WRITE,command,
1455 I2C_SMBUS_WORD_DATA,&data);
1457 EXPORT_SYMBOL(i2c_smbus_write_word_data);
1460 * i2c_smbus_read_block_data - SMBus "block read" protocol
1461 * @client: Handle to slave device
1462 * @command: Byte interpreted by slave
1463 * @values: Byte array into which data will be read; big enough to hold
1464 * the data returned by the slave. SMBus allows at most 32 bytes.
1466 * This executes the SMBus "block read" protocol, returning negative errno
1467 * else the number of data bytes in the slave's response.
1469 * Note that using this function requires that the client's adapter support
1470 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
1471 * support this; its emulation through I2C messaging relies on a specific
1472 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
1474 s32 i2c_smbus_read_block_data(struct i2c_client *client, u8 command,
1477 union i2c_smbus_data data;
1480 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1481 I2C_SMBUS_READ, command,
1482 I2C_SMBUS_BLOCK_DATA, &data);
1486 memcpy(values, &data.block[1], data.block[0]);
1487 return data.block[0];
1489 EXPORT_SYMBOL(i2c_smbus_read_block_data);
1492 * i2c_smbus_write_block_data - SMBus "block write" protocol
1493 * @client: Handle to slave device
1494 * @command: Byte interpreted by slave
1495 * @length: Size of data block; SMBus allows at most 32 bytes
1496 * @values: Byte array which will be written.
1498 * This executes the SMBus "block write" protocol, returning negative errno
1499 * else zero on success.
1501 s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
1502 u8 length, const u8 *values)
1504 union i2c_smbus_data data;
1506 if (length > I2C_SMBUS_BLOCK_MAX)
1507 length = I2C_SMBUS_BLOCK_MAX;
1508 data.block[0] = length;
1509 memcpy(&data.block[1], values, length);
1510 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1511 I2C_SMBUS_WRITE,command,
1512 I2C_SMBUS_BLOCK_DATA,&data);
1514 EXPORT_SYMBOL(i2c_smbus_write_block_data);
1516 /* Returns the number of read bytes */
1517 s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command,
1518 u8 length, u8 *values)
1520 union i2c_smbus_data data;
1523 if (length > I2C_SMBUS_BLOCK_MAX)
1524 length = I2C_SMBUS_BLOCK_MAX;
1525 data.block[0] = length;
1526 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1527 I2C_SMBUS_READ, command,
1528 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1532 memcpy(values, &data.block[1], data.block[0]);
1533 return data.block[0];
1535 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1537 s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, u8 command,
1538 u8 length, const u8 *values)
1540 union i2c_smbus_data data;
1542 if (length > I2C_SMBUS_BLOCK_MAX)
1543 length = I2C_SMBUS_BLOCK_MAX;
1544 data.block[0] = length;
1545 memcpy(data.block + 1, values, length);
1546 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1547 I2C_SMBUS_WRITE, command,
1548 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1550 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
1552 /* Simulate a SMBus command using the i2c protocol
1553 No checking of parameters is done! */
1554 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
1555 unsigned short flags,
1556 char read_write, u8 command, int size,
1557 union i2c_smbus_data * data)
1559 /* So we need to generate a series of msgs. In the case of writing, we
1560 need to use only one message; when reading, we need two. We initialize
1561 most things with sane defaults, to keep the code below somewhat
1563 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1564 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
1565 int num = read_write == I2C_SMBUS_READ?2:1;
1566 struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
1567 { addr, flags | I2C_M_RD, 0, msgbuf1 }
1573 msgbuf0[0] = command;
1575 case I2C_SMBUS_QUICK:
1577 /* Special case: The read/write field is used as data */
1578 msg[0].flags = flags | (read_write==I2C_SMBUS_READ)?I2C_M_RD:0;
1581 case I2C_SMBUS_BYTE:
1582 if (read_write == I2C_SMBUS_READ) {
1583 /* Special case: only a read! */
1584 msg[0].flags = I2C_M_RD | flags;
1588 case I2C_SMBUS_BYTE_DATA:
1589 if (read_write == I2C_SMBUS_READ)
1593 msgbuf0[1] = data->byte;
1596 case I2C_SMBUS_WORD_DATA:
1597 if (read_write == I2C_SMBUS_READ)
1601 msgbuf0[1] = data->word & 0xff;
1602 msgbuf0[2] = data->word >> 8;
1605 case I2C_SMBUS_PROC_CALL:
1606 num = 2; /* Special case */
1607 read_write = I2C_SMBUS_READ;
1610 msgbuf0[1] = data->word & 0xff;
1611 msgbuf0[2] = data->word >> 8;
1613 case I2C_SMBUS_BLOCK_DATA:
1614 if (read_write == I2C_SMBUS_READ) {
1615 msg[1].flags |= I2C_M_RECV_LEN;
1616 msg[1].len = 1; /* block length will be added by
1617 the underlying bus driver */
1619 msg[0].len = data->block[0] + 2;
1620 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
1621 dev_err(&adapter->dev,
1622 "Invalid block write size %d\n",
1626 for (i = 1; i < msg[0].len; i++)
1627 msgbuf0[i] = data->block[i-1];
1630 case I2C_SMBUS_BLOCK_PROC_CALL:
1631 num = 2; /* Another special case */
1632 read_write = I2C_SMBUS_READ;
1633 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
1634 dev_err(&adapter->dev,
1635 "Invalid block write size %d\n",
1639 msg[0].len = data->block[0] + 2;
1640 for (i = 1; i < msg[0].len; i++)
1641 msgbuf0[i] = data->block[i-1];
1642 msg[1].flags |= I2C_M_RECV_LEN;
1643 msg[1].len = 1; /* block length will be added by
1644 the underlying bus driver */
1646 case I2C_SMBUS_I2C_BLOCK_DATA:
1647 if (read_write == I2C_SMBUS_READ) {
1648 msg[1].len = data->block[0];
1650 msg[0].len = data->block[0] + 1;
1651 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
1652 dev_err(&adapter->dev,
1653 "Invalid block write size %d\n",
1657 for (i = 1; i <= data->block[0]; i++)
1658 msgbuf0[i] = data->block[i];
1662 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
1666 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
1667 && size != I2C_SMBUS_I2C_BLOCK_DATA);
1669 /* Compute PEC if first message is a write */
1670 if (!(msg[0].flags & I2C_M_RD)) {
1671 if (num == 1) /* Write only */
1672 i2c_smbus_add_pec(&msg[0]);
1673 else /* Write followed by read */
1674 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
1676 /* Ask for PEC if last message is a read */
1677 if (msg[num-1].flags & I2C_M_RD)
1681 status = i2c_transfer(adapter, msg, num);
1685 /* Check PEC if last message is a read */
1686 if (i && (msg[num-1].flags & I2C_M_RD)) {
1687 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
1692 if (read_write == I2C_SMBUS_READ)
1694 case I2C_SMBUS_BYTE:
1695 data->byte = msgbuf0[0];
1697 case I2C_SMBUS_BYTE_DATA:
1698 data->byte = msgbuf1[0];
1700 case I2C_SMBUS_WORD_DATA:
1701 case I2C_SMBUS_PROC_CALL:
1702 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
1704 case I2C_SMBUS_I2C_BLOCK_DATA:
1705 for (i = 0; i < data->block[0]; i++)
1706 data->block[i+1] = msgbuf1[i];
1708 case I2C_SMBUS_BLOCK_DATA:
1709 case I2C_SMBUS_BLOCK_PROC_CALL:
1710 for (i = 0; i < msgbuf1[0] + 1; i++)
1711 data->block[i] = msgbuf1[i];
1718 * i2c_smbus_xfer - execute SMBus protocol operations
1719 * @adapter: Handle to I2C bus
1720 * @addr: Address of SMBus slave on that bus
1721 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
1722 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
1723 * @command: Byte interpreted by slave, for protocols which use such bytes
1724 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
1725 * @data: Data to be read or written
1727 * This executes an SMBus protocol operation, and returns a negative
1728 * errno code else zero on success.
1730 s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u16 addr, unsigned short flags,
1731 char read_write, u8 command, int protocol,
1732 union i2c_smbus_data * data)
1736 flags &= I2C_M_TEN | I2C_CLIENT_PEC;
1738 if (adapter->algo->smbus_xfer) {
1739 mutex_lock(&adapter->bus_lock);
1740 res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write,
1741 command, protocol, data);
1742 mutex_unlock(&adapter->bus_lock);
1744 res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
1745 command, protocol, data);
1749 EXPORT_SYMBOL(i2c_smbus_xfer);
1751 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
1752 MODULE_DESCRIPTION("I2C-Bus main module");
1753 MODULE_LICENSE("GPL");