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);
106 if (!driver->probe || !driver->id_table)
108 client->driver = driver;
109 dev_dbg(dev, "probe\n");
111 status = driver->probe(client, i2c_match_id(driver->id_table, client));
113 client->driver = NULL;
117 static int i2c_device_remove(struct device *dev)
119 struct i2c_client *client = to_i2c_client(dev);
120 struct i2c_driver *driver;
126 driver = to_i2c_driver(dev->driver);
127 if (driver->remove) {
128 dev_dbg(dev, "remove\n");
129 status = driver->remove(client);
135 client->driver = NULL;
139 static void i2c_device_shutdown(struct device *dev)
141 struct i2c_driver *driver;
145 driver = to_i2c_driver(dev->driver);
146 if (driver->shutdown)
147 driver->shutdown(to_i2c_client(dev));
150 static int i2c_device_suspend(struct device * dev, pm_message_t mesg)
152 struct i2c_driver *driver;
156 driver = to_i2c_driver(dev->driver);
157 if (!driver->suspend)
159 return driver->suspend(to_i2c_client(dev), mesg);
162 static int i2c_device_resume(struct device * dev)
164 struct i2c_driver *driver;
168 driver = to_i2c_driver(dev->driver);
171 return driver->resume(to_i2c_client(dev));
174 static void i2c_client_release(struct device *dev)
176 struct i2c_client *client = to_i2c_client(dev);
177 complete(&client->released);
180 static void i2c_client_dev_release(struct device *dev)
182 kfree(to_i2c_client(dev));
185 static ssize_t show_client_name(struct device *dev, struct device_attribute *attr, char *buf)
187 struct i2c_client *client = to_i2c_client(dev);
188 return sprintf(buf, "%s\n", client->name);
191 static ssize_t show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
193 struct i2c_client *client = to_i2c_client(dev);
194 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
197 static struct device_attribute i2c_dev_attrs[] = {
198 __ATTR(name, S_IRUGO, show_client_name, NULL),
199 /* modalias helps coldplug: modprobe $(cat .../modalias) */
200 __ATTR(modalias, S_IRUGO, show_modalias, NULL),
204 struct bus_type i2c_bus_type = {
206 .dev_attrs = i2c_dev_attrs,
207 .match = i2c_device_match,
208 .uevent = i2c_device_uevent,
209 .probe = i2c_device_probe,
210 .remove = i2c_device_remove,
211 .shutdown = i2c_device_shutdown,
212 .suspend = i2c_device_suspend,
213 .resume = i2c_device_resume,
215 EXPORT_SYMBOL_GPL(i2c_bus_type);
219 * i2c_verify_client - return parameter as i2c_client, or NULL
220 * @dev: device, probably from some driver model iterator
222 * When traversing the driver model tree, perhaps using driver model
223 * iterators like @device_for_each_child(), you can't assume very much
224 * about the nodes you find. Use this function to avoid oopses caused
225 * by wrongly treating some non-I2C device as an i2c_client.
227 struct i2c_client *i2c_verify_client(struct device *dev)
229 return (dev->bus == &i2c_bus_type)
233 EXPORT_SYMBOL(i2c_verify_client);
237 * i2c_new_device - instantiate an i2c device for use with a new style driver
238 * @adap: the adapter managing the device
239 * @info: describes one I2C device; bus_num is ignored
242 * Create a device to work with a new style i2c driver, where binding is
243 * handled through driver model probe()/remove() methods. This call is not
244 * appropriate for use by mainboad initialization logic, which usually runs
245 * during an arch_initcall() long before any i2c_adapter could exist.
247 * This returns the new i2c client, which may be saved for later use with
248 * i2c_unregister_device(); or NULL to indicate an error.
251 i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
253 struct i2c_client *client;
256 client = kzalloc(sizeof *client, GFP_KERNEL);
260 client->adapter = adap;
262 client->dev.platform_data = info->platform_data;
263 device_init_wakeup(&client->dev, info->flags & I2C_CLIENT_WAKE);
265 client->flags = info->flags & ~I2C_CLIENT_WAKE;
266 client->addr = info->addr;
267 client->irq = info->irq;
269 strlcpy(client->name, info->type, sizeof(client->name));
271 /* a new style driver may be bound to this device when we
272 * return from this function, or any later moment (e.g. maybe
273 * hotplugging will load the driver module). and the device
274 * refcount model is the standard driver model one.
276 status = i2c_attach_client(client);
283 EXPORT_SYMBOL_GPL(i2c_new_device);
287 * i2c_unregister_device - reverse effect of i2c_new_device()
288 * @client: value returned from i2c_new_device()
291 void i2c_unregister_device(struct i2c_client *client)
293 struct i2c_adapter *adapter = client->adapter;
294 struct i2c_driver *driver = client->driver;
296 if (driver && !is_newstyle_driver(driver)) {
297 dev_err(&client->dev, "can't unregister devices "
298 "with legacy drivers\n");
303 mutex_lock(&adapter->clist_lock);
304 list_del(&client->list);
305 mutex_unlock(&adapter->clist_lock);
307 device_unregister(&client->dev);
309 EXPORT_SYMBOL_GPL(i2c_unregister_device);
312 static const struct i2c_device_id dummy_id[] = {
317 static int dummy_probe(struct i2c_client *client,
318 const struct i2c_device_id *id)
323 static int dummy_remove(struct i2c_client *client)
328 static struct i2c_driver dummy_driver = {
329 .driver.name = "dummy",
330 .probe = dummy_probe,
331 .remove = dummy_remove,
332 .id_table = dummy_id,
336 * i2c_new_dummy - return a new i2c device bound to a dummy driver
337 * @adapter: the adapter managing the device
338 * @address: seven bit address to be used
341 * This returns an I2C client bound to the "dummy" driver, intended for use
342 * with devices that consume multiple addresses. Examples of such chips
343 * include various EEPROMS (like 24c04 and 24c08 models).
345 * These dummy devices have two main uses. First, most I2C and SMBus calls
346 * except i2c_transfer() need a client handle; the dummy will be that handle.
347 * And second, this prevents the specified address from being bound to a
350 * This returns the new i2c client, which should be saved for later use with
351 * i2c_unregister_device(); or NULL to indicate an error.
354 i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
356 struct i2c_board_info info = {
357 I2C_BOARD_INFO("dummy", address),
360 return i2c_new_device(adapter, &info);
362 EXPORT_SYMBOL_GPL(i2c_new_dummy);
364 /* ------------------------------------------------------------------------- */
366 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
368 static void i2c_adapter_dev_release(struct device *dev)
370 struct i2c_adapter *adap = to_i2c_adapter(dev);
371 complete(&adap->dev_released);
375 show_adapter_name(struct device *dev, struct device_attribute *attr, char *buf)
377 struct i2c_adapter *adap = to_i2c_adapter(dev);
378 return sprintf(buf, "%s\n", adap->name);
381 static struct device_attribute i2c_adapter_attrs[] = {
382 __ATTR(name, S_IRUGO, show_adapter_name, NULL),
386 static struct class i2c_adapter_class = {
387 .owner = THIS_MODULE,
388 .name = "i2c-adapter",
389 .dev_attrs = i2c_adapter_attrs,
392 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
394 struct i2c_devinfo *devinfo;
396 mutex_lock(&__i2c_board_lock);
397 list_for_each_entry(devinfo, &__i2c_board_list, list) {
398 if (devinfo->busnum == adapter->nr
399 && !i2c_new_device(adapter,
400 &devinfo->board_info))
401 printk(KERN_ERR "i2c-core: can't create i2c%d-%04x\n",
402 i2c_adapter_id(adapter),
403 devinfo->board_info.addr);
405 mutex_unlock(&__i2c_board_lock);
408 static int i2c_do_add_adapter(struct device_driver *d, void *data)
410 struct i2c_driver *driver = to_i2c_driver(d);
411 struct i2c_adapter *adap = data;
413 if (driver->attach_adapter) {
414 /* We ignore the return code; if it fails, too bad */
415 driver->attach_adapter(adap);
420 static int i2c_register_adapter(struct i2c_adapter *adap)
424 mutex_init(&adap->bus_lock);
425 mutex_init(&adap->clist_lock);
426 INIT_LIST_HEAD(&adap->clients);
428 mutex_lock(&core_lock);
430 /* Add the adapter to the driver core.
431 * If the parent pointer is not set up,
432 * we add this adapter to the host bus.
434 if (adap->dev.parent == NULL) {
435 adap->dev.parent = &platform_bus;
436 pr_debug("I2C adapter driver [%s] forgot to specify "
437 "physical device\n", adap->name);
439 sprintf(adap->dev.bus_id, "i2c-%d", adap->nr);
440 adap->dev.release = &i2c_adapter_dev_release;
441 adap->dev.class = &i2c_adapter_class;
442 res = device_register(&adap->dev);
446 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
448 /* create pre-declared device nodes for new-style drivers */
449 if (adap->nr < __i2c_first_dynamic_bus_num)
450 i2c_scan_static_board_info(adap);
452 /* let legacy drivers scan this bus for matching devices */
453 dummy = bus_for_each_drv(&i2c_bus_type, NULL, adap,
457 mutex_unlock(&core_lock);
461 idr_remove(&i2c_adapter_idr, adap->nr);
466 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
467 * @adapter: the adapter to add
470 * This routine is used to declare an I2C adapter when its bus number
471 * doesn't matter. Examples: for I2C adapters dynamically added by
472 * USB links or PCI plugin cards.
474 * When this returns zero, a new bus number was allocated and stored
475 * in adap->nr, and the specified adapter became available for clients.
476 * Otherwise, a negative errno value is returned.
478 int i2c_add_adapter(struct i2c_adapter *adapter)
483 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
486 mutex_lock(&core_lock);
487 /* "above" here means "above or equal to", sigh */
488 res = idr_get_new_above(&i2c_adapter_idr, adapter,
489 __i2c_first_dynamic_bus_num, &id);
490 mutex_unlock(&core_lock);
499 return i2c_register_adapter(adapter);
501 EXPORT_SYMBOL(i2c_add_adapter);
504 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
505 * @adap: the adapter to register (with adap->nr initialized)
508 * This routine is used to declare an I2C adapter when its bus number
509 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
510 * or otherwise built in to the system's mainboard, and where i2c_board_info
511 * is used to properly configure I2C devices.
513 * If no devices have pre-been declared for this bus, then be sure to
514 * register the adapter before any dynamically allocated ones. Otherwise
515 * the required bus ID may not be available.
517 * When this returns zero, the specified adapter became available for
518 * clients using the bus number provided in adap->nr. Also, the table
519 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
520 * and the appropriate driver model device nodes are created. Otherwise, a
521 * negative errno value is returned.
523 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
528 if (adap->nr & ~MAX_ID_MASK)
532 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
535 mutex_lock(&core_lock);
536 /* "above" here means "above or equal to", sigh;
537 * we need the "equal to" result to force the result
539 status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
540 if (status == 0 && id != adap->nr) {
542 idr_remove(&i2c_adapter_idr, id);
544 mutex_unlock(&core_lock);
545 if (status == -EAGAIN)
549 status = i2c_register_adapter(adap);
552 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
554 static int i2c_do_del_adapter(struct device_driver *d, void *data)
556 struct i2c_driver *driver = to_i2c_driver(d);
557 struct i2c_adapter *adapter = data;
560 if (!driver->detach_adapter)
562 res = driver->detach_adapter(adapter);
564 dev_err(&adapter->dev, "detach_adapter failed (%d) "
565 "for driver [%s]\n", res, driver->driver.name);
570 * i2c_del_adapter - unregister I2C adapter
571 * @adap: the adapter being unregistered
574 * This unregisters an I2C adapter which was previously registered
575 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
577 int i2c_del_adapter(struct i2c_adapter *adap)
579 struct i2c_client *client, *_n;
582 mutex_lock(&core_lock);
584 /* First make sure that this adapter was ever added */
585 if (idr_find(&i2c_adapter_idr, adap->nr) != adap) {
586 pr_debug("i2c-core: attempting to delete unregistered "
587 "adapter [%s]\n", adap->name);
592 /* Tell drivers about this removal */
593 res = bus_for_each_drv(&i2c_bus_type, NULL, adap,
598 /* detach any active clients. This must be done first, because
599 * it can fail; in which case we give up. */
600 list_for_each_entry_safe(client, _n, &adap->clients, list) {
601 struct i2c_driver *driver;
603 driver = client->driver;
605 /* new style, follow standard driver model */
606 if (!driver || is_newstyle_driver(driver)) {
607 i2c_unregister_device(client);
611 /* legacy drivers create and remove clients themselves */
612 if ((res = driver->detach_client(client))) {
613 dev_err(&adap->dev, "detach_client failed for client "
614 "[%s] at address 0x%02x\n", client->name,
620 /* clean up the sysfs representation */
621 init_completion(&adap->dev_released);
622 device_unregister(&adap->dev);
624 /* wait for sysfs to drop all references */
625 wait_for_completion(&adap->dev_released);
628 idr_remove(&i2c_adapter_idr, adap->nr);
630 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
633 mutex_unlock(&core_lock);
636 EXPORT_SYMBOL(i2c_del_adapter);
639 /* ------------------------------------------------------------------------- */
641 static int __attach_adapter(struct device *dev, void *data)
643 struct i2c_adapter *adapter = to_i2c_adapter(dev);
644 struct i2c_driver *driver = data;
646 driver->attach_adapter(adapter);
652 * An i2c_driver is used with one or more i2c_client (device) nodes to access
653 * i2c slave chips, on a bus instance associated with some i2c_adapter. There
654 * are two models for binding the driver to its device: "new style" drivers
655 * follow the standard Linux driver model and just respond to probe() calls
656 * issued if the driver core sees they match(); "legacy" drivers create device
660 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
664 /* new style driver methods can't mix with legacy ones */
665 if (is_newstyle_driver(driver)) {
666 if (driver->attach_adapter || driver->detach_adapter
667 || driver->detach_client) {
669 "i2c-core: driver [%s] is confused\n",
670 driver->driver.name);
675 /* add the driver to the list of i2c drivers in the driver core */
676 driver->driver.owner = owner;
677 driver->driver.bus = &i2c_bus_type;
679 /* for new style drivers, when registration returns the driver core
680 * will have called probe() for all matching-but-unbound devices.
682 res = driver_register(&driver->driver);
686 mutex_lock(&core_lock);
688 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
690 /* legacy drivers scan i2c busses directly */
691 if (driver->attach_adapter)
692 class_for_each_device(&i2c_adapter_class, driver,
695 mutex_unlock(&core_lock);
698 EXPORT_SYMBOL(i2c_register_driver);
700 static int __detach_adapter(struct device *dev, void *data)
702 struct i2c_adapter *adapter = to_i2c_adapter(dev);
703 struct i2c_driver *driver = data;
705 /* Have a look at each adapter, if clients of this driver are still
706 * attached. If so, detach them to be able to kill the driver
709 if (driver->detach_adapter) {
710 if (driver->detach_adapter(adapter))
711 dev_err(&adapter->dev,
712 "detach_adapter failed for driver [%s]\n",
713 driver->driver.name);
715 struct i2c_client *client, *_n;
717 list_for_each_entry_safe(client, _n, &adapter->clients, list) {
718 if (client->driver != driver)
720 dev_dbg(&adapter->dev,
721 "detaching client [%s] at 0x%02x\n",
722 client->name, client->addr);
723 if (driver->detach_client(client))
724 dev_err(&adapter->dev, "detach_client "
725 "failed for client [%s] at 0x%02x\n",
726 client->name, client->addr);
734 * i2c_del_driver - unregister I2C driver
735 * @driver: the driver being unregistered
738 void i2c_del_driver(struct i2c_driver *driver)
740 mutex_lock(&core_lock);
743 if (!is_newstyle_driver(driver))
744 class_for_each_device(&i2c_adapter_class, driver,
747 driver_unregister(&driver->driver);
748 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
750 mutex_unlock(&core_lock);
752 EXPORT_SYMBOL(i2c_del_driver);
754 /* ------------------------------------------------------------------------- */
756 static int __i2c_check_addr(struct device *dev, void *addrp)
758 struct i2c_client *client = i2c_verify_client(dev);
759 int addr = *(int *)addrp;
761 if (client && client->addr == addr)
766 static int i2c_check_addr(struct i2c_adapter *adapter, int addr)
768 return device_for_each_child(&adapter->dev, &addr, __i2c_check_addr);
771 int i2c_attach_client(struct i2c_client *client)
773 struct i2c_adapter *adapter = client->adapter;
776 client->dev.parent = &client->adapter->dev;
777 client->dev.bus = &i2c_bus_type;
780 client->dev.driver = &client->driver->driver;
782 if (client->driver && !is_newstyle_driver(client->driver)) {
783 client->dev.release = i2c_client_release;
784 client->dev.uevent_suppress = 1;
786 client->dev.release = i2c_client_dev_release;
788 snprintf(&client->dev.bus_id[0], sizeof(client->dev.bus_id),
789 "%d-%04x", i2c_adapter_id(adapter), client->addr);
790 res = device_register(&client->dev);
794 mutex_lock(&adapter->clist_lock);
795 list_add_tail(&client->list, &adapter->clients);
796 mutex_unlock(&adapter->clist_lock);
798 dev_dbg(&adapter->dev, "client [%s] registered with bus id %s\n",
799 client->name, client->dev.bus_id);
801 if (adapter->client_register) {
802 if (adapter->client_register(client)) {
803 dev_dbg(&adapter->dev, "client_register "
804 "failed for client [%s] at 0x%02x\n",
805 client->name, client->addr);
812 dev_err(&adapter->dev, "Failed to attach i2c client %s at 0x%02x "
813 "(%d)\n", client->name, client->addr, res);
816 EXPORT_SYMBOL(i2c_attach_client);
818 int i2c_detach_client(struct i2c_client *client)
820 struct i2c_adapter *adapter = client->adapter;
823 if (adapter->client_unregister) {
824 res = adapter->client_unregister(client);
826 dev_err(&client->dev,
827 "client_unregister [%s] failed, "
828 "client not detached\n", client->name);
833 mutex_lock(&adapter->clist_lock);
834 list_del(&client->list);
835 mutex_unlock(&adapter->clist_lock);
837 init_completion(&client->released);
838 device_unregister(&client->dev);
839 wait_for_completion(&client->released);
844 EXPORT_SYMBOL(i2c_detach_client);
847 * i2c_use_client - increments the reference count of the i2c client structure
848 * @client: the client being referenced
850 * Each live reference to a client should be refcounted. The driver model does
851 * that automatically as part of driver binding, so that most drivers don't
852 * need to do this explicitly: they hold a reference until they're unbound
855 * A pointer to the client with the incremented reference counter is returned.
857 struct i2c_client *i2c_use_client(struct i2c_client *client)
859 if (client && get_device(&client->dev))
863 EXPORT_SYMBOL(i2c_use_client);
866 * i2c_release_client - release a use of the i2c client structure
867 * @client: the client being no longer referenced
869 * Must be called when a user of a client is finished with it.
871 void i2c_release_client(struct i2c_client *client)
874 put_device(&client->dev);
876 EXPORT_SYMBOL(i2c_release_client);
883 static int i2c_cmd(struct device *dev, void *_arg)
885 struct i2c_client *client = i2c_verify_client(dev);
886 struct i2c_cmd_arg *arg = _arg;
888 if (client && client->driver && client->driver->command)
889 client->driver->command(client, arg->cmd, arg->arg);
893 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
895 struct i2c_cmd_arg cmd_arg;
899 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
901 EXPORT_SYMBOL(i2c_clients_command);
903 static int __init i2c_init(void)
907 retval = bus_register(&i2c_bus_type);
910 retval = class_register(&i2c_adapter_class);
913 retval = i2c_add_driver(&dummy_driver);
919 class_unregister(&i2c_adapter_class);
921 bus_unregister(&i2c_bus_type);
925 static void __exit i2c_exit(void)
927 i2c_del_driver(&dummy_driver);
928 class_unregister(&i2c_adapter_class);
929 bus_unregister(&i2c_bus_type);
932 subsys_initcall(i2c_init);
933 module_exit(i2c_exit);
935 /* ----------------------------------------------------
936 * the functional interface to the i2c busses.
937 * ----------------------------------------------------
941 * i2c_transfer - execute a single or combined I2C message
942 * @adap: Handle to I2C bus
943 * @msgs: One or more messages to execute before STOP is issued to
944 * terminate the operation; each message begins with a START.
945 * @num: Number of messages to be executed.
947 * Returns negative errno, else the number of messages executed.
949 * Note that there is no requirement that each message be sent to
950 * the same slave address, although that is the most common model.
952 int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num)
956 /* REVISIT the fault reporting model here is weak:
958 * - When we get an error after receiving N bytes from a slave,
959 * there is no way to report "N".
961 * - When we get a NAK after transmitting N bytes to a slave,
962 * there is no way to report "N" ... or to let the master
963 * continue executing the rest of this combined message, if
964 * that's the appropriate response.
966 * - When for example "num" is two and we successfully complete
967 * the first message but get an error part way through the
968 * second, it's unclear whether that should be reported as
969 * one (discarding status on the second message) or errno
970 * (discarding status on the first one).
973 if (adap->algo->master_xfer) {
975 for (ret = 0; ret < num; ret++) {
976 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
977 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
978 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
979 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
983 if (in_atomic() || irqs_disabled()) {
984 ret = mutex_trylock(&adap->bus_lock);
986 /* I2C activity is ongoing. */
989 mutex_lock_nested(&adap->bus_lock, adap->level);
992 ret = adap->algo->master_xfer(adap,msgs,num);
993 mutex_unlock(&adap->bus_lock);
997 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
1001 EXPORT_SYMBOL(i2c_transfer);
1004 * i2c_master_send - issue a single I2C message in master transmit mode
1005 * @client: Handle to slave device
1006 * @buf: Data that will be written to the slave
1007 * @count: How many bytes to write
1009 * Returns negative errno, or else the number of bytes written.
1011 int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
1014 struct i2c_adapter *adap=client->adapter;
1017 msg.addr = client->addr;
1018 msg.flags = client->flags & I2C_M_TEN;
1020 msg.buf = (char *)buf;
1022 ret = i2c_transfer(adap, &msg, 1);
1024 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1025 transmitted, else error code. */
1026 return (ret == 1) ? count : ret;
1028 EXPORT_SYMBOL(i2c_master_send);
1031 * i2c_master_recv - issue a single I2C message in master receive mode
1032 * @client: Handle to slave device
1033 * @buf: Where to store data read from slave
1034 * @count: How many bytes to read
1036 * Returns negative errno, or else the number of bytes read.
1038 int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
1040 struct i2c_adapter *adap=client->adapter;
1044 msg.addr = client->addr;
1045 msg.flags = client->flags & I2C_M_TEN;
1046 msg.flags |= I2C_M_RD;
1050 ret = i2c_transfer(adap, &msg, 1);
1052 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1053 transmitted, else error code. */
1054 return (ret == 1) ? count : ret;
1056 EXPORT_SYMBOL(i2c_master_recv);
1058 /* ----------------------------------------------------
1059 * the i2c address scanning function
1060 * Will not work for 10-bit addresses!
1061 * ----------------------------------------------------
1063 static int i2c_probe_address(struct i2c_adapter *adapter, int addr, int kind,
1064 int (*found_proc) (struct i2c_adapter *, int, int))
1068 /* Make sure the address is valid */
1069 if (addr < 0x03 || addr > 0x77) {
1070 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1075 /* Skip if already in use */
1076 if (i2c_check_addr(adapter, addr))
1079 /* Make sure there is something at this address, unless forced */
1081 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1082 I2C_SMBUS_QUICK, NULL) < 0)
1085 /* prevent 24RF08 corruption */
1086 if ((addr & ~0x0f) == 0x50)
1087 i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1088 I2C_SMBUS_QUICK, NULL);
1091 /* Finally call the custom detection function */
1092 err = found_proc(adapter, addr, kind);
1093 /* -ENODEV can be returned if there is a chip at the given address
1094 but it isn't supported by this chip driver. We catch it here as
1095 this isn't an error. */
1100 dev_warn(&adapter->dev, "Client creation failed at 0x%x (%d)\n",
1105 int i2c_probe(struct i2c_adapter *adapter,
1106 const struct i2c_client_address_data *address_data,
1107 int (*found_proc) (struct i2c_adapter *, int, int))
1110 int adap_id = i2c_adapter_id(adapter);
1112 /* Force entries are done first, and are not affected by ignore
1114 if (address_data->forces) {
1115 const unsigned short * const *forces = address_data->forces;
1118 for (kind = 0; forces[kind]; kind++) {
1119 for (i = 0; forces[kind][i] != I2C_CLIENT_END;
1121 if (forces[kind][i] == adap_id
1122 || forces[kind][i] == ANY_I2C_BUS) {
1123 dev_dbg(&adapter->dev, "found force "
1124 "parameter for adapter %d, "
1125 "addr 0x%02x, kind %d\n",
1126 adap_id, forces[kind][i + 1],
1128 err = i2c_probe_address(adapter,
1129 forces[kind][i + 1],
1138 /* Stop here if we can't use SMBUS_QUICK */
1139 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
1140 if (address_data->probe[0] == I2C_CLIENT_END
1141 && address_data->normal_i2c[0] == I2C_CLIENT_END)
1144 dev_warn(&adapter->dev, "SMBus Quick command not supported, "
1145 "can't probe for chips\n");
1149 /* Probe entries are done second, and are not affected by ignore
1151 for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
1152 if (address_data->probe[i] == adap_id
1153 || address_data->probe[i] == ANY_I2C_BUS) {
1154 dev_dbg(&adapter->dev, "found probe parameter for "
1155 "adapter %d, addr 0x%02x\n", adap_id,
1156 address_data->probe[i + 1]);
1157 err = i2c_probe_address(adapter,
1158 address_data->probe[i + 1],
1165 /* Normal entries are done last, unless shadowed by an ignore entry */
1166 for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
1170 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
1172 if ((address_data->ignore[j] == adap_id ||
1173 address_data->ignore[j] == ANY_I2C_BUS)
1174 && address_data->ignore[j + 1]
1175 == address_data->normal_i2c[i]) {
1176 dev_dbg(&adapter->dev, "found ignore "
1177 "parameter for adapter %d, "
1178 "addr 0x%02x\n", adap_id,
1179 address_data->ignore[j + 1]);
1187 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1188 "addr 0x%02x\n", adap_id,
1189 address_data->normal_i2c[i]);
1190 err = i2c_probe_address(adapter, address_data->normal_i2c[i],
1198 EXPORT_SYMBOL(i2c_probe);
1201 i2c_new_probed_device(struct i2c_adapter *adap,
1202 struct i2c_board_info *info,
1203 unsigned short const *addr_list)
1207 /* Stop here if the bus doesn't support probing */
1208 if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE)) {
1209 dev_err(&adap->dev, "Probing not supported\n");
1213 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1214 /* Check address validity */
1215 if (addr_list[i] < 0x03 || addr_list[i] > 0x77) {
1216 dev_warn(&adap->dev, "Invalid 7-bit address "
1217 "0x%02x\n", addr_list[i]);
1221 /* Check address availability */
1222 if (i2c_check_addr(adap, addr_list[i])) {
1223 dev_dbg(&adap->dev, "Address 0x%02x already in "
1224 "use, not probing\n", addr_list[i]);
1228 /* Test address responsiveness
1229 The default probe method is a quick write, but it is known
1230 to corrupt the 24RF08 EEPROMs due to a state machine bug,
1231 and could also irreversibly write-protect some EEPROMs, so
1232 for address ranges 0x30-0x37 and 0x50-0x5f, we use a byte
1233 read instead. Also, some bus drivers don't implement
1234 quick write, so we fallback to a byte read it that case
1236 if ((addr_list[i] & ~0x07) == 0x30
1237 || (addr_list[i] & ~0x0f) == 0x50
1238 || !i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK)) {
1239 if (i2c_smbus_xfer(adap, addr_list[i], 0,
1241 I2C_SMBUS_BYTE, NULL) >= 0)
1244 if (i2c_smbus_xfer(adap, addr_list[i], 0,
1246 I2C_SMBUS_QUICK, NULL) >= 0)
1251 if (addr_list[i] == I2C_CLIENT_END) {
1252 dev_dbg(&adap->dev, "Probing failed, no device found\n");
1256 info->addr = addr_list[i];
1257 return i2c_new_device(adap, info);
1259 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1261 struct i2c_adapter* i2c_get_adapter(int id)
1263 struct i2c_adapter *adapter;
1265 mutex_lock(&core_lock);
1266 adapter = (struct i2c_adapter *)idr_find(&i2c_adapter_idr, id);
1267 if (adapter && !try_module_get(adapter->owner))
1270 mutex_unlock(&core_lock);
1273 EXPORT_SYMBOL(i2c_get_adapter);
1275 void i2c_put_adapter(struct i2c_adapter *adap)
1277 module_put(adap->owner);
1279 EXPORT_SYMBOL(i2c_put_adapter);
1281 /* The SMBus parts */
1283 #define POLY (0x1070U << 3)
1289 for(i = 0; i < 8; i++) {
1294 return (u8)(data >> 8);
1297 /* Incremental CRC8 over count bytes in the array pointed to by p */
1298 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
1302 for(i = 0; i < count; i++)
1303 crc = crc8((crc ^ p[i]) << 8);
1307 /* Assume a 7-bit address, which is reasonable for SMBus */
1308 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
1310 /* The address will be sent first */
1311 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1312 pec = i2c_smbus_pec(pec, &addr, 1);
1314 /* The data buffer follows */
1315 return i2c_smbus_pec(pec, msg->buf, msg->len);
1318 /* Used for write only transactions */
1319 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
1321 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1325 /* Return <0 on CRC error
1326 If there was a write before this read (most cases) we need to take the
1327 partial CRC from the write part into account.
1328 Note that this function does modify the message (we need to decrease the
1329 message length to hide the CRC byte from the caller). */
1330 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
1332 u8 rpec = msg->buf[--msg->len];
1333 cpec = i2c_smbus_msg_pec(cpec, msg);
1336 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1344 * i2c_smbus_read_byte - SMBus "receive byte" protocol
1345 * @client: Handle to slave device
1347 * This executes the SMBus "receive byte" protocol, returning negative errno
1348 * else the byte received from the device.
1350 s32 i2c_smbus_read_byte(struct i2c_client *client)
1352 union i2c_smbus_data data;
1355 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1357 I2C_SMBUS_BYTE, &data);
1358 return (status < 0) ? status : data.byte;
1360 EXPORT_SYMBOL(i2c_smbus_read_byte);
1363 * i2c_smbus_write_byte - SMBus "send byte" protocol
1364 * @client: Handle to slave device
1365 * @value: Byte to be sent
1367 * This executes the SMBus "send byte" protocol, returning negative errno
1368 * else zero on success.
1370 s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
1372 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1373 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
1375 EXPORT_SYMBOL(i2c_smbus_write_byte);
1378 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
1379 * @client: Handle to slave device
1380 * @command: Byte interpreted by slave
1382 * This executes the SMBus "read byte" protocol, returning negative errno
1383 * else a data byte received from the device.
1385 s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
1387 union i2c_smbus_data data;
1390 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1391 I2C_SMBUS_READ, command,
1392 I2C_SMBUS_BYTE_DATA, &data);
1393 return (status < 0) ? status : data.byte;
1395 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1398 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
1399 * @client: Handle to slave device
1400 * @command: Byte interpreted by slave
1401 * @value: Byte being written
1403 * This executes the SMBus "write byte" protocol, returning negative errno
1404 * else zero on success.
1406 s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
1408 union i2c_smbus_data data;
1410 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1411 I2C_SMBUS_WRITE,command,
1412 I2C_SMBUS_BYTE_DATA,&data);
1414 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1417 * i2c_smbus_read_word_data - SMBus "read word" protocol
1418 * @client: Handle to slave device
1419 * @command: Byte interpreted by slave
1421 * This executes the SMBus "read word" protocol, returning negative errno
1422 * else a 16-bit unsigned "word" received from the device.
1424 s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
1426 union i2c_smbus_data data;
1429 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1430 I2C_SMBUS_READ, command,
1431 I2C_SMBUS_WORD_DATA, &data);
1432 return (status < 0) ? status : data.word;
1434 EXPORT_SYMBOL(i2c_smbus_read_word_data);
1437 * i2c_smbus_write_word_data - SMBus "write word" protocol
1438 * @client: Handle to slave device
1439 * @command: Byte interpreted by slave
1440 * @value: 16-bit "word" being written
1442 * This executes the SMBus "write word" protocol, returning negative errno
1443 * else zero on success.
1445 s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
1447 union i2c_smbus_data data;
1449 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1450 I2C_SMBUS_WRITE,command,
1451 I2C_SMBUS_WORD_DATA,&data);
1453 EXPORT_SYMBOL(i2c_smbus_write_word_data);
1456 * i2c_smbus_read_block_data - SMBus "block read" protocol
1457 * @client: Handle to slave device
1458 * @command: Byte interpreted by slave
1459 * @values: Byte array into which data will be read; big enough to hold
1460 * the data returned by the slave. SMBus allows at most 32 bytes.
1462 * This executes the SMBus "block read" protocol, returning negative errno
1463 * else the number of data bytes in the slave's response.
1465 * Note that using this function requires that the client's adapter support
1466 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
1467 * support this; its emulation through I2C messaging relies on a specific
1468 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
1470 s32 i2c_smbus_read_block_data(struct i2c_client *client, u8 command,
1473 union i2c_smbus_data data;
1476 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1477 I2C_SMBUS_READ, command,
1478 I2C_SMBUS_BLOCK_DATA, &data);
1482 memcpy(values, &data.block[1], data.block[0]);
1483 return data.block[0];
1485 EXPORT_SYMBOL(i2c_smbus_read_block_data);
1488 * i2c_smbus_write_block_data - SMBus "block write" protocol
1489 * @client: Handle to slave device
1490 * @command: Byte interpreted by slave
1491 * @length: Size of data block; SMBus allows at most 32 bytes
1492 * @values: Byte array which will be written.
1494 * This executes the SMBus "block write" protocol, returning negative errno
1495 * else zero on success.
1497 s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
1498 u8 length, const u8 *values)
1500 union i2c_smbus_data data;
1502 if (length > I2C_SMBUS_BLOCK_MAX)
1503 length = I2C_SMBUS_BLOCK_MAX;
1504 data.block[0] = length;
1505 memcpy(&data.block[1], values, length);
1506 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1507 I2C_SMBUS_WRITE,command,
1508 I2C_SMBUS_BLOCK_DATA,&data);
1510 EXPORT_SYMBOL(i2c_smbus_write_block_data);
1512 /* Returns the number of read bytes */
1513 s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command,
1514 u8 length, u8 *values)
1516 union i2c_smbus_data data;
1519 if (length > I2C_SMBUS_BLOCK_MAX)
1520 length = I2C_SMBUS_BLOCK_MAX;
1521 data.block[0] = length;
1522 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1523 I2C_SMBUS_READ, command,
1524 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1528 memcpy(values, &data.block[1], data.block[0]);
1529 return data.block[0];
1531 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1533 s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, u8 command,
1534 u8 length, const u8 *values)
1536 union i2c_smbus_data data;
1538 if (length > I2C_SMBUS_BLOCK_MAX)
1539 length = I2C_SMBUS_BLOCK_MAX;
1540 data.block[0] = length;
1541 memcpy(data.block + 1, values, length);
1542 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1543 I2C_SMBUS_WRITE, command,
1544 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1546 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
1548 /* Simulate a SMBus command using the i2c protocol
1549 No checking of parameters is done! */
1550 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
1551 unsigned short flags,
1552 char read_write, u8 command, int size,
1553 union i2c_smbus_data * data)
1555 /* So we need to generate a series of msgs. In the case of writing, we
1556 need to use only one message; when reading, we need two. We initialize
1557 most things with sane defaults, to keep the code below somewhat
1559 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1560 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
1561 int num = read_write == I2C_SMBUS_READ?2:1;
1562 struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
1563 { addr, flags | I2C_M_RD, 0, msgbuf1 }
1569 msgbuf0[0] = command;
1571 case I2C_SMBUS_QUICK:
1573 /* Special case: The read/write field is used as data */
1574 msg[0].flags = flags | (read_write==I2C_SMBUS_READ)?I2C_M_RD:0;
1577 case I2C_SMBUS_BYTE:
1578 if (read_write == I2C_SMBUS_READ) {
1579 /* Special case: only a read! */
1580 msg[0].flags = I2C_M_RD | flags;
1584 case I2C_SMBUS_BYTE_DATA:
1585 if (read_write == I2C_SMBUS_READ)
1589 msgbuf0[1] = data->byte;
1592 case I2C_SMBUS_WORD_DATA:
1593 if (read_write == I2C_SMBUS_READ)
1597 msgbuf0[1] = data->word & 0xff;
1598 msgbuf0[2] = data->word >> 8;
1601 case I2C_SMBUS_PROC_CALL:
1602 num = 2; /* Special case */
1603 read_write = I2C_SMBUS_READ;
1606 msgbuf0[1] = data->word & 0xff;
1607 msgbuf0[2] = data->word >> 8;
1609 case I2C_SMBUS_BLOCK_DATA:
1610 if (read_write == I2C_SMBUS_READ) {
1611 msg[1].flags |= I2C_M_RECV_LEN;
1612 msg[1].len = 1; /* block length will be added by
1613 the underlying bus driver */
1615 msg[0].len = data->block[0] + 2;
1616 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
1617 dev_err(&adapter->dev,
1618 "Invalid block write size %d\n",
1622 for (i = 1; i < msg[0].len; i++)
1623 msgbuf0[i] = data->block[i-1];
1626 case I2C_SMBUS_BLOCK_PROC_CALL:
1627 num = 2; /* Another special case */
1628 read_write = I2C_SMBUS_READ;
1629 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
1630 dev_err(&adapter->dev,
1631 "Invalid block write size %d\n",
1635 msg[0].len = data->block[0] + 2;
1636 for (i = 1; i < msg[0].len; i++)
1637 msgbuf0[i] = data->block[i-1];
1638 msg[1].flags |= I2C_M_RECV_LEN;
1639 msg[1].len = 1; /* block length will be added by
1640 the underlying bus driver */
1642 case I2C_SMBUS_I2C_BLOCK_DATA:
1643 if (read_write == I2C_SMBUS_READ) {
1644 msg[1].len = data->block[0];
1646 msg[0].len = data->block[0] + 1;
1647 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
1648 dev_err(&adapter->dev,
1649 "Invalid block write size %d\n",
1653 for (i = 1; i <= data->block[0]; i++)
1654 msgbuf0[i] = data->block[i];
1658 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
1662 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
1663 && size != I2C_SMBUS_I2C_BLOCK_DATA);
1665 /* Compute PEC if first message is a write */
1666 if (!(msg[0].flags & I2C_M_RD)) {
1667 if (num == 1) /* Write only */
1668 i2c_smbus_add_pec(&msg[0]);
1669 else /* Write followed by read */
1670 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
1672 /* Ask for PEC if last message is a read */
1673 if (msg[num-1].flags & I2C_M_RD)
1677 status = i2c_transfer(adapter, msg, num);
1681 /* Check PEC if last message is a read */
1682 if (i && (msg[num-1].flags & I2C_M_RD)) {
1683 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
1688 if (read_write == I2C_SMBUS_READ)
1690 case I2C_SMBUS_BYTE:
1691 data->byte = msgbuf0[0];
1693 case I2C_SMBUS_BYTE_DATA:
1694 data->byte = msgbuf1[0];
1696 case I2C_SMBUS_WORD_DATA:
1697 case I2C_SMBUS_PROC_CALL:
1698 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
1700 case I2C_SMBUS_I2C_BLOCK_DATA:
1701 for (i = 0; i < data->block[0]; i++)
1702 data->block[i+1] = msgbuf1[i];
1704 case I2C_SMBUS_BLOCK_DATA:
1705 case I2C_SMBUS_BLOCK_PROC_CALL:
1706 for (i = 0; i < msgbuf1[0] + 1; i++)
1707 data->block[i] = msgbuf1[i];
1714 * i2c_smbus_xfer - execute SMBus protocol operations
1715 * @adapter: Handle to I2C bus
1716 * @addr: Address of SMBus slave on that bus
1717 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
1718 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
1719 * @command: Byte interpreted by slave, for protocols which use such bytes
1720 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
1721 * @data: Data to be read or written
1723 * This executes an SMBus protocol operation, and returns a negative
1724 * errno code else zero on success.
1726 s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u16 addr, unsigned short flags,
1727 char read_write, u8 command, int protocol,
1728 union i2c_smbus_data * data)
1732 flags &= I2C_M_TEN | I2C_CLIENT_PEC;
1734 if (adapter->algo->smbus_xfer) {
1735 mutex_lock(&adapter->bus_lock);
1736 res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write,
1737 command, protocol, data);
1738 mutex_unlock(&adapter->bus_lock);
1740 res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
1741 command, protocol, data);
1745 EXPORT_SYMBOL(i2c_smbus_xfer);
1747 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
1748 MODULE_DESCRIPTION("I2C-Bus main module");
1749 MODULE_LICENSE("GPL");