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 <asm/uaccess.h>
41 static LIST_HEAD(adapters);
42 static LIST_HEAD(drivers);
43 static DEFINE_MUTEX(core_lists);
44 static DEFINE_IDR(i2c_adapter_idr);
46 #define is_newstyle_driver(d) ((d)->probe || (d)->remove)
48 /* ------------------------------------------------------------------------- */
50 static int i2c_device_match(struct device *dev, struct device_driver *drv)
52 struct i2c_client *client = to_i2c_client(dev);
53 struct i2c_driver *driver = to_i2c_driver(drv);
55 /* make legacy i2c drivers bypass driver model probing entirely;
56 * such drivers scan each i2c adapter/bus themselves.
58 if (!is_newstyle_driver(driver))
61 /* new style drivers use the same kind of driver matching policy
62 * as platform devices or SPI: compare device and driver IDs.
64 return strcmp(client->driver_name, drv->name) == 0;
69 /* uevent helps with hotplug: modprobe -q $(MODALIAS) */
70 static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
72 struct i2c_client *client = to_i2c_client(dev);
74 /* by definition, legacy drivers can't hotplug */
75 if (dev->driver || !client->driver_name)
78 if (add_uevent_var(env, "MODALIAS=%s", client->driver_name))
80 dev_dbg(dev, "uevent\n");
85 #define i2c_device_uevent NULL
86 #endif /* CONFIG_HOTPLUG */
88 static int i2c_device_probe(struct device *dev)
90 struct i2c_client *client = to_i2c_client(dev);
91 struct i2c_driver *driver = to_i2c_driver(dev->driver);
95 client->driver = driver;
96 dev_dbg(dev, "probe\n");
97 return driver->probe(client);
100 static int i2c_device_remove(struct device *dev)
102 struct i2c_client *client = to_i2c_client(dev);
103 struct i2c_driver *driver;
109 driver = to_i2c_driver(dev->driver);
110 if (driver->remove) {
111 dev_dbg(dev, "remove\n");
112 status = driver->remove(client);
118 client->driver = NULL;
122 static void i2c_device_shutdown(struct device *dev)
124 struct i2c_driver *driver;
128 driver = to_i2c_driver(dev->driver);
129 if (driver->shutdown)
130 driver->shutdown(to_i2c_client(dev));
133 static int i2c_device_suspend(struct device * dev, pm_message_t mesg)
135 struct i2c_driver *driver;
139 driver = to_i2c_driver(dev->driver);
140 if (!driver->suspend)
142 return driver->suspend(to_i2c_client(dev), mesg);
145 static int i2c_device_resume(struct device * dev)
147 struct i2c_driver *driver;
151 driver = to_i2c_driver(dev->driver);
154 return driver->resume(to_i2c_client(dev));
157 static void i2c_client_release(struct device *dev)
159 struct i2c_client *client = to_i2c_client(dev);
160 complete(&client->released);
163 static void i2c_client_dev_release(struct device *dev)
165 kfree(to_i2c_client(dev));
168 static ssize_t show_client_name(struct device *dev, struct device_attribute *attr, char *buf)
170 struct i2c_client *client = to_i2c_client(dev);
171 return sprintf(buf, "%s\n", client->name);
174 static ssize_t show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
176 struct i2c_client *client = to_i2c_client(dev);
177 return client->driver_name
178 ? sprintf(buf, "%s\n", client->driver_name)
182 static struct device_attribute i2c_dev_attrs[] = {
183 __ATTR(name, S_IRUGO, show_client_name, NULL),
184 /* modalias helps coldplug: modprobe $(cat .../modalias) */
185 __ATTR(modalias, S_IRUGO, show_modalias, NULL),
189 struct bus_type i2c_bus_type = {
191 .dev_attrs = i2c_dev_attrs,
192 .match = i2c_device_match,
193 .uevent = i2c_device_uevent,
194 .probe = i2c_device_probe,
195 .remove = i2c_device_remove,
196 .shutdown = i2c_device_shutdown,
197 .suspend = i2c_device_suspend,
198 .resume = i2c_device_resume,
200 EXPORT_SYMBOL_GPL(i2c_bus_type);
203 * i2c_new_device - instantiate an i2c device for use with a new style driver
204 * @adap: the adapter managing the device
205 * @info: describes one I2C device; bus_num is ignored
208 * Create a device to work with a new style i2c driver, where binding is
209 * handled through driver model probe()/remove() methods. This call is not
210 * appropriate for use by mainboad initialization logic, which usually runs
211 * during an arch_initcall() long before any i2c_adapter could exist.
213 * This returns the new i2c client, which may be saved for later use with
214 * i2c_unregister_device(); or NULL to indicate an error.
217 i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
219 struct i2c_client *client;
222 client = kzalloc(sizeof *client, GFP_KERNEL);
226 client->adapter = adap;
228 client->dev.platform_data = info->platform_data;
229 device_init_wakeup(&client->dev, info->flags & I2C_CLIENT_WAKE);
231 client->flags = info->flags & ~I2C_CLIENT_WAKE;
232 client->addr = info->addr;
233 client->irq = info->irq;
235 strlcpy(client->driver_name, info->driver_name,
236 sizeof(client->driver_name));
237 strlcpy(client->name, info->type, sizeof(client->name));
239 /* a new style driver may be bound to this device when we
240 * return from this function, or any later moment (e.g. maybe
241 * hotplugging will load the driver module). and the device
242 * refcount model is the standard driver model one.
244 status = i2c_attach_client(client);
251 EXPORT_SYMBOL_GPL(i2c_new_device);
255 * i2c_unregister_device - reverse effect of i2c_new_device()
256 * @client: value returned from i2c_new_device()
259 void i2c_unregister_device(struct i2c_client *client)
261 struct i2c_adapter *adapter = client->adapter;
262 struct i2c_driver *driver = client->driver;
264 if (driver && !is_newstyle_driver(driver)) {
265 dev_err(&client->dev, "can't unregister devices "
266 "with legacy drivers\n");
271 mutex_lock(&adapter->clist_lock);
272 list_del(&client->list);
273 mutex_unlock(&adapter->clist_lock);
275 device_unregister(&client->dev);
277 EXPORT_SYMBOL_GPL(i2c_unregister_device);
280 /* ------------------------------------------------------------------------- */
282 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
284 void i2c_adapter_dev_release(struct device *dev)
286 struct i2c_adapter *adap = to_i2c_adapter(dev);
287 complete(&adap->dev_released);
291 show_adapter_name(struct device *dev, struct device_attribute *attr, char *buf)
293 struct i2c_adapter *adap = to_i2c_adapter(dev);
294 return sprintf(buf, "%s\n", adap->name);
297 static struct device_attribute i2c_adapter_attrs[] = {
298 __ATTR(name, S_IRUGO, show_adapter_name, NULL),
302 struct class i2c_adapter_class = {
303 .owner = THIS_MODULE,
304 .name = "i2c-adapter",
305 .dev_attrs = i2c_adapter_attrs,
308 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
310 struct i2c_devinfo *devinfo;
312 mutex_lock(&__i2c_board_lock);
313 list_for_each_entry(devinfo, &__i2c_board_list, list) {
314 if (devinfo->busnum == adapter->nr
315 && !i2c_new_device(adapter,
316 &devinfo->board_info))
317 printk(KERN_ERR "i2c-core: can't create i2c%d-%04x\n",
318 i2c_adapter_id(adapter),
319 devinfo->board_info.addr);
321 mutex_unlock(&__i2c_board_lock);
324 static int i2c_register_adapter(struct i2c_adapter *adap)
327 struct list_head *item;
328 struct i2c_driver *driver;
330 mutex_init(&adap->bus_lock);
331 mutex_init(&adap->clist_lock);
332 INIT_LIST_HEAD(&adap->clients);
334 mutex_lock(&core_lists);
335 list_add_tail(&adap->list, &adapters);
337 /* Add the adapter to the driver core.
338 * If the parent pointer is not set up,
339 * we add this adapter to the host bus.
341 if (adap->dev.parent == NULL) {
342 adap->dev.parent = &platform_bus;
343 pr_debug("I2C adapter driver [%s] forgot to specify "
344 "physical device\n", adap->name);
346 sprintf(adap->dev.bus_id, "i2c-%d", adap->nr);
347 adap->dev.release = &i2c_adapter_dev_release;
348 adap->dev.class = &i2c_adapter_class;
349 res = device_register(&adap->dev);
353 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
355 /* create pre-declared device nodes for new-style drivers */
356 if (adap->nr < __i2c_first_dynamic_bus_num)
357 i2c_scan_static_board_info(adap);
359 /* let legacy drivers scan this bus for matching devices */
360 list_for_each(item,&drivers) {
361 driver = list_entry(item, struct i2c_driver, list);
362 if (driver->attach_adapter)
363 /* We ignore the return code; if it fails, too bad */
364 driver->attach_adapter(adap);
368 mutex_unlock(&core_lists);
372 list_del(&adap->list);
373 idr_remove(&i2c_adapter_idr, adap->nr);
378 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
379 * @adapter: the adapter to add
382 * This routine is used to declare an I2C adapter when its bus number
383 * doesn't matter. Examples: for I2C adapters dynamically added by
384 * USB links or PCI plugin cards.
386 * When this returns zero, a new bus number was allocated and stored
387 * in adap->nr, and the specified adapter became available for clients.
388 * Otherwise, a negative errno value is returned.
390 int i2c_add_adapter(struct i2c_adapter *adapter)
395 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
398 mutex_lock(&core_lists);
399 /* "above" here means "above or equal to", sigh */
400 res = idr_get_new_above(&i2c_adapter_idr, adapter,
401 __i2c_first_dynamic_bus_num, &id);
402 mutex_unlock(&core_lists);
411 return i2c_register_adapter(adapter);
413 EXPORT_SYMBOL(i2c_add_adapter);
416 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
417 * @adap: the adapter to register (with adap->nr initialized)
420 * This routine is used to declare an I2C adapter when its bus number
421 * matters. Example: for I2C adapters from system-on-chip CPUs, or
422 * otherwise built in to the system's mainboard, and where i2c_board_info
423 * is used to properly configure I2C devices.
425 * If no devices have pre-been declared for this bus, then be sure to
426 * register the adapter before any dynamically allocated ones. Otherwise
427 * the required bus ID may not be available.
429 * When this returns zero, the specified adapter became available for
430 * clients using the bus number provided in adap->nr. Also, the table
431 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
432 * and the appropriate driver model device nodes are created. Otherwise, a
433 * negative errno value is returned.
435 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
440 if (adap->nr & ~MAX_ID_MASK)
444 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
447 mutex_lock(&core_lists);
448 /* "above" here means "above or equal to", sigh;
449 * we need the "equal to" result to force the result
451 status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
452 if (status == 0 && id != adap->nr) {
454 idr_remove(&i2c_adapter_idr, id);
456 mutex_unlock(&core_lists);
457 if (status == -EAGAIN)
461 status = i2c_register_adapter(adap);
464 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
467 * i2c_del_adapter - unregister I2C adapter
468 * @adap: the adapter being unregistered
471 * This unregisters an I2C adapter which was previously registered
472 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
474 int i2c_del_adapter(struct i2c_adapter *adap)
476 struct list_head *item, *_n;
477 struct i2c_adapter *adap_from_list;
478 struct i2c_driver *driver;
479 struct i2c_client *client;
482 mutex_lock(&core_lists);
484 /* First make sure that this adapter was ever added */
485 list_for_each_entry(adap_from_list, &adapters, list) {
486 if (adap_from_list == adap)
489 if (adap_from_list != adap) {
490 pr_debug("i2c-core: attempting to delete unregistered "
491 "adapter [%s]\n", adap->name);
496 list_for_each(item,&drivers) {
497 driver = list_entry(item, struct i2c_driver, list);
498 if (driver->detach_adapter)
499 if ((res = driver->detach_adapter(adap))) {
500 dev_err(&adap->dev, "detach_adapter failed "
502 driver->driver.name);
507 /* detach any active clients. This must be done first, because
508 * it can fail; in which case we give up. */
509 list_for_each_safe(item, _n, &adap->clients) {
510 struct i2c_driver *driver;
512 client = list_entry(item, struct i2c_client, list);
513 driver = client->driver;
515 /* new style, follow standard driver model */
516 if (!driver || is_newstyle_driver(driver)) {
517 i2c_unregister_device(client);
521 /* legacy drivers create and remove clients themselves */
522 if ((res = driver->detach_client(client))) {
523 dev_err(&adap->dev, "detach_client failed for client "
524 "[%s] at address 0x%02x\n", client->name,
530 /* clean up the sysfs representation */
531 init_completion(&adap->dev_released);
532 device_unregister(&adap->dev);
533 list_del(&adap->list);
535 /* wait for sysfs to drop all references */
536 wait_for_completion(&adap->dev_released);
539 idr_remove(&i2c_adapter_idr, adap->nr);
541 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
544 mutex_unlock(&core_lists);
547 EXPORT_SYMBOL(i2c_del_adapter);
550 /* ------------------------------------------------------------------------- */
553 * An i2c_driver is used with one or more i2c_client (device) nodes to access
554 * i2c slave chips, on a bus instance associated with some i2c_adapter. There
555 * are two models for binding the driver to its device: "new style" drivers
556 * follow the standard Linux driver model and just respond to probe() calls
557 * issued if the driver core sees they match(); "legacy" drivers create device
561 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
565 /* new style driver methods can't mix with legacy ones */
566 if (is_newstyle_driver(driver)) {
567 if (driver->attach_adapter || driver->detach_adapter
568 || driver->detach_client) {
570 "i2c-core: driver [%s] is confused\n",
571 driver->driver.name);
576 /* add the driver to the list of i2c drivers in the driver core */
577 driver->driver.owner = owner;
578 driver->driver.bus = &i2c_bus_type;
580 /* for new style drivers, when registration returns the driver core
581 * will have called probe() for all matching-but-unbound devices.
583 res = driver_register(&driver->driver);
587 mutex_lock(&core_lists);
589 list_add_tail(&driver->list,&drivers);
590 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
592 /* legacy drivers scan i2c busses directly */
593 if (driver->attach_adapter) {
594 struct i2c_adapter *adapter;
596 list_for_each_entry(adapter, &adapters, list) {
597 driver->attach_adapter(adapter);
601 mutex_unlock(&core_lists);
604 EXPORT_SYMBOL(i2c_register_driver);
607 * i2c_del_driver - unregister I2C driver
608 * @driver: the driver being unregistered
611 void i2c_del_driver(struct i2c_driver *driver)
613 struct list_head *item1, *item2, *_n;
614 struct i2c_client *client;
615 struct i2c_adapter *adap;
617 mutex_lock(&core_lists);
619 /* new-style driver? */
620 if (is_newstyle_driver(driver))
623 /* Have a look at each adapter, if clients of this driver are still
624 * attached. If so, detach them to be able to kill the driver
627 list_for_each(item1,&adapters) {
628 adap = list_entry(item1, struct i2c_adapter, list);
629 if (driver->detach_adapter) {
630 if (driver->detach_adapter(adap)) {
631 dev_err(&adap->dev, "detach_adapter failed "
633 driver->driver.name);
636 list_for_each_safe(item2, _n, &adap->clients) {
637 client = list_entry(item2, struct i2c_client, list);
638 if (client->driver != driver)
640 dev_dbg(&adap->dev, "detaching client [%s] "
641 "at 0x%02x\n", client->name,
643 if (driver->detach_client(client)) {
644 dev_err(&adap->dev, "detach_client "
645 "failed for client [%s] at "
646 "0x%02x\n", client->name,
654 driver_unregister(&driver->driver);
655 list_del(&driver->list);
656 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
658 mutex_unlock(&core_lists);
660 EXPORT_SYMBOL(i2c_del_driver);
662 /* ------------------------------------------------------------------------- */
664 static int __i2c_check_addr(struct i2c_adapter *adapter, unsigned int addr)
666 struct list_head *item;
667 struct i2c_client *client;
669 list_for_each(item,&adapter->clients) {
670 client = list_entry(item, struct i2c_client, list);
671 if (client->addr == addr)
677 int i2c_check_addr(struct i2c_adapter *adapter, int addr)
681 mutex_lock(&adapter->clist_lock);
682 rval = __i2c_check_addr(adapter, addr);
683 mutex_unlock(&adapter->clist_lock);
687 EXPORT_SYMBOL(i2c_check_addr);
689 int i2c_attach_client(struct i2c_client *client)
691 struct i2c_adapter *adapter = client->adapter;
694 mutex_lock(&adapter->clist_lock);
695 if (__i2c_check_addr(client->adapter, client->addr)) {
699 list_add_tail(&client->list,&adapter->clients);
701 client->usage_count = 0;
703 client->dev.parent = &client->adapter->dev;
704 client->dev.bus = &i2c_bus_type;
707 client->dev.driver = &client->driver->driver;
709 if (client->driver && !is_newstyle_driver(client->driver)) {
710 client->dev.release = i2c_client_release;
711 client->dev.uevent_suppress = 1;
713 client->dev.release = i2c_client_dev_release;
715 snprintf(&client->dev.bus_id[0], sizeof(client->dev.bus_id),
716 "%d-%04x", i2c_adapter_id(adapter), client->addr);
717 dev_dbg(&adapter->dev, "client [%s] registered with bus id %s\n",
718 client->name, client->dev.bus_id);
719 res = device_register(&client->dev);
722 mutex_unlock(&adapter->clist_lock);
724 if (adapter->client_register) {
725 if (adapter->client_register(client)) {
726 dev_dbg(&adapter->dev, "client_register "
727 "failed for client [%s] at 0x%02x\n",
728 client->name, client->addr);
735 list_del(&client->list);
736 dev_err(&adapter->dev, "Failed to attach i2c client %s at 0x%02x "
737 "(%d)\n", client->name, client->addr, res);
739 mutex_unlock(&adapter->clist_lock);
742 EXPORT_SYMBOL(i2c_attach_client);
744 int i2c_detach_client(struct i2c_client *client)
746 struct i2c_adapter *adapter = client->adapter;
749 if (client->usage_count > 0) {
750 dev_warn(&client->dev, "Client [%s] still busy, "
751 "can't detach\n", client->name);
755 if (adapter->client_unregister) {
756 res = adapter->client_unregister(client);
758 dev_err(&client->dev,
759 "client_unregister [%s] failed, "
760 "client not detached\n", client->name);
765 mutex_lock(&adapter->clist_lock);
766 list_del(&client->list);
767 init_completion(&client->released);
768 device_unregister(&client->dev);
769 mutex_unlock(&adapter->clist_lock);
770 wait_for_completion(&client->released);
775 EXPORT_SYMBOL(i2c_detach_client);
777 static int i2c_inc_use_client(struct i2c_client *client)
780 if (!try_module_get(client->driver->driver.owner))
782 if (!try_module_get(client->adapter->owner)) {
783 module_put(client->driver->driver.owner);
790 static void i2c_dec_use_client(struct i2c_client *client)
792 module_put(client->driver->driver.owner);
793 module_put(client->adapter->owner);
796 int i2c_use_client(struct i2c_client *client)
800 ret = i2c_inc_use_client(client);
804 client->usage_count++;
808 EXPORT_SYMBOL(i2c_use_client);
810 int i2c_release_client(struct i2c_client *client)
812 if (!client->usage_count) {
813 pr_debug("i2c-core: %s used one too many times\n",
818 client->usage_count--;
819 i2c_dec_use_client(client);
823 EXPORT_SYMBOL(i2c_release_client);
825 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
827 struct list_head *item;
828 struct i2c_client *client;
830 mutex_lock(&adap->clist_lock);
831 list_for_each(item,&adap->clients) {
832 client = list_entry(item, struct i2c_client, list);
833 if (!try_module_get(client->driver->driver.owner))
835 if (NULL != client->driver->command) {
836 mutex_unlock(&adap->clist_lock);
837 client->driver->command(client,cmd,arg);
838 mutex_lock(&adap->clist_lock);
840 module_put(client->driver->driver.owner);
842 mutex_unlock(&adap->clist_lock);
844 EXPORT_SYMBOL(i2c_clients_command);
846 static int __init i2c_init(void)
850 retval = bus_register(&i2c_bus_type);
853 return class_register(&i2c_adapter_class);
856 static void __exit i2c_exit(void)
858 class_unregister(&i2c_adapter_class);
859 bus_unregister(&i2c_bus_type);
862 subsys_initcall(i2c_init);
863 module_exit(i2c_exit);
865 /* ----------------------------------------------------
866 * the functional interface to the i2c busses.
867 * ----------------------------------------------------
870 int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num)
874 if (adap->algo->master_xfer) {
876 for (ret = 0; ret < num; ret++) {
877 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
878 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
879 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
880 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
884 mutex_lock_nested(&adap->bus_lock, adap->level);
885 ret = adap->algo->master_xfer(adap,msgs,num);
886 mutex_unlock(&adap->bus_lock);
890 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
894 EXPORT_SYMBOL(i2c_transfer);
896 int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
899 struct i2c_adapter *adap=client->adapter;
902 msg.addr = client->addr;
903 msg.flags = client->flags & I2C_M_TEN;
905 msg.buf = (char *)buf;
907 ret = i2c_transfer(adap, &msg, 1);
909 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
910 transmitted, else error code. */
911 return (ret == 1) ? count : ret;
913 EXPORT_SYMBOL(i2c_master_send);
915 int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
917 struct i2c_adapter *adap=client->adapter;
921 msg.addr = client->addr;
922 msg.flags = client->flags & I2C_M_TEN;
923 msg.flags |= I2C_M_RD;
927 ret = i2c_transfer(adap, &msg, 1);
929 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
930 transmitted, else error code. */
931 return (ret == 1) ? count : ret;
933 EXPORT_SYMBOL(i2c_master_recv);
935 int i2c_control(struct i2c_client *client,
936 unsigned int cmd, unsigned long arg)
939 struct i2c_adapter *adap = client->adapter;
941 dev_dbg(&client->adapter->dev, "i2c ioctl, cmd: 0x%x, arg: %#lx\n", cmd, arg);
950 if (adap->algo->algo_control!=NULL)
951 ret = adap->algo->algo_control(adap,cmd,arg);
955 EXPORT_SYMBOL(i2c_control);
957 /* ----------------------------------------------------
958 * the i2c address scanning function
959 * Will not work for 10-bit addresses!
960 * ----------------------------------------------------
962 static int i2c_probe_address(struct i2c_adapter *adapter, int addr, int kind,
963 int (*found_proc) (struct i2c_adapter *, int, int))
967 /* Make sure the address is valid */
968 if (addr < 0x03 || addr > 0x77) {
969 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
974 /* Skip if already in use */
975 if (i2c_check_addr(adapter, addr))
978 /* Make sure there is something at this address, unless forced */
980 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
981 I2C_SMBUS_QUICK, NULL) < 0)
984 /* prevent 24RF08 corruption */
985 if ((addr & ~0x0f) == 0x50)
986 i2c_smbus_xfer(adapter, addr, 0, 0, 0,
987 I2C_SMBUS_QUICK, NULL);
990 /* Finally call the custom detection function */
991 err = found_proc(adapter, addr, kind);
992 /* -ENODEV can be returned if there is a chip at the given address
993 but it isn't supported by this chip driver. We catch it here as
994 this isn't an error. */
999 dev_warn(&adapter->dev, "Client creation failed at 0x%x (%d)\n",
1004 int i2c_probe(struct i2c_adapter *adapter,
1005 struct i2c_client_address_data *address_data,
1006 int (*found_proc) (struct i2c_adapter *, int, int))
1009 int adap_id = i2c_adapter_id(adapter);
1011 /* Force entries are done first, and are not affected by ignore
1013 if (address_data->forces) {
1014 unsigned short **forces = address_data->forces;
1017 for (kind = 0; forces[kind]; kind++) {
1018 for (i = 0; forces[kind][i] != I2C_CLIENT_END;
1020 if (forces[kind][i] == adap_id
1021 || forces[kind][i] == ANY_I2C_BUS) {
1022 dev_dbg(&adapter->dev, "found force "
1023 "parameter for adapter %d, "
1024 "addr 0x%02x, kind %d\n",
1025 adap_id, forces[kind][i + 1],
1027 err = i2c_probe_address(adapter,
1028 forces[kind][i + 1],
1037 /* Stop here if we can't use SMBUS_QUICK */
1038 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
1039 if (address_data->probe[0] == I2C_CLIENT_END
1040 && address_data->normal_i2c[0] == I2C_CLIENT_END)
1043 dev_warn(&adapter->dev, "SMBus Quick command not supported, "
1044 "can't probe for chips\n");
1048 /* Probe entries are done second, and are not affected by ignore
1050 for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
1051 if (address_data->probe[i] == adap_id
1052 || address_data->probe[i] == ANY_I2C_BUS) {
1053 dev_dbg(&adapter->dev, "found probe parameter for "
1054 "adapter %d, addr 0x%02x\n", adap_id,
1055 address_data->probe[i + 1]);
1056 err = i2c_probe_address(adapter,
1057 address_data->probe[i + 1],
1064 /* Normal entries are done last, unless shadowed by an ignore entry */
1065 for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
1069 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
1071 if ((address_data->ignore[j] == adap_id ||
1072 address_data->ignore[j] == ANY_I2C_BUS)
1073 && address_data->ignore[j + 1]
1074 == address_data->normal_i2c[i]) {
1075 dev_dbg(&adapter->dev, "found ignore "
1076 "parameter for adapter %d, "
1077 "addr 0x%02x\n", adap_id,
1078 address_data->ignore[j + 1]);
1086 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1087 "addr 0x%02x\n", adap_id,
1088 address_data->normal_i2c[i]);
1089 err = i2c_probe_address(adapter, address_data->normal_i2c[i],
1097 EXPORT_SYMBOL(i2c_probe);
1100 i2c_new_probed_device(struct i2c_adapter *adap,
1101 struct i2c_board_info *info,
1102 unsigned short const *addr_list)
1106 /* Stop here if the bus doesn't support probing */
1107 if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE)) {
1108 dev_err(&adap->dev, "Probing not supported\n");
1112 mutex_lock(&adap->clist_lock);
1113 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1114 /* Check address validity */
1115 if (addr_list[i] < 0x03 || addr_list[i] > 0x77) {
1116 dev_warn(&adap->dev, "Invalid 7-bit address "
1117 "0x%02x\n", addr_list[i]);
1121 /* Check address availability */
1122 if (__i2c_check_addr(adap, addr_list[i])) {
1123 dev_dbg(&adap->dev, "Address 0x%02x already in "
1124 "use, not probing\n", addr_list[i]);
1128 /* Test address responsiveness
1129 The default probe method is a quick write, but it is known
1130 to corrupt the 24RF08 EEPROMs due to a state machine bug,
1131 and could also irreversibly write-protect some EEPROMs, so
1132 for address ranges 0x30-0x37 and 0x50-0x5f, we use a byte
1133 read instead. Also, some bus drivers don't implement
1134 quick write, so we fallback to a byte read it that case
1136 if ((addr_list[i] & ~0x07) == 0x30
1137 || (addr_list[i] & ~0x0f) == 0x50
1138 || !i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK)) {
1139 if (i2c_smbus_xfer(adap, addr_list[i], 0,
1141 I2C_SMBUS_BYTE, NULL) >= 0)
1144 if (i2c_smbus_xfer(adap, addr_list[i], 0,
1146 I2C_SMBUS_QUICK, NULL) >= 0)
1150 mutex_unlock(&adap->clist_lock);
1152 if (addr_list[i] == I2C_CLIENT_END) {
1153 dev_dbg(&adap->dev, "Probing failed, no device found\n");
1157 info->addr = addr_list[i];
1158 return i2c_new_device(adap, info);
1160 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1162 struct i2c_adapter* i2c_get_adapter(int id)
1164 struct i2c_adapter *adapter;
1166 mutex_lock(&core_lists);
1167 adapter = (struct i2c_adapter *)idr_find(&i2c_adapter_idr, id);
1168 if (adapter && !try_module_get(adapter->owner))
1171 mutex_unlock(&core_lists);
1174 EXPORT_SYMBOL(i2c_get_adapter);
1176 void i2c_put_adapter(struct i2c_adapter *adap)
1178 module_put(adap->owner);
1180 EXPORT_SYMBOL(i2c_put_adapter);
1182 /* The SMBus parts */
1184 #define POLY (0x1070U << 3)
1190 for(i = 0; i < 8; i++) {
1195 return (u8)(data >> 8);
1198 /* Incremental CRC8 over count bytes in the array pointed to by p */
1199 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
1203 for(i = 0; i < count; i++)
1204 crc = crc8((crc ^ p[i]) << 8);
1208 /* Assume a 7-bit address, which is reasonable for SMBus */
1209 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
1211 /* The address will be sent first */
1212 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1213 pec = i2c_smbus_pec(pec, &addr, 1);
1215 /* The data buffer follows */
1216 return i2c_smbus_pec(pec, msg->buf, msg->len);
1219 /* Used for write only transactions */
1220 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
1222 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1226 /* Return <0 on CRC error
1227 If there was a write before this read (most cases) we need to take the
1228 partial CRC from the write part into account.
1229 Note that this function does modify the message (we need to decrease the
1230 message length to hide the CRC byte from the caller). */
1231 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
1233 u8 rpec = msg->buf[--msg->len];
1234 cpec = i2c_smbus_msg_pec(cpec, msg);
1237 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1244 s32 i2c_smbus_write_quick(struct i2c_client *client, u8 value)
1246 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1247 value,0,I2C_SMBUS_QUICK,NULL);
1249 EXPORT_SYMBOL(i2c_smbus_write_quick);
1251 s32 i2c_smbus_read_byte(struct i2c_client *client)
1253 union i2c_smbus_data data;
1254 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1255 I2C_SMBUS_READ,0,I2C_SMBUS_BYTE, &data))
1260 EXPORT_SYMBOL(i2c_smbus_read_byte);
1262 s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
1264 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1265 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
1267 EXPORT_SYMBOL(i2c_smbus_write_byte);
1269 s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
1271 union i2c_smbus_data data;
1272 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1273 I2C_SMBUS_READ,command, I2C_SMBUS_BYTE_DATA,&data))
1278 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1280 s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
1282 union i2c_smbus_data data;
1284 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1285 I2C_SMBUS_WRITE,command,
1286 I2C_SMBUS_BYTE_DATA,&data);
1288 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1290 s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
1292 union i2c_smbus_data data;
1293 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1294 I2C_SMBUS_READ,command, I2C_SMBUS_WORD_DATA, &data))
1299 EXPORT_SYMBOL(i2c_smbus_read_word_data);
1301 s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
1303 union i2c_smbus_data data;
1305 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1306 I2C_SMBUS_WRITE,command,
1307 I2C_SMBUS_WORD_DATA,&data);
1309 EXPORT_SYMBOL(i2c_smbus_write_word_data);
1311 /* Returns the number of read bytes */
1312 s32 i2c_smbus_read_block_data(struct i2c_client *client, u8 command,
1315 union i2c_smbus_data data;
1317 if (i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1318 I2C_SMBUS_READ, command,
1319 I2C_SMBUS_BLOCK_DATA, &data))
1322 memcpy(values, &data.block[1], data.block[0]);
1323 return data.block[0];
1325 EXPORT_SYMBOL(i2c_smbus_read_block_data);
1327 s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
1328 u8 length, const u8 *values)
1330 union i2c_smbus_data data;
1332 if (length > I2C_SMBUS_BLOCK_MAX)
1333 length = I2C_SMBUS_BLOCK_MAX;
1334 data.block[0] = length;
1335 memcpy(&data.block[1], values, length);
1336 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1337 I2C_SMBUS_WRITE,command,
1338 I2C_SMBUS_BLOCK_DATA,&data);
1340 EXPORT_SYMBOL(i2c_smbus_write_block_data);
1342 /* Returns the number of read bytes */
1343 s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command,
1344 u8 length, u8 *values)
1346 union i2c_smbus_data data;
1348 if (length > I2C_SMBUS_BLOCK_MAX)
1349 length = I2C_SMBUS_BLOCK_MAX;
1350 data.block[0] = length;
1351 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1352 I2C_SMBUS_READ,command,
1353 I2C_SMBUS_I2C_BLOCK_DATA,&data))
1356 memcpy(values, &data.block[1], data.block[0]);
1357 return data.block[0];
1359 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1361 s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, u8 command,
1362 u8 length, const u8 *values)
1364 union i2c_smbus_data data;
1366 if (length > I2C_SMBUS_BLOCK_MAX)
1367 length = I2C_SMBUS_BLOCK_MAX;
1368 data.block[0] = length;
1369 memcpy(data.block + 1, values, length);
1370 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1371 I2C_SMBUS_WRITE, command,
1372 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1374 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
1376 /* Simulate a SMBus command using the i2c protocol
1377 No checking of parameters is done! */
1378 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
1379 unsigned short flags,
1380 char read_write, u8 command, int size,
1381 union i2c_smbus_data * data)
1383 /* So we need to generate a series of msgs. In the case of writing, we
1384 need to use only one message; when reading, we need two. We initialize
1385 most things with sane defaults, to keep the code below somewhat
1387 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1388 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
1389 int num = read_write == I2C_SMBUS_READ?2:1;
1390 struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
1391 { addr, flags | I2C_M_RD, 0, msgbuf1 }
1396 msgbuf0[0] = command;
1398 case I2C_SMBUS_QUICK:
1400 /* Special case: The read/write field is used as data */
1401 msg[0].flags = flags | (read_write==I2C_SMBUS_READ)?I2C_M_RD:0;
1404 case I2C_SMBUS_BYTE:
1405 if (read_write == I2C_SMBUS_READ) {
1406 /* Special case: only a read! */
1407 msg[0].flags = I2C_M_RD | flags;
1411 case I2C_SMBUS_BYTE_DATA:
1412 if (read_write == I2C_SMBUS_READ)
1416 msgbuf0[1] = data->byte;
1419 case I2C_SMBUS_WORD_DATA:
1420 if (read_write == I2C_SMBUS_READ)
1424 msgbuf0[1] = data->word & 0xff;
1425 msgbuf0[2] = data->word >> 8;
1428 case I2C_SMBUS_PROC_CALL:
1429 num = 2; /* Special case */
1430 read_write = I2C_SMBUS_READ;
1433 msgbuf0[1] = data->word & 0xff;
1434 msgbuf0[2] = data->word >> 8;
1436 case I2C_SMBUS_BLOCK_DATA:
1437 if (read_write == I2C_SMBUS_READ) {
1438 msg[1].flags |= I2C_M_RECV_LEN;
1439 msg[1].len = 1; /* block length will be added by
1440 the underlying bus driver */
1442 msg[0].len = data->block[0] + 2;
1443 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
1444 dev_err(&adapter->dev, "smbus_access called with "
1445 "invalid block write size (%d)\n",
1449 for (i = 1; i < msg[0].len; i++)
1450 msgbuf0[i] = data->block[i-1];
1453 case I2C_SMBUS_BLOCK_PROC_CALL:
1454 num = 2; /* Another special case */
1455 read_write = I2C_SMBUS_READ;
1456 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
1457 dev_err(&adapter->dev, "%s called with invalid "
1458 "block proc call size (%d)\n", __FUNCTION__,
1462 msg[0].len = data->block[0] + 2;
1463 for (i = 1; i < msg[0].len; i++)
1464 msgbuf0[i] = data->block[i-1];
1465 msg[1].flags |= I2C_M_RECV_LEN;
1466 msg[1].len = 1; /* block length will be added by
1467 the underlying bus driver */
1469 case I2C_SMBUS_I2C_BLOCK_DATA:
1470 if (read_write == I2C_SMBUS_READ) {
1471 msg[1].len = data->block[0];
1473 msg[0].len = data->block[0] + 1;
1474 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
1475 dev_err(&adapter->dev, "i2c_smbus_xfer_emulated called with "
1476 "invalid block write size (%d)\n",
1480 for (i = 1; i <= data->block[0]; i++)
1481 msgbuf0[i] = data->block[i];
1485 dev_err(&adapter->dev, "smbus_access called with invalid size (%d)\n",
1490 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
1491 && size != I2C_SMBUS_I2C_BLOCK_DATA);
1493 /* Compute PEC if first message is a write */
1494 if (!(msg[0].flags & I2C_M_RD)) {
1495 if (num == 1) /* Write only */
1496 i2c_smbus_add_pec(&msg[0]);
1497 else /* Write followed by read */
1498 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
1500 /* Ask for PEC if last message is a read */
1501 if (msg[num-1].flags & I2C_M_RD)
1505 if (i2c_transfer(adapter, msg, num) < 0)
1508 /* Check PEC if last message is a read */
1509 if (i && (msg[num-1].flags & I2C_M_RD)) {
1510 if (i2c_smbus_check_pec(partial_pec, &msg[num-1]) < 0)
1514 if (read_write == I2C_SMBUS_READ)
1516 case I2C_SMBUS_BYTE:
1517 data->byte = msgbuf0[0];
1519 case I2C_SMBUS_BYTE_DATA:
1520 data->byte = msgbuf1[0];
1522 case I2C_SMBUS_WORD_DATA:
1523 case I2C_SMBUS_PROC_CALL:
1524 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
1526 case I2C_SMBUS_I2C_BLOCK_DATA:
1527 for (i = 0; i < data->block[0]; i++)
1528 data->block[i+1] = msgbuf1[i];
1530 case I2C_SMBUS_BLOCK_DATA:
1531 case I2C_SMBUS_BLOCK_PROC_CALL:
1532 for (i = 0; i < msgbuf1[0] + 1; i++)
1533 data->block[i] = msgbuf1[i];
1540 s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u16 addr, unsigned short flags,
1541 char read_write, u8 command, int size,
1542 union i2c_smbus_data * data)
1546 flags &= I2C_M_TEN | I2C_CLIENT_PEC;
1548 if (adapter->algo->smbus_xfer) {
1549 mutex_lock(&adapter->bus_lock);
1550 res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write,
1552 mutex_unlock(&adapter->bus_lock);
1554 res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
1559 EXPORT_SYMBOL(i2c_smbus_xfer);
1561 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
1562 MODULE_DESCRIPTION("I2C-Bus main module");
1563 MODULE_LICENSE("GPL");