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>
24
Mux support by Rodolfo Giometti <giometti@enneenne.com> and
25
Michael Lawnick <michael.lawnick.ext@nsn.com> */
27
#include <linux/module.h>
28
#include <linux/kernel.h>
29
#include <linux/errno.h>
30
#include <linux/slab.h>
31
#include <linux/i2c.h>
32
#include <linux/init.h>
33
#include <linux/idr.h>
34
#include <linux/mutex.h>
35
#include <linux/of_device.h>
36
#include <linux/completion.h>
37
#include <linux/hardirq.h>
38
#include <linux/irqflags.h>
39
#include <linux/rwsem.h>
40
#include <linux/pm_runtime.h>
41
#include <asm/uaccess.h>
46
/* core_lock protects i2c_adapter_idr, and guarantees
47
that device detection, deletion of detected devices, and attach_adapter
48
and detach_adapter calls are serialized */
49
static DEFINE_MUTEX(core_lock);
50
static DEFINE_IDR(i2c_adapter_idr);
52
static struct device_type i2c_client_type;
53
static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
55
/* ------------------------------------------------------------------------- */
57
static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
58
const struct i2c_client *client)
61
if (strcmp(client->name, id->name) == 0)
68
static int i2c_device_match(struct device *dev, struct device_driver *drv)
70
struct i2c_client *client = i2c_verify_client(dev);
71
struct i2c_driver *driver;
76
/* Attempt an OF style match */
77
if (of_driver_match_device(dev, drv))
80
driver = to_i2c_driver(drv);
81
/* match on an id table if there is one */
83
return i2c_match_id(driver->id_table, client) != NULL;
90
/* uevent helps with hotplug: modprobe -q $(MODALIAS) */
91
static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
93
struct i2c_client *client = to_i2c_client(dev);
95
if (add_uevent_var(env, "MODALIAS=%s%s",
96
I2C_MODULE_PREFIX, client->name))
98
dev_dbg(dev, "uevent\n");
103
#define i2c_device_uevent NULL
104
#endif /* CONFIG_HOTPLUG */
106
static int i2c_device_probe(struct device *dev)
108
struct i2c_client *client = i2c_verify_client(dev);
109
struct i2c_driver *driver;
115
driver = to_i2c_driver(dev->driver);
116
if (!driver->probe || !driver->id_table)
118
client->driver = driver;
119
if (!device_can_wakeup(&client->dev))
120
device_init_wakeup(&client->dev,
121
client->flags & I2C_CLIENT_WAKE);
122
dev_dbg(dev, "probe\n");
124
status = driver->probe(client, i2c_match_id(driver->id_table, client));
126
client->driver = NULL;
127
i2c_set_clientdata(client, NULL);
132
static int i2c_device_remove(struct device *dev)
134
struct i2c_client *client = i2c_verify_client(dev);
135
struct i2c_driver *driver;
138
if (!client || !dev->driver)
141
driver = to_i2c_driver(dev->driver);
142
if (driver->remove) {
143
dev_dbg(dev, "remove\n");
144
status = driver->remove(client);
150
client->driver = NULL;
151
i2c_set_clientdata(client, NULL);
156
static void i2c_device_shutdown(struct device *dev)
158
struct i2c_client *client = i2c_verify_client(dev);
159
struct i2c_driver *driver;
161
if (!client || !dev->driver)
163
driver = to_i2c_driver(dev->driver);
164
if (driver->shutdown)
165
driver->shutdown(client);
168
#ifdef CONFIG_PM_SLEEP
169
static int i2c_legacy_suspend(struct device *dev, pm_message_t mesg)
171
struct i2c_client *client = i2c_verify_client(dev);
172
struct i2c_driver *driver;
174
if (!client || !dev->driver)
176
driver = to_i2c_driver(dev->driver);
177
if (!driver->suspend)
179
return driver->suspend(client, mesg);
182
static int i2c_legacy_resume(struct device *dev)
184
struct i2c_client *client = i2c_verify_client(dev);
185
struct i2c_driver *driver;
187
if (!client || !dev->driver)
189
driver = to_i2c_driver(dev->driver);
192
return driver->resume(client);
195
static int i2c_device_pm_suspend(struct device *dev)
197
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
200
return pm_generic_suspend(dev);
202
return i2c_legacy_suspend(dev, PMSG_SUSPEND);
205
static int i2c_device_pm_resume(struct device *dev)
207
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
210
return pm_generic_resume(dev);
212
return i2c_legacy_resume(dev);
215
static int i2c_device_pm_freeze(struct device *dev)
217
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
220
return pm_generic_freeze(dev);
222
return i2c_legacy_suspend(dev, PMSG_FREEZE);
225
static int i2c_device_pm_thaw(struct device *dev)
227
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
230
return pm_generic_thaw(dev);
232
return i2c_legacy_resume(dev);
235
static int i2c_device_pm_poweroff(struct device *dev)
237
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
240
return pm_generic_poweroff(dev);
242
return i2c_legacy_suspend(dev, PMSG_HIBERNATE);
245
static int i2c_device_pm_restore(struct device *dev)
247
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
250
return pm_generic_restore(dev);
252
return i2c_legacy_resume(dev);
254
#else /* !CONFIG_PM_SLEEP */
255
#define i2c_device_pm_suspend NULL
256
#define i2c_device_pm_resume NULL
257
#define i2c_device_pm_freeze NULL
258
#define i2c_device_pm_thaw NULL
259
#define i2c_device_pm_poweroff NULL
260
#define i2c_device_pm_restore NULL
261
#endif /* !CONFIG_PM_SLEEP */
263
static void i2c_client_dev_release(struct device *dev)
265
kfree(to_i2c_client(dev));
269
show_name(struct device *dev, struct device_attribute *attr, char *buf)
271
return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
272
to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
276
show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
278
struct i2c_client *client = to_i2c_client(dev);
279
return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
282
static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
283
static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
285
static struct attribute *i2c_dev_attrs[] = {
287
/* modalias helps coldplug: modprobe $(cat .../modalias) */
288
&dev_attr_modalias.attr,
292
static struct attribute_group i2c_dev_attr_group = {
293
.attrs = i2c_dev_attrs,
296
static const struct attribute_group *i2c_dev_attr_groups[] = {
301
static const struct dev_pm_ops i2c_device_pm_ops = {
302
.suspend = i2c_device_pm_suspend,
303
.resume = i2c_device_pm_resume,
304
.freeze = i2c_device_pm_freeze,
305
.thaw = i2c_device_pm_thaw,
306
.poweroff = i2c_device_pm_poweroff,
307
.restore = i2c_device_pm_restore,
309
pm_generic_runtime_suspend,
310
pm_generic_runtime_resume,
311
pm_generic_runtime_idle
315
struct bus_type i2c_bus_type = {
317
.match = i2c_device_match,
318
.probe = i2c_device_probe,
319
.remove = i2c_device_remove,
320
.shutdown = i2c_device_shutdown,
321
.pm = &i2c_device_pm_ops,
323
EXPORT_SYMBOL_GPL(i2c_bus_type);
325
static struct device_type i2c_client_type = {
326
.groups = i2c_dev_attr_groups,
327
.uevent = i2c_device_uevent,
328
.release = i2c_client_dev_release,
333
* i2c_verify_client - return parameter as i2c_client, or NULL
334
* @dev: device, probably from some driver model iterator
336
* When traversing the driver model tree, perhaps using driver model
337
* iterators like @device_for_each_child(), you can't assume very much
338
* about the nodes you find. Use this function to avoid oopses caused
339
* by wrongly treating some non-I2C device as an i2c_client.
341
struct i2c_client *i2c_verify_client(struct device *dev)
343
return (dev->type == &i2c_client_type)
347
EXPORT_SYMBOL(i2c_verify_client);
350
/* This is a permissive address validity check, I2C address map constraints
351
* are purposely not enforced, except for the general call address. */
352
static int i2c_check_client_addr_validity(const struct i2c_client *client)
354
if (client->flags & I2C_CLIENT_TEN) {
355
/* 10-bit address, all values are valid */
356
if (client->addr > 0x3ff)
359
/* 7-bit address, reject the general call address */
360
if (client->addr == 0x00 || client->addr > 0x7f)
366
/* And this is a strict address validity check, used when probing. If a
367
* device uses a reserved address, then it shouldn't be probed. 7-bit
368
* addressing is assumed, 10-bit address devices are rare and should be
369
* explicitly enumerated. */
370
static int i2c_check_addr_validity(unsigned short addr)
373
* Reserved addresses per I2C specification:
374
* 0x00 General call address / START byte
376
* 0x02 Reserved for different bus format
377
* 0x03 Reserved for future purposes
378
* 0x04-0x07 Hs-mode master code
379
* 0x78-0x7b 10-bit slave addressing
380
* 0x7c-0x7f Reserved for future purposes
382
if (addr < 0x08 || addr > 0x77)
387
static int __i2c_check_addr_busy(struct device *dev, void *addrp)
389
struct i2c_client *client = i2c_verify_client(dev);
390
int addr = *(int *)addrp;
392
if (client && client->addr == addr)
397
/* walk up mux tree */
398
static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
400
struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
403
result = device_for_each_child(&adapter->dev, &addr,
404
__i2c_check_addr_busy);
406
if (!result && parent)
407
result = i2c_check_mux_parents(parent, addr);
412
/* recurse down mux tree */
413
static int i2c_check_mux_children(struct device *dev, void *addrp)
417
if (dev->type == &i2c_adapter_type)
418
result = device_for_each_child(dev, addrp,
419
i2c_check_mux_children);
421
result = __i2c_check_addr_busy(dev, addrp);
426
static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
428
struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
432
result = i2c_check_mux_parents(parent, addr);
435
result = device_for_each_child(&adapter->dev, &addr,
436
i2c_check_mux_children);
442
* i2c_lock_adapter - Get exclusive access to an I2C bus segment
443
* @adapter: Target I2C bus segment
445
void i2c_lock_adapter(struct i2c_adapter *adapter)
447
struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
450
i2c_lock_adapter(parent);
452
rt_mutex_lock(&adapter->bus_lock);
454
EXPORT_SYMBOL_GPL(i2c_lock_adapter);
457
* i2c_trylock_adapter - Try to get exclusive access to an I2C bus segment
458
* @adapter: Target I2C bus segment
460
static int i2c_trylock_adapter(struct i2c_adapter *adapter)
462
struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
465
return i2c_trylock_adapter(parent);
467
return rt_mutex_trylock(&adapter->bus_lock);
471
* i2c_unlock_adapter - Release exclusive access to an I2C bus segment
472
* @adapter: Target I2C bus segment
474
void i2c_unlock_adapter(struct i2c_adapter *adapter)
476
struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
479
i2c_unlock_adapter(parent);
481
rt_mutex_unlock(&adapter->bus_lock);
483
EXPORT_SYMBOL_GPL(i2c_unlock_adapter);
486
* i2c_new_device - instantiate an i2c device
487
* @adap: the adapter managing the device
488
* @info: describes one I2C device; bus_num is ignored
491
* Create an i2c device. Binding is handled through driver model
492
* probe()/remove() methods. A driver may be bound to this device when we
493
* return from this function, or any later moment (e.g. maybe hotplugging will
494
* load the driver module). This call is not appropriate for use by mainboard
495
* initialization logic, which usually runs during an arch_initcall() long
496
* before any i2c_adapter could exist.
498
* This returns the new i2c client, which may be saved for later use with
499
* i2c_unregister_device(); or NULL to indicate an error.
502
i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
504
struct i2c_client *client;
507
client = kzalloc(sizeof *client, GFP_KERNEL);
511
client->adapter = adap;
513
client->dev.platform_data = info->platform_data;
516
client->dev.archdata = *info->archdata;
518
client->flags = info->flags;
519
client->addr = info->addr;
520
client->irq = info->irq;
522
strlcpy(client->name, info->type, sizeof(client->name));
524
/* Check for address validity */
525
status = i2c_check_client_addr_validity(client);
527
dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
528
client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
532
/* Check for address business */
533
status = i2c_check_addr_busy(adap, client->addr);
537
client->dev.parent = &client->adapter->dev;
538
client->dev.bus = &i2c_bus_type;
539
client->dev.type = &i2c_client_type;
540
client->dev.of_node = info->of_node;
542
/* For 10-bit clients, add an arbitrary offset to avoid collisions */
543
dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
544
client->addr | ((client->flags & I2C_CLIENT_TEN)
546
status = device_register(&client->dev);
550
dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
551
client->name, dev_name(&client->dev));
556
dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
557
"(%d)\n", client->name, client->addr, status);
562
EXPORT_SYMBOL_GPL(i2c_new_device);
566
* i2c_unregister_device - reverse effect of i2c_new_device()
567
* @client: value returned from i2c_new_device()
570
void i2c_unregister_device(struct i2c_client *client)
572
device_unregister(&client->dev);
574
EXPORT_SYMBOL_GPL(i2c_unregister_device);
577
static const struct i2c_device_id dummy_id[] = {
582
static int dummy_probe(struct i2c_client *client,
583
const struct i2c_device_id *id)
588
static int dummy_remove(struct i2c_client *client)
593
static struct i2c_driver dummy_driver = {
594
.driver.name = "dummy",
595
.probe = dummy_probe,
596
.remove = dummy_remove,
597
.id_table = dummy_id,
601
* i2c_new_dummy - return a new i2c device bound to a dummy driver
602
* @adapter: the adapter managing the device
603
* @address: seven bit address to be used
606
* This returns an I2C client bound to the "dummy" driver, intended for use
607
* with devices that consume multiple addresses. Examples of such chips
608
* include various EEPROMS (like 24c04 and 24c08 models).
610
* These dummy devices have two main uses. First, most I2C and SMBus calls
611
* except i2c_transfer() need a client handle; the dummy will be that handle.
612
* And second, this prevents the specified address from being bound to a
615
* This returns the new i2c client, which should be saved for later use with
616
* i2c_unregister_device(); or NULL to indicate an error.
618
struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
620
struct i2c_board_info info = {
621
I2C_BOARD_INFO("dummy", address),
624
return i2c_new_device(adapter, &info);
626
EXPORT_SYMBOL_GPL(i2c_new_dummy);
628
/* ------------------------------------------------------------------------- */
630
/* I2C bus adapters -- one roots each I2C or SMBUS segment */
632
static void i2c_adapter_dev_release(struct device *dev)
634
struct i2c_adapter *adap = to_i2c_adapter(dev);
635
complete(&adap->dev_released);
639
* Let users instantiate I2C devices through sysfs. This can be used when
640
* platform initialization code doesn't contain the proper data for
641
* whatever reason. Also useful for drivers that do device detection and
642
* detection fails, either because the device uses an unexpected address,
643
* or this is a compatible device with different ID register values.
645
* Parameter checking may look overzealous, but we really don't want
646
* the user to provide incorrect parameters.
649
i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
650
const char *buf, size_t count)
652
struct i2c_adapter *adap = to_i2c_adapter(dev);
653
struct i2c_board_info info;
654
struct i2c_client *client;
658
memset(&info, 0, sizeof(struct i2c_board_info));
660
blank = strchr(buf, ' ');
662
dev_err(dev, "%s: Missing parameters\n", "new_device");
665
if (blank - buf > I2C_NAME_SIZE - 1) {
666
dev_err(dev, "%s: Invalid device name\n", "new_device");
669
memcpy(info.type, buf, blank - buf);
671
/* Parse remaining parameters, reject extra parameters */
672
res = sscanf(++blank, "%hi%c", &info.addr, &end);
674
dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
677
if (res > 1 && end != '\n') {
678
dev_err(dev, "%s: Extra parameters\n", "new_device");
682
client = i2c_new_device(adap, &info);
686
/* Keep track of the added device */
687
mutex_lock(&adap->userspace_clients_lock);
688
list_add_tail(&client->detected, &adap->userspace_clients);
689
mutex_unlock(&adap->userspace_clients_lock);
690
dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
691
info.type, info.addr);
697
* And of course let the users delete the devices they instantiated, if
698
* they got it wrong. This interface can only be used to delete devices
699
* instantiated by i2c_sysfs_new_device above. This guarantees that we
700
* don't delete devices to which some kernel code still has references.
702
* Parameter checking may look overzealous, but we really don't want
703
* the user to delete the wrong device.
706
i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
707
const char *buf, size_t count)
709
struct i2c_adapter *adap = to_i2c_adapter(dev);
710
struct i2c_client *client, *next;
715
/* Parse parameters, reject extra parameters */
716
res = sscanf(buf, "%hi%c", &addr, &end);
718
dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
721
if (res > 1 && end != '\n') {
722
dev_err(dev, "%s: Extra parameters\n", "delete_device");
726
/* Make sure the device was added through sysfs */
728
mutex_lock(&adap->userspace_clients_lock);
729
list_for_each_entry_safe(client, next, &adap->userspace_clients,
731
if (client->addr == addr) {
732
dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
733
"delete_device", client->name, client->addr);
735
list_del(&client->detected);
736
i2c_unregister_device(client);
741
mutex_unlock(&adap->userspace_clients_lock);
744
dev_err(dev, "%s: Can't find device in list\n",
749
static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
750
static DEVICE_ATTR(delete_device, S_IWUSR, NULL, i2c_sysfs_delete_device);
752
static struct attribute *i2c_adapter_attrs[] = {
754
&dev_attr_new_device.attr,
755
&dev_attr_delete_device.attr,
759
static struct attribute_group i2c_adapter_attr_group = {
760
.attrs = i2c_adapter_attrs,
763
static const struct attribute_group *i2c_adapter_attr_groups[] = {
764
&i2c_adapter_attr_group,
768
struct device_type i2c_adapter_type = {
769
.groups = i2c_adapter_attr_groups,
770
.release = i2c_adapter_dev_release,
772
EXPORT_SYMBOL_GPL(i2c_adapter_type);
774
#ifdef CONFIG_I2C_COMPAT
775
static struct class_compat *i2c_adapter_compat_class;
778
static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
780
struct i2c_devinfo *devinfo;
782
down_read(&__i2c_board_lock);
783
list_for_each_entry(devinfo, &__i2c_board_list, list) {
784
if (devinfo->busnum == adapter->nr
785
&& !i2c_new_device(adapter,
786
&devinfo->board_info))
787
dev_err(&adapter->dev,
788
"Can't create device at 0x%02x\n",
789
devinfo->board_info.addr);
791
up_read(&__i2c_board_lock);
794
static int i2c_do_add_adapter(struct i2c_driver *driver,
795
struct i2c_adapter *adap)
797
/* Detect supported devices on that bus, and instantiate them */
798
i2c_detect(adap, driver);
800
/* Let legacy drivers scan this bus for matching devices */
801
if (driver->attach_adapter) {
802
dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
803
driver->driver.name);
804
dev_warn(&adap->dev, "Please use another way to instantiate "
805
"your i2c_client\n");
806
/* We ignore the return code; if it fails, too bad */
807
driver->attach_adapter(adap);
812
static int __process_new_adapter(struct device_driver *d, void *data)
814
return i2c_do_add_adapter(to_i2c_driver(d), data);
817
static int i2c_register_adapter(struct i2c_adapter *adap)
821
/* Can't register until after driver model init */
822
if (unlikely(WARN_ON(!i2c_bus_type.p))) {
828
if (unlikely(adap->name[0] == '\0')) {
829
pr_err("i2c-core: Attempt to register an adapter with "
833
if (unlikely(!adap->algo)) {
834
pr_err("i2c-core: Attempt to register adapter '%s' with "
835
"no algo!\n", adap->name);
839
rt_mutex_init(&adap->bus_lock);
840
mutex_init(&adap->userspace_clients_lock);
841
INIT_LIST_HEAD(&adap->userspace_clients);
843
/* Set default timeout to 1 second if not already set */
844
if (adap->timeout == 0)
847
dev_set_name(&adap->dev, "i2c-%d", adap->nr);
848
adap->dev.bus = &i2c_bus_type;
849
adap->dev.type = &i2c_adapter_type;
850
res = device_register(&adap->dev);
854
dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
856
#ifdef CONFIG_I2C_COMPAT
857
res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
861
"Failed to create compatibility class link\n");
864
/* create pre-declared device nodes */
865
if (adap->nr < __i2c_first_dynamic_bus_num)
866
i2c_scan_static_board_info(adap);
869
mutex_lock(&core_lock);
870
bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
871
mutex_unlock(&core_lock);
876
mutex_lock(&core_lock);
877
idr_remove(&i2c_adapter_idr, adap->nr);
878
mutex_unlock(&core_lock);
883
* i2c_add_adapter - declare i2c adapter, use dynamic bus number
884
* @adapter: the adapter to add
887
* This routine is used to declare an I2C adapter when its bus number
888
* doesn't matter. Examples: for I2C adapters dynamically added by
889
* USB links or PCI plugin cards.
891
* When this returns zero, a new bus number was allocated and stored
892
* in adap->nr, and the specified adapter became available for clients.
893
* Otherwise, a negative errno value is returned.
895
int i2c_add_adapter(struct i2c_adapter *adapter)
900
if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
903
mutex_lock(&core_lock);
904
/* "above" here means "above or equal to", sigh */
905
res = idr_get_new_above(&i2c_adapter_idr, adapter,
906
__i2c_first_dynamic_bus_num, &id);
907
mutex_unlock(&core_lock);
916
return i2c_register_adapter(adapter);
918
EXPORT_SYMBOL(i2c_add_adapter);
921
* i2c_add_numbered_adapter - declare i2c adapter, use static bus number
922
* @adap: the adapter to register (with adap->nr initialized)
925
* This routine is used to declare an I2C adapter when its bus number
926
* matters. For example, use it for I2C adapters from system-on-chip CPUs,
927
* or otherwise built in to the system's mainboard, and where i2c_board_info
928
* is used to properly configure I2C devices.
930
* If the requested bus number is set to -1, then this function will behave
931
* identically to i2c_add_adapter, and will dynamically assign a bus number.
933
* If no devices have pre-been declared for this bus, then be sure to
934
* register the adapter before any dynamically allocated ones. Otherwise
935
* the required bus ID may not be available.
937
* When this returns zero, the specified adapter became available for
938
* clients using the bus number provided in adap->nr. Also, the table
939
* of I2C devices pre-declared using i2c_register_board_info() is scanned,
940
* and the appropriate driver model device nodes are created. Otherwise, a
941
* negative errno value is returned.
943
int i2c_add_numbered_adapter(struct i2c_adapter *adap)
948
if (adap->nr == -1) /* -1 means dynamically assign bus id */
949
return i2c_add_adapter(adap);
950
if (adap->nr & ~MAX_ID_MASK)
954
if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
957
mutex_lock(&core_lock);
958
/* "above" here means "above or equal to", sigh;
959
* we need the "equal to" result to force the result
961
status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
962
if (status == 0 && id != adap->nr) {
964
idr_remove(&i2c_adapter_idr, id);
966
mutex_unlock(&core_lock);
967
if (status == -EAGAIN)
971
status = i2c_register_adapter(adap);
974
EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
976
static int i2c_do_del_adapter(struct i2c_driver *driver,
977
struct i2c_adapter *adapter)
979
struct i2c_client *client, *_n;
982
/* Remove the devices we created ourselves as the result of hardware
983
* probing (using a driver's detect method) */
984
list_for_each_entry_safe(client, _n, &driver->clients, detected) {
985
if (client->adapter == adapter) {
986
dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
987
client->name, client->addr);
988
list_del(&client->detected);
989
i2c_unregister_device(client);
993
if (!driver->detach_adapter)
995
dev_warn(&adapter->dev, "%s: detach_adapter method is deprecated\n",
996
driver->driver.name);
997
res = driver->detach_adapter(adapter);
999
dev_err(&adapter->dev, "detach_adapter failed (%d) "
1000
"for driver [%s]\n", res, driver->driver.name);
1004
static int __unregister_client(struct device *dev, void *dummy)
1006
struct i2c_client *client = i2c_verify_client(dev);
1007
if (client && strcmp(client->name, "dummy"))
1008
i2c_unregister_device(client);
1012
static int __unregister_dummy(struct device *dev, void *dummy)
1014
struct i2c_client *client = i2c_verify_client(dev);
1016
i2c_unregister_device(client);
1020
static int __process_removed_adapter(struct device_driver *d, void *data)
1022
return i2c_do_del_adapter(to_i2c_driver(d), data);
1026
* i2c_del_adapter - unregister I2C adapter
1027
* @adap: the adapter being unregistered
1028
* Context: can sleep
1030
* This unregisters an I2C adapter which was previously registered
1031
* by @i2c_add_adapter or @i2c_add_numbered_adapter.
1033
int i2c_del_adapter(struct i2c_adapter *adap)
1036
struct i2c_adapter *found;
1037
struct i2c_client *client, *next;
1039
/* First make sure that this adapter was ever added */
1040
mutex_lock(&core_lock);
1041
found = idr_find(&i2c_adapter_idr, adap->nr);
1042
mutex_unlock(&core_lock);
1043
if (found != adap) {
1044
pr_debug("i2c-core: attempting to delete unregistered "
1045
"adapter [%s]\n", adap->name);
1049
/* Tell drivers about this removal */
1050
mutex_lock(&core_lock);
1051
res = bus_for_each_drv(&i2c_bus_type, NULL, adap,
1052
__process_removed_adapter);
1053
mutex_unlock(&core_lock);
1057
/* Remove devices instantiated from sysfs */
1058
mutex_lock(&adap->userspace_clients_lock);
1059
list_for_each_entry_safe(client, next, &adap->userspace_clients,
1061
dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
1063
list_del(&client->detected);
1064
i2c_unregister_device(client);
1066
mutex_unlock(&adap->userspace_clients_lock);
1068
/* Detach any active clients. This can't fail, thus we do not
1069
* check the returned value. This is a two-pass process, because
1070
* we can't remove the dummy devices during the first pass: they
1071
* could have been instantiated by real devices wishing to clean
1072
* them up properly, so we give them a chance to do that first. */
1073
res = device_for_each_child(&adap->dev, NULL, __unregister_client);
1074
res = device_for_each_child(&adap->dev, NULL, __unregister_dummy);
1076
#ifdef CONFIG_I2C_COMPAT
1077
class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
1081
/* device name is gone after device_unregister */
1082
dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
1084
/* clean up the sysfs representation */
1085
init_completion(&adap->dev_released);
1086
device_unregister(&adap->dev);
1088
/* wait for sysfs to drop all references */
1089
wait_for_completion(&adap->dev_released);
1092
mutex_lock(&core_lock);
1093
idr_remove(&i2c_adapter_idr, adap->nr);
1094
mutex_unlock(&core_lock);
1096
/* Clear the device structure in case this adapter is ever going to be
1098
memset(&adap->dev, 0, sizeof(adap->dev));
1102
EXPORT_SYMBOL(i2c_del_adapter);
1105
/* ------------------------------------------------------------------------- */
1107
int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
1111
mutex_lock(&core_lock);
1112
res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
1113
mutex_unlock(&core_lock);
1117
EXPORT_SYMBOL_GPL(i2c_for_each_dev);
1119
static int __process_new_driver(struct device *dev, void *data)
1121
if (dev->type != &i2c_adapter_type)
1123
return i2c_do_add_adapter(data, to_i2c_adapter(dev));
1127
* An i2c_driver is used with one or more i2c_client (device) nodes to access
1128
* i2c slave chips, on a bus instance associated with some i2c_adapter.
1131
int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
1135
/* Can't register until after driver model init */
1136
if (unlikely(WARN_ON(!i2c_bus_type.p)))
1139
/* add the driver to the list of i2c drivers in the driver core */
1140
driver->driver.owner = owner;
1141
driver->driver.bus = &i2c_bus_type;
1143
/* When registration returns, the driver core
1144
* will have called probe() for all matching-but-unbound devices.
1146
res = driver_register(&driver->driver);
1150
/* Drivers should switch to dev_pm_ops instead. */
1151
if (driver->suspend)
1152
pr_warn("i2c-core: driver [%s] using legacy suspend method\n",
1153
driver->driver.name);
1155
pr_warn("i2c-core: driver [%s] using legacy resume method\n",
1156
driver->driver.name);
1158
pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
1160
INIT_LIST_HEAD(&driver->clients);
1161
/* Walk the adapters that are already present */
1162
i2c_for_each_dev(driver, __process_new_driver);
1166
EXPORT_SYMBOL(i2c_register_driver);
1168
static int __process_removed_driver(struct device *dev, void *data)
1170
if (dev->type != &i2c_adapter_type)
1172
return i2c_do_del_adapter(data, to_i2c_adapter(dev));
1176
* i2c_del_driver - unregister I2C driver
1177
* @driver: the driver being unregistered
1178
* Context: can sleep
1180
void i2c_del_driver(struct i2c_driver *driver)
1182
i2c_for_each_dev(driver, __process_removed_driver);
1184
driver_unregister(&driver->driver);
1185
pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
1187
EXPORT_SYMBOL(i2c_del_driver);
1189
/* ------------------------------------------------------------------------- */
1192
* i2c_use_client - increments the reference count of the i2c client structure
1193
* @client: the client being referenced
1195
* Each live reference to a client should be refcounted. The driver model does
1196
* that automatically as part of driver binding, so that most drivers don't
1197
* need to do this explicitly: they hold a reference until they're unbound
1200
* A pointer to the client with the incremented reference counter is returned.
1202
struct i2c_client *i2c_use_client(struct i2c_client *client)
1204
if (client && get_device(&client->dev))
1208
EXPORT_SYMBOL(i2c_use_client);
1211
* i2c_release_client - release a use of the i2c client structure
1212
* @client: the client being no longer referenced
1214
* Must be called when a user of a client is finished with it.
1216
void i2c_release_client(struct i2c_client *client)
1219
put_device(&client->dev);
1221
EXPORT_SYMBOL(i2c_release_client);
1223
struct i2c_cmd_arg {
1228
static int i2c_cmd(struct device *dev, void *_arg)
1230
struct i2c_client *client = i2c_verify_client(dev);
1231
struct i2c_cmd_arg *arg = _arg;
1233
if (client && client->driver && client->driver->command)
1234
client->driver->command(client, arg->cmd, arg->arg);
1238
void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
1240
struct i2c_cmd_arg cmd_arg;
1244
device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
1246
EXPORT_SYMBOL(i2c_clients_command);
1248
static int __init i2c_init(void)
1252
retval = bus_register(&i2c_bus_type);
1255
#ifdef CONFIG_I2C_COMPAT
1256
i2c_adapter_compat_class = class_compat_register("i2c-adapter");
1257
if (!i2c_adapter_compat_class) {
1262
retval = i2c_add_driver(&dummy_driver);
1268
#ifdef CONFIG_I2C_COMPAT
1269
class_compat_unregister(i2c_adapter_compat_class);
1272
bus_unregister(&i2c_bus_type);
1276
static void __exit i2c_exit(void)
1278
i2c_del_driver(&dummy_driver);
1279
#ifdef CONFIG_I2C_COMPAT
1280
class_compat_unregister(i2c_adapter_compat_class);
1282
bus_unregister(&i2c_bus_type);
1285
/* We must initialize early, because some subsystems register i2c drivers
1286
* in subsys_initcall() code, but are linked (and initialized) before i2c.
1288
postcore_initcall(i2c_init);
1289
module_exit(i2c_exit);
1291
/* ----------------------------------------------------
1292
* the functional interface to the i2c busses.
1293
* ----------------------------------------------------
1297
* i2c_transfer - execute a single or combined I2C message
1298
* @adap: Handle to I2C bus
1299
* @msgs: One or more messages to execute before STOP is issued to
1300
* terminate the operation; each message begins with a START.
1301
* @num: Number of messages to be executed.
1303
* Returns negative errno, else the number of messages executed.
1305
* Note that there is no requirement that each message be sent to
1306
* the same slave address, although that is the most common model.
1308
int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
1310
unsigned long orig_jiffies;
1313
/* REVISIT the fault reporting model here is weak:
1315
* - When we get an error after receiving N bytes from a slave,
1316
* there is no way to report "N".
1318
* - When we get a NAK after transmitting N bytes to a slave,
1319
* there is no way to report "N" ... or to let the master
1320
* continue executing the rest of this combined message, if
1321
* that's the appropriate response.
1323
* - When for example "num" is two and we successfully complete
1324
* the first message but get an error part way through the
1325
* second, it's unclear whether that should be reported as
1326
* one (discarding status on the second message) or errno
1327
* (discarding status on the first one).
1330
if (adap->algo->master_xfer) {
1332
for (ret = 0; ret < num; ret++) {
1333
dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
1334
"len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
1335
? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
1336
(msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
1340
if (in_atomic() || irqs_disabled()) {
1341
ret = i2c_trylock_adapter(adap);
1343
/* I2C activity is ongoing. */
1346
i2c_lock_adapter(adap);
1349
/* Retry automatically on arbitration loss */
1350
orig_jiffies = jiffies;
1351
for (ret = 0, try = 0; try <= adap->retries; try++) {
1352
ret = adap->algo->master_xfer(adap, msgs, num);
1355
if (time_after(jiffies, orig_jiffies + adap->timeout))
1358
i2c_unlock_adapter(adap);
1362
dev_dbg(&adap->dev, "I2C level transfers not supported\n");
1366
EXPORT_SYMBOL(i2c_transfer);
1369
* i2c_master_send - issue a single I2C message in master transmit mode
1370
* @client: Handle to slave device
1371
* @buf: Data that will be written to the slave
1372
* @count: How many bytes to write, must be less than 64k since msg.len is u16
1374
* Returns negative errno, or else the number of bytes written.
1376
int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
1379
struct i2c_adapter *adap = client->adapter;
1382
msg.addr = client->addr;
1383
msg.flags = client->flags & I2C_M_TEN;
1385
msg.buf = (char *)buf;
1387
ret = i2c_transfer(adap, &msg, 1);
1389
/* If everything went ok (i.e. 1 msg transmitted), return #bytes
1390
transmitted, else error code. */
1391
return (ret == 1) ? count : ret;
1393
EXPORT_SYMBOL(i2c_master_send);
1396
* i2c_master_recv - issue a single I2C message in master receive mode
1397
* @client: Handle to slave device
1398
* @buf: Where to store data read from slave
1399
* @count: How many bytes to read, must be less than 64k since msg.len is u16
1401
* Returns negative errno, or else the number of bytes read.
1403
int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
1405
struct i2c_adapter *adap = client->adapter;
1409
msg.addr = client->addr;
1410
msg.flags = client->flags & I2C_M_TEN;
1411
msg.flags |= I2C_M_RD;
1415
ret = i2c_transfer(adap, &msg, 1);
1417
/* If everything went ok (i.e. 1 msg transmitted), return #bytes
1418
transmitted, else error code. */
1419
return (ret == 1) ? count : ret;
1421
EXPORT_SYMBOL(i2c_master_recv);
1423
/* ----------------------------------------------------
1424
* the i2c address scanning function
1425
* Will not work for 10-bit addresses!
1426
* ----------------------------------------------------
1430
* Legacy default probe function, mostly relevant for SMBus. The default
1431
* probe method is a quick write, but it is known to corrupt the 24RF08
1432
* EEPROMs due to a state machine bug, and could also irreversibly
1433
* write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
1434
* we use a short byte read instead. Also, some bus drivers don't implement
1435
* quick write, so we fallback to a byte read in that case too.
1436
* On x86, there is another special case for FSC hardware monitoring chips,
1437
* which want regular byte reads (address 0x73.) Fortunately, these are the
1438
* only known chips using this I2C address on PC hardware.
1439
* Returns 1 if probe succeeded, 0 if not.
1441
static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
1444
union i2c_smbus_data dummy;
1447
if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
1448
&& i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
1449
err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1450
I2C_SMBUS_BYTE_DATA, &dummy);
1453
if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
1454
&& i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
1455
err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
1456
I2C_SMBUS_QUICK, NULL);
1457
else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
1458
err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1459
I2C_SMBUS_BYTE, &dummy);
1461
dev_warn(&adap->dev, "No suitable probing method supported\n");
1468
static int i2c_detect_address(struct i2c_client *temp_client,
1469
struct i2c_driver *driver)
1471
struct i2c_board_info info;
1472
struct i2c_adapter *adapter = temp_client->adapter;
1473
int addr = temp_client->addr;
1476
/* Make sure the address is valid */
1477
err = i2c_check_addr_validity(addr);
1479
dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1484
/* Skip if already in use */
1485
if (i2c_check_addr_busy(adapter, addr))
1488
/* Make sure there is something at this address */
1489
if (!i2c_default_probe(adapter, addr))
1492
/* Finally call the custom detection function */
1493
memset(&info, 0, sizeof(struct i2c_board_info));
1495
err = driver->detect(temp_client, &info);
1497
/* -ENODEV is returned if the detection fails. We catch it
1498
here as this isn't an error. */
1499
return err == -ENODEV ? 0 : err;
1502
/* Consistency check */
1503
if (info.type[0] == '\0') {
1504
dev_err(&adapter->dev, "%s detection function provided "
1505
"no name for 0x%x\n", driver->driver.name,
1508
struct i2c_client *client;
1510
/* Detection succeeded, instantiate the device */
1511
dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
1512
info.type, info.addr);
1513
client = i2c_new_device(adapter, &info);
1515
list_add_tail(&client->detected, &driver->clients);
1517
dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
1518
info.type, info.addr);
1523
static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
1525
const unsigned short *address_list;
1526
struct i2c_client *temp_client;
1528
int adap_id = i2c_adapter_id(adapter);
1530
address_list = driver->address_list;
1531
if (!driver->detect || !address_list)
1534
/* Stop here if the classes do not match */
1535
if (!(adapter->class & driver->class))
1538
/* Set up a temporary client to help detect callback */
1539
temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
1542
temp_client->adapter = adapter;
1544
for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
1545
dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1546
"addr 0x%02x\n", adap_id, address_list[i]);
1547
temp_client->addr = address_list[i];
1548
err = i2c_detect_address(temp_client, driver);
1557
int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
1559
return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1560
I2C_SMBUS_QUICK, NULL) >= 0;
1562
EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
1565
i2c_new_probed_device(struct i2c_adapter *adap,
1566
struct i2c_board_info *info,
1567
unsigned short const *addr_list,
1568
int (*probe)(struct i2c_adapter *, unsigned short addr))
1573
probe = i2c_default_probe;
1575
for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1576
/* Check address validity */
1577
if (i2c_check_addr_validity(addr_list[i]) < 0) {
1578
dev_warn(&adap->dev, "Invalid 7-bit address "
1579
"0x%02x\n", addr_list[i]);
1583
/* Check address availability */
1584
if (i2c_check_addr_busy(adap, addr_list[i])) {
1585
dev_dbg(&adap->dev, "Address 0x%02x already in "
1586
"use, not probing\n", addr_list[i]);
1590
/* Test address responsiveness */
1591
if (probe(adap, addr_list[i]))
1595
if (addr_list[i] == I2C_CLIENT_END) {
1596
dev_dbg(&adap->dev, "Probing failed, no device found\n");
1600
info->addr = addr_list[i];
1601
return i2c_new_device(adap, info);
1603
EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1605
struct i2c_adapter *i2c_get_adapter(int nr)
1607
struct i2c_adapter *adapter;
1609
mutex_lock(&core_lock);
1610
adapter = idr_find(&i2c_adapter_idr, nr);
1611
if (adapter && !try_module_get(adapter->owner))
1614
mutex_unlock(&core_lock);
1617
EXPORT_SYMBOL(i2c_get_adapter);
1619
void i2c_put_adapter(struct i2c_adapter *adap)
1621
module_put(adap->owner);
1623
EXPORT_SYMBOL(i2c_put_adapter);
1625
/* The SMBus parts */
1627
#define POLY (0x1070U << 3)
1628
static u8 crc8(u16 data)
1632
for (i = 0; i < 8; i++) {
1637
return (u8)(data >> 8);
1640
/* Incremental CRC8 over count bytes in the array pointed to by p */
1641
static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
1645
for (i = 0; i < count; i++)
1646
crc = crc8((crc ^ p[i]) << 8);
1650
/* Assume a 7-bit address, which is reasonable for SMBus */
1651
static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
1653
/* The address will be sent first */
1654
u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1655
pec = i2c_smbus_pec(pec, &addr, 1);
1657
/* The data buffer follows */
1658
return i2c_smbus_pec(pec, msg->buf, msg->len);
1661
/* Used for write only transactions */
1662
static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
1664
msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1668
/* Return <0 on CRC error
1669
If there was a write before this read (most cases) we need to take the
1670
partial CRC from the write part into account.
1671
Note that this function does modify the message (we need to decrease the
1672
message length to hide the CRC byte from the caller). */
1673
static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
1675
u8 rpec = msg->buf[--msg->len];
1676
cpec = i2c_smbus_msg_pec(cpec, msg);
1679
pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1687
* i2c_smbus_read_byte - SMBus "receive byte" protocol
1688
* @client: Handle to slave device
1690
* This executes the SMBus "receive byte" protocol, returning negative errno
1691
* else the byte received from the device.
1693
s32 i2c_smbus_read_byte(const struct i2c_client *client)
1695
union i2c_smbus_data data;
1698
status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1700
I2C_SMBUS_BYTE, &data);
1701
return (status < 0) ? status : data.byte;
1703
EXPORT_SYMBOL(i2c_smbus_read_byte);
1706
* i2c_smbus_write_byte - SMBus "send byte" protocol
1707
* @client: Handle to slave device
1708
* @value: Byte to be sent
1710
* This executes the SMBus "send byte" protocol, returning negative errno
1711
* else zero on success.
1713
s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
1715
return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1716
I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
1718
EXPORT_SYMBOL(i2c_smbus_write_byte);
1721
* i2c_smbus_read_byte_data - SMBus "read byte" protocol
1722
* @client: Handle to slave device
1723
* @command: Byte interpreted by slave
1725
* This executes the SMBus "read byte" protocol, returning negative errno
1726
* else a data byte received from the device.
1728
s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
1730
union i2c_smbus_data data;
1733
status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1734
I2C_SMBUS_READ, command,
1735
I2C_SMBUS_BYTE_DATA, &data);
1736
return (status < 0) ? status : data.byte;
1738
EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1741
* i2c_smbus_write_byte_data - SMBus "write byte" protocol
1742
* @client: Handle to slave device
1743
* @command: Byte interpreted by slave
1744
* @value: Byte being written
1746
* This executes the SMBus "write byte" protocol, returning negative errno
1747
* else zero on success.
1749
s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
1752
union i2c_smbus_data data;
1754
return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1755
I2C_SMBUS_WRITE, command,
1756
I2C_SMBUS_BYTE_DATA, &data);
1758
EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1761
* i2c_smbus_read_word_data - SMBus "read word" protocol
1762
* @client: Handle to slave device
1763
* @command: Byte interpreted by slave
1765
* This executes the SMBus "read word" protocol, returning negative errno
1766
* else a 16-bit unsigned "word" received from the device.
1768
s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
1770
union i2c_smbus_data data;
1773
status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1774
I2C_SMBUS_READ, command,
1775
I2C_SMBUS_WORD_DATA, &data);
1776
return (status < 0) ? status : data.word;
1778
EXPORT_SYMBOL(i2c_smbus_read_word_data);
1781
* i2c_smbus_write_word_data - SMBus "write word" protocol
1782
* @client: Handle to slave device
1783
* @command: Byte interpreted by slave
1784
* @value: 16-bit "word" being written
1786
* This executes the SMBus "write word" protocol, returning negative errno
1787
* else zero on success.
1789
s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
1792
union i2c_smbus_data data;
1794
return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1795
I2C_SMBUS_WRITE, command,
1796
I2C_SMBUS_WORD_DATA, &data);
1798
EXPORT_SYMBOL(i2c_smbus_write_word_data);
1801
* i2c_smbus_process_call - SMBus "process call" protocol
1802
* @client: Handle to slave device
1803
* @command: Byte interpreted by slave
1804
* @value: 16-bit "word" being written
1806
* This executes the SMBus "process call" protocol, returning negative errno
1807
* else a 16-bit unsigned "word" received from the device.
1809
s32 i2c_smbus_process_call(const struct i2c_client *client, u8 command,
1812
union i2c_smbus_data data;
1816
status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1817
I2C_SMBUS_WRITE, command,
1818
I2C_SMBUS_PROC_CALL, &data);
1819
return (status < 0) ? status : data.word;
1821
EXPORT_SYMBOL(i2c_smbus_process_call);
1824
* i2c_smbus_read_block_data - SMBus "block read" protocol
1825
* @client: Handle to slave device
1826
* @command: Byte interpreted by slave
1827
* @values: Byte array into which data will be read; big enough to hold
1828
* the data returned by the slave. SMBus allows at most 32 bytes.
1830
* This executes the SMBus "block read" protocol, returning negative errno
1831
* else the number of data bytes in the slave's response.
1833
* Note that using this function requires that the client's adapter support
1834
* the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
1835
* support this; its emulation through I2C messaging relies on a specific
1836
* mechanism (I2C_M_RECV_LEN) which may not be implemented.
1838
s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
1841
union i2c_smbus_data data;
1844
status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1845
I2C_SMBUS_READ, command,
1846
I2C_SMBUS_BLOCK_DATA, &data);
1850
memcpy(values, &data.block[1], data.block[0]);
1851
return data.block[0];
1853
EXPORT_SYMBOL(i2c_smbus_read_block_data);
1856
* i2c_smbus_write_block_data - SMBus "block write" protocol
1857
* @client: Handle to slave device
1858
* @command: Byte interpreted by slave
1859
* @length: Size of data block; SMBus allows at most 32 bytes
1860
* @values: Byte array which will be written.
1862
* This executes the SMBus "block write" protocol, returning negative errno
1863
* else zero on success.
1865
s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
1866
u8 length, const u8 *values)
1868
union i2c_smbus_data data;
1870
if (length > I2C_SMBUS_BLOCK_MAX)
1871
length = I2C_SMBUS_BLOCK_MAX;
1872
data.block[0] = length;
1873
memcpy(&data.block[1], values, length);
1874
return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1875
I2C_SMBUS_WRITE, command,
1876
I2C_SMBUS_BLOCK_DATA, &data);
1878
EXPORT_SYMBOL(i2c_smbus_write_block_data);
1880
/* Returns the number of read bytes */
1881
s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
1882
u8 length, u8 *values)
1884
union i2c_smbus_data data;
1887
if (length > I2C_SMBUS_BLOCK_MAX)
1888
length = I2C_SMBUS_BLOCK_MAX;
1889
data.block[0] = length;
1890
status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1891
I2C_SMBUS_READ, command,
1892
I2C_SMBUS_I2C_BLOCK_DATA, &data);
1896
memcpy(values, &data.block[1], data.block[0]);
1897
return data.block[0];
1899
EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1901
s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
1902
u8 length, const u8 *values)
1904
union i2c_smbus_data data;
1906
if (length > I2C_SMBUS_BLOCK_MAX)
1907
length = I2C_SMBUS_BLOCK_MAX;
1908
data.block[0] = length;
1909
memcpy(data.block + 1, values, length);
1910
return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1911
I2C_SMBUS_WRITE, command,
1912
I2C_SMBUS_I2C_BLOCK_DATA, &data);
1914
EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
1916
/* Simulate a SMBus command using the i2c protocol
1917
No checking of parameters is done! */
1918
static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
1919
unsigned short flags,
1920
char read_write, u8 command, int size,
1921
union i2c_smbus_data *data)
1923
/* So we need to generate a series of msgs. In the case of writing, we
1924
need to use only one message; when reading, we need two. We initialize
1925
most things with sane defaults, to keep the code below somewhat
1927
unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1928
unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
1929
int num = read_write == I2C_SMBUS_READ ? 2 : 1;
1930
struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
1931
{ addr, flags | I2C_M_RD, 0, msgbuf1 }
1937
msgbuf0[0] = command;
1939
case I2C_SMBUS_QUICK:
1941
/* Special case: The read/write field is used as data */
1942
msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
1946
case I2C_SMBUS_BYTE:
1947
if (read_write == I2C_SMBUS_READ) {
1948
/* Special case: only a read! */
1949
msg[0].flags = I2C_M_RD | flags;
1953
case I2C_SMBUS_BYTE_DATA:
1954
if (read_write == I2C_SMBUS_READ)
1958
msgbuf0[1] = data->byte;
1961
case I2C_SMBUS_WORD_DATA:
1962
if (read_write == I2C_SMBUS_READ)
1966
msgbuf0[1] = data->word & 0xff;
1967
msgbuf0[2] = data->word >> 8;
1970
case I2C_SMBUS_PROC_CALL:
1971
num = 2; /* Special case */
1972
read_write = I2C_SMBUS_READ;
1975
msgbuf0[1] = data->word & 0xff;
1976
msgbuf0[2] = data->word >> 8;
1978
case I2C_SMBUS_BLOCK_DATA:
1979
if (read_write == I2C_SMBUS_READ) {
1980
msg[1].flags |= I2C_M_RECV_LEN;
1981
msg[1].len = 1; /* block length will be added by
1982
the underlying bus driver */
1984
msg[0].len = data->block[0] + 2;
1985
if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
1986
dev_err(&adapter->dev,
1987
"Invalid block write size %d\n",
1991
for (i = 1; i < msg[0].len; i++)
1992
msgbuf0[i] = data->block[i-1];
1995
case I2C_SMBUS_BLOCK_PROC_CALL:
1996
num = 2; /* Another special case */
1997
read_write = I2C_SMBUS_READ;
1998
if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
1999
dev_err(&adapter->dev,
2000
"Invalid block write size %d\n",
2004
msg[0].len = data->block[0] + 2;
2005
for (i = 1; i < msg[0].len; i++)
2006
msgbuf0[i] = data->block[i-1];
2007
msg[1].flags |= I2C_M_RECV_LEN;
2008
msg[1].len = 1; /* block length will be added by
2009
the underlying bus driver */
2011
case I2C_SMBUS_I2C_BLOCK_DATA:
2012
if (read_write == I2C_SMBUS_READ) {
2013
msg[1].len = data->block[0];
2015
msg[0].len = data->block[0] + 1;
2016
if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
2017
dev_err(&adapter->dev,
2018
"Invalid block write size %d\n",
2022
for (i = 1; i <= data->block[0]; i++)
2023
msgbuf0[i] = data->block[i];
2027
dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
2031
i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
2032
&& size != I2C_SMBUS_I2C_BLOCK_DATA);
2034
/* Compute PEC if first message is a write */
2035
if (!(msg[0].flags & I2C_M_RD)) {
2036
if (num == 1) /* Write only */
2037
i2c_smbus_add_pec(&msg[0]);
2038
else /* Write followed by read */
2039
partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
2041
/* Ask for PEC if last message is a read */
2042
if (msg[num-1].flags & I2C_M_RD)
2046
status = i2c_transfer(adapter, msg, num);
2050
/* Check PEC if last message is a read */
2051
if (i && (msg[num-1].flags & I2C_M_RD)) {
2052
status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
2057
if (read_write == I2C_SMBUS_READ)
2059
case I2C_SMBUS_BYTE:
2060
data->byte = msgbuf0[0];
2062
case I2C_SMBUS_BYTE_DATA:
2063
data->byte = msgbuf1[0];
2065
case I2C_SMBUS_WORD_DATA:
2066
case I2C_SMBUS_PROC_CALL:
2067
data->word = msgbuf1[0] | (msgbuf1[1] << 8);
2069
case I2C_SMBUS_I2C_BLOCK_DATA:
2070
for (i = 0; i < data->block[0]; i++)
2071
data->block[i+1] = msgbuf1[i];
2073
case I2C_SMBUS_BLOCK_DATA:
2074
case I2C_SMBUS_BLOCK_PROC_CALL:
2075
for (i = 0; i < msgbuf1[0] + 1; i++)
2076
data->block[i] = msgbuf1[i];
2083
* i2c_smbus_xfer - execute SMBus protocol operations
2084
* @adapter: Handle to I2C bus
2085
* @addr: Address of SMBus slave on that bus
2086
* @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
2087
* @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
2088
* @command: Byte interpreted by slave, for protocols which use such bytes
2089
* @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
2090
* @data: Data to be read or written
2092
* This executes an SMBus protocol operation, and returns a negative
2093
* errno code else zero on success.
2095
s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
2096
char read_write, u8 command, int protocol,
2097
union i2c_smbus_data *data)
2099
unsigned long orig_jiffies;
2103
flags &= I2C_M_TEN | I2C_CLIENT_PEC;
2105
if (adapter->algo->smbus_xfer) {
2106
i2c_lock_adapter(adapter);
2108
/* Retry automatically on arbitration loss */
2109
orig_jiffies = jiffies;
2110
for (res = 0, try = 0; try <= adapter->retries; try++) {
2111
res = adapter->algo->smbus_xfer(adapter, addr, flags,
2112
read_write, command,
2116
if (time_after(jiffies,
2117
orig_jiffies + adapter->timeout))
2120
i2c_unlock_adapter(adapter);
2122
res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
2123
command, protocol, data);
2127
EXPORT_SYMBOL(i2c_smbus_xfer);
2129
MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
2130
MODULE_DESCRIPTION("I2C-Bus main module");
2131
MODULE_LICENSE("GPL");