cpufreq: kirkwood: Reinstate cpufreq driver for ARCH_KIRKWOOD
[linux/fpc-iii.git] / drivers / i2c / i2c-core.c
blob7c7f4b856badaea86063483e3b37c49485e411d3
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., 51 Franklin Street, Fifth Floor, Boston,
18 MA 02110-1301 USA. */
19 /* ------------------------------------------------------------------------- */
21 /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi>.
22 All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl>
23 SMBus 2.0 support by Mark Studebaker <mdsxyz123@yahoo.com> and
24 Jean Delvare <jdelvare@suse.de>
25 Mux support by Rodolfo Giometti <giometti@enneenne.com> and
26 Michael Lawnick <michael.lawnick.ext@nsn.com>
27 OF support is copyright (c) 2008 Jochen Friedrich <jochen@scram.de>
28 (based on a previous patch from Jon Smirl <jonsmirl@gmail.com>) and
29 (c) 2013 Wolfram Sang <wsa@the-dreams.de>
32 #include <linux/module.h>
33 #include <linux/kernel.h>
34 #include <linux/delay.h>
35 #include <linux/errno.h>
36 #include <linux/gpio.h>
37 #include <linux/slab.h>
38 #include <linux/i2c.h>
39 #include <linux/init.h>
40 #include <linux/idr.h>
41 #include <linux/mutex.h>
42 #include <linux/of.h>
43 #include <linux/of_device.h>
44 #include <linux/of_irq.h>
45 #include <linux/completion.h>
46 #include <linux/hardirq.h>
47 #include <linux/irqflags.h>
48 #include <linux/rwsem.h>
49 #include <linux/pm_runtime.h>
50 #include <linux/acpi.h>
51 #include <linux/jump_label.h>
52 #include <asm/uaccess.h>
54 #include "i2c-core.h"
56 #define CREATE_TRACE_POINTS
57 #include <trace/events/i2c.h>
59 /* core_lock protects i2c_adapter_idr, and guarantees
60 that device detection, deletion of detected devices, and attach_adapter
61 calls are serialized */
62 static DEFINE_MUTEX(core_lock);
63 static DEFINE_IDR(i2c_adapter_idr);
65 static struct device_type i2c_client_type;
66 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
68 static struct static_key i2c_trace_msg = STATIC_KEY_INIT_FALSE;
70 void i2c_transfer_trace_reg(void)
72 static_key_slow_inc(&i2c_trace_msg);
75 void i2c_transfer_trace_unreg(void)
77 static_key_slow_dec(&i2c_trace_msg);
80 /* ------------------------------------------------------------------------- */
82 static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
83 const struct i2c_client *client)
85 while (id->name[0]) {
86 if (strcmp(client->name, id->name) == 0)
87 return id;
88 id++;
90 return NULL;
93 static int i2c_device_match(struct device *dev, struct device_driver *drv)
95 struct i2c_client *client = i2c_verify_client(dev);
96 struct i2c_driver *driver;
98 if (!client)
99 return 0;
101 /* Attempt an OF style match */
102 if (of_driver_match_device(dev, drv))
103 return 1;
105 /* Then ACPI style match */
106 if (acpi_driver_match_device(dev, drv))
107 return 1;
109 driver = to_i2c_driver(drv);
110 /* match on an id table if there is one */
111 if (driver->id_table)
112 return i2c_match_id(driver->id_table, client) != NULL;
114 return 0;
118 /* uevent helps with hotplug: modprobe -q $(MODALIAS) */
119 static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
121 struct i2c_client *client = to_i2c_client(dev);
122 int rc;
124 rc = acpi_device_uevent_modalias(dev, env);
125 if (rc != -ENODEV)
126 return rc;
128 if (add_uevent_var(env, "MODALIAS=%s%s",
129 I2C_MODULE_PREFIX, client->name))
130 return -ENOMEM;
131 dev_dbg(dev, "uevent\n");
132 return 0;
135 /* i2c bus recovery routines */
136 static int get_scl_gpio_value(struct i2c_adapter *adap)
138 return gpio_get_value(adap->bus_recovery_info->scl_gpio);
141 static void set_scl_gpio_value(struct i2c_adapter *adap, int val)
143 gpio_set_value(adap->bus_recovery_info->scl_gpio, val);
146 static int get_sda_gpio_value(struct i2c_adapter *adap)
148 return gpio_get_value(adap->bus_recovery_info->sda_gpio);
151 static int i2c_get_gpios_for_recovery(struct i2c_adapter *adap)
153 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
154 struct device *dev = &adap->dev;
155 int ret = 0;
157 ret = gpio_request_one(bri->scl_gpio, GPIOF_OPEN_DRAIN |
158 GPIOF_OUT_INIT_HIGH, "i2c-scl");
159 if (ret) {
160 dev_warn(dev, "Can't get SCL gpio: %d\n", bri->scl_gpio);
161 return ret;
164 if (bri->get_sda) {
165 if (gpio_request_one(bri->sda_gpio, GPIOF_IN, "i2c-sda")) {
166 /* work without SDA polling */
167 dev_warn(dev, "Can't get SDA gpio: %d. Not using SDA polling\n",
168 bri->sda_gpio);
169 bri->get_sda = NULL;
173 return ret;
176 static void i2c_put_gpios_for_recovery(struct i2c_adapter *adap)
178 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
180 if (bri->get_sda)
181 gpio_free(bri->sda_gpio);
183 gpio_free(bri->scl_gpio);
187 * We are generating clock pulses. ndelay() determines durating of clk pulses.
188 * We will generate clock with rate 100 KHz and so duration of both clock levels
189 * is: delay in ns = (10^6 / 100) / 2
191 #define RECOVERY_NDELAY 5000
192 #define RECOVERY_CLK_CNT 9
194 static int i2c_generic_recovery(struct i2c_adapter *adap)
196 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
197 int i = 0, val = 1, ret = 0;
199 if (bri->prepare_recovery)
200 bri->prepare_recovery(bri);
203 * By this time SCL is high, as we need to give 9 falling-rising edges
205 while (i++ < RECOVERY_CLK_CNT * 2) {
206 if (val) {
207 /* Break if SDA is high */
208 if (bri->get_sda && bri->get_sda(adap))
209 break;
210 /* SCL shouldn't be low here */
211 if (!bri->get_scl(adap)) {
212 dev_err(&adap->dev,
213 "SCL is stuck low, exit recovery\n");
214 ret = -EBUSY;
215 break;
219 val = !val;
220 bri->set_scl(adap, val);
221 ndelay(RECOVERY_NDELAY);
224 if (bri->unprepare_recovery)
225 bri->unprepare_recovery(bri);
227 return ret;
230 int i2c_generic_scl_recovery(struct i2c_adapter *adap)
232 adap->bus_recovery_info->set_scl(adap, 1);
233 return i2c_generic_recovery(adap);
236 int i2c_generic_gpio_recovery(struct i2c_adapter *adap)
238 int ret;
240 ret = i2c_get_gpios_for_recovery(adap);
241 if (ret)
242 return ret;
244 ret = i2c_generic_recovery(adap);
245 i2c_put_gpios_for_recovery(adap);
247 return ret;
250 int i2c_recover_bus(struct i2c_adapter *adap)
252 if (!adap->bus_recovery_info)
253 return -EOPNOTSUPP;
255 dev_dbg(&adap->dev, "Trying i2c bus recovery\n");
256 return adap->bus_recovery_info->recover_bus(adap);
259 static int i2c_device_probe(struct device *dev)
261 struct i2c_client *client = i2c_verify_client(dev);
262 struct i2c_driver *driver;
263 int status;
265 if (!client)
266 return 0;
268 driver = to_i2c_driver(dev->driver);
269 if (!driver->probe || !driver->id_table)
270 return -ENODEV;
272 if (!device_can_wakeup(&client->dev))
273 device_init_wakeup(&client->dev,
274 client->flags & I2C_CLIENT_WAKE);
275 dev_dbg(dev, "probe\n");
277 acpi_dev_pm_attach(&client->dev, true);
278 status = driver->probe(client, i2c_match_id(driver->id_table, client));
279 if (status)
280 acpi_dev_pm_detach(&client->dev, true);
282 return status;
285 static int i2c_device_remove(struct device *dev)
287 struct i2c_client *client = i2c_verify_client(dev);
288 struct i2c_driver *driver;
289 int status = 0;
291 if (!client || !dev->driver)
292 return 0;
294 driver = to_i2c_driver(dev->driver);
295 if (driver->remove) {
296 dev_dbg(dev, "remove\n");
297 status = driver->remove(client);
300 acpi_dev_pm_detach(&client->dev, true);
301 return status;
304 static void i2c_device_shutdown(struct device *dev)
306 struct i2c_client *client = i2c_verify_client(dev);
307 struct i2c_driver *driver;
309 if (!client || !dev->driver)
310 return;
311 driver = to_i2c_driver(dev->driver);
312 if (driver->shutdown)
313 driver->shutdown(client);
316 #ifdef CONFIG_PM_SLEEP
317 static int i2c_legacy_suspend(struct device *dev, pm_message_t mesg)
319 struct i2c_client *client = i2c_verify_client(dev);
320 struct i2c_driver *driver;
322 if (!client || !dev->driver)
323 return 0;
324 driver = to_i2c_driver(dev->driver);
325 if (!driver->suspend)
326 return 0;
327 return driver->suspend(client, mesg);
330 static int i2c_legacy_resume(struct device *dev)
332 struct i2c_client *client = i2c_verify_client(dev);
333 struct i2c_driver *driver;
335 if (!client || !dev->driver)
336 return 0;
337 driver = to_i2c_driver(dev->driver);
338 if (!driver->resume)
339 return 0;
340 return driver->resume(client);
343 static int i2c_device_pm_suspend(struct device *dev)
345 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
347 if (pm)
348 return pm_generic_suspend(dev);
349 else
350 return i2c_legacy_suspend(dev, PMSG_SUSPEND);
353 static int i2c_device_pm_resume(struct device *dev)
355 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
357 if (pm)
358 return pm_generic_resume(dev);
359 else
360 return i2c_legacy_resume(dev);
363 static int i2c_device_pm_freeze(struct device *dev)
365 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
367 if (pm)
368 return pm_generic_freeze(dev);
369 else
370 return i2c_legacy_suspend(dev, PMSG_FREEZE);
373 static int i2c_device_pm_thaw(struct device *dev)
375 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
377 if (pm)
378 return pm_generic_thaw(dev);
379 else
380 return i2c_legacy_resume(dev);
383 static int i2c_device_pm_poweroff(struct device *dev)
385 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
387 if (pm)
388 return pm_generic_poweroff(dev);
389 else
390 return i2c_legacy_suspend(dev, PMSG_HIBERNATE);
393 static int i2c_device_pm_restore(struct device *dev)
395 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
397 if (pm)
398 return pm_generic_restore(dev);
399 else
400 return i2c_legacy_resume(dev);
402 #else /* !CONFIG_PM_SLEEP */
403 #define i2c_device_pm_suspend NULL
404 #define i2c_device_pm_resume NULL
405 #define i2c_device_pm_freeze NULL
406 #define i2c_device_pm_thaw NULL
407 #define i2c_device_pm_poweroff NULL
408 #define i2c_device_pm_restore NULL
409 #endif /* !CONFIG_PM_SLEEP */
411 static void i2c_client_dev_release(struct device *dev)
413 kfree(to_i2c_client(dev));
416 static ssize_t
417 show_name(struct device *dev, struct device_attribute *attr, char *buf)
419 return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
420 to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
423 static ssize_t
424 show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
426 struct i2c_client *client = to_i2c_client(dev);
427 int len;
429 len = acpi_device_modalias(dev, buf, PAGE_SIZE -1);
430 if (len != -ENODEV)
431 return len;
433 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
436 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
437 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
439 static struct attribute *i2c_dev_attrs[] = {
440 &dev_attr_name.attr,
441 /* modalias helps coldplug: modprobe $(cat .../modalias) */
442 &dev_attr_modalias.attr,
443 NULL
446 static struct attribute_group i2c_dev_attr_group = {
447 .attrs = i2c_dev_attrs,
450 static const struct attribute_group *i2c_dev_attr_groups[] = {
451 &i2c_dev_attr_group,
452 NULL
455 static const struct dev_pm_ops i2c_device_pm_ops = {
456 .suspend = i2c_device_pm_suspend,
457 .resume = i2c_device_pm_resume,
458 .freeze = i2c_device_pm_freeze,
459 .thaw = i2c_device_pm_thaw,
460 .poweroff = i2c_device_pm_poweroff,
461 .restore = i2c_device_pm_restore,
462 SET_RUNTIME_PM_OPS(
463 pm_generic_runtime_suspend,
464 pm_generic_runtime_resume,
465 NULL
469 struct bus_type i2c_bus_type = {
470 .name = "i2c",
471 .match = i2c_device_match,
472 .probe = i2c_device_probe,
473 .remove = i2c_device_remove,
474 .shutdown = i2c_device_shutdown,
475 .pm = &i2c_device_pm_ops,
477 EXPORT_SYMBOL_GPL(i2c_bus_type);
479 static struct device_type i2c_client_type = {
480 .groups = i2c_dev_attr_groups,
481 .uevent = i2c_device_uevent,
482 .release = i2c_client_dev_release,
487 * i2c_verify_client - return parameter as i2c_client, or NULL
488 * @dev: device, probably from some driver model iterator
490 * When traversing the driver model tree, perhaps using driver model
491 * iterators like @device_for_each_child(), you can't assume very much
492 * about the nodes you find. Use this function to avoid oopses caused
493 * by wrongly treating some non-I2C device as an i2c_client.
495 struct i2c_client *i2c_verify_client(struct device *dev)
497 return (dev->type == &i2c_client_type)
498 ? to_i2c_client(dev)
499 : NULL;
501 EXPORT_SYMBOL(i2c_verify_client);
504 /* This is a permissive address validity check, I2C address map constraints
505 * are purposely not enforced, except for the general call address. */
506 static int i2c_check_client_addr_validity(const struct i2c_client *client)
508 if (client->flags & I2C_CLIENT_TEN) {
509 /* 10-bit address, all values are valid */
510 if (client->addr > 0x3ff)
511 return -EINVAL;
512 } else {
513 /* 7-bit address, reject the general call address */
514 if (client->addr == 0x00 || client->addr > 0x7f)
515 return -EINVAL;
517 return 0;
520 /* And this is a strict address validity check, used when probing. If a
521 * device uses a reserved address, then it shouldn't be probed. 7-bit
522 * addressing is assumed, 10-bit address devices are rare and should be
523 * explicitly enumerated. */
524 static int i2c_check_addr_validity(unsigned short addr)
527 * Reserved addresses per I2C specification:
528 * 0x00 General call address / START byte
529 * 0x01 CBUS address
530 * 0x02 Reserved for different bus format
531 * 0x03 Reserved for future purposes
532 * 0x04-0x07 Hs-mode master code
533 * 0x78-0x7b 10-bit slave addressing
534 * 0x7c-0x7f Reserved for future purposes
536 if (addr < 0x08 || addr > 0x77)
537 return -EINVAL;
538 return 0;
541 static int __i2c_check_addr_busy(struct device *dev, void *addrp)
543 struct i2c_client *client = i2c_verify_client(dev);
544 int addr = *(int *)addrp;
546 if (client && client->addr == addr)
547 return -EBUSY;
548 return 0;
551 /* walk up mux tree */
552 static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
554 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
555 int result;
557 result = device_for_each_child(&adapter->dev, &addr,
558 __i2c_check_addr_busy);
560 if (!result && parent)
561 result = i2c_check_mux_parents(parent, addr);
563 return result;
566 /* recurse down mux tree */
567 static int i2c_check_mux_children(struct device *dev, void *addrp)
569 int result;
571 if (dev->type == &i2c_adapter_type)
572 result = device_for_each_child(dev, addrp,
573 i2c_check_mux_children);
574 else
575 result = __i2c_check_addr_busy(dev, addrp);
577 return result;
580 static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
582 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
583 int result = 0;
585 if (parent)
586 result = i2c_check_mux_parents(parent, addr);
588 if (!result)
589 result = device_for_each_child(&adapter->dev, &addr,
590 i2c_check_mux_children);
592 return result;
596 * i2c_lock_adapter - Get exclusive access to an I2C bus segment
597 * @adapter: Target I2C bus segment
599 void i2c_lock_adapter(struct i2c_adapter *adapter)
601 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
603 if (parent)
604 i2c_lock_adapter(parent);
605 else
606 rt_mutex_lock(&adapter->bus_lock);
608 EXPORT_SYMBOL_GPL(i2c_lock_adapter);
611 * i2c_trylock_adapter - Try to get exclusive access to an I2C bus segment
612 * @adapter: Target I2C bus segment
614 static int i2c_trylock_adapter(struct i2c_adapter *adapter)
616 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
618 if (parent)
619 return i2c_trylock_adapter(parent);
620 else
621 return rt_mutex_trylock(&adapter->bus_lock);
625 * i2c_unlock_adapter - Release exclusive access to an I2C bus segment
626 * @adapter: Target I2C bus segment
628 void i2c_unlock_adapter(struct i2c_adapter *adapter)
630 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
632 if (parent)
633 i2c_unlock_adapter(parent);
634 else
635 rt_mutex_unlock(&adapter->bus_lock);
637 EXPORT_SYMBOL_GPL(i2c_unlock_adapter);
639 static void i2c_dev_set_name(struct i2c_adapter *adap,
640 struct i2c_client *client)
642 struct acpi_device *adev = ACPI_COMPANION(&client->dev);
644 if (adev) {
645 dev_set_name(&client->dev, "i2c-%s", acpi_dev_name(adev));
646 return;
649 /* For 10-bit clients, add an arbitrary offset to avoid collisions */
650 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
651 client->addr | ((client->flags & I2C_CLIENT_TEN)
652 ? 0xa000 : 0));
656 * i2c_new_device - instantiate an i2c device
657 * @adap: the adapter managing the device
658 * @info: describes one I2C device; bus_num is ignored
659 * Context: can sleep
661 * Create an i2c device. Binding is handled through driver model
662 * probe()/remove() methods. A driver may be bound to this device when we
663 * return from this function, or any later moment (e.g. maybe hotplugging will
664 * load the driver module). This call is not appropriate for use by mainboard
665 * initialization logic, which usually runs during an arch_initcall() long
666 * before any i2c_adapter could exist.
668 * This returns the new i2c client, which may be saved for later use with
669 * i2c_unregister_device(); or NULL to indicate an error.
671 struct i2c_client *
672 i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
674 struct i2c_client *client;
675 int status;
677 client = kzalloc(sizeof *client, GFP_KERNEL);
678 if (!client)
679 return NULL;
681 client->adapter = adap;
683 client->dev.platform_data = info->platform_data;
685 if (info->archdata)
686 client->dev.archdata = *info->archdata;
688 client->flags = info->flags;
689 client->addr = info->addr;
690 client->irq = info->irq;
692 strlcpy(client->name, info->type, sizeof(client->name));
694 /* Check for address validity */
695 status = i2c_check_client_addr_validity(client);
696 if (status) {
697 dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
698 client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
699 goto out_err_silent;
702 /* Check for address business */
703 status = i2c_check_addr_busy(adap, client->addr);
704 if (status)
705 goto out_err;
707 client->dev.parent = &client->adapter->dev;
708 client->dev.bus = &i2c_bus_type;
709 client->dev.type = &i2c_client_type;
710 client->dev.of_node = info->of_node;
711 ACPI_COMPANION_SET(&client->dev, info->acpi_node.companion);
713 i2c_dev_set_name(adap, client);
714 status = device_register(&client->dev);
715 if (status)
716 goto out_err;
718 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
719 client->name, dev_name(&client->dev));
721 return client;
723 out_err:
724 dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
725 "(%d)\n", client->name, client->addr, status);
726 out_err_silent:
727 kfree(client);
728 return NULL;
730 EXPORT_SYMBOL_GPL(i2c_new_device);
734 * i2c_unregister_device - reverse effect of i2c_new_device()
735 * @client: value returned from i2c_new_device()
736 * Context: can sleep
738 void i2c_unregister_device(struct i2c_client *client)
740 device_unregister(&client->dev);
742 EXPORT_SYMBOL_GPL(i2c_unregister_device);
745 static const struct i2c_device_id dummy_id[] = {
746 { "dummy", 0 },
747 { },
750 static int dummy_probe(struct i2c_client *client,
751 const struct i2c_device_id *id)
753 return 0;
756 static int dummy_remove(struct i2c_client *client)
758 return 0;
761 static struct i2c_driver dummy_driver = {
762 .driver.name = "dummy",
763 .probe = dummy_probe,
764 .remove = dummy_remove,
765 .id_table = dummy_id,
769 * i2c_new_dummy - return a new i2c device bound to a dummy driver
770 * @adapter: the adapter managing the device
771 * @address: seven bit address to be used
772 * Context: can sleep
774 * This returns an I2C client bound to the "dummy" driver, intended for use
775 * with devices that consume multiple addresses. Examples of such chips
776 * include various EEPROMS (like 24c04 and 24c08 models).
778 * These dummy devices have two main uses. First, most I2C and SMBus calls
779 * except i2c_transfer() need a client handle; the dummy will be that handle.
780 * And second, this prevents the specified address from being bound to a
781 * different driver.
783 * This returns the new i2c client, which should be saved for later use with
784 * i2c_unregister_device(); or NULL to indicate an error.
786 struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
788 struct i2c_board_info info = {
789 I2C_BOARD_INFO("dummy", address),
792 return i2c_new_device(adapter, &info);
794 EXPORT_SYMBOL_GPL(i2c_new_dummy);
796 /* ------------------------------------------------------------------------- */
798 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
800 static void i2c_adapter_dev_release(struct device *dev)
802 struct i2c_adapter *adap = to_i2c_adapter(dev);
803 complete(&adap->dev_released);
807 * This function is only needed for mutex_lock_nested, so it is never
808 * called unless locking correctness checking is enabled. Thus we
809 * make it inline to avoid a compiler warning. That's what gcc ends up
810 * doing anyway.
812 static inline unsigned int i2c_adapter_depth(struct i2c_adapter *adapter)
814 unsigned int depth = 0;
816 while ((adapter = i2c_parent_is_i2c_adapter(adapter)))
817 depth++;
819 return depth;
823 * Let users instantiate I2C devices through sysfs. This can be used when
824 * platform initialization code doesn't contain the proper data for
825 * whatever reason. Also useful for drivers that do device detection and
826 * detection fails, either because the device uses an unexpected address,
827 * or this is a compatible device with different ID register values.
829 * Parameter checking may look overzealous, but we really don't want
830 * the user to provide incorrect parameters.
832 static ssize_t
833 i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
834 const char *buf, size_t count)
836 struct i2c_adapter *adap = to_i2c_adapter(dev);
837 struct i2c_board_info info;
838 struct i2c_client *client;
839 char *blank, end;
840 int res;
842 memset(&info, 0, sizeof(struct i2c_board_info));
844 blank = strchr(buf, ' ');
845 if (!blank) {
846 dev_err(dev, "%s: Missing parameters\n", "new_device");
847 return -EINVAL;
849 if (blank - buf > I2C_NAME_SIZE - 1) {
850 dev_err(dev, "%s: Invalid device name\n", "new_device");
851 return -EINVAL;
853 memcpy(info.type, buf, blank - buf);
855 /* Parse remaining parameters, reject extra parameters */
856 res = sscanf(++blank, "%hi%c", &info.addr, &end);
857 if (res < 1) {
858 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
859 return -EINVAL;
861 if (res > 1 && end != '\n') {
862 dev_err(dev, "%s: Extra parameters\n", "new_device");
863 return -EINVAL;
866 client = i2c_new_device(adap, &info);
867 if (!client)
868 return -EINVAL;
870 /* Keep track of the added device */
871 mutex_lock(&adap->userspace_clients_lock);
872 list_add_tail(&client->detected, &adap->userspace_clients);
873 mutex_unlock(&adap->userspace_clients_lock);
874 dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
875 info.type, info.addr);
877 return count;
881 * And of course let the users delete the devices they instantiated, if
882 * they got it wrong. This interface can only be used to delete devices
883 * instantiated by i2c_sysfs_new_device above. This guarantees that we
884 * don't delete devices to which some kernel code still has references.
886 * Parameter checking may look overzealous, but we really don't want
887 * the user to delete the wrong device.
889 static ssize_t
890 i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
891 const char *buf, size_t count)
893 struct i2c_adapter *adap = to_i2c_adapter(dev);
894 struct i2c_client *client, *next;
895 unsigned short addr;
896 char end;
897 int res;
899 /* Parse parameters, reject extra parameters */
900 res = sscanf(buf, "%hi%c", &addr, &end);
901 if (res < 1) {
902 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
903 return -EINVAL;
905 if (res > 1 && end != '\n') {
906 dev_err(dev, "%s: Extra parameters\n", "delete_device");
907 return -EINVAL;
910 /* Make sure the device was added through sysfs */
911 res = -ENOENT;
912 mutex_lock_nested(&adap->userspace_clients_lock,
913 i2c_adapter_depth(adap));
914 list_for_each_entry_safe(client, next, &adap->userspace_clients,
915 detected) {
916 if (client->addr == addr) {
917 dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
918 "delete_device", client->name, client->addr);
920 list_del(&client->detected);
921 i2c_unregister_device(client);
922 res = count;
923 break;
926 mutex_unlock(&adap->userspace_clients_lock);
928 if (res < 0)
929 dev_err(dev, "%s: Can't find device in list\n",
930 "delete_device");
931 return res;
934 static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
935 static DEVICE_ATTR_IGNORE_LOCKDEP(delete_device, S_IWUSR, NULL,
936 i2c_sysfs_delete_device);
938 static struct attribute *i2c_adapter_attrs[] = {
939 &dev_attr_name.attr,
940 &dev_attr_new_device.attr,
941 &dev_attr_delete_device.attr,
942 NULL
945 static struct attribute_group i2c_adapter_attr_group = {
946 .attrs = i2c_adapter_attrs,
949 static const struct attribute_group *i2c_adapter_attr_groups[] = {
950 &i2c_adapter_attr_group,
951 NULL
954 struct device_type i2c_adapter_type = {
955 .groups = i2c_adapter_attr_groups,
956 .release = i2c_adapter_dev_release,
958 EXPORT_SYMBOL_GPL(i2c_adapter_type);
961 * i2c_verify_adapter - return parameter as i2c_adapter or NULL
962 * @dev: device, probably from some driver model iterator
964 * When traversing the driver model tree, perhaps using driver model
965 * iterators like @device_for_each_child(), you can't assume very much
966 * about the nodes you find. Use this function to avoid oopses caused
967 * by wrongly treating some non-I2C device as an i2c_adapter.
969 struct i2c_adapter *i2c_verify_adapter(struct device *dev)
971 return (dev->type == &i2c_adapter_type)
972 ? to_i2c_adapter(dev)
973 : NULL;
975 EXPORT_SYMBOL(i2c_verify_adapter);
977 #ifdef CONFIG_I2C_COMPAT
978 static struct class_compat *i2c_adapter_compat_class;
979 #endif
981 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
983 struct i2c_devinfo *devinfo;
985 down_read(&__i2c_board_lock);
986 list_for_each_entry(devinfo, &__i2c_board_list, list) {
987 if (devinfo->busnum == adapter->nr
988 && !i2c_new_device(adapter,
989 &devinfo->board_info))
990 dev_err(&adapter->dev,
991 "Can't create device at 0x%02x\n",
992 devinfo->board_info.addr);
994 up_read(&__i2c_board_lock);
997 /* OF support code */
999 #if IS_ENABLED(CONFIG_OF)
1000 static void of_i2c_register_devices(struct i2c_adapter *adap)
1002 void *result;
1003 struct device_node *node;
1005 /* Only register child devices if the adapter has a node pointer set */
1006 if (!adap->dev.of_node)
1007 return;
1009 dev_dbg(&adap->dev, "of_i2c: walking child nodes\n");
1011 for_each_available_child_of_node(adap->dev.of_node, node) {
1012 struct i2c_board_info info = {};
1013 struct dev_archdata dev_ad = {};
1014 const __be32 *addr;
1015 int len;
1017 dev_dbg(&adap->dev, "of_i2c: register %s\n", node->full_name);
1019 if (of_modalias_node(node, info.type, sizeof(info.type)) < 0) {
1020 dev_err(&adap->dev, "of_i2c: modalias failure on %s\n",
1021 node->full_name);
1022 continue;
1025 addr = of_get_property(node, "reg", &len);
1026 if (!addr || (len < sizeof(int))) {
1027 dev_err(&adap->dev, "of_i2c: invalid reg on %s\n",
1028 node->full_name);
1029 continue;
1032 info.addr = be32_to_cpup(addr);
1033 if (info.addr > (1 << 10) - 1) {
1034 dev_err(&adap->dev, "of_i2c: invalid addr=%x on %s\n",
1035 info.addr, node->full_name);
1036 continue;
1039 info.irq = irq_of_parse_and_map(node, 0);
1040 info.of_node = of_node_get(node);
1041 info.archdata = &dev_ad;
1043 if (of_get_property(node, "wakeup-source", NULL))
1044 info.flags |= I2C_CLIENT_WAKE;
1046 request_module("%s%s", I2C_MODULE_PREFIX, info.type);
1048 result = i2c_new_device(adap, &info);
1049 if (result == NULL) {
1050 dev_err(&adap->dev, "of_i2c: Failure registering %s\n",
1051 node->full_name);
1052 of_node_put(node);
1053 irq_dispose_mapping(info.irq);
1054 continue;
1059 static int of_dev_node_match(struct device *dev, void *data)
1061 return dev->of_node == data;
1064 /* must call put_device() when done with returned i2c_client device */
1065 struct i2c_client *of_find_i2c_device_by_node(struct device_node *node)
1067 struct device *dev;
1069 dev = bus_find_device(&i2c_bus_type, NULL, node,
1070 of_dev_node_match);
1071 if (!dev)
1072 return NULL;
1074 return i2c_verify_client(dev);
1076 EXPORT_SYMBOL(of_find_i2c_device_by_node);
1078 /* must call put_device() when done with returned i2c_adapter device */
1079 struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node)
1081 struct device *dev;
1083 dev = bus_find_device(&i2c_bus_type, NULL, node,
1084 of_dev_node_match);
1085 if (!dev)
1086 return NULL;
1088 return i2c_verify_adapter(dev);
1090 EXPORT_SYMBOL(of_find_i2c_adapter_by_node);
1091 #else
1092 static void of_i2c_register_devices(struct i2c_adapter *adap) { }
1093 #endif /* CONFIG_OF */
1095 /* ACPI support code */
1097 #if IS_ENABLED(CONFIG_ACPI)
1098 static int acpi_i2c_add_resource(struct acpi_resource *ares, void *data)
1100 struct i2c_board_info *info = data;
1102 if (ares->type == ACPI_RESOURCE_TYPE_SERIAL_BUS) {
1103 struct acpi_resource_i2c_serialbus *sb;
1105 sb = &ares->data.i2c_serial_bus;
1106 if (sb->type == ACPI_RESOURCE_SERIAL_TYPE_I2C) {
1107 info->addr = sb->slave_address;
1108 if (sb->access_mode == ACPI_I2C_10BIT_MODE)
1109 info->flags |= I2C_CLIENT_TEN;
1111 } else if (info->irq < 0) {
1112 struct resource r;
1114 if (acpi_dev_resource_interrupt(ares, 0, &r))
1115 info->irq = r.start;
1118 /* Tell the ACPI core to skip this resource */
1119 return 1;
1122 static acpi_status acpi_i2c_add_device(acpi_handle handle, u32 level,
1123 void *data, void **return_value)
1125 struct i2c_adapter *adapter = data;
1126 struct list_head resource_list;
1127 struct i2c_board_info info;
1128 struct acpi_device *adev;
1129 int ret;
1131 if (acpi_bus_get_device(handle, &adev))
1132 return AE_OK;
1133 if (acpi_bus_get_status(adev) || !adev->status.present)
1134 return AE_OK;
1136 memset(&info, 0, sizeof(info));
1137 info.acpi_node.companion = adev;
1138 info.irq = -1;
1140 INIT_LIST_HEAD(&resource_list);
1141 ret = acpi_dev_get_resources(adev, &resource_list,
1142 acpi_i2c_add_resource, &info);
1143 acpi_dev_free_resource_list(&resource_list);
1145 if (ret < 0 || !info.addr)
1146 return AE_OK;
1148 adev->power.flags.ignore_parent = true;
1149 strlcpy(info.type, dev_name(&adev->dev), sizeof(info.type));
1150 if (!i2c_new_device(adapter, &info)) {
1151 adev->power.flags.ignore_parent = false;
1152 dev_err(&adapter->dev,
1153 "failed to add I2C device %s from ACPI\n",
1154 dev_name(&adev->dev));
1157 return AE_OK;
1161 * acpi_i2c_register_devices - enumerate I2C slave devices behind adapter
1162 * @adap: pointer to adapter
1164 * Enumerate all I2C slave devices behind this adapter by walking the ACPI
1165 * namespace. When a device is found it will be added to the Linux device
1166 * model and bound to the corresponding ACPI handle.
1168 static void acpi_i2c_register_devices(struct i2c_adapter *adap)
1170 acpi_handle handle;
1171 acpi_status status;
1173 if (!adap->dev.parent)
1174 return;
1176 handle = ACPI_HANDLE(adap->dev.parent);
1177 if (!handle)
1178 return;
1180 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1,
1181 acpi_i2c_add_device, NULL,
1182 adap, NULL);
1183 if (ACPI_FAILURE(status))
1184 dev_warn(&adap->dev, "failed to enumerate I2C slaves\n");
1186 #else
1187 static inline void acpi_i2c_register_devices(struct i2c_adapter *adap) {}
1188 #endif /* CONFIG_ACPI */
1190 static int i2c_do_add_adapter(struct i2c_driver *driver,
1191 struct i2c_adapter *adap)
1193 /* Detect supported devices on that bus, and instantiate them */
1194 i2c_detect(adap, driver);
1196 /* Let legacy drivers scan this bus for matching devices */
1197 if (driver->attach_adapter) {
1198 dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
1199 driver->driver.name);
1200 dev_warn(&adap->dev, "Please use another way to instantiate "
1201 "your i2c_client\n");
1202 /* We ignore the return code; if it fails, too bad */
1203 driver->attach_adapter(adap);
1205 return 0;
1208 static int __process_new_adapter(struct device_driver *d, void *data)
1210 return i2c_do_add_adapter(to_i2c_driver(d), data);
1213 static int i2c_register_adapter(struct i2c_adapter *adap)
1215 int res = 0;
1217 /* Can't register until after driver model init */
1218 if (unlikely(WARN_ON(!i2c_bus_type.p))) {
1219 res = -EAGAIN;
1220 goto out_list;
1223 /* Sanity checks */
1224 if (unlikely(adap->name[0] == '\0')) {
1225 pr_err("i2c-core: Attempt to register an adapter with "
1226 "no name!\n");
1227 return -EINVAL;
1229 if (unlikely(!adap->algo)) {
1230 pr_err("i2c-core: Attempt to register adapter '%s' with "
1231 "no algo!\n", adap->name);
1232 return -EINVAL;
1235 rt_mutex_init(&adap->bus_lock);
1236 mutex_init(&adap->userspace_clients_lock);
1237 INIT_LIST_HEAD(&adap->userspace_clients);
1239 /* Set default timeout to 1 second if not already set */
1240 if (adap->timeout == 0)
1241 adap->timeout = HZ;
1243 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
1244 adap->dev.bus = &i2c_bus_type;
1245 adap->dev.type = &i2c_adapter_type;
1246 res = device_register(&adap->dev);
1247 if (res)
1248 goto out_list;
1250 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
1252 #ifdef CONFIG_I2C_COMPAT
1253 res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
1254 adap->dev.parent);
1255 if (res)
1256 dev_warn(&adap->dev,
1257 "Failed to create compatibility class link\n");
1258 #endif
1260 /* bus recovery specific initialization */
1261 if (adap->bus_recovery_info) {
1262 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
1264 if (!bri->recover_bus) {
1265 dev_err(&adap->dev, "No recover_bus() found, not using recovery\n");
1266 adap->bus_recovery_info = NULL;
1267 goto exit_recovery;
1270 /* Generic GPIO recovery */
1271 if (bri->recover_bus == i2c_generic_gpio_recovery) {
1272 if (!gpio_is_valid(bri->scl_gpio)) {
1273 dev_err(&adap->dev, "Invalid SCL gpio, not using recovery\n");
1274 adap->bus_recovery_info = NULL;
1275 goto exit_recovery;
1278 if (gpio_is_valid(bri->sda_gpio))
1279 bri->get_sda = get_sda_gpio_value;
1280 else
1281 bri->get_sda = NULL;
1283 bri->get_scl = get_scl_gpio_value;
1284 bri->set_scl = set_scl_gpio_value;
1285 } else if (!bri->set_scl || !bri->get_scl) {
1286 /* Generic SCL recovery */
1287 dev_err(&adap->dev, "No {get|set}_gpio() found, not using recovery\n");
1288 adap->bus_recovery_info = NULL;
1292 exit_recovery:
1293 /* create pre-declared device nodes */
1294 of_i2c_register_devices(adap);
1295 acpi_i2c_register_devices(adap);
1297 if (adap->nr < __i2c_first_dynamic_bus_num)
1298 i2c_scan_static_board_info(adap);
1300 /* Notify drivers */
1301 mutex_lock(&core_lock);
1302 bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
1303 mutex_unlock(&core_lock);
1305 return 0;
1307 out_list:
1308 mutex_lock(&core_lock);
1309 idr_remove(&i2c_adapter_idr, adap->nr);
1310 mutex_unlock(&core_lock);
1311 return res;
1315 * __i2c_add_numbered_adapter - i2c_add_numbered_adapter where nr is never -1
1316 * @adap: the adapter to register (with adap->nr initialized)
1317 * Context: can sleep
1319 * See i2c_add_numbered_adapter() for details.
1321 static int __i2c_add_numbered_adapter(struct i2c_adapter *adap)
1323 int id;
1325 mutex_lock(&core_lock);
1326 id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1,
1327 GFP_KERNEL);
1328 mutex_unlock(&core_lock);
1329 if (id < 0)
1330 return id == -ENOSPC ? -EBUSY : id;
1332 return i2c_register_adapter(adap);
1336 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
1337 * @adapter: the adapter to add
1338 * Context: can sleep
1340 * This routine is used to declare an I2C adapter when its bus number
1341 * doesn't matter or when its bus number is specified by an dt alias.
1342 * Examples of bases when the bus number doesn't matter: I2C adapters
1343 * dynamically added by USB links or PCI plugin cards.
1345 * When this returns zero, a new bus number was allocated and stored
1346 * in adap->nr, and the specified adapter became available for clients.
1347 * Otherwise, a negative errno value is returned.
1349 int i2c_add_adapter(struct i2c_adapter *adapter)
1351 struct device *dev = &adapter->dev;
1352 int id;
1354 if (dev->of_node) {
1355 id = of_alias_get_id(dev->of_node, "i2c");
1356 if (id >= 0) {
1357 adapter->nr = id;
1358 return __i2c_add_numbered_adapter(adapter);
1362 mutex_lock(&core_lock);
1363 id = idr_alloc(&i2c_adapter_idr, adapter,
1364 __i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
1365 mutex_unlock(&core_lock);
1366 if (id < 0)
1367 return id;
1369 adapter->nr = id;
1371 return i2c_register_adapter(adapter);
1373 EXPORT_SYMBOL(i2c_add_adapter);
1376 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
1377 * @adap: the adapter to register (with adap->nr initialized)
1378 * Context: can sleep
1380 * This routine is used to declare an I2C adapter when its bus number
1381 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
1382 * or otherwise built in to the system's mainboard, and where i2c_board_info
1383 * is used to properly configure I2C devices.
1385 * If the requested bus number is set to -1, then this function will behave
1386 * identically to i2c_add_adapter, and will dynamically assign a bus number.
1388 * If no devices have pre-been declared for this bus, then be sure to
1389 * register the adapter before any dynamically allocated ones. Otherwise
1390 * the required bus ID may not be available.
1392 * When this returns zero, the specified adapter became available for
1393 * clients using the bus number provided in adap->nr. Also, the table
1394 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
1395 * and the appropriate driver model device nodes are created. Otherwise, a
1396 * negative errno value is returned.
1398 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
1400 if (adap->nr == -1) /* -1 means dynamically assign bus id */
1401 return i2c_add_adapter(adap);
1403 return __i2c_add_numbered_adapter(adap);
1405 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
1407 static void i2c_do_del_adapter(struct i2c_driver *driver,
1408 struct i2c_adapter *adapter)
1410 struct i2c_client *client, *_n;
1412 /* Remove the devices we created ourselves as the result of hardware
1413 * probing (using a driver's detect method) */
1414 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
1415 if (client->adapter == adapter) {
1416 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
1417 client->name, client->addr);
1418 list_del(&client->detected);
1419 i2c_unregister_device(client);
1424 static int __unregister_client(struct device *dev, void *dummy)
1426 struct i2c_client *client = i2c_verify_client(dev);
1427 if (client && strcmp(client->name, "dummy"))
1428 i2c_unregister_device(client);
1429 return 0;
1432 static int __unregister_dummy(struct device *dev, void *dummy)
1434 struct i2c_client *client = i2c_verify_client(dev);
1435 if (client)
1436 i2c_unregister_device(client);
1437 return 0;
1440 static int __process_removed_adapter(struct device_driver *d, void *data)
1442 i2c_do_del_adapter(to_i2c_driver(d), data);
1443 return 0;
1447 * i2c_del_adapter - unregister I2C adapter
1448 * @adap: the adapter being unregistered
1449 * Context: can sleep
1451 * This unregisters an I2C adapter which was previously registered
1452 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
1454 void i2c_del_adapter(struct i2c_adapter *adap)
1456 struct i2c_adapter *found;
1457 struct i2c_client *client, *next;
1459 /* First make sure that this adapter was ever added */
1460 mutex_lock(&core_lock);
1461 found = idr_find(&i2c_adapter_idr, adap->nr);
1462 mutex_unlock(&core_lock);
1463 if (found != adap) {
1464 pr_debug("i2c-core: attempting to delete unregistered "
1465 "adapter [%s]\n", adap->name);
1466 return;
1469 /* Tell drivers about this removal */
1470 mutex_lock(&core_lock);
1471 bus_for_each_drv(&i2c_bus_type, NULL, adap,
1472 __process_removed_adapter);
1473 mutex_unlock(&core_lock);
1475 /* Remove devices instantiated from sysfs */
1476 mutex_lock_nested(&adap->userspace_clients_lock,
1477 i2c_adapter_depth(adap));
1478 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1479 detected) {
1480 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
1481 client->addr);
1482 list_del(&client->detected);
1483 i2c_unregister_device(client);
1485 mutex_unlock(&adap->userspace_clients_lock);
1487 /* Detach any active clients. This can't fail, thus we do not
1488 * check the returned value. This is a two-pass process, because
1489 * we can't remove the dummy devices during the first pass: they
1490 * could have been instantiated by real devices wishing to clean
1491 * them up properly, so we give them a chance to do that first. */
1492 device_for_each_child(&adap->dev, NULL, __unregister_client);
1493 device_for_each_child(&adap->dev, NULL, __unregister_dummy);
1495 #ifdef CONFIG_I2C_COMPAT
1496 class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
1497 adap->dev.parent);
1498 #endif
1500 /* device name is gone after device_unregister */
1501 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
1503 /* clean up the sysfs representation */
1504 init_completion(&adap->dev_released);
1505 device_unregister(&adap->dev);
1507 /* wait for sysfs to drop all references */
1508 wait_for_completion(&adap->dev_released);
1510 /* free bus id */
1511 mutex_lock(&core_lock);
1512 idr_remove(&i2c_adapter_idr, adap->nr);
1513 mutex_unlock(&core_lock);
1515 /* Clear the device structure in case this adapter is ever going to be
1516 added again */
1517 memset(&adap->dev, 0, sizeof(adap->dev));
1519 EXPORT_SYMBOL(i2c_del_adapter);
1521 /* ------------------------------------------------------------------------- */
1523 int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
1525 int res;
1527 mutex_lock(&core_lock);
1528 res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
1529 mutex_unlock(&core_lock);
1531 return res;
1533 EXPORT_SYMBOL_GPL(i2c_for_each_dev);
1535 static int __process_new_driver(struct device *dev, void *data)
1537 if (dev->type != &i2c_adapter_type)
1538 return 0;
1539 return i2c_do_add_adapter(data, to_i2c_adapter(dev));
1543 * An i2c_driver is used with one or more i2c_client (device) nodes to access
1544 * i2c slave chips, on a bus instance associated with some i2c_adapter.
1547 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
1549 int res;
1551 /* Can't register until after driver model init */
1552 if (unlikely(WARN_ON(!i2c_bus_type.p)))
1553 return -EAGAIN;
1555 /* add the driver to the list of i2c drivers in the driver core */
1556 driver->driver.owner = owner;
1557 driver->driver.bus = &i2c_bus_type;
1559 /* When registration returns, the driver core
1560 * will have called probe() for all matching-but-unbound devices.
1562 res = driver_register(&driver->driver);
1563 if (res)
1564 return res;
1566 /* Drivers should switch to dev_pm_ops instead. */
1567 if (driver->suspend)
1568 pr_warn("i2c-core: driver [%s] using legacy suspend method\n",
1569 driver->driver.name);
1570 if (driver->resume)
1571 pr_warn("i2c-core: driver [%s] using legacy resume method\n",
1572 driver->driver.name);
1574 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
1576 INIT_LIST_HEAD(&driver->clients);
1577 /* Walk the adapters that are already present */
1578 i2c_for_each_dev(driver, __process_new_driver);
1580 return 0;
1582 EXPORT_SYMBOL(i2c_register_driver);
1584 static int __process_removed_driver(struct device *dev, void *data)
1586 if (dev->type == &i2c_adapter_type)
1587 i2c_do_del_adapter(data, to_i2c_adapter(dev));
1588 return 0;
1592 * i2c_del_driver - unregister I2C driver
1593 * @driver: the driver being unregistered
1594 * Context: can sleep
1596 void i2c_del_driver(struct i2c_driver *driver)
1598 i2c_for_each_dev(driver, __process_removed_driver);
1600 driver_unregister(&driver->driver);
1601 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
1603 EXPORT_SYMBOL(i2c_del_driver);
1605 /* ------------------------------------------------------------------------- */
1608 * i2c_use_client - increments the reference count of the i2c client structure
1609 * @client: the client being referenced
1611 * Each live reference to a client should be refcounted. The driver model does
1612 * that automatically as part of driver binding, so that most drivers don't
1613 * need to do this explicitly: they hold a reference until they're unbound
1614 * from the device.
1616 * A pointer to the client with the incremented reference counter is returned.
1618 struct i2c_client *i2c_use_client(struct i2c_client *client)
1620 if (client && get_device(&client->dev))
1621 return client;
1622 return NULL;
1624 EXPORT_SYMBOL(i2c_use_client);
1627 * i2c_release_client - release a use of the i2c client structure
1628 * @client: the client being no longer referenced
1630 * Must be called when a user of a client is finished with it.
1632 void i2c_release_client(struct i2c_client *client)
1634 if (client)
1635 put_device(&client->dev);
1637 EXPORT_SYMBOL(i2c_release_client);
1639 struct i2c_cmd_arg {
1640 unsigned cmd;
1641 void *arg;
1644 static int i2c_cmd(struct device *dev, void *_arg)
1646 struct i2c_client *client = i2c_verify_client(dev);
1647 struct i2c_cmd_arg *arg = _arg;
1648 struct i2c_driver *driver;
1650 if (!client || !client->dev.driver)
1651 return 0;
1653 driver = to_i2c_driver(client->dev.driver);
1654 if (driver->command)
1655 driver->command(client, arg->cmd, arg->arg);
1656 return 0;
1659 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
1661 struct i2c_cmd_arg cmd_arg;
1663 cmd_arg.cmd = cmd;
1664 cmd_arg.arg = arg;
1665 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
1667 EXPORT_SYMBOL(i2c_clients_command);
1669 static int __init i2c_init(void)
1671 int retval;
1673 retval = bus_register(&i2c_bus_type);
1674 if (retval)
1675 return retval;
1676 #ifdef CONFIG_I2C_COMPAT
1677 i2c_adapter_compat_class = class_compat_register("i2c-adapter");
1678 if (!i2c_adapter_compat_class) {
1679 retval = -ENOMEM;
1680 goto bus_err;
1682 #endif
1683 retval = i2c_add_driver(&dummy_driver);
1684 if (retval)
1685 goto class_err;
1686 return 0;
1688 class_err:
1689 #ifdef CONFIG_I2C_COMPAT
1690 class_compat_unregister(i2c_adapter_compat_class);
1691 bus_err:
1692 #endif
1693 bus_unregister(&i2c_bus_type);
1694 return retval;
1697 static void __exit i2c_exit(void)
1699 i2c_del_driver(&dummy_driver);
1700 #ifdef CONFIG_I2C_COMPAT
1701 class_compat_unregister(i2c_adapter_compat_class);
1702 #endif
1703 bus_unregister(&i2c_bus_type);
1704 tracepoint_synchronize_unregister();
1707 /* We must initialize early, because some subsystems register i2c drivers
1708 * in subsys_initcall() code, but are linked (and initialized) before i2c.
1710 postcore_initcall(i2c_init);
1711 module_exit(i2c_exit);
1713 /* ----------------------------------------------------
1714 * the functional interface to the i2c busses.
1715 * ----------------------------------------------------
1719 * __i2c_transfer - unlocked flavor of i2c_transfer
1720 * @adap: Handle to I2C bus
1721 * @msgs: One or more messages to execute before STOP is issued to
1722 * terminate the operation; each message begins with a START.
1723 * @num: Number of messages to be executed.
1725 * Returns negative errno, else the number of messages executed.
1727 * Adapter lock must be held when calling this function. No debug logging
1728 * takes place. adap->algo->master_xfer existence isn't checked.
1730 int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
1732 unsigned long orig_jiffies;
1733 int ret, try;
1735 /* i2c_trace_msg gets enabled when tracepoint i2c_transfer gets
1736 * enabled. This is an efficient way of keeping the for-loop from
1737 * being executed when not needed.
1739 if (static_key_false(&i2c_trace_msg)) {
1740 int i;
1741 for (i = 0; i < num; i++)
1742 if (msgs[i].flags & I2C_M_RD)
1743 trace_i2c_read(adap, &msgs[i], i);
1744 else
1745 trace_i2c_write(adap, &msgs[i], i);
1748 /* Retry automatically on arbitration loss */
1749 orig_jiffies = jiffies;
1750 for (ret = 0, try = 0; try <= adap->retries; try++) {
1751 ret = adap->algo->master_xfer(adap, msgs, num);
1752 if (ret != -EAGAIN)
1753 break;
1754 if (time_after(jiffies, orig_jiffies + adap->timeout))
1755 break;
1758 if (static_key_false(&i2c_trace_msg)) {
1759 int i;
1760 for (i = 0; i < ret; i++)
1761 if (msgs[i].flags & I2C_M_RD)
1762 trace_i2c_reply(adap, &msgs[i], i);
1763 trace_i2c_result(adap, i, ret);
1766 return ret;
1768 EXPORT_SYMBOL(__i2c_transfer);
1771 * i2c_transfer - execute a single or combined I2C message
1772 * @adap: Handle to I2C bus
1773 * @msgs: One or more messages to execute before STOP is issued to
1774 * terminate the operation; each message begins with a START.
1775 * @num: Number of messages to be executed.
1777 * Returns negative errno, else the number of messages executed.
1779 * Note that there is no requirement that each message be sent to
1780 * the same slave address, although that is the most common model.
1782 int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
1784 int ret;
1786 /* REVISIT the fault reporting model here is weak:
1788 * - When we get an error after receiving N bytes from a slave,
1789 * there is no way to report "N".
1791 * - When we get a NAK after transmitting N bytes to a slave,
1792 * there is no way to report "N" ... or to let the master
1793 * continue executing the rest of this combined message, if
1794 * that's the appropriate response.
1796 * - When for example "num" is two and we successfully complete
1797 * the first message but get an error part way through the
1798 * second, it's unclear whether that should be reported as
1799 * one (discarding status on the second message) or errno
1800 * (discarding status on the first one).
1803 if (adap->algo->master_xfer) {
1804 #ifdef DEBUG
1805 for (ret = 0; ret < num; ret++) {
1806 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
1807 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
1808 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
1809 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
1811 #endif
1813 if (in_atomic() || irqs_disabled()) {
1814 ret = i2c_trylock_adapter(adap);
1815 if (!ret)
1816 /* I2C activity is ongoing. */
1817 return -EAGAIN;
1818 } else {
1819 i2c_lock_adapter(adap);
1822 ret = __i2c_transfer(adap, msgs, num);
1823 i2c_unlock_adapter(adap);
1825 return ret;
1826 } else {
1827 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
1828 return -EOPNOTSUPP;
1831 EXPORT_SYMBOL(i2c_transfer);
1834 * i2c_master_send - issue a single I2C message in master transmit mode
1835 * @client: Handle to slave device
1836 * @buf: Data that will be written to the slave
1837 * @count: How many bytes to write, must be less than 64k since msg.len is u16
1839 * Returns negative errno, or else the number of bytes written.
1841 int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
1843 int ret;
1844 struct i2c_adapter *adap = client->adapter;
1845 struct i2c_msg msg;
1847 msg.addr = client->addr;
1848 msg.flags = client->flags & I2C_M_TEN;
1849 msg.len = count;
1850 msg.buf = (char *)buf;
1852 ret = i2c_transfer(adap, &msg, 1);
1855 * If everything went ok (i.e. 1 msg transmitted), return #bytes
1856 * transmitted, else error code.
1858 return (ret == 1) ? count : ret;
1860 EXPORT_SYMBOL(i2c_master_send);
1863 * i2c_master_recv - issue a single I2C message in master receive mode
1864 * @client: Handle to slave device
1865 * @buf: Where to store data read from slave
1866 * @count: How many bytes to read, must be less than 64k since msg.len is u16
1868 * Returns negative errno, or else the number of bytes read.
1870 int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
1872 struct i2c_adapter *adap = client->adapter;
1873 struct i2c_msg msg;
1874 int ret;
1876 msg.addr = client->addr;
1877 msg.flags = client->flags & I2C_M_TEN;
1878 msg.flags |= I2C_M_RD;
1879 msg.len = count;
1880 msg.buf = buf;
1882 ret = i2c_transfer(adap, &msg, 1);
1885 * If everything went ok (i.e. 1 msg received), return #bytes received,
1886 * else error code.
1888 return (ret == 1) ? count : ret;
1890 EXPORT_SYMBOL(i2c_master_recv);
1892 /* ----------------------------------------------------
1893 * the i2c address scanning function
1894 * Will not work for 10-bit addresses!
1895 * ----------------------------------------------------
1899 * Legacy default probe function, mostly relevant for SMBus. The default
1900 * probe method is a quick write, but it is known to corrupt the 24RF08
1901 * EEPROMs due to a state machine bug, and could also irreversibly
1902 * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
1903 * we use a short byte read instead. Also, some bus drivers don't implement
1904 * quick write, so we fallback to a byte read in that case too.
1905 * On x86, there is another special case for FSC hardware monitoring chips,
1906 * which want regular byte reads (address 0x73.) Fortunately, these are the
1907 * only known chips using this I2C address on PC hardware.
1908 * Returns 1 if probe succeeded, 0 if not.
1910 static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
1912 int err;
1913 union i2c_smbus_data dummy;
1915 #ifdef CONFIG_X86
1916 if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
1917 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
1918 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1919 I2C_SMBUS_BYTE_DATA, &dummy);
1920 else
1921 #endif
1922 if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
1923 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
1924 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
1925 I2C_SMBUS_QUICK, NULL);
1926 else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
1927 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1928 I2C_SMBUS_BYTE, &dummy);
1929 else {
1930 dev_warn(&adap->dev, "No suitable probing method supported for address 0x%02X\n",
1931 addr);
1932 err = -EOPNOTSUPP;
1935 return err >= 0;
1938 static int i2c_detect_address(struct i2c_client *temp_client,
1939 struct i2c_driver *driver)
1941 struct i2c_board_info info;
1942 struct i2c_adapter *adapter = temp_client->adapter;
1943 int addr = temp_client->addr;
1944 int err;
1946 /* Make sure the address is valid */
1947 err = i2c_check_addr_validity(addr);
1948 if (err) {
1949 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1950 addr);
1951 return err;
1954 /* Skip if already in use */
1955 if (i2c_check_addr_busy(adapter, addr))
1956 return 0;
1958 /* Make sure there is something at this address */
1959 if (!i2c_default_probe(adapter, addr))
1960 return 0;
1962 /* Finally call the custom detection function */
1963 memset(&info, 0, sizeof(struct i2c_board_info));
1964 info.addr = addr;
1965 err = driver->detect(temp_client, &info);
1966 if (err) {
1967 /* -ENODEV is returned if the detection fails. We catch it
1968 here as this isn't an error. */
1969 return err == -ENODEV ? 0 : err;
1972 /* Consistency check */
1973 if (info.type[0] == '\0') {
1974 dev_err(&adapter->dev, "%s detection function provided "
1975 "no name for 0x%x\n", driver->driver.name,
1976 addr);
1977 } else {
1978 struct i2c_client *client;
1980 /* Detection succeeded, instantiate the device */
1981 if (adapter->class & I2C_CLASS_DEPRECATED)
1982 dev_warn(&adapter->dev,
1983 "This adapter will soon drop class based instantiation of devices. "
1984 "Please make sure client 0x%02x gets instantiated by other means. "
1985 "Check 'Documentation/i2c/instantiating-devices' for details.\n",
1986 info.addr);
1988 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
1989 info.type, info.addr);
1990 client = i2c_new_device(adapter, &info);
1991 if (client)
1992 list_add_tail(&client->detected, &driver->clients);
1993 else
1994 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
1995 info.type, info.addr);
1997 return 0;
2000 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
2002 const unsigned short *address_list;
2003 struct i2c_client *temp_client;
2004 int i, err = 0;
2005 int adap_id = i2c_adapter_id(adapter);
2007 address_list = driver->address_list;
2008 if (!driver->detect || !address_list)
2009 return 0;
2011 /* Stop here if the classes do not match */
2012 if (!(adapter->class & driver->class))
2013 return 0;
2015 /* Set up a temporary client to help detect callback */
2016 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
2017 if (!temp_client)
2018 return -ENOMEM;
2019 temp_client->adapter = adapter;
2021 for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
2022 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
2023 "addr 0x%02x\n", adap_id, address_list[i]);
2024 temp_client->addr = address_list[i];
2025 err = i2c_detect_address(temp_client, driver);
2026 if (unlikely(err))
2027 break;
2030 kfree(temp_client);
2031 return err;
2034 int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
2036 return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2037 I2C_SMBUS_QUICK, NULL) >= 0;
2039 EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
2041 struct i2c_client *
2042 i2c_new_probed_device(struct i2c_adapter *adap,
2043 struct i2c_board_info *info,
2044 unsigned short const *addr_list,
2045 int (*probe)(struct i2c_adapter *, unsigned short addr))
2047 int i;
2049 if (!probe)
2050 probe = i2c_default_probe;
2052 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
2053 /* Check address validity */
2054 if (i2c_check_addr_validity(addr_list[i]) < 0) {
2055 dev_warn(&adap->dev, "Invalid 7-bit address "
2056 "0x%02x\n", addr_list[i]);
2057 continue;
2060 /* Check address availability */
2061 if (i2c_check_addr_busy(adap, addr_list[i])) {
2062 dev_dbg(&adap->dev, "Address 0x%02x already in "
2063 "use, not probing\n", addr_list[i]);
2064 continue;
2067 /* Test address responsiveness */
2068 if (probe(adap, addr_list[i]))
2069 break;
2072 if (addr_list[i] == I2C_CLIENT_END) {
2073 dev_dbg(&adap->dev, "Probing failed, no device found\n");
2074 return NULL;
2077 info->addr = addr_list[i];
2078 return i2c_new_device(adap, info);
2080 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
2082 struct i2c_adapter *i2c_get_adapter(int nr)
2084 struct i2c_adapter *adapter;
2086 mutex_lock(&core_lock);
2087 adapter = idr_find(&i2c_adapter_idr, nr);
2088 if (adapter && !try_module_get(adapter->owner))
2089 adapter = NULL;
2091 mutex_unlock(&core_lock);
2092 return adapter;
2094 EXPORT_SYMBOL(i2c_get_adapter);
2096 void i2c_put_adapter(struct i2c_adapter *adap)
2098 if (adap)
2099 module_put(adap->owner);
2101 EXPORT_SYMBOL(i2c_put_adapter);
2103 /* The SMBus parts */
2105 #define POLY (0x1070U << 3)
2106 static u8 crc8(u16 data)
2108 int i;
2110 for (i = 0; i < 8; i++) {
2111 if (data & 0x8000)
2112 data = data ^ POLY;
2113 data = data << 1;
2115 return (u8)(data >> 8);
2118 /* Incremental CRC8 over count bytes in the array pointed to by p */
2119 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
2121 int i;
2123 for (i = 0; i < count; i++)
2124 crc = crc8((crc ^ p[i]) << 8);
2125 return crc;
2128 /* Assume a 7-bit address, which is reasonable for SMBus */
2129 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
2131 /* The address will be sent first */
2132 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
2133 pec = i2c_smbus_pec(pec, &addr, 1);
2135 /* The data buffer follows */
2136 return i2c_smbus_pec(pec, msg->buf, msg->len);
2139 /* Used for write only transactions */
2140 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
2142 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
2143 msg->len++;
2146 /* Return <0 on CRC error
2147 If there was a write before this read (most cases) we need to take the
2148 partial CRC from the write part into account.
2149 Note that this function does modify the message (we need to decrease the
2150 message length to hide the CRC byte from the caller). */
2151 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
2153 u8 rpec = msg->buf[--msg->len];
2154 cpec = i2c_smbus_msg_pec(cpec, msg);
2156 if (rpec != cpec) {
2157 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
2158 rpec, cpec);
2159 return -EBADMSG;
2161 return 0;
2165 * i2c_smbus_read_byte - SMBus "receive byte" protocol
2166 * @client: Handle to slave device
2168 * This executes the SMBus "receive byte" protocol, returning negative errno
2169 * else the byte received from the device.
2171 s32 i2c_smbus_read_byte(const struct i2c_client *client)
2173 union i2c_smbus_data data;
2174 int status;
2176 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2177 I2C_SMBUS_READ, 0,
2178 I2C_SMBUS_BYTE, &data);
2179 return (status < 0) ? status : data.byte;
2181 EXPORT_SYMBOL(i2c_smbus_read_byte);
2184 * i2c_smbus_write_byte - SMBus "send byte" protocol
2185 * @client: Handle to slave device
2186 * @value: Byte to be sent
2188 * This executes the SMBus "send byte" protocol, returning negative errno
2189 * else zero on success.
2191 s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
2193 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2194 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
2196 EXPORT_SYMBOL(i2c_smbus_write_byte);
2199 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
2200 * @client: Handle to slave device
2201 * @command: Byte interpreted by slave
2203 * This executes the SMBus "read byte" protocol, returning negative errno
2204 * else a data byte received from the device.
2206 s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
2208 union i2c_smbus_data data;
2209 int status;
2211 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2212 I2C_SMBUS_READ, command,
2213 I2C_SMBUS_BYTE_DATA, &data);
2214 return (status < 0) ? status : data.byte;
2216 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
2219 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
2220 * @client: Handle to slave device
2221 * @command: Byte interpreted by slave
2222 * @value: Byte being written
2224 * This executes the SMBus "write byte" protocol, returning negative errno
2225 * else zero on success.
2227 s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
2228 u8 value)
2230 union i2c_smbus_data data;
2231 data.byte = value;
2232 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2233 I2C_SMBUS_WRITE, command,
2234 I2C_SMBUS_BYTE_DATA, &data);
2236 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
2239 * i2c_smbus_read_word_data - SMBus "read word" protocol
2240 * @client: Handle to slave device
2241 * @command: Byte interpreted by slave
2243 * This executes the SMBus "read word" protocol, returning negative errno
2244 * else a 16-bit unsigned "word" received from the device.
2246 s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
2248 union i2c_smbus_data data;
2249 int status;
2251 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2252 I2C_SMBUS_READ, command,
2253 I2C_SMBUS_WORD_DATA, &data);
2254 return (status < 0) ? status : data.word;
2256 EXPORT_SYMBOL(i2c_smbus_read_word_data);
2259 * i2c_smbus_write_word_data - SMBus "write word" protocol
2260 * @client: Handle to slave device
2261 * @command: Byte interpreted by slave
2262 * @value: 16-bit "word" being written
2264 * This executes the SMBus "write word" protocol, returning negative errno
2265 * else zero on success.
2267 s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
2268 u16 value)
2270 union i2c_smbus_data data;
2271 data.word = value;
2272 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2273 I2C_SMBUS_WRITE, command,
2274 I2C_SMBUS_WORD_DATA, &data);
2276 EXPORT_SYMBOL(i2c_smbus_write_word_data);
2279 * i2c_smbus_read_block_data - SMBus "block read" protocol
2280 * @client: Handle to slave device
2281 * @command: Byte interpreted by slave
2282 * @values: Byte array into which data will be read; big enough to hold
2283 * the data returned by the slave. SMBus allows at most 32 bytes.
2285 * This executes the SMBus "block read" protocol, returning negative errno
2286 * else the number of data bytes in the slave's response.
2288 * Note that using this function requires that the client's adapter support
2289 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
2290 * support this; its emulation through I2C messaging relies on a specific
2291 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
2293 s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
2294 u8 *values)
2296 union i2c_smbus_data data;
2297 int status;
2299 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2300 I2C_SMBUS_READ, command,
2301 I2C_SMBUS_BLOCK_DATA, &data);
2302 if (status)
2303 return status;
2305 memcpy(values, &data.block[1], data.block[0]);
2306 return data.block[0];
2308 EXPORT_SYMBOL(i2c_smbus_read_block_data);
2311 * i2c_smbus_write_block_data - SMBus "block write" protocol
2312 * @client: Handle to slave device
2313 * @command: Byte interpreted by slave
2314 * @length: Size of data block; SMBus allows at most 32 bytes
2315 * @values: Byte array which will be written.
2317 * This executes the SMBus "block write" protocol, returning negative errno
2318 * else zero on success.
2320 s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
2321 u8 length, const u8 *values)
2323 union i2c_smbus_data data;
2325 if (length > I2C_SMBUS_BLOCK_MAX)
2326 length = I2C_SMBUS_BLOCK_MAX;
2327 data.block[0] = length;
2328 memcpy(&data.block[1], values, length);
2329 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2330 I2C_SMBUS_WRITE, command,
2331 I2C_SMBUS_BLOCK_DATA, &data);
2333 EXPORT_SYMBOL(i2c_smbus_write_block_data);
2335 /* Returns the number of read bytes */
2336 s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
2337 u8 length, u8 *values)
2339 union i2c_smbus_data data;
2340 int status;
2342 if (length > I2C_SMBUS_BLOCK_MAX)
2343 length = I2C_SMBUS_BLOCK_MAX;
2344 data.block[0] = length;
2345 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2346 I2C_SMBUS_READ, command,
2347 I2C_SMBUS_I2C_BLOCK_DATA, &data);
2348 if (status < 0)
2349 return status;
2351 memcpy(values, &data.block[1], data.block[0]);
2352 return data.block[0];
2354 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
2356 s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
2357 u8 length, const u8 *values)
2359 union i2c_smbus_data data;
2361 if (length > I2C_SMBUS_BLOCK_MAX)
2362 length = I2C_SMBUS_BLOCK_MAX;
2363 data.block[0] = length;
2364 memcpy(data.block + 1, values, length);
2365 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2366 I2C_SMBUS_WRITE, command,
2367 I2C_SMBUS_I2C_BLOCK_DATA, &data);
2369 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
2371 /* Simulate a SMBus command using the i2c protocol
2372 No checking of parameters is done! */
2373 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
2374 unsigned short flags,
2375 char read_write, u8 command, int size,
2376 union i2c_smbus_data *data)
2378 /* So we need to generate a series of msgs. In the case of writing, we
2379 need to use only one message; when reading, we need two. We initialize
2380 most things with sane defaults, to keep the code below somewhat
2381 simpler. */
2382 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
2383 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
2384 int num = read_write == I2C_SMBUS_READ ? 2 : 1;
2385 int i;
2386 u8 partial_pec = 0;
2387 int status;
2388 struct i2c_msg msg[2] = {
2390 .addr = addr,
2391 .flags = flags,
2392 .len = 1,
2393 .buf = msgbuf0,
2394 }, {
2395 .addr = addr,
2396 .flags = flags | I2C_M_RD,
2397 .len = 0,
2398 .buf = msgbuf1,
2402 msgbuf0[0] = command;
2403 switch (size) {
2404 case I2C_SMBUS_QUICK:
2405 msg[0].len = 0;
2406 /* Special case: The read/write field is used as data */
2407 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
2408 I2C_M_RD : 0);
2409 num = 1;
2410 break;
2411 case I2C_SMBUS_BYTE:
2412 if (read_write == I2C_SMBUS_READ) {
2413 /* Special case: only a read! */
2414 msg[0].flags = I2C_M_RD | flags;
2415 num = 1;
2417 break;
2418 case I2C_SMBUS_BYTE_DATA:
2419 if (read_write == I2C_SMBUS_READ)
2420 msg[1].len = 1;
2421 else {
2422 msg[0].len = 2;
2423 msgbuf0[1] = data->byte;
2425 break;
2426 case I2C_SMBUS_WORD_DATA:
2427 if (read_write == I2C_SMBUS_READ)
2428 msg[1].len = 2;
2429 else {
2430 msg[0].len = 3;
2431 msgbuf0[1] = data->word & 0xff;
2432 msgbuf0[2] = data->word >> 8;
2434 break;
2435 case I2C_SMBUS_PROC_CALL:
2436 num = 2; /* Special case */
2437 read_write = I2C_SMBUS_READ;
2438 msg[0].len = 3;
2439 msg[1].len = 2;
2440 msgbuf0[1] = data->word & 0xff;
2441 msgbuf0[2] = data->word >> 8;
2442 break;
2443 case I2C_SMBUS_BLOCK_DATA:
2444 if (read_write == I2C_SMBUS_READ) {
2445 msg[1].flags |= I2C_M_RECV_LEN;
2446 msg[1].len = 1; /* block length will be added by
2447 the underlying bus driver */
2448 } else {
2449 msg[0].len = data->block[0] + 2;
2450 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
2451 dev_err(&adapter->dev,
2452 "Invalid block write size %d\n",
2453 data->block[0]);
2454 return -EINVAL;
2456 for (i = 1; i < msg[0].len; i++)
2457 msgbuf0[i] = data->block[i-1];
2459 break;
2460 case I2C_SMBUS_BLOCK_PROC_CALL:
2461 num = 2; /* Another special case */
2462 read_write = I2C_SMBUS_READ;
2463 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
2464 dev_err(&adapter->dev,
2465 "Invalid block write size %d\n",
2466 data->block[0]);
2467 return -EINVAL;
2469 msg[0].len = data->block[0] + 2;
2470 for (i = 1; i < msg[0].len; i++)
2471 msgbuf0[i] = data->block[i-1];
2472 msg[1].flags |= I2C_M_RECV_LEN;
2473 msg[1].len = 1; /* block length will be added by
2474 the underlying bus driver */
2475 break;
2476 case I2C_SMBUS_I2C_BLOCK_DATA:
2477 if (read_write == I2C_SMBUS_READ) {
2478 msg[1].len = data->block[0];
2479 } else {
2480 msg[0].len = data->block[0] + 1;
2481 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
2482 dev_err(&adapter->dev,
2483 "Invalid block write size %d\n",
2484 data->block[0]);
2485 return -EINVAL;
2487 for (i = 1; i <= data->block[0]; i++)
2488 msgbuf0[i] = data->block[i];
2490 break;
2491 default:
2492 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
2493 return -EOPNOTSUPP;
2496 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
2497 && size != I2C_SMBUS_I2C_BLOCK_DATA);
2498 if (i) {
2499 /* Compute PEC if first message is a write */
2500 if (!(msg[0].flags & I2C_M_RD)) {
2501 if (num == 1) /* Write only */
2502 i2c_smbus_add_pec(&msg[0]);
2503 else /* Write followed by read */
2504 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
2506 /* Ask for PEC if last message is a read */
2507 if (msg[num-1].flags & I2C_M_RD)
2508 msg[num-1].len++;
2511 status = i2c_transfer(adapter, msg, num);
2512 if (status < 0)
2513 return status;
2515 /* Check PEC if last message is a read */
2516 if (i && (msg[num-1].flags & I2C_M_RD)) {
2517 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
2518 if (status < 0)
2519 return status;
2522 if (read_write == I2C_SMBUS_READ)
2523 switch (size) {
2524 case I2C_SMBUS_BYTE:
2525 data->byte = msgbuf0[0];
2526 break;
2527 case I2C_SMBUS_BYTE_DATA:
2528 data->byte = msgbuf1[0];
2529 break;
2530 case I2C_SMBUS_WORD_DATA:
2531 case I2C_SMBUS_PROC_CALL:
2532 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
2533 break;
2534 case I2C_SMBUS_I2C_BLOCK_DATA:
2535 for (i = 0; i < data->block[0]; i++)
2536 data->block[i+1] = msgbuf1[i];
2537 break;
2538 case I2C_SMBUS_BLOCK_DATA:
2539 case I2C_SMBUS_BLOCK_PROC_CALL:
2540 for (i = 0; i < msgbuf1[0] + 1; i++)
2541 data->block[i] = msgbuf1[i];
2542 break;
2544 return 0;
2548 * i2c_smbus_xfer - execute SMBus protocol operations
2549 * @adapter: Handle to I2C bus
2550 * @addr: Address of SMBus slave on that bus
2551 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
2552 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
2553 * @command: Byte interpreted by slave, for protocols which use such bytes
2554 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
2555 * @data: Data to be read or written
2557 * This executes an SMBus protocol operation, and returns a negative
2558 * errno code else zero on success.
2560 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
2561 char read_write, u8 command, int protocol,
2562 union i2c_smbus_data *data)
2564 unsigned long orig_jiffies;
2565 int try;
2566 s32 res;
2568 /* If enabled, the following two tracepoints are conditional on
2569 * read_write and protocol.
2571 trace_smbus_write(adapter, addr, flags, read_write,
2572 command, protocol, data);
2573 trace_smbus_read(adapter, addr, flags, read_write,
2574 command, protocol);
2576 flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
2578 if (adapter->algo->smbus_xfer) {
2579 i2c_lock_adapter(adapter);
2581 /* Retry automatically on arbitration loss */
2582 orig_jiffies = jiffies;
2583 for (res = 0, try = 0; try <= adapter->retries; try++) {
2584 res = adapter->algo->smbus_xfer(adapter, addr, flags,
2585 read_write, command,
2586 protocol, data);
2587 if (res != -EAGAIN)
2588 break;
2589 if (time_after(jiffies,
2590 orig_jiffies + adapter->timeout))
2591 break;
2593 i2c_unlock_adapter(adapter);
2595 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
2596 goto trace;
2598 * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
2599 * implement native support for the SMBus operation.
2603 res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
2604 command, protocol, data);
2606 trace:
2607 /* If enabled, the reply tracepoint is conditional on read_write. */
2608 trace_smbus_reply(adapter, addr, flags, read_write,
2609 command, protocol, data);
2610 trace_smbus_result(adapter, addr, flags, read_write,
2611 command, protocol, res);
2613 return res;
2615 EXPORT_SYMBOL(i2c_smbus_xfer);
2617 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
2618 MODULE_DESCRIPTION("I2C-Bus main module");
2619 MODULE_LICENSE("GPL");