1 /* i2c-core.c - a device driver for the iic-bus interface */
2 /* ------------------------------------------------------------------------- */
3 /* Copyright (C) 1995-99 Simon G. Vogl
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
18 /* ------------------------------------------------------------------------- */
20 /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi>.
21 All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl>
22 SMBus 2.0 support by Mark Studebaker <mdsxyz123@yahoo.com> and
23 Jean Delvare <khali@linux-fr.org> */
25 #include <linux/module.h>
26 #include <linux/kernel.h>
27 #include <linux/errno.h>
28 #include <linux/slab.h>
29 #include <linux/i2c.h>
30 #include <linux/init.h>
31 #include <linux/idr.h>
32 #include <linux/seq_file.h>
33 #include <linux/platform_device.h>
34 #include <linux/mutex.h>
35 #include <linux/completion.h>
36 #include <linux/hardirq.h>
37 #include <linux/irqflags.h>
38 #include <asm/uaccess.h>
39 #include <asm/semaphore.h>
44 static DEFINE_MUTEX(core_lock);
45 static DEFINE_IDR(i2c_adapter_idr);
47 #define is_newstyle_driver(d) ((d)->probe || (d)->remove)
49 /* ------------------------------------------------------------------------- */
51 static int i2c_device_match(struct device *dev, struct device_driver *drv)
53 struct i2c_client *client = to_i2c_client(dev);
54 struct i2c_driver *driver = to_i2c_driver(drv);
56 /* make legacy i2c drivers bypass driver model probing entirely;
57 * such drivers scan each i2c adapter/bus themselves.
59 if (!is_newstyle_driver(driver))
62 /* new style drivers use the same kind of driver matching policy
63 * as platform devices or SPI: compare device and driver IDs.
65 return strcmp(client->driver_name, drv->name) == 0;
70 /* uevent helps with hotplug: modprobe -q $(MODALIAS) */
71 static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
73 struct i2c_client *client = to_i2c_client(dev);
75 /* by definition, legacy drivers can't hotplug */
76 if (dev->driver || !client->driver_name)
79 if (add_uevent_var(env, "MODALIAS=%s", client->driver_name))
81 dev_dbg(dev, "uevent\n");
86 #define i2c_device_uevent NULL
87 #endif /* CONFIG_HOTPLUG */
89 static int i2c_device_probe(struct device *dev)
91 struct i2c_client *client = to_i2c_client(dev);
92 struct i2c_driver *driver = to_i2c_driver(dev->driver);
96 client->driver = driver;
97 dev_dbg(dev, "probe\n");
98 return driver->probe(client);
101 static int i2c_device_remove(struct device *dev)
103 struct i2c_client *client = to_i2c_client(dev);
104 struct i2c_driver *driver;
110 driver = to_i2c_driver(dev->driver);
111 if (driver->remove) {
112 dev_dbg(dev, "remove\n");
113 status = driver->remove(client);
119 client->driver = NULL;
123 static void i2c_device_shutdown(struct device *dev)
125 struct i2c_driver *driver;
129 driver = to_i2c_driver(dev->driver);
130 if (driver->shutdown)
131 driver->shutdown(to_i2c_client(dev));
134 static int i2c_device_suspend(struct device * dev, pm_message_t mesg)
136 struct i2c_driver *driver;
140 driver = to_i2c_driver(dev->driver);
141 if (!driver->suspend)
143 return driver->suspend(to_i2c_client(dev), mesg);
146 static int i2c_device_resume(struct device * dev)
148 struct i2c_driver *driver;
152 driver = to_i2c_driver(dev->driver);
155 return driver->resume(to_i2c_client(dev));
158 static void i2c_client_release(struct device *dev)
160 struct i2c_client *client = to_i2c_client(dev);
161 complete(&client->released);
164 static void i2c_client_dev_release(struct device *dev)
166 kfree(to_i2c_client(dev));
169 static ssize_t show_client_name(struct device *dev, struct device_attribute *attr, char *buf)
171 struct i2c_client *client = to_i2c_client(dev);
172 return sprintf(buf, "%s\n", client->name);
175 static ssize_t show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
177 struct i2c_client *client = to_i2c_client(dev);
178 return client->driver_name
179 ? sprintf(buf, "%s\n", client->driver_name)
183 static struct device_attribute i2c_dev_attrs[] = {
184 __ATTR(name, S_IRUGO, show_client_name, NULL),
185 /* modalias helps coldplug: modprobe $(cat .../modalias) */
186 __ATTR(modalias, S_IRUGO, show_modalias, NULL),
190 static struct bus_type i2c_bus_type = {
192 .dev_attrs = i2c_dev_attrs,
193 .match = i2c_device_match,
194 .uevent = i2c_device_uevent,
195 .probe = i2c_device_probe,
196 .remove = i2c_device_remove,
197 .shutdown = i2c_device_shutdown,
198 .suspend = i2c_device_suspend,
199 .resume = i2c_device_resume,
204 * i2c_verify_client - return parameter as i2c_client, or NULL
205 * @dev: device, probably from some driver model iterator
207 * When traversing the driver model tree, perhaps using driver model
208 * iterators like @device_for_each_child(), you can't assume very much
209 * about the nodes you find. Use this function to avoid oopses caused
210 * by wrongly treating some non-I2C device as an i2c_client.
212 struct i2c_client *i2c_verify_client(struct device *dev)
214 return (dev->bus == &i2c_bus_type)
218 EXPORT_SYMBOL(i2c_verify_client);
222 * i2c_new_device - instantiate an i2c device for use with a new style driver
223 * @adap: the adapter managing the device
224 * @info: describes one I2C device; bus_num is ignored
227 * Create a device to work with a new style i2c driver, where binding is
228 * handled through driver model probe()/remove() methods. This call is not
229 * appropriate for use by mainboad initialization logic, which usually runs
230 * during an arch_initcall() long before any i2c_adapter could exist.
232 * This returns the new i2c client, which may be saved for later use with
233 * i2c_unregister_device(); or NULL to indicate an error.
236 i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
238 struct i2c_client *client;
241 client = kzalloc(sizeof *client, GFP_KERNEL);
245 client->adapter = adap;
247 client->dev.platform_data = info->platform_data;
248 device_init_wakeup(&client->dev, info->flags & I2C_CLIENT_WAKE);
250 client->flags = info->flags & ~I2C_CLIENT_WAKE;
251 client->addr = info->addr;
252 client->irq = info->irq;
254 strlcpy(client->driver_name, info->driver_name,
255 sizeof(client->driver_name));
256 strlcpy(client->name, info->type, sizeof(client->name));
258 /* a new style driver may be bound to this device when we
259 * return from this function, or any later moment (e.g. maybe
260 * hotplugging will load the driver module). and the device
261 * refcount model is the standard driver model one.
263 status = i2c_attach_client(client);
270 EXPORT_SYMBOL_GPL(i2c_new_device);
274 * i2c_unregister_device - reverse effect of i2c_new_device()
275 * @client: value returned from i2c_new_device()
278 void i2c_unregister_device(struct i2c_client *client)
280 struct i2c_adapter *adapter = client->adapter;
281 struct i2c_driver *driver = client->driver;
283 if (driver && !is_newstyle_driver(driver)) {
284 dev_err(&client->dev, "can't unregister devices "
285 "with legacy drivers\n");
290 mutex_lock(&adapter->clist_lock);
291 list_del(&client->list);
292 mutex_unlock(&adapter->clist_lock);
294 device_unregister(&client->dev);
296 EXPORT_SYMBOL_GPL(i2c_unregister_device);
299 /* ------------------------------------------------------------------------- */
301 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
303 static void i2c_adapter_dev_release(struct device *dev)
305 struct i2c_adapter *adap = to_i2c_adapter(dev);
306 complete(&adap->dev_released);
310 show_adapter_name(struct device *dev, struct device_attribute *attr, char *buf)
312 struct i2c_adapter *adap = to_i2c_adapter(dev);
313 return sprintf(buf, "%s\n", adap->name);
316 static struct device_attribute i2c_adapter_attrs[] = {
317 __ATTR(name, S_IRUGO, show_adapter_name, NULL),
321 static struct class i2c_adapter_class = {
322 .owner = THIS_MODULE,
323 .name = "i2c-adapter",
324 .dev_attrs = i2c_adapter_attrs,
327 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
329 struct i2c_devinfo *devinfo;
331 mutex_lock(&__i2c_board_lock);
332 list_for_each_entry(devinfo, &__i2c_board_list, list) {
333 if (devinfo->busnum == adapter->nr
334 && !i2c_new_device(adapter,
335 &devinfo->board_info))
336 printk(KERN_ERR "i2c-core: can't create i2c%d-%04x\n",
337 i2c_adapter_id(adapter),
338 devinfo->board_info.addr);
340 mutex_unlock(&__i2c_board_lock);
343 static int i2c_do_add_adapter(struct device_driver *d, void *data)
345 struct i2c_driver *driver = to_i2c_driver(d);
346 struct i2c_adapter *adap = data;
348 if (driver->attach_adapter) {
349 /* We ignore the return code; if it fails, too bad */
350 driver->attach_adapter(adap);
355 static int i2c_register_adapter(struct i2c_adapter *adap)
359 mutex_init(&adap->bus_lock);
360 mutex_init(&adap->clist_lock);
361 INIT_LIST_HEAD(&adap->clients);
363 mutex_lock(&core_lock);
365 /* Add the adapter to the driver core.
366 * If the parent pointer is not set up,
367 * we add this adapter to the host bus.
369 if (adap->dev.parent == NULL) {
370 adap->dev.parent = &platform_bus;
371 pr_debug("I2C adapter driver [%s] forgot to specify "
372 "physical device\n", adap->name);
374 sprintf(adap->dev.bus_id, "i2c-%d", adap->nr);
375 adap->dev.release = &i2c_adapter_dev_release;
376 adap->dev.class = &i2c_adapter_class;
377 res = device_register(&adap->dev);
381 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
383 /* create pre-declared device nodes for new-style drivers */
384 if (adap->nr < __i2c_first_dynamic_bus_num)
385 i2c_scan_static_board_info(adap);
387 /* let legacy drivers scan this bus for matching devices */
388 dummy = bus_for_each_drv(&i2c_bus_type, NULL, adap,
392 mutex_unlock(&core_lock);
396 idr_remove(&i2c_adapter_idr, adap->nr);
401 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
402 * @adapter: the adapter to add
405 * This routine is used to declare an I2C adapter when its bus number
406 * doesn't matter. Examples: for I2C adapters dynamically added by
407 * USB links or PCI plugin cards.
409 * When this returns zero, a new bus number was allocated and stored
410 * in adap->nr, and the specified adapter became available for clients.
411 * Otherwise, a negative errno value is returned.
413 int i2c_add_adapter(struct i2c_adapter *adapter)
418 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
421 mutex_lock(&core_lock);
422 /* "above" here means "above or equal to", sigh */
423 res = idr_get_new_above(&i2c_adapter_idr, adapter,
424 __i2c_first_dynamic_bus_num, &id);
425 mutex_unlock(&core_lock);
434 return i2c_register_adapter(adapter);
436 EXPORT_SYMBOL(i2c_add_adapter);
439 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
440 * @adap: the adapter to register (with adap->nr initialized)
443 * This routine is used to declare an I2C adapter when its bus number
444 * matters. Example: for I2C adapters from system-on-chip CPUs, or
445 * otherwise built in to the system's mainboard, and where i2c_board_info
446 * is used to properly configure I2C devices.
448 * If no devices have pre-been declared for this bus, then be sure to
449 * register the adapter before any dynamically allocated ones. Otherwise
450 * the required bus ID may not be available.
452 * When this returns zero, the specified adapter became available for
453 * clients using the bus number provided in adap->nr. Also, the table
454 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
455 * and the appropriate driver model device nodes are created. Otherwise, a
456 * negative errno value is returned.
458 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
463 if (adap->nr & ~MAX_ID_MASK)
467 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
470 mutex_lock(&core_lock);
471 /* "above" here means "above or equal to", sigh;
472 * we need the "equal to" result to force the result
474 status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
475 if (status == 0 && id != adap->nr) {
477 idr_remove(&i2c_adapter_idr, id);
479 mutex_unlock(&core_lock);
480 if (status == -EAGAIN)
484 status = i2c_register_adapter(adap);
487 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
489 static int i2c_do_del_adapter(struct device_driver *d, void *data)
491 struct i2c_driver *driver = to_i2c_driver(d);
492 struct i2c_adapter *adapter = data;
495 if (!driver->detach_adapter)
497 res = driver->detach_adapter(adapter);
499 dev_err(&adapter->dev, "detach_adapter failed (%d) "
500 "for driver [%s]\n", res, driver->driver.name);
505 * i2c_del_adapter - unregister I2C adapter
506 * @adap: the adapter being unregistered
509 * This unregisters an I2C adapter which was previously registered
510 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
512 int i2c_del_adapter(struct i2c_adapter *adap)
514 struct list_head *item, *_n;
515 struct i2c_client *client;
518 mutex_lock(&core_lock);
520 /* First make sure that this adapter was ever added */
521 if (idr_find(&i2c_adapter_idr, adap->nr) != adap) {
522 pr_debug("i2c-core: attempting to delete unregistered "
523 "adapter [%s]\n", adap->name);
528 /* Tell drivers about this removal */
529 res = bus_for_each_drv(&i2c_bus_type, NULL, adap,
534 /* detach any active clients. This must be done first, because
535 * it can fail; in which case we give up. */
536 list_for_each_safe(item, _n, &adap->clients) {
537 struct i2c_driver *driver;
539 client = list_entry(item, struct i2c_client, list);
540 driver = client->driver;
542 /* new style, follow standard driver model */
543 if (!driver || is_newstyle_driver(driver)) {
544 i2c_unregister_device(client);
548 /* legacy drivers create and remove clients themselves */
549 if ((res = driver->detach_client(client))) {
550 dev_err(&adap->dev, "detach_client failed for client "
551 "[%s] at address 0x%02x\n", client->name,
557 /* clean up the sysfs representation */
558 init_completion(&adap->dev_released);
559 device_unregister(&adap->dev);
561 /* wait for sysfs to drop all references */
562 wait_for_completion(&adap->dev_released);
565 idr_remove(&i2c_adapter_idr, adap->nr);
567 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
570 mutex_unlock(&core_lock);
573 EXPORT_SYMBOL(i2c_del_adapter);
576 /* ------------------------------------------------------------------------- */
579 * An i2c_driver is used with one or more i2c_client (device) nodes to access
580 * i2c slave chips, on a bus instance associated with some i2c_adapter. There
581 * are two models for binding the driver to its device: "new style" drivers
582 * follow the standard Linux driver model and just respond to probe() calls
583 * issued if the driver core sees they match(); "legacy" drivers create device
587 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
591 /* new style driver methods can't mix with legacy ones */
592 if (is_newstyle_driver(driver)) {
593 if (driver->attach_adapter || driver->detach_adapter
594 || driver->detach_client) {
596 "i2c-core: driver [%s] is confused\n",
597 driver->driver.name);
602 /* add the driver to the list of i2c drivers in the driver core */
603 driver->driver.owner = owner;
604 driver->driver.bus = &i2c_bus_type;
606 /* for new style drivers, when registration returns the driver core
607 * will have called probe() for all matching-but-unbound devices.
609 res = driver_register(&driver->driver);
613 mutex_lock(&core_lock);
615 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
617 /* legacy drivers scan i2c busses directly */
618 if (driver->attach_adapter) {
619 struct i2c_adapter *adapter;
621 down(&i2c_adapter_class.sem);
622 list_for_each_entry(adapter, &i2c_adapter_class.devices,
624 driver->attach_adapter(adapter);
626 up(&i2c_adapter_class.sem);
629 mutex_unlock(&core_lock);
632 EXPORT_SYMBOL(i2c_register_driver);
635 * i2c_del_driver - unregister I2C driver
636 * @driver: the driver being unregistered
639 void i2c_del_driver(struct i2c_driver *driver)
641 struct list_head *item2, *_n;
642 struct i2c_client *client;
643 struct i2c_adapter *adap;
645 mutex_lock(&core_lock);
647 /* new-style driver? */
648 if (is_newstyle_driver(driver))
651 /* Have a look at each adapter, if clients of this driver are still
652 * attached. If so, detach them to be able to kill the driver
655 down(&i2c_adapter_class.sem);
656 list_for_each_entry(adap, &i2c_adapter_class.devices, dev.node) {
657 if (driver->detach_adapter) {
658 if (driver->detach_adapter(adap)) {
659 dev_err(&adap->dev, "detach_adapter failed "
661 driver->driver.name);
664 list_for_each_safe(item2, _n, &adap->clients) {
665 client = list_entry(item2, struct i2c_client, list);
666 if (client->driver != driver)
668 dev_dbg(&adap->dev, "detaching client [%s] "
669 "at 0x%02x\n", client->name,
671 if (driver->detach_client(client)) {
672 dev_err(&adap->dev, "detach_client "
673 "failed for client [%s] at "
674 "0x%02x\n", client->name,
680 up(&i2c_adapter_class.sem);
683 driver_unregister(&driver->driver);
684 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
686 mutex_unlock(&core_lock);
688 EXPORT_SYMBOL(i2c_del_driver);
690 /* ------------------------------------------------------------------------- */
692 static int __i2c_check_addr(struct device *dev, void *addrp)
694 struct i2c_client *client = i2c_verify_client(dev);
695 int addr = *(int *)addrp;
697 if (client && client->addr == addr)
702 static int i2c_check_addr(struct i2c_adapter *adapter, int addr)
704 return device_for_each_child(&adapter->dev, &addr, __i2c_check_addr);
707 int i2c_attach_client(struct i2c_client *client)
709 struct i2c_adapter *adapter = client->adapter;
712 mutex_lock(&adapter->clist_lock);
713 if (i2c_check_addr(client->adapter, client->addr)) {
717 list_add_tail(&client->list,&adapter->clients);
719 client->dev.parent = &client->adapter->dev;
720 client->dev.bus = &i2c_bus_type;
723 client->dev.driver = &client->driver->driver;
725 if (client->driver && !is_newstyle_driver(client->driver)) {
726 client->dev.release = i2c_client_release;
727 client->dev.uevent_suppress = 1;
729 client->dev.release = i2c_client_dev_release;
731 snprintf(&client->dev.bus_id[0], sizeof(client->dev.bus_id),
732 "%d-%04x", i2c_adapter_id(adapter), client->addr);
733 dev_dbg(&adapter->dev, "client [%s] registered with bus id %s\n",
734 client->name, client->dev.bus_id);
735 res = device_register(&client->dev);
738 mutex_unlock(&adapter->clist_lock);
740 if (adapter->client_register) {
741 if (adapter->client_register(client)) {
742 dev_dbg(&adapter->dev, "client_register "
743 "failed for client [%s] at 0x%02x\n",
744 client->name, client->addr);
751 list_del(&client->list);
752 dev_err(&adapter->dev, "Failed to attach i2c client %s at 0x%02x "
753 "(%d)\n", client->name, client->addr, res);
755 mutex_unlock(&adapter->clist_lock);
758 EXPORT_SYMBOL(i2c_attach_client);
760 int i2c_detach_client(struct i2c_client *client)
762 struct i2c_adapter *adapter = client->adapter;
765 if (adapter->client_unregister) {
766 res = adapter->client_unregister(client);
768 dev_err(&client->dev,
769 "client_unregister [%s] failed, "
770 "client not detached\n", client->name);
775 mutex_lock(&adapter->clist_lock);
776 list_del(&client->list);
777 init_completion(&client->released);
778 device_unregister(&client->dev);
779 mutex_unlock(&adapter->clist_lock);
780 wait_for_completion(&client->released);
785 EXPORT_SYMBOL(i2c_detach_client);
788 * i2c_use_client - increments the reference count of the i2c client structure
789 * @client: the client being referenced
791 * Each live reference to a client should be refcounted. The driver model does
792 * that automatically as part of driver binding, so that most drivers don't
793 * need to do this explicitly: they hold a reference until they're unbound
796 * A pointer to the client with the incremented reference counter is returned.
798 struct i2c_client *i2c_use_client(struct i2c_client *client)
800 get_device(&client->dev);
803 EXPORT_SYMBOL(i2c_use_client);
806 * i2c_release_client - release a use of the i2c client structure
807 * @client: the client being no longer referenced
809 * Must be called when a user of a client is finished with it.
811 void i2c_release_client(struct i2c_client *client)
813 put_device(&client->dev);
815 EXPORT_SYMBOL(i2c_release_client);
822 static int i2c_cmd(struct device *dev, void *_arg)
824 struct i2c_client *client = i2c_verify_client(dev);
825 struct i2c_cmd_arg *arg = _arg;
827 if (client && client->driver && client->driver->command)
828 client->driver->command(client, arg->cmd, arg->arg);
832 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
834 struct i2c_cmd_arg cmd_arg;
838 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
840 EXPORT_SYMBOL(i2c_clients_command);
842 static int __init i2c_init(void)
846 retval = bus_register(&i2c_bus_type);
849 return class_register(&i2c_adapter_class);
852 static void __exit i2c_exit(void)
854 class_unregister(&i2c_adapter_class);
855 bus_unregister(&i2c_bus_type);
858 subsys_initcall(i2c_init);
859 module_exit(i2c_exit);
861 /* ----------------------------------------------------
862 * the functional interface to the i2c busses.
863 * ----------------------------------------------------
866 int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num)
870 if (adap->algo->master_xfer) {
872 for (ret = 0; ret < num; ret++) {
873 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
874 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
875 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
876 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
880 if (in_atomic() || irqs_disabled()) {
881 ret = mutex_trylock(&adap->bus_lock);
883 /* I2C activity is ongoing. */
886 mutex_lock_nested(&adap->bus_lock, adap->level);
889 ret = adap->algo->master_xfer(adap,msgs,num);
890 mutex_unlock(&adap->bus_lock);
894 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
898 EXPORT_SYMBOL(i2c_transfer);
900 int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
903 struct i2c_adapter *adap=client->adapter;
906 msg.addr = client->addr;
907 msg.flags = client->flags & I2C_M_TEN;
909 msg.buf = (char *)buf;
911 ret = i2c_transfer(adap, &msg, 1);
913 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
914 transmitted, else error code. */
915 return (ret == 1) ? count : ret;
917 EXPORT_SYMBOL(i2c_master_send);
919 int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
921 struct i2c_adapter *adap=client->adapter;
925 msg.addr = client->addr;
926 msg.flags = client->flags & I2C_M_TEN;
927 msg.flags |= I2C_M_RD;
931 ret = i2c_transfer(adap, &msg, 1);
933 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
934 transmitted, else error code. */
935 return (ret == 1) ? count : ret;
937 EXPORT_SYMBOL(i2c_master_recv);
939 /* ----------------------------------------------------
940 * the i2c address scanning function
941 * Will not work for 10-bit addresses!
942 * ----------------------------------------------------
944 static int i2c_probe_address(struct i2c_adapter *adapter, int addr, int kind,
945 int (*found_proc) (struct i2c_adapter *, int, int))
949 /* Make sure the address is valid */
950 if (addr < 0x03 || addr > 0x77) {
951 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
956 /* Skip if already in use */
957 if (i2c_check_addr(adapter, addr))
960 /* Make sure there is something at this address, unless forced */
962 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
963 I2C_SMBUS_QUICK, NULL) < 0)
966 /* prevent 24RF08 corruption */
967 if ((addr & ~0x0f) == 0x50)
968 i2c_smbus_xfer(adapter, addr, 0, 0, 0,
969 I2C_SMBUS_QUICK, NULL);
972 /* Finally call the custom detection function */
973 err = found_proc(adapter, addr, kind);
974 /* -ENODEV can be returned if there is a chip at the given address
975 but it isn't supported by this chip driver. We catch it here as
976 this isn't an error. */
981 dev_warn(&adapter->dev, "Client creation failed at 0x%x (%d)\n",
986 int i2c_probe(struct i2c_adapter *adapter,
987 const struct i2c_client_address_data *address_data,
988 int (*found_proc) (struct i2c_adapter *, int, int))
991 int adap_id = i2c_adapter_id(adapter);
993 /* Force entries are done first, and are not affected by ignore
995 if (address_data->forces) {
996 const unsigned short * const *forces = address_data->forces;
999 for (kind = 0; forces[kind]; kind++) {
1000 for (i = 0; forces[kind][i] != I2C_CLIENT_END;
1002 if (forces[kind][i] == adap_id
1003 || forces[kind][i] == ANY_I2C_BUS) {
1004 dev_dbg(&adapter->dev, "found force "
1005 "parameter for adapter %d, "
1006 "addr 0x%02x, kind %d\n",
1007 adap_id, forces[kind][i + 1],
1009 err = i2c_probe_address(adapter,
1010 forces[kind][i + 1],
1019 /* Stop here if we can't use SMBUS_QUICK */
1020 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
1021 if (address_data->probe[0] == I2C_CLIENT_END
1022 && address_data->normal_i2c[0] == I2C_CLIENT_END)
1025 dev_warn(&adapter->dev, "SMBus Quick command not supported, "
1026 "can't probe for chips\n");
1030 /* Probe entries are done second, and are not affected by ignore
1032 for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
1033 if (address_data->probe[i] == adap_id
1034 || address_data->probe[i] == ANY_I2C_BUS) {
1035 dev_dbg(&adapter->dev, "found probe parameter for "
1036 "adapter %d, addr 0x%02x\n", adap_id,
1037 address_data->probe[i + 1]);
1038 err = i2c_probe_address(adapter,
1039 address_data->probe[i + 1],
1046 /* Normal entries are done last, unless shadowed by an ignore entry */
1047 for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
1051 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
1053 if ((address_data->ignore[j] == adap_id ||
1054 address_data->ignore[j] == ANY_I2C_BUS)
1055 && address_data->ignore[j + 1]
1056 == address_data->normal_i2c[i]) {
1057 dev_dbg(&adapter->dev, "found ignore "
1058 "parameter for adapter %d, "
1059 "addr 0x%02x\n", adap_id,
1060 address_data->ignore[j + 1]);
1068 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1069 "addr 0x%02x\n", adap_id,
1070 address_data->normal_i2c[i]);
1071 err = i2c_probe_address(adapter, address_data->normal_i2c[i],
1079 EXPORT_SYMBOL(i2c_probe);
1082 i2c_new_probed_device(struct i2c_adapter *adap,
1083 struct i2c_board_info *info,
1084 unsigned short const *addr_list)
1088 /* Stop here if the bus doesn't support probing */
1089 if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE)) {
1090 dev_err(&adap->dev, "Probing not supported\n");
1094 mutex_lock(&adap->clist_lock);
1095 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1096 /* Check address validity */
1097 if (addr_list[i] < 0x03 || addr_list[i] > 0x77) {
1098 dev_warn(&adap->dev, "Invalid 7-bit address "
1099 "0x%02x\n", addr_list[i]);
1103 /* Check address availability */
1104 if (i2c_check_addr(adap, addr_list[i])) {
1105 dev_dbg(&adap->dev, "Address 0x%02x already in "
1106 "use, not probing\n", addr_list[i]);
1110 /* Test address responsiveness
1111 The default probe method is a quick write, but it is known
1112 to corrupt the 24RF08 EEPROMs due to a state machine bug,
1113 and could also irreversibly write-protect some EEPROMs, so
1114 for address ranges 0x30-0x37 and 0x50-0x5f, we use a byte
1115 read instead. Also, some bus drivers don't implement
1116 quick write, so we fallback to a byte read it that case
1118 if ((addr_list[i] & ~0x07) == 0x30
1119 || (addr_list[i] & ~0x0f) == 0x50
1120 || !i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK)) {
1121 if (i2c_smbus_xfer(adap, addr_list[i], 0,
1123 I2C_SMBUS_BYTE, NULL) >= 0)
1126 if (i2c_smbus_xfer(adap, addr_list[i], 0,
1128 I2C_SMBUS_QUICK, NULL) >= 0)
1132 mutex_unlock(&adap->clist_lock);
1134 if (addr_list[i] == I2C_CLIENT_END) {
1135 dev_dbg(&adap->dev, "Probing failed, no device found\n");
1139 info->addr = addr_list[i];
1140 return i2c_new_device(adap, info);
1142 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1144 struct i2c_adapter* i2c_get_adapter(int id)
1146 struct i2c_adapter *adapter;
1148 mutex_lock(&core_lock);
1149 adapter = (struct i2c_adapter *)idr_find(&i2c_adapter_idr, id);
1150 if (adapter && !try_module_get(adapter->owner))
1153 mutex_unlock(&core_lock);
1156 EXPORT_SYMBOL(i2c_get_adapter);
1158 void i2c_put_adapter(struct i2c_adapter *adap)
1160 module_put(adap->owner);
1162 EXPORT_SYMBOL(i2c_put_adapter);
1164 /* The SMBus parts */
1166 #define POLY (0x1070U << 3)
1172 for(i = 0; i < 8; i++) {
1177 return (u8)(data >> 8);
1180 /* Incremental CRC8 over count bytes in the array pointed to by p */
1181 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
1185 for(i = 0; i < count; i++)
1186 crc = crc8((crc ^ p[i]) << 8);
1190 /* Assume a 7-bit address, which is reasonable for SMBus */
1191 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
1193 /* The address will be sent first */
1194 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1195 pec = i2c_smbus_pec(pec, &addr, 1);
1197 /* The data buffer follows */
1198 return i2c_smbus_pec(pec, msg->buf, msg->len);
1201 /* Used for write only transactions */
1202 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
1204 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1208 /* Return <0 on CRC error
1209 If there was a write before this read (most cases) we need to take the
1210 partial CRC from the write part into account.
1211 Note that this function does modify the message (we need to decrease the
1212 message length to hide the CRC byte from the caller). */
1213 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
1215 u8 rpec = msg->buf[--msg->len];
1216 cpec = i2c_smbus_msg_pec(cpec, msg);
1219 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1226 s32 i2c_smbus_write_quick(struct i2c_client *client, u8 value)
1228 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1229 value,0,I2C_SMBUS_QUICK,NULL);
1231 EXPORT_SYMBOL(i2c_smbus_write_quick);
1233 s32 i2c_smbus_read_byte(struct i2c_client *client)
1235 union i2c_smbus_data data;
1236 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1237 I2C_SMBUS_READ,0,I2C_SMBUS_BYTE, &data))
1242 EXPORT_SYMBOL(i2c_smbus_read_byte);
1244 s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
1246 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1247 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
1249 EXPORT_SYMBOL(i2c_smbus_write_byte);
1251 s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
1253 union i2c_smbus_data data;
1254 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1255 I2C_SMBUS_READ,command, I2C_SMBUS_BYTE_DATA,&data))
1260 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1262 s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
1264 union i2c_smbus_data data;
1266 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1267 I2C_SMBUS_WRITE,command,
1268 I2C_SMBUS_BYTE_DATA,&data);
1270 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1272 s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
1274 union i2c_smbus_data data;
1275 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1276 I2C_SMBUS_READ,command, I2C_SMBUS_WORD_DATA, &data))
1281 EXPORT_SYMBOL(i2c_smbus_read_word_data);
1283 s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
1285 union i2c_smbus_data data;
1287 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1288 I2C_SMBUS_WRITE,command,
1289 I2C_SMBUS_WORD_DATA,&data);
1291 EXPORT_SYMBOL(i2c_smbus_write_word_data);
1294 * i2c_smbus_read_block_data - SMBus block read request
1295 * @client: Handle to slave device
1296 * @command: Command byte issued to let the slave know what data should
1298 * @values: Byte array into which data will be read; big enough to hold
1299 * the data returned by the slave. SMBus allows at most 32 bytes.
1301 * Returns the number of bytes read in the slave's response, else a
1302 * negative number to indicate some kind of error.
1304 * Note that using this function requires that the client's adapter support
1305 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
1306 * support this; its emulation through I2C messaging relies on a specific
1307 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
1309 s32 i2c_smbus_read_block_data(struct i2c_client *client, u8 command,
1312 union i2c_smbus_data data;
1314 if (i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1315 I2C_SMBUS_READ, command,
1316 I2C_SMBUS_BLOCK_DATA, &data))
1319 memcpy(values, &data.block[1], data.block[0]);
1320 return data.block[0];
1322 EXPORT_SYMBOL(i2c_smbus_read_block_data);
1324 s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
1325 u8 length, const u8 *values)
1327 union i2c_smbus_data data;
1329 if (length > I2C_SMBUS_BLOCK_MAX)
1330 length = I2C_SMBUS_BLOCK_MAX;
1331 data.block[0] = length;
1332 memcpy(&data.block[1], values, length);
1333 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1334 I2C_SMBUS_WRITE,command,
1335 I2C_SMBUS_BLOCK_DATA,&data);
1337 EXPORT_SYMBOL(i2c_smbus_write_block_data);
1339 /* Returns the number of read bytes */
1340 s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command,
1341 u8 length, u8 *values)
1343 union i2c_smbus_data data;
1345 if (length > I2C_SMBUS_BLOCK_MAX)
1346 length = I2C_SMBUS_BLOCK_MAX;
1347 data.block[0] = length;
1348 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1349 I2C_SMBUS_READ,command,
1350 I2C_SMBUS_I2C_BLOCK_DATA,&data))
1353 memcpy(values, &data.block[1], data.block[0]);
1354 return data.block[0];
1356 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1358 s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, u8 command,
1359 u8 length, const u8 *values)
1361 union i2c_smbus_data data;
1363 if (length > I2C_SMBUS_BLOCK_MAX)
1364 length = I2C_SMBUS_BLOCK_MAX;
1365 data.block[0] = length;
1366 memcpy(data.block + 1, values, length);
1367 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1368 I2C_SMBUS_WRITE, command,
1369 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1371 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
1373 /* Simulate a SMBus command using the i2c protocol
1374 No checking of parameters is done! */
1375 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
1376 unsigned short flags,
1377 char read_write, u8 command, int size,
1378 union i2c_smbus_data * data)
1380 /* So we need to generate a series of msgs. In the case of writing, we
1381 need to use only one message; when reading, we need two. We initialize
1382 most things with sane defaults, to keep the code below somewhat
1384 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1385 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
1386 int num = read_write == I2C_SMBUS_READ?2:1;
1387 struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
1388 { addr, flags | I2C_M_RD, 0, msgbuf1 }
1393 msgbuf0[0] = command;
1395 case I2C_SMBUS_QUICK:
1397 /* Special case: The read/write field is used as data */
1398 msg[0].flags = flags | (read_write==I2C_SMBUS_READ)?I2C_M_RD:0;
1401 case I2C_SMBUS_BYTE:
1402 if (read_write == I2C_SMBUS_READ) {
1403 /* Special case: only a read! */
1404 msg[0].flags = I2C_M_RD | flags;
1408 case I2C_SMBUS_BYTE_DATA:
1409 if (read_write == I2C_SMBUS_READ)
1413 msgbuf0[1] = data->byte;
1416 case I2C_SMBUS_WORD_DATA:
1417 if (read_write == I2C_SMBUS_READ)
1421 msgbuf0[1] = data->word & 0xff;
1422 msgbuf0[2] = data->word >> 8;
1425 case I2C_SMBUS_PROC_CALL:
1426 num = 2; /* Special case */
1427 read_write = I2C_SMBUS_READ;
1430 msgbuf0[1] = data->word & 0xff;
1431 msgbuf0[2] = data->word >> 8;
1433 case I2C_SMBUS_BLOCK_DATA:
1434 if (read_write == I2C_SMBUS_READ) {
1435 msg[1].flags |= I2C_M_RECV_LEN;
1436 msg[1].len = 1; /* block length will be added by
1437 the underlying bus driver */
1439 msg[0].len = data->block[0] + 2;
1440 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
1441 dev_err(&adapter->dev, "smbus_access called with "
1442 "invalid block write size (%d)\n",
1446 for (i = 1; i < msg[0].len; i++)
1447 msgbuf0[i] = data->block[i-1];
1450 case I2C_SMBUS_BLOCK_PROC_CALL:
1451 num = 2; /* Another special case */
1452 read_write = I2C_SMBUS_READ;
1453 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
1454 dev_err(&adapter->dev, "%s called with invalid "
1455 "block proc call size (%d)\n", __FUNCTION__,
1459 msg[0].len = data->block[0] + 2;
1460 for (i = 1; i < msg[0].len; i++)
1461 msgbuf0[i] = data->block[i-1];
1462 msg[1].flags |= I2C_M_RECV_LEN;
1463 msg[1].len = 1; /* block length will be added by
1464 the underlying bus driver */
1466 case I2C_SMBUS_I2C_BLOCK_DATA:
1467 if (read_write == I2C_SMBUS_READ) {
1468 msg[1].len = data->block[0];
1470 msg[0].len = data->block[0] + 1;
1471 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
1472 dev_err(&adapter->dev, "i2c_smbus_xfer_emulated called with "
1473 "invalid block write size (%d)\n",
1477 for (i = 1; i <= data->block[0]; i++)
1478 msgbuf0[i] = data->block[i];
1482 dev_err(&adapter->dev, "smbus_access called with invalid size (%d)\n",
1487 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
1488 && size != I2C_SMBUS_I2C_BLOCK_DATA);
1490 /* Compute PEC if first message is a write */
1491 if (!(msg[0].flags & I2C_M_RD)) {
1492 if (num == 1) /* Write only */
1493 i2c_smbus_add_pec(&msg[0]);
1494 else /* Write followed by read */
1495 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
1497 /* Ask for PEC if last message is a read */
1498 if (msg[num-1].flags & I2C_M_RD)
1502 if (i2c_transfer(adapter, msg, num) < 0)
1505 /* Check PEC if last message is a read */
1506 if (i && (msg[num-1].flags & I2C_M_RD)) {
1507 if (i2c_smbus_check_pec(partial_pec, &msg[num-1]) < 0)
1511 if (read_write == I2C_SMBUS_READ)
1513 case I2C_SMBUS_BYTE:
1514 data->byte = msgbuf0[0];
1516 case I2C_SMBUS_BYTE_DATA:
1517 data->byte = msgbuf1[0];
1519 case I2C_SMBUS_WORD_DATA:
1520 case I2C_SMBUS_PROC_CALL:
1521 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
1523 case I2C_SMBUS_I2C_BLOCK_DATA:
1524 for (i = 0; i < data->block[0]; i++)
1525 data->block[i+1] = msgbuf1[i];
1527 case I2C_SMBUS_BLOCK_DATA:
1528 case I2C_SMBUS_BLOCK_PROC_CALL:
1529 for (i = 0; i < msgbuf1[0] + 1; i++)
1530 data->block[i] = msgbuf1[i];
1537 s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u16 addr, unsigned short flags,
1538 char read_write, u8 command, int size,
1539 union i2c_smbus_data * data)
1543 flags &= I2C_M_TEN | I2C_CLIENT_PEC;
1545 if (adapter->algo->smbus_xfer) {
1546 mutex_lock(&adapter->bus_lock);
1547 res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write,
1549 mutex_unlock(&adapter->bus_lock);
1551 res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
1556 EXPORT_SYMBOL(i2c_smbus_xfer);
1558 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
1559 MODULE_DESCRIPTION("I2C-Bus main module");
1560 MODULE_LICENSE("GPL");