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 || (d)->detect)
47 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
49 /* ------------------------------------------------------------------------- */
51 static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
52 const struct i2c_client *client)
55 if (strcmp(client->name, id->name) == 0)
62 static int i2c_device_match(struct device *dev, struct device_driver *drv)
64 struct i2c_client *client = to_i2c_client(dev);
65 struct i2c_driver *driver = to_i2c_driver(drv);
67 /* make legacy i2c drivers bypass driver model probing entirely;
68 * such drivers scan each i2c adapter/bus themselves.
70 if (!is_newstyle_driver(driver))
73 /* match on an id table if there is one */
75 return i2c_match_id(driver->id_table, client) != NULL;
82 /* uevent helps with hotplug: modprobe -q $(MODALIAS) */
83 static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
85 struct i2c_client *client = to_i2c_client(dev);
87 /* by definition, legacy drivers can't hotplug */
91 if (add_uevent_var(env, "MODALIAS=%s%s",
92 I2C_MODULE_PREFIX, client->name))
94 dev_dbg(dev, "uevent\n");
99 #define i2c_device_uevent NULL
100 #endif /* CONFIG_HOTPLUG */
102 static int i2c_device_probe(struct device *dev)
104 struct i2c_client *client = to_i2c_client(dev);
105 struct i2c_driver *driver = to_i2c_driver(dev->driver);
108 if (!driver->probe || !driver->id_table)
110 client->driver = driver;
111 dev_dbg(dev, "probe\n");
113 status = driver->probe(client, i2c_match_id(driver->id_table, client));
115 client->driver = NULL;
119 static int i2c_device_remove(struct device *dev)
121 struct i2c_client *client = to_i2c_client(dev);
122 struct i2c_driver *driver;
128 driver = to_i2c_driver(dev->driver);
129 if (driver->remove) {
130 dev_dbg(dev, "remove\n");
131 status = driver->remove(client);
137 client->driver = NULL;
141 static void i2c_device_shutdown(struct device *dev)
143 struct i2c_driver *driver;
147 driver = to_i2c_driver(dev->driver);
148 if (driver->shutdown)
149 driver->shutdown(to_i2c_client(dev));
152 static int i2c_device_suspend(struct device * dev, pm_message_t mesg)
154 struct i2c_driver *driver;
158 driver = to_i2c_driver(dev->driver);
159 if (!driver->suspend)
161 return driver->suspend(to_i2c_client(dev), mesg);
164 static int i2c_device_resume(struct device * dev)
166 struct i2c_driver *driver;
170 driver = to_i2c_driver(dev->driver);
173 return driver->resume(to_i2c_client(dev));
176 static void i2c_client_release(struct device *dev)
178 struct i2c_client *client = to_i2c_client(dev);
179 complete(&client->released);
182 static void i2c_client_dev_release(struct device *dev)
184 kfree(to_i2c_client(dev));
187 static ssize_t show_client_name(struct device *dev, struct device_attribute *attr, char *buf)
189 struct i2c_client *client = to_i2c_client(dev);
190 return sprintf(buf, "%s\n", client->name);
193 static ssize_t show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
195 struct i2c_client *client = to_i2c_client(dev);
196 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
199 static struct device_attribute i2c_dev_attrs[] = {
200 __ATTR(name, S_IRUGO, show_client_name, NULL),
201 /* modalias helps coldplug: modprobe $(cat .../modalias) */
202 __ATTR(modalias, S_IRUGO, show_modalias, NULL),
206 struct bus_type i2c_bus_type = {
208 .dev_attrs = i2c_dev_attrs,
209 .match = i2c_device_match,
210 .uevent = i2c_device_uevent,
211 .probe = i2c_device_probe,
212 .remove = i2c_device_remove,
213 .shutdown = i2c_device_shutdown,
214 .suspend = i2c_device_suspend,
215 .resume = i2c_device_resume,
217 EXPORT_SYMBOL_GPL(i2c_bus_type);
221 * i2c_verify_client - return parameter as i2c_client, or NULL
222 * @dev: device, probably from some driver model iterator
224 * When traversing the driver model tree, perhaps using driver model
225 * iterators like @device_for_each_child(), you can't assume very much
226 * about the nodes you find. Use this function to avoid oopses caused
227 * by wrongly treating some non-I2C device as an i2c_client.
229 struct i2c_client *i2c_verify_client(struct device *dev)
231 return (dev->bus == &i2c_bus_type)
235 EXPORT_SYMBOL(i2c_verify_client);
239 * i2c_new_device - instantiate an i2c device for use with a new style driver
240 * @adap: the adapter managing the device
241 * @info: describes one I2C device; bus_num is ignored
244 * Create a device to work with a new style i2c driver, where binding is
245 * handled through driver model probe()/remove() methods. This call is not
246 * appropriate for use by mainboad initialization logic, which usually runs
247 * during an arch_initcall() long before any i2c_adapter could exist.
249 * This returns the new i2c client, which may be saved for later use with
250 * i2c_unregister_device(); or NULL to indicate an error.
253 i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
255 struct i2c_client *client;
258 client = kzalloc(sizeof *client, GFP_KERNEL);
262 client->adapter = adap;
264 client->dev.platform_data = info->platform_data;
265 device_init_wakeup(&client->dev, info->flags & I2C_CLIENT_WAKE);
267 client->flags = info->flags & ~I2C_CLIENT_WAKE;
268 client->addr = info->addr;
269 client->irq = info->irq;
271 strlcpy(client->name, info->type, sizeof(client->name));
273 /* a new style driver may be bound to this device when we
274 * return from this function, or any later moment (e.g. maybe
275 * hotplugging will load the driver module). and the device
276 * refcount model is the standard driver model one.
278 status = i2c_attach_client(client);
285 EXPORT_SYMBOL_GPL(i2c_new_device);
289 * i2c_unregister_device - reverse effect of i2c_new_device()
290 * @client: value returned from i2c_new_device()
293 void i2c_unregister_device(struct i2c_client *client)
295 struct i2c_adapter *adapter = client->adapter;
296 struct i2c_driver *driver = client->driver;
298 if (driver && !is_newstyle_driver(driver)) {
299 dev_err(&client->dev, "can't unregister devices "
300 "with legacy drivers\n");
305 if (adapter->client_unregister) {
306 if (adapter->client_unregister(client)) {
307 dev_warn(&client->dev,
308 "client_unregister [%s] failed\n",
313 mutex_lock(&adapter->clist_lock);
314 list_del(&client->list);
315 mutex_unlock(&adapter->clist_lock);
317 device_unregister(&client->dev);
319 EXPORT_SYMBOL_GPL(i2c_unregister_device);
322 static const struct i2c_device_id dummy_id[] = {
327 static int dummy_probe(struct i2c_client *client,
328 const struct i2c_device_id *id)
333 static int dummy_remove(struct i2c_client *client)
338 static struct i2c_driver dummy_driver = {
339 .driver.name = "dummy",
340 .probe = dummy_probe,
341 .remove = dummy_remove,
342 .id_table = dummy_id,
346 * i2c_new_dummy - return a new i2c device bound to a dummy driver
347 * @adapter: the adapter managing the device
348 * @address: seven bit address to be used
351 * This returns an I2C client bound to the "dummy" driver, intended for use
352 * with devices that consume multiple addresses. Examples of such chips
353 * include various EEPROMS (like 24c04 and 24c08 models).
355 * These dummy devices have two main uses. First, most I2C and SMBus calls
356 * except i2c_transfer() need a client handle; the dummy will be that handle.
357 * And second, this prevents the specified address from being bound to a
360 * This returns the new i2c client, which should be saved for later use with
361 * i2c_unregister_device(); or NULL to indicate an error.
364 i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
366 struct i2c_board_info info = {
367 I2C_BOARD_INFO("dummy", address),
370 return i2c_new_device(adapter, &info);
372 EXPORT_SYMBOL_GPL(i2c_new_dummy);
374 /* ------------------------------------------------------------------------- */
376 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
378 static void i2c_adapter_dev_release(struct device *dev)
380 struct i2c_adapter *adap = to_i2c_adapter(dev);
381 complete(&adap->dev_released);
385 show_adapter_name(struct device *dev, struct device_attribute *attr, char *buf)
387 struct i2c_adapter *adap = to_i2c_adapter(dev);
388 return sprintf(buf, "%s\n", adap->name);
391 static struct device_attribute i2c_adapter_attrs[] = {
392 __ATTR(name, S_IRUGO, show_adapter_name, NULL),
396 static struct class i2c_adapter_class = {
397 .owner = THIS_MODULE,
398 .name = "i2c-adapter",
399 .dev_attrs = i2c_adapter_attrs,
402 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
404 struct i2c_devinfo *devinfo;
406 mutex_lock(&__i2c_board_lock);
407 list_for_each_entry(devinfo, &__i2c_board_list, list) {
408 if (devinfo->busnum == adapter->nr
409 && !i2c_new_device(adapter,
410 &devinfo->board_info))
411 printk(KERN_ERR "i2c-core: can't create i2c%d-%04x\n",
412 i2c_adapter_id(adapter),
413 devinfo->board_info.addr);
415 mutex_unlock(&__i2c_board_lock);
418 static int i2c_do_add_adapter(struct device_driver *d, void *data)
420 struct i2c_driver *driver = to_i2c_driver(d);
421 struct i2c_adapter *adap = data;
423 /* Detect supported devices on that bus, and instantiate them */
424 i2c_detect(adap, driver);
426 /* Let legacy drivers scan this bus for matching devices */
427 if (driver->attach_adapter) {
428 /* We ignore the return code; if it fails, too bad */
429 driver->attach_adapter(adap);
434 static int i2c_register_adapter(struct i2c_adapter *adap)
438 mutex_init(&adap->bus_lock);
439 mutex_init(&adap->clist_lock);
440 INIT_LIST_HEAD(&adap->clients);
442 mutex_lock(&core_lock);
444 /* Add the adapter to the driver core.
445 * If the parent pointer is not set up,
446 * we add this adapter to the host bus.
448 if (adap->dev.parent == NULL) {
449 adap->dev.parent = &platform_bus;
450 pr_debug("I2C adapter driver [%s] forgot to specify "
451 "physical device\n", adap->name);
453 sprintf(adap->dev.bus_id, "i2c-%d", adap->nr);
454 adap->dev.release = &i2c_adapter_dev_release;
455 adap->dev.class = &i2c_adapter_class;
456 res = device_register(&adap->dev);
460 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
462 /* create pre-declared device nodes for new-style drivers */
463 if (adap->nr < __i2c_first_dynamic_bus_num)
464 i2c_scan_static_board_info(adap);
467 dummy = bus_for_each_drv(&i2c_bus_type, NULL, adap,
471 mutex_unlock(&core_lock);
475 idr_remove(&i2c_adapter_idr, adap->nr);
480 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
481 * @adapter: the adapter to add
484 * This routine is used to declare an I2C adapter when its bus number
485 * doesn't matter. Examples: for I2C adapters dynamically added by
486 * USB links or PCI plugin cards.
488 * When this returns zero, a new bus number was allocated and stored
489 * in adap->nr, and the specified adapter became available for clients.
490 * Otherwise, a negative errno value is returned.
492 int i2c_add_adapter(struct i2c_adapter *adapter)
497 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
500 mutex_lock(&core_lock);
501 /* "above" here means "above or equal to", sigh */
502 res = idr_get_new_above(&i2c_adapter_idr, adapter,
503 __i2c_first_dynamic_bus_num, &id);
504 mutex_unlock(&core_lock);
513 return i2c_register_adapter(adapter);
515 EXPORT_SYMBOL(i2c_add_adapter);
518 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
519 * @adap: the adapter to register (with adap->nr initialized)
522 * This routine is used to declare an I2C adapter when its bus number
523 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
524 * or otherwise built in to the system's mainboard, and where i2c_board_info
525 * is used to properly configure I2C devices.
527 * If no devices have pre-been declared for this bus, then be sure to
528 * register the adapter before any dynamically allocated ones. Otherwise
529 * the required bus ID may not be available.
531 * When this returns zero, the specified adapter became available for
532 * clients using the bus number provided in adap->nr. Also, the table
533 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
534 * and the appropriate driver model device nodes are created. Otherwise, a
535 * negative errno value is returned.
537 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
542 if (adap->nr & ~MAX_ID_MASK)
546 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
549 mutex_lock(&core_lock);
550 /* "above" here means "above or equal to", sigh;
551 * we need the "equal to" result to force the result
553 status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
554 if (status == 0 && id != adap->nr) {
556 idr_remove(&i2c_adapter_idr, id);
558 mutex_unlock(&core_lock);
559 if (status == -EAGAIN)
563 status = i2c_register_adapter(adap);
566 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
568 static int i2c_do_del_adapter(struct device_driver *d, void *data)
570 struct i2c_driver *driver = to_i2c_driver(d);
571 struct i2c_adapter *adapter = data;
572 struct i2c_client *client, *_n;
575 /* Remove the devices we created ourselves */
576 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
577 if (client->adapter == adapter) {
578 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
579 client->name, client->addr);
580 list_del(&client->detected);
581 i2c_unregister_device(client);
585 if (!driver->detach_adapter)
587 res = driver->detach_adapter(adapter);
589 dev_err(&adapter->dev, "detach_adapter failed (%d) "
590 "for driver [%s]\n", res, driver->driver.name);
595 * i2c_del_adapter - unregister I2C adapter
596 * @adap: the adapter being unregistered
599 * This unregisters an I2C adapter which was previously registered
600 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
602 int i2c_del_adapter(struct i2c_adapter *adap)
604 struct i2c_client *client, *_n;
607 mutex_lock(&core_lock);
609 /* First make sure that this adapter was ever added */
610 if (idr_find(&i2c_adapter_idr, adap->nr) != adap) {
611 pr_debug("i2c-core: attempting to delete unregistered "
612 "adapter [%s]\n", adap->name);
617 /* Tell drivers about this removal */
618 res = bus_for_each_drv(&i2c_bus_type, NULL, adap,
623 /* detach any active clients. This must be done first, because
624 * it can fail; in which case we give up. */
625 list_for_each_entry_safe(client, _n, &adap->clients, list) {
626 struct i2c_driver *driver;
628 driver = client->driver;
630 /* new style, follow standard driver model */
631 if (!driver || is_newstyle_driver(driver)) {
632 i2c_unregister_device(client);
636 /* legacy drivers create and remove clients themselves */
637 if ((res = driver->detach_client(client))) {
638 dev_err(&adap->dev, "detach_client failed for client "
639 "[%s] at address 0x%02x\n", client->name,
645 /* clean up the sysfs representation */
646 init_completion(&adap->dev_released);
647 device_unregister(&adap->dev);
649 /* wait for sysfs to drop all references */
650 wait_for_completion(&adap->dev_released);
653 idr_remove(&i2c_adapter_idr, adap->nr);
655 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
657 /* Clear the device structure in case this adapter is ever going to be
659 memset(&adap->dev, 0, sizeof(adap->dev));
662 mutex_unlock(&core_lock);
665 EXPORT_SYMBOL(i2c_del_adapter);
668 /* ------------------------------------------------------------------------- */
670 static int __attach_adapter(struct device *dev, void *data)
672 struct i2c_adapter *adapter = to_i2c_adapter(dev);
673 struct i2c_driver *driver = data;
675 i2c_detect(adapter, driver);
677 /* Legacy drivers scan i2c busses directly */
678 if (driver->attach_adapter)
679 driver->attach_adapter(adapter);
685 * An i2c_driver is used with one or more i2c_client (device) nodes to access
686 * i2c slave chips, on a bus instance associated with some i2c_adapter. There
687 * are two models for binding the driver to its device: "new style" drivers
688 * follow the standard Linux driver model and just respond to probe() calls
689 * issued if the driver core sees they match(); "legacy" drivers create device
693 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
697 /* new style driver methods can't mix with legacy ones */
698 if (is_newstyle_driver(driver)) {
699 if (driver->attach_adapter || driver->detach_adapter
700 || driver->detach_client) {
702 "i2c-core: driver [%s] is confused\n",
703 driver->driver.name);
708 /* add the driver to the list of i2c drivers in the driver core */
709 driver->driver.owner = owner;
710 driver->driver.bus = &i2c_bus_type;
712 /* for new style drivers, when registration returns the driver core
713 * will have called probe() for all matching-but-unbound devices.
715 res = driver_register(&driver->driver);
719 mutex_lock(&core_lock);
721 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
723 INIT_LIST_HEAD(&driver->clients);
724 /* Walk the adapters that are already present */
725 class_for_each_device(&i2c_adapter_class, NULL, driver,
728 mutex_unlock(&core_lock);
731 EXPORT_SYMBOL(i2c_register_driver);
733 static int __detach_adapter(struct device *dev, void *data)
735 struct i2c_adapter *adapter = to_i2c_adapter(dev);
736 struct i2c_driver *driver = data;
737 struct i2c_client *client, *_n;
739 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
740 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
741 client->name, client->addr);
742 list_del(&client->detected);
743 i2c_unregister_device(client);
746 if (is_newstyle_driver(driver))
749 /* Have a look at each adapter, if clients of this driver are still
750 * attached. If so, detach them to be able to kill the driver
753 if (driver->detach_adapter) {
754 if (driver->detach_adapter(adapter))
755 dev_err(&adapter->dev,
756 "detach_adapter failed for driver [%s]\n",
757 driver->driver.name);
759 struct i2c_client *client, *_n;
761 list_for_each_entry_safe(client, _n, &adapter->clients, list) {
762 if (client->driver != driver)
764 dev_dbg(&adapter->dev,
765 "detaching client [%s] at 0x%02x\n",
766 client->name, client->addr);
767 if (driver->detach_client(client))
768 dev_err(&adapter->dev, "detach_client "
769 "failed for client [%s] at 0x%02x\n",
770 client->name, client->addr);
778 * i2c_del_driver - unregister I2C driver
779 * @driver: the driver being unregistered
782 void i2c_del_driver(struct i2c_driver *driver)
784 mutex_lock(&core_lock);
786 class_for_each_device(&i2c_adapter_class, NULL, driver,
789 driver_unregister(&driver->driver);
790 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
792 mutex_unlock(&core_lock);
794 EXPORT_SYMBOL(i2c_del_driver);
796 /* ------------------------------------------------------------------------- */
798 static int __i2c_check_addr(struct device *dev, void *addrp)
800 struct i2c_client *client = i2c_verify_client(dev);
801 int addr = *(int *)addrp;
803 if (client && client->addr == addr)
808 static int i2c_check_addr(struct i2c_adapter *adapter, int addr)
810 return device_for_each_child(&adapter->dev, &addr, __i2c_check_addr);
813 int i2c_attach_client(struct i2c_client *client)
815 struct i2c_adapter *adapter = client->adapter;
818 client->dev.parent = &client->adapter->dev;
819 client->dev.bus = &i2c_bus_type;
822 client->dev.driver = &client->driver->driver;
824 if (client->driver && !is_newstyle_driver(client->driver)) {
825 client->dev.release = i2c_client_release;
826 client->dev.uevent_suppress = 1;
828 client->dev.release = i2c_client_dev_release;
830 snprintf(&client->dev.bus_id[0], sizeof(client->dev.bus_id),
831 "%d-%04x", i2c_adapter_id(adapter), client->addr);
832 res = device_register(&client->dev);
836 mutex_lock(&adapter->clist_lock);
837 list_add_tail(&client->list, &adapter->clients);
838 mutex_unlock(&adapter->clist_lock);
840 dev_dbg(&adapter->dev, "client [%s] registered with bus id %s\n",
841 client->name, client->dev.bus_id);
843 if (adapter->client_register) {
844 if (adapter->client_register(client)) {
845 dev_dbg(&adapter->dev, "client_register "
846 "failed for client [%s] at 0x%02x\n",
847 client->name, client->addr);
854 dev_err(&adapter->dev, "Failed to attach i2c client %s at 0x%02x "
855 "(%d)\n", client->name, client->addr, res);
858 EXPORT_SYMBOL(i2c_attach_client);
860 int i2c_detach_client(struct i2c_client *client)
862 struct i2c_adapter *adapter = client->adapter;
865 if (adapter->client_unregister) {
866 res = adapter->client_unregister(client);
868 dev_err(&client->dev,
869 "client_unregister [%s] failed, "
870 "client not detached\n", client->name);
875 mutex_lock(&adapter->clist_lock);
876 list_del(&client->list);
877 mutex_unlock(&adapter->clist_lock);
879 init_completion(&client->released);
880 device_unregister(&client->dev);
881 wait_for_completion(&client->released);
886 EXPORT_SYMBOL(i2c_detach_client);
889 * i2c_use_client - increments the reference count of the i2c client structure
890 * @client: the client being referenced
892 * Each live reference to a client should be refcounted. The driver model does
893 * that automatically as part of driver binding, so that most drivers don't
894 * need to do this explicitly: they hold a reference until they're unbound
897 * A pointer to the client with the incremented reference counter is returned.
899 struct i2c_client *i2c_use_client(struct i2c_client *client)
901 if (client && get_device(&client->dev))
905 EXPORT_SYMBOL(i2c_use_client);
908 * i2c_release_client - release a use of the i2c client structure
909 * @client: the client being no longer referenced
911 * Must be called when a user of a client is finished with it.
913 void i2c_release_client(struct i2c_client *client)
916 put_device(&client->dev);
918 EXPORT_SYMBOL(i2c_release_client);
925 static int i2c_cmd(struct device *dev, void *_arg)
927 struct i2c_client *client = i2c_verify_client(dev);
928 struct i2c_cmd_arg *arg = _arg;
930 if (client && client->driver && client->driver->command)
931 client->driver->command(client, arg->cmd, arg->arg);
935 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
937 struct i2c_cmd_arg cmd_arg;
941 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
943 EXPORT_SYMBOL(i2c_clients_command);
945 static int __init i2c_init(void)
949 retval = bus_register(&i2c_bus_type);
952 retval = class_register(&i2c_adapter_class);
955 retval = i2c_add_driver(&dummy_driver);
961 class_unregister(&i2c_adapter_class);
963 bus_unregister(&i2c_bus_type);
967 static void __exit i2c_exit(void)
969 i2c_del_driver(&dummy_driver);
970 class_unregister(&i2c_adapter_class);
971 bus_unregister(&i2c_bus_type);
974 subsys_initcall(i2c_init);
975 module_exit(i2c_exit);
977 /* ----------------------------------------------------
978 * the functional interface to the i2c busses.
979 * ----------------------------------------------------
983 * i2c_transfer - execute a single or combined I2C message
984 * @adap: Handle to I2C bus
985 * @msgs: One or more messages to execute before STOP is issued to
986 * terminate the operation; each message begins with a START.
987 * @num: Number of messages to be executed.
989 * Returns negative errno, else the number of messages executed.
991 * Note that there is no requirement that each message be sent to
992 * the same slave address, although that is the most common model.
994 int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num)
998 /* REVISIT the fault reporting model here is weak:
1000 * - When we get an error after receiving N bytes from a slave,
1001 * there is no way to report "N".
1003 * - When we get a NAK after transmitting N bytes to a slave,
1004 * there is no way to report "N" ... or to let the master
1005 * continue executing the rest of this combined message, if
1006 * that's the appropriate response.
1008 * - When for example "num" is two and we successfully complete
1009 * the first message but get an error part way through the
1010 * second, it's unclear whether that should be reported as
1011 * one (discarding status on the second message) or errno
1012 * (discarding status on the first one).
1015 if (adap->algo->master_xfer) {
1017 for (ret = 0; ret < num; ret++) {
1018 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
1019 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
1020 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
1021 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
1025 if (in_atomic() || irqs_disabled()) {
1026 ret = mutex_trylock(&adap->bus_lock);
1028 /* I2C activity is ongoing. */
1031 mutex_lock_nested(&adap->bus_lock, adap->level);
1034 ret = adap->algo->master_xfer(adap,msgs,num);
1035 mutex_unlock(&adap->bus_lock);
1039 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
1043 EXPORT_SYMBOL(i2c_transfer);
1046 * i2c_master_send - issue a single I2C message in master transmit mode
1047 * @client: Handle to slave device
1048 * @buf: Data that will be written to the slave
1049 * @count: How many bytes to write
1051 * Returns negative errno, or else the number of bytes written.
1053 int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
1056 struct i2c_adapter *adap=client->adapter;
1059 msg.addr = client->addr;
1060 msg.flags = client->flags & I2C_M_TEN;
1062 msg.buf = (char *)buf;
1064 ret = i2c_transfer(adap, &msg, 1);
1066 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1067 transmitted, else error code. */
1068 return (ret == 1) ? count : ret;
1070 EXPORT_SYMBOL(i2c_master_send);
1073 * i2c_master_recv - issue a single I2C message in master receive mode
1074 * @client: Handle to slave device
1075 * @buf: Where to store data read from slave
1076 * @count: How many bytes to read
1078 * Returns negative errno, or else the number of bytes read.
1080 int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
1082 struct i2c_adapter *adap=client->adapter;
1086 msg.addr = client->addr;
1087 msg.flags = client->flags & I2C_M_TEN;
1088 msg.flags |= I2C_M_RD;
1092 ret = i2c_transfer(adap, &msg, 1);
1094 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1095 transmitted, else error code. */
1096 return (ret == 1) ? count : ret;
1098 EXPORT_SYMBOL(i2c_master_recv);
1100 /* ----------------------------------------------------
1101 * the i2c address scanning function
1102 * Will not work for 10-bit addresses!
1103 * ----------------------------------------------------
1105 static int i2c_probe_address(struct i2c_adapter *adapter, int addr, int kind,
1106 int (*found_proc) (struct i2c_adapter *, int, int))
1110 /* Make sure the address is valid */
1111 if (addr < 0x03 || addr > 0x77) {
1112 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1117 /* Skip if already in use */
1118 if (i2c_check_addr(adapter, addr))
1121 /* Make sure there is something at this address, unless forced */
1123 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1124 I2C_SMBUS_QUICK, NULL) < 0)
1127 /* prevent 24RF08 corruption */
1128 if ((addr & ~0x0f) == 0x50)
1129 i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1130 I2C_SMBUS_QUICK, NULL);
1133 /* Finally call the custom detection function */
1134 err = found_proc(adapter, addr, kind);
1135 /* -ENODEV can be returned if there is a chip at the given address
1136 but it isn't supported by this chip driver. We catch it here as
1137 this isn't an error. */
1142 dev_warn(&adapter->dev, "Client creation failed at 0x%x (%d)\n",
1147 int i2c_probe(struct i2c_adapter *adapter,
1148 const struct i2c_client_address_data *address_data,
1149 int (*found_proc) (struct i2c_adapter *, int, int))
1152 int adap_id = i2c_adapter_id(adapter);
1154 /* Force entries are done first, and are not affected by ignore
1156 if (address_data->forces) {
1157 const unsigned short * const *forces = address_data->forces;
1160 for (kind = 0; forces[kind]; kind++) {
1161 for (i = 0; forces[kind][i] != I2C_CLIENT_END;
1163 if (forces[kind][i] == adap_id
1164 || forces[kind][i] == ANY_I2C_BUS) {
1165 dev_dbg(&adapter->dev, "found force "
1166 "parameter for adapter %d, "
1167 "addr 0x%02x, kind %d\n",
1168 adap_id, forces[kind][i + 1],
1170 err = i2c_probe_address(adapter,
1171 forces[kind][i + 1],
1180 /* Stop here if we can't use SMBUS_QUICK */
1181 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
1182 if (address_data->probe[0] == I2C_CLIENT_END
1183 && address_data->normal_i2c[0] == I2C_CLIENT_END)
1186 dev_warn(&adapter->dev, "SMBus Quick command not supported, "
1187 "can't probe for chips\n");
1191 /* Probe entries are done second, and are not affected by ignore
1193 for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
1194 if (address_data->probe[i] == adap_id
1195 || address_data->probe[i] == ANY_I2C_BUS) {
1196 dev_dbg(&adapter->dev, "found probe parameter for "
1197 "adapter %d, addr 0x%02x\n", adap_id,
1198 address_data->probe[i + 1]);
1199 err = i2c_probe_address(adapter,
1200 address_data->probe[i + 1],
1207 /* Normal entries are done last, unless shadowed by an ignore entry */
1208 for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
1212 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
1214 if ((address_data->ignore[j] == adap_id ||
1215 address_data->ignore[j] == ANY_I2C_BUS)
1216 && address_data->ignore[j + 1]
1217 == address_data->normal_i2c[i]) {
1218 dev_dbg(&adapter->dev, "found ignore "
1219 "parameter for adapter %d, "
1220 "addr 0x%02x\n", adap_id,
1221 address_data->ignore[j + 1]);
1229 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1230 "addr 0x%02x\n", adap_id,
1231 address_data->normal_i2c[i]);
1232 err = i2c_probe_address(adapter, address_data->normal_i2c[i],
1240 EXPORT_SYMBOL(i2c_probe);
1242 /* Separate detection function for new-style drivers */
1243 static int i2c_detect_address(struct i2c_client *temp_client, int kind,
1244 struct i2c_driver *driver)
1246 struct i2c_board_info info;
1247 struct i2c_adapter *adapter = temp_client->adapter;
1248 int addr = temp_client->addr;
1251 /* Make sure the address is valid */
1252 if (addr < 0x03 || addr > 0x77) {
1253 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1258 /* Skip if already in use */
1259 if (i2c_check_addr(adapter, addr))
1262 /* Make sure there is something at this address, unless forced */
1264 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1265 I2C_SMBUS_QUICK, NULL) < 0)
1268 /* prevent 24RF08 corruption */
1269 if ((addr & ~0x0f) == 0x50)
1270 i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1271 I2C_SMBUS_QUICK, NULL);
1274 /* Finally call the custom detection function */
1275 memset(&info, 0, sizeof(struct i2c_board_info));
1277 err = driver->detect(temp_client, kind, &info);
1279 /* -ENODEV is returned if the detection fails. We catch it
1280 here as this isn't an error. */
1281 return err == -ENODEV ? 0 : err;
1284 /* Consistency check */
1285 if (info.type[0] == '\0') {
1286 dev_err(&adapter->dev, "%s detection function provided "
1287 "no name for 0x%x\n", driver->driver.name,
1290 struct i2c_client *client;
1292 /* Detection succeeded, instantiate the device */
1293 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
1294 info.type, info.addr);
1295 client = i2c_new_device(adapter, &info);
1297 list_add_tail(&client->detected, &driver->clients);
1299 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
1300 info.type, info.addr);
1305 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
1307 const struct i2c_client_address_data *address_data;
1308 struct i2c_client *temp_client;
1310 int adap_id = i2c_adapter_id(adapter);
1312 address_data = driver->address_data;
1313 if (!driver->detect || !address_data)
1316 /* Set up a temporary client to help detect callback */
1317 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
1320 temp_client->adapter = adapter;
1322 /* Force entries are done first, and are not affected by ignore
1324 if (address_data->forces) {
1325 const unsigned short * const *forces = address_data->forces;
1328 for (kind = 0; forces[kind]; kind++) {
1329 for (i = 0; forces[kind][i] != I2C_CLIENT_END;
1331 if (forces[kind][i] == adap_id
1332 || forces[kind][i] == ANY_I2C_BUS) {
1333 dev_dbg(&adapter->dev, "found force "
1334 "parameter for adapter %d, "
1335 "addr 0x%02x, kind %d\n",
1336 adap_id, forces[kind][i + 1],
1338 temp_client->addr = forces[kind][i + 1];
1339 err = i2c_detect_address(temp_client,
1348 /* Stop here if we can't use SMBUS_QUICK */
1349 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
1350 if (address_data->probe[0] == I2C_CLIENT_END
1351 && address_data->normal_i2c[0] == I2C_CLIENT_END)
1354 dev_warn(&adapter->dev, "SMBus Quick command not supported, "
1355 "can't probe for chips\n");
1360 /* Stop here if the classes do not match */
1361 if (!(adapter->class & driver->class))
1364 /* Probe entries are done second, and are not affected by ignore
1366 for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
1367 if (address_data->probe[i] == adap_id
1368 || address_data->probe[i] == ANY_I2C_BUS) {
1369 dev_dbg(&adapter->dev, "found probe parameter for "
1370 "adapter %d, addr 0x%02x\n", adap_id,
1371 address_data->probe[i + 1]);
1372 temp_client->addr = address_data->probe[i + 1];
1373 err = i2c_detect_address(temp_client, -1, driver);
1379 /* Normal entries are done last, unless shadowed by an ignore entry */
1380 for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
1384 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
1386 if ((address_data->ignore[j] == adap_id ||
1387 address_data->ignore[j] == ANY_I2C_BUS)
1388 && address_data->ignore[j + 1]
1389 == address_data->normal_i2c[i]) {
1390 dev_dbg(&adapter->dev, "found ignore "
1391 "parameter for adapter %d, "
1392 "addr 0x%02x\n", adap_id,
1393 address_data->ignore[j + 1]);
1401 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1402 "addr 0x%02x\n", adap_id,
1403 address_data->normal_i2c[i]);
1404 temp_client->addr = address_data->normal_i2c[i];
1405 err = i2c_detect_address(temp_client, -1, driver);
1416 i2c_new_probed_device(struct i2c_adapter *adap,
1417 struct i2c_board_info *info,
1418 unsigned short const *addr_list)
1422 /* Stop here if the bus doesn't support probing */
1423 if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE)) {
1424 dev_err(&adap->dev, "Probing not supported\n");
1428 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1429 /* Check address validity */
1430 if (addr_list[i] < 0x03 || addr_list[i] > 0x77) {
1431 dev_warn(&adap->dev, "Invalid 7-bit address "
1432 "0x%02x\n", addr_list[i]);
1436 /* Check address availability */
1437 if (i2c_check_addr(adap, addr_list[i])) {
1438 dev_dbg(&adap->dev, "Address 0x%02x already in "
1439 "use, not probing\n", addr_list[i]);
1443 /* Test address responsiveness
1444 The default probe method is a quick write, but it is known
1445 to corrupt the 24RF08 EEPROMs due to a state machine bug,
1446 and could also irreversibly write-protect some EEPROMs, so
1447 for address ranges 0x30-0x37 and 0x50-0x5f, we use a byte
1448 read instead. Also, some bus drivers don't implement
1449 quick write, so we fallback to a byte read it that case
1451 if ((addr_list[i] & ~0x07) == 0x30
1452 || (addr_list[i] & ~0x0f) == 0x50
1453 || !i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK)) {
1454 union i2c_smbus_data data;
1456 if (i2c_smbus_xfer(adap, addr_list[i], 0,
1458 I2C_SMBUS_BYTE, &data) >= 0)
1461 if (i2c_smbus_xfer(adap, addr_list[i], 0,
1463 I2C_SMBUS_QUICK, NULL) >= 0)
1468 if (addr_list[i] == I2C_CLIENT_END) {
1469 dev_dbg(&adap->dev, "Probing failed, no device found\n");
1473 info->addr = addr_list[i];
1474 return i2c_new_device(adap, info);
1476 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1478 struct i2c_adapter* i2c_get_adapter(int id)
1480 struct i2c_adapter *adapter;
1482 mutex_lock(&core_lock);
1483 adapter = (struct i2c_adapter *)idr_find(&i2c_adapter_idr, id);
1484 if (adapter && !try_module_get(adapter->owner))
1487 mutex_unlock(&core_lock);
1490 EXPORT_SYMBOL(i2c_get_adapter);
1492 void i2c_put_adapter(struct i2c_adapter *adap)
1494 module_put(adap->owner);
1496 EXPORT_SYMBOL(i2c_put_adapter);
1498 /* The SMBus parts */
1500 #define POLY (0x1070U << 3)
1506 for(i = 0; i < 8; i++) {
1511 return (u8)(data >> 8);
1514 /* Incremental CRC8 over count bytes in the array pointed to by p */
1515 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
1519 for(i = 0; i < count; i++)
1520 crc = crc8((crc ^ p[i]) << 8);
1524 /* Assume a 7-bit address, which is reasonable for SMBus */
1525 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
1527 /* The address will be sent first */
1528 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1529 pec = i2c_smbus_pec(pec, &addr, 1);
1531 /* The data buffer follows */
1532 return i2c_smbus_pec(pec, msg->buf, msg->len);
1535 /* Used for write only transactions */
1536 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
1538 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1542 /* Return <0 on CRC error
1543 If there was a write before this read (most cases) we need to take the
1544 partial CRC from the write part into account.
1545 Note that this function does modify the message (we need to decrease the
1546 message length to hide the CRC byte from the caller). */
1547 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
1549 u8 rpec = msg->buf[--msg->len];
1550 cpec = i2c_smbus_msg_pec(cpec, msg);
1553 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1561 * i2c_smbus_read_byte - SMBus "receive byte" protocol
1562 * @client: Handle to slave device
1564 * This executes the SMBus "receive byte" protocol, returning negative errno
1565 * else the byte received from the device.
1567 s32 i2c_smbus_read_byte(struct i2c_client *client)
1569 union i2c_smbus_data data;
1572 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1574 I2C_SMBUS_BYTE, &data);
1575 return (status < 0) ? status : data.byte;
1577 EXPORT_SYMBOL(i2c_smbus_read_byte);
1580 * i2c_smbus_write_byte - SMBus "send byte" protocol
1581 * @client: Handle to slave device
1582 * @value: Byte to be sent
1584 * This executes the SMBus "send byte" protocol, returning negative errno
1585 * else zero on success.
1587 s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
1589 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1590 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
1592 EXPORT_SYMBOL(i2c_smbus_write_byte);
1595 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
1596 * @client: Handle to slave device
1597 * @command: Byte interpreted by slave
1599 * This executes the SMBus "read byte" protocol, returning negative errno
1600 * else a data byte received from the device.
1602 s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
1604 union i2c_smbus_data data;
1607 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1608 I2C_SMBUS_READ, command,
1609 I2C_SMBUS_BYTE_DATA, &data);
1610 return (status < 0) ? status : data.byte;
1612 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1615 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
1616 * @client: Handle to slave device
1617 * @command: Byte interpreted by slave
1618 * @value: Byte being written
1620 * This executes the SMBus "write byte" protocol, returning negative errno
1621 * else zero on success.
1623 s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
1625 union i2c_smbus_data data;
1627 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1628 I2C_SMBUS_WRITE,command,
1629 I2C_SMBUS_BYTE_DATA,&data);
1631 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1634 * i2c_smbus_read_word_data - SMBus "read word" protocol
1635 * @client: Handle to slave device
1636 * @command: Byte interpreted by slave
1638 * This executes the SMBus "read word" protocol, returning negative errno
1639 * else a 16-bit unsigned "word" received from the device.
1641 s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
1643 union i2c_smbus_data data;
1646 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1647 I2C_SMBUS_READ, command,
1648 I2C_SMBUS_WORD_DATA, &data);
1649 return (status < 0) ? status : data.word;
1651 EXPORT_SYMBOL(i2c_smbus_read_word_data);
1654 * i2c_smbus_write_word_data - SMBus "write word" protocol
1655 * @client: Handle to slave device
1656 * @command: Byte interpreted by slave
1657 * @value: 16-bit "word" being written
1659 * This executes the SMBus "write word" protocol, returning negative errno
1660 * else zero on success.
1662 s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
1664 union i2c_smbus_data data;
1666 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1667 I2C_SMBUS_WRITE,command,
1668 I2C_SMBUS_WORD_DATA,&data);
1670 EXPORT_SYMBOL(i2c_smbus_write_word_data);
1673 * i2c_smbus_read_block_data - SMBus "block read" protocol
1674 * @client: Handle to slave device
1675 * @command: Byte interpreted by slave
1676 * @values: Byte array into which data will be read; big enough to hold
1677 * the data returned by the slave. SMBus allows at most 32 bytes.
1679 * This executes the SMBus "block read" protocol, returning negative errno
1680 * else the number of data bytes in the slave's response.
1682 * Note that using this function requires that the client's adapter support
1683 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
1684 * support this; its emulation through I2C messaging relies on a specific
1685 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
1687 s32 i2c_smbus_read_block_data(struct i2c_client *client, u8 command,
1690 union i2c_smbus_data data;
1693 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1694 I2C_SMBUS_READ, command,
1695 I2C_SMBUS_BLOCK_DATA, &data);
1699 memcpy(values, &data.block[1], data.block[0]);
1700 return data.block[0];
1702 EXPORT_SYMBOL(i2c_smbus_read_block_data);
1705 * i2c_smbus_write_block_data - SMBus "block write" protocol
1706 * @client: Handle to slave device
1707 * @command: Byte interpreted by slave
1708 * @length: Size of data block; SMBus allows at most 32 bytes
1709 * @values: Byte array which will be written.
1711 * This executes the SMBus "block write" protocol, returning negative errno
1712 * else zero on success.
1714 s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
1715 u8 length, const u8 *values)
1717 union i2c_smbus_data data;
1719 if (length > I2C_SMBUS_BLOCK_MAX)
1720 length = I2C_SMBUS_BLOCK_MAX;
1721 data.block[0] = length;
1722 memcpy(&data.block[1], values, length);
1723 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1724 I2C_SMBUS_WRITE,command,
1725 I2C_SMBUS_BLOCK_DATA,&data);
1727 EXPORT_SYMBOL(i2c_smbus_write_block_data);
1729 /* Returns the number of read bytes */
1730 s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command,
1731 u8 length, u8 *values)
1733 union i2c_smbus_data data;
1736 if (length > I2C_SMBUS_BLOCK_MAX)
1737 length = I2C_SMBUS_BLOCK_MAX;
1738 data.block[0] = length;
1739 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1740 I2C_SMBUS_READ, command,
1741 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1745 memcpy(values, &data.block[1], data.block[0]);
1746 return data.block[0];
1748 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1750 s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, u8 command,
1751 u8 length, const u8 *values)
1753 union i2c_smbus_data data;
1755 if (length > I2C_SMBUS_BLOCK_MAX)
1756 length = I2C_SMBUS_BLOCK_MAX;
1757 data.block[0] = length;
1758 memcpy(data.block + 1, values, length);
1759 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1760 I2C_SMBUS_WRITE, command,
1761 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1763 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
1765 /* Simulate a SMBus command using the i2c protocol
1766 No checking of parameters is done! */
1767 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
1768 unsigned short flags,
1769 char read_write, u8 command, int size,
1770 union i2c_smbus_data * data)
1772 /* So we need to generate a series of msgs. In the case of writing, we
1773 need to use only one message; when reading, we need two. We initialize
1774 most things with sane defaults, to keep the code below somewhat
1776 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1777 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
1778 int num = read_write == I2C_SMBUS_READ?2:1;
1779 struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
1780 { addr, flags | I2C_M_RD, 0, msgbuf1 }
1786 msgbuf0[0] = command;
1788 case I2C_SMBUS_QUICK:
1790 /* Special case: The read/write field is used as data */
1791 msg[0].flags = flags | (read_write==I2C_SMBUS_READ)?I2C_M_RD:0;
1794 case I2C_SMBUS_BYTE:
1795 if (read_write == I2C_SMBUS_READ) {
1796 /* Special case: only a read! */
1797 msg[0].flags = I2C_M_RD | flags;
1801 case I2C_SMBUS_BYTE_DATA:
1802 if (read_write == I2C_SMBUS_READ)
1806 msgbuf0[1] = data->byte;
1809 case I2C_SMBUS_WORD_DATA:
1810 if (read_write == I2C_SMBUS_READ)
1814 msgbuf0[1] = data->word & 0xff;
1815 msgbuf0[2] = data->word >> 8;
1818 case I2C_SMBUS_PROC_CALL:
1819 num = 2; /* Special case */
1820 read_write = I2C_SMBUS_READ;
1823 msgbuf0[1] = data->word & 0xff;
1824 msgbuf0[2] = data->word >> 8;
1826 case I2C_SMBUS_BLOCK_DATA:
1827 if (read_write == I2C_SMBUS_READ) {
1828 msg[1].flags |= I2C_M_RECV_LEN;
1829 msg[1].len = 1; /* block length will be added by
1830 the underlying bus driver */
1832 msg[0].len = data->block[0] + 2;
1833 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
1834 dev_err(&adapter->dev,
1835 "Invalid block write size %d\n",
1839 for (i = 1; i < msg[0].len; i++)
1840 msgbuf0[i] = data->block[i-1];
1843 case I2C_SMBUS_BLOCK_PROC_CALL:
1844 num = 2; /* Another special case */
1845 read_write = I2C_SMBUS_READ;
1846 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
1847 dev_err(&adapter->dev,
1848 "Invalid block write size %d\n",
1852 msg[0].len = data->block[0] + 2;
1853 for (i = 1; i < msg[0].len; i++)
1854 msgbuf0[i] = data->block[i-1];
1855 msg[1].flags |= I2C_M_RECV_LEN;
1856 msg[1].len = 1; /* block length will be added by
1857 the underlying bus driver */
1859 case I2C_SMBUS_I2C_BLOCK_DATA:
1860 if (read_write == I2C_SMBUS_READ) {
1861 msg[1].len = data->block[0];
1863 msg[0].len = data->block[0] + 1;
1864 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
1865 dev_err(&adapter->dev,
1866 "Invalid block write size %d\n",
1870 for (i = 1; i <= data->block[0]; i++)
1871 msgbuf0[i] = data->block[i];
1875 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
1879 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
1880 && size != I2C_SMBUS_I2C_BLOCK_DATA);
1882 /* Compute PEC if first message is a write */
1883 if (!(msg[0].flags & I2C_M_RD)) {
1884 if (num == 1) /* Write only */
1885 i2c_smbus_add_pec(&msg[0]);
1886 else /* Write followed by read */
1887 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
1889 /* Ask for PEC if last message is a read */
1890 if (msg[num-1].flags & I2C_M_RD)
1894 status = i2c_transfer(adapter, msg, num);
1898 /* Check PEC if last message is a read */
1899 if (i && (msg[num-1].flags & I2C_M_RD)) {
1900 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
1905 if (read_write == I2C_SMBUS_READ)
1907 case I2C_SMBUS_BYTE:
1908 data->byte = msgbuf0[0];
1910 case I2C_SMBUS_BYTE_DATA:
1911 data->byte = msgbuf1[0];
1913 case I2C_SMBUS_WORD_DATA:
1914 case I2C_SMBUS_PROC_CALL:
1915 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
1917 case I2C_SMBUS_I2C_BLOCK_DATA:
1918 for (i = 0; i < data->block[0]; i++)
1919 data->block[i+1] = msgbuf1[i];
1921 case I2C_SMBUS_BLOCK_DATA:
1922 case I2C_SMBUS_BLOCK_PROC_CALL:
1923 for (i = 0; i < msgbuf1[0] + 1; i++)
1924 data->block[i] = msgbuf1[i];
1931 * i2c_smbus_xfer - execute SMBus protocol operations
1932 * @adapter: Handle to I2C bus
1933 * @addr: Address of SMBus slave on that bus
1934 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
1935 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
1936 * @command: Byte interpreted by slave, for protocols which use such bytes
1937 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
1938 * @data: Data to be read or written
1940 * This executes an SMBus protocol operation, and returns a negative
1941 * errno code else zero on success.
1943 s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u16 addr, unsigned short flags,
1944 char read_write, u8 command, int protocol,
1945 union i2c_smbus_data * data)
1949 flags &= I2C_M_TEN | I2C_CLIENT_PEC;
1951 if (adapter->algo->smbus_xfer) {
1952 mutex_lock(&adapter->bus_lock);
1953 res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write,
1954 command, protocol, data);
1955 mutex_unlock(&adapter->bus_lock);
1957 res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
1958 command, protocol, data);
1962 EXPORT_SYMBOL(i2c_smbus_xfer);
1964 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
1965 MODULE_DESCRIPTION("I2C-Bus main module");
1966 MODULE_LICENSE("GPL");