Merge branch 'devel'
[deliverable/linux.git] / drivers / i2c / i2c-core.c
CommitLineData
1da177e4
LT
1/* i2c-core.c - a device driver for the iic-bus interface */
2/* ------------------------------------------------------------------------- */
3/* Copyright (C) 1995-99 Simon G. Vogl
4
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.
9
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.
14
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
5694f8a8
JD
17 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
18 MA 02110-1301 USA. */
1da177e4
LT
19/* ------------------------------------------------------------------------- */
20
96de0e25 21/* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi>.
1da177e4 22 All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl>
421ef47b 23 SMBus 2.0 support by Mark Studebaker <mdsxyz123@yahoo.com> and
0826374b
ML
24 Jean Delvare <khali@linux-fr.org>
25 Mux support by Rodolfo Giometti <giometti@enneenne.com> and
26 Michael Lawnick <michael.lawnick.ext@nsn.com> */
1da177e4 27
1da177e4
LT
28#include <linux/module.h>
29#include <linux/kernel.h>
30#include <linux/errno.h>
31#include <linux/slab.h>
32#include <linux/i2c.h>
33#include <linux/init.h>
34#include <linux/idr.h>
b3585e4f 35#include <linux/mutex.h>
959e85f7 36#include <linux/of_device.h>
b8d6f45b 37#include <linux/completion.h>
cea443a8
MR
38#include <linux/hardirq.h>
39#include <linux/irqflags.h>
f18c41da 40#include <linux/rwsem.h>
6de468ae 41#include <linux/pm_runtime.h>
1da177e4
LT
42#include <asm/uaccess.h>
43
9c1600ed
DB
44#include "i2c-core.h"
45
1da177e4 46
6629dcff 47/* core_lock protects i2c_adapter_idr, and guarantees
35fc37f8
JD
48 that device detection, deletion of detected devices, and attach_adapter
49 and detach_adapter calls are serialized */
caada32a 50static DEFINE_MUTEX(core_lock);
1da177e4
LT
51static DEFINE_IDR(i2c_adapter_idr);
52
4f8cf824 53static struct device_type i2c_client_type;
4735c98f 54static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
f37dd80a
DB
55
56/* ------------------------------------------------------------------------- */
57
d2653e92
JD
58static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
59 const struct i2c_client *client)
60{
61 while (id->name[0]) {
62 if (strcmp(client->name, id->name) == 0)
63 return id;
64 id++;
65 }
66 return NULL;
67}
68
1da177e4
LT
69static int i2c_device_match(struct device *dev, struct device_driver *drv)
70{
51298d12
JD
71 struct i2c_client *client = i2c_verify_client(dev);
72 struct i2c_driver *driver;
73
74 if (!client)
75 return 0;
7b4fbc50 76
959e85f7
GL
77 /* Attempt an OF style match */
78 if (of_driver_match_device(dev, drv))
79 return 1;
80
51298d12 81 driver = to_i2c_driver(drv);
d2653e92
JD
82 /* match on an id table if there is one */
83 if (driver->id_table)
84 return i2c_match_id(driver->id_table, client) != NULL;
85
eb8a7908 86 return 0;
1da177e4
LT
87}
88
7b4fbc50
DB
89#ifdef CONFIG_HOTPLUG
90
91/* uevent helps with hotplug: modprobe -q $(MODALIAS) */
7eff2e7a 92static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
7b4fbc50
DB
93{
94 struct i2c_client *client = to_i2c_client(dev);
7b4fbc50 95
eb8a7908
JD
96 if (add_uevent_var(env, "MODALIAS=%s%s",
97 I2C_MODULE_PREFIX, client->name))
98 return -ENOMEM;
7b4fbc50
DB
99 dev_dbg(dev, "uevent\n");
100 return 0;
101}
102
103#else
104#define i2c_device_uevent NULL
105#endif /* CONFIG_HOTPLUG */
106
f37dd80a 107static int i2c_device_probe(struct device *dev)
1da177e4 108{
51298d12
JD
109 struct i2c_client *client = i2c_verify_client(dev);
110 struct i2c_driver *driver;
50c3304a 111 int status;
7b4fbc50 112
51298d12
JD
113 if (!client)
114 return 0;
115
116 driver = to_i2c_driver(dev->driver);
e0457442 117 if (!driver->probe || !driver->id_table)
7b4fbc50
DB
118 return -ENODEV;
119 client->driver = driver;
ee35425c
MP
120 if (!device_can_wakeup(&client->dev))
121 device_init_wakeup(&client->dev,
122 client->flags & I2C_CLIENT_WAKE);
7b4fbc50 123 dev_dbg(dev, "probe\n");
d2653e92 124
e0457442 125 status = driver->probe(client, i2c_match_id(driver->id_table, client));
e4a7b9b0 126 if (status) {
50c3304a 127 client->driver = NULL;
e4a7b9b0
WS
128 i2c_set_clientdata(client, NULL);
129 }
50c3304a 130 return status;
f37dd80a 131}
1da177e4 132
f37dd80a
DB
133static int i2c_device_remove(struct device *dev)
134{
51298d12 135 struct i2c_client *client = i2c_verify_client(dev);
a1d9e6e4
DB
136 struct i2c_driver *driver;
137 int status;
138
51298d12 139 if (!client || !dev->driver)
a1d9e6e4
DB
140 return 0;
141
142 driver = to_i2c_driver(dev->driver);
143 if (driver->remove) {
144 dev_dbg(dev, "remove\n");
145 status = driver->remove(client);
146 } else {
147 dev->driver = NULL;
148 status = 0;
149 }
e4a7b9b0 150 if (status == 0) {
a1d9e6e4 151 client->driver = NULL;
e4a7b9b0
WS
152 i2c_set_clientdata(client, NULL);
153 }
a1d9e6e4 154 return status;
1da177e4
LT
155}
156
f37dd80a 157static void i2c_device_shutdown(struct device *dev)
1da177e4 158{
51298d12 159 struct i2c_client *client = i2c_verify_client(dev);
f37dd80a
DB
160 struct i2c_driver *driver;
161
51298d12 162 if (!client || !dev->driver)
f37dd80a
DB
163 return;
164 driver = to_i2c_driver(dev->driver);
165 if (driver->shutdown)
51298d12 166 driver->shutdown(client);
1da177e4
LT
167}
168
2f60ba70
RW
169#ifdef CONFIG_PM_SLEEP
170static int i2c_legacy_suspend(struct device *dev, pm_message_t mesg)
54067ee2 171{
2f60ba70
RW
172 struct i2c_client *client = i2c_verify_client(dev);
173 struct i2c_driver *driver;
54067ee2 174
2f60ba70 175 if (!client || !dev->driver)
54067ee2 176 return 0;
2f60ba70
RW
177 driver = to_i2c_driver(dev->driver);
178 if (!driver->suspend)
54067ee2 179 return 0;
2f60ba70 180 return driver->suspend(client, mesg);
54067ee2 181}
182
2f60ba70 183static int i2c_legacy_resume(struct device *dev)
54067ee2 184{
2f60ba70
RW
185 struct i2c_client *client = i2c_verify_client(dev);
186 struct i2c_driver *driver;
54067ee2 187
2f60ba70 188 if (!client || !dev->driver)
54067ee2 189 return 0;
2f60ba70
RW
190 driver = to_i2c_driver(dev->driver);
191 if (!driver->resume)
54067ee2 192 return 0;
2f60ba70 193 return driver->resume(client);
54067ee2 194}
54067ee2 195
2f60ba70 196static int i2c_device_pm_suspend(struct device *dev)
6de468ae 197{
2f60ba70 198 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
6de468ae 199
d529de29
MB
200 if (pm)
201 return pm_generic_suspend(dev);
202 else
203 return i2c_legacy_suspend(dev, PMSG_SUSPEND);
6de468ae
MB
204}
205
2f60ba70 206static int i2c_device_pm_resume(struct device *dev)
6de468ae 207{
2f60ba70 208 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
6de468ae 209
2f60ba70 210 if (pm)
d529de29 211 return pm_generic_resume(dev);
2f60ba70 212 else
d529de29 213 return i2c_legacy_resume(dev);
6de468ae 214}
6de468ae 215
2f60ba70 216static int i2c_device_pm_freeze(struct device *dev)
1da177e4 217{
2f60ba70 218 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
f37dd80a 219
d529de29
MB
220 if (pm)
221 return pm_generic_freeze(dev);
222 else
223 return i2c_legacy_suspend(dev, PMSG_FREEZE);
1da177e4
LT
224}
225
2f60ba70 226static int i2c_device_pm_thaw(struct device *dev)
1da177e4 227{
2f60ba70 228 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
f37dd80a 229
d529de29
MB
230 if (pm)
231 return pm_generic_thaw(dev);
232 else
233 return i2c_legacy_resume(dev);
2f60ba70
RW
234}
235
236static int i2c_device_pm_poweroff(struct device *dev)
237{
238 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
239
d529de29
MB
240 if (pm)
241 return pm_generic_poweroff(dev);
242 else
243 return i2c_legacy_suspend(dev, PMSG_HIBERNATE);
2f60ba70
RW
244}
245
246static int i2c_device_pm_restore(struct device *dev)
247{
248 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
2f60ba70
RW
249
250 if (pm)
d529de29 251 return pm_generic_restore(dev);
2f60ba70 252 else
d529de29 253 return i2c_legacy_resume(dev);
1da177e4 254}
2f60ba70
RW
255#else /* !CONFIG_PM_SLEEP */
256#define i2c_device_pm_suspend NULL
257#define i2c_device_pm_resume NULL
258#define i2c_device_pm_freeze NULL
259#define i2c_device_pm_thaw NULL
260#define i2c_device_pm_poweroff NULL
261#define i2c_device_pm_restore NULL
262#endif /* !CONFIG_PM_SLEEP */
1da177e4 263
9c1600ed
DB
264static void i2c_client_dev_release(struct device *dev)
265{
266 kfree(to_i2c_client(dev));
267}
268
09b8ce0a 269static ssize_t
4f8cf824 270show_name(struct device *dev, struct device_attribute *attr, char *buf)
7b4fbc50 271{
4f8cf824
JD
272 return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
273 to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
7b4fbc50
DB
274}
275
09b8ce0a
ZX
276static ssize_t
277show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
7b4fbc50
DB
278{
279 struct i2c_client *client = to_i2c_client(dev);
eb8a7908 280 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
7b4fbc50
DB
281}
282
4f8cf824 283static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
51298d12
JD
284static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
285
286static struct attribute *i2c_dev_attrs[] = {
287 &dev_attr_name.attr,
7b4fbc50 288 /* modalias helps coldplug: modprobe $(cat .../modalias) */
51298d12
JD
289 &dev_attr_modalias.attr,
290 NULL
291};
292
293static struct attribute_group i2c_dev_attr_group = {
294 .attrs = i2c_dev_attrs,
295};
296
297static const struct attribute_group *i2c_dev_attr_groups[] = {
298 &i2c_dev_attr_group,
299 NULL
7b4fbc50
DB
300};
301
0b2c3688 302static const struct dev_pm_ops i2c_device_pm_ops = {
54067ee2 303 .suspend = i2c_device_pm_suspend,
304 .resume = i2c_device_pm_resume,
2f60ba70
RW
305 .freeze = i2c_device_pm_freeze,
306 .thaw = i2c_device_pm_thaw,
307 .poweroff = i2c_device_pm_poweroff,
308 .restore = i2c_device_pm_restore,
309 SET_RUNTIME_PM_OPS(
310 pm_generic_runtime_suspend,
311 pm_generic_runtime_resume,
312 pm_generic_runtime_idle
313 )
54067ee2 314};
315
e9ca9eb9 316struct bus_type i2c_bus_type = {
f37dd80a
DB
317 .name = "i2c",
318 .match = i2c_device_match,
319 .probe = i2c_device_probe,
320 .remove = i2c_device_remove,
321 .shutdown = i2c_device_shutdown,
54067ee2 322 .pm = &i2c_device_pm_ops,
b864c7d5 323};
e9ca9eb9 324EXPORT_SYMBOL_GPL(i2c_bus_type);
b864c7d5 325
51298d12
JD
326static struct device_type i2c_client_type = {
327 .groups = i2c_dev_attr_groups,
328 .uevent = i2c_device_uevent,
329 .release = i2c_client_dev_release,
330};
331
9b766b81
DB
332
333/**
334 * i2c_verify_client - return parameter as i2c_client, or NULL
335 * @dev: device, probably from some driver model iterator
336 *
337 * When traversing the driver model tree, perhaps using driver model
338 * iterators like @device_for_each_child(), you can't assume very much
339 * about the nodes you find. Use this function to avoid oopses caused
340 * by wrongly treating some non-I2C device as an i2c_client.
341 */
342struct i2c_client *i2c_verify_client(struct device *dev)
343{
51298d12 344 return (dev->type == &i2c_client_type)
9b766b81
DB
345 ? to_i2c_client(dev)
346 : NULL;
347}
348EXPORT_SYMBOL(i2c_verify_client);
349
350
3a89db5f 351/* This is a permissive address validity check, I2C address map constraints
25985edc 352 * are purposely not enforced, except for the general call address. */
3a89db5f
JD
353static int i2c_check_client_addr_validity(const struct i2c_client *client)
354{
355 if (client->flags & I2C_CLIENT_TEN) {
356 /* 10-bit address, all values are valid */
357 if (client->addr > 0x3ff)
358 return -EINVAL;
359 } else {
360 /* 7-bit address, reject the general call address */
361 if (client->addr == 0x00 || client->addr > 0x7f)
362 return -EINVAL;
363 }
364 return 0;
365}
366
656b8761
JD
367/* And this is a strict address validity check, used when probing. If a
368 * device uses a reserved address, then it shouldn't be probed. 7-bit
369 * addressing is assumed, 10-bit address devices are rare and should be
370 * explicitly enumerated. */
371static int i2c_check_addr_validity(unsigned short addr)
372{
373 /*
374 * Reserved addresses per I2C specification:
375 * 0x00 General call address / START byte
376 * 0x01 CBUS address
377 * 0x02 Reserved for different bus format
378 * 0x03 Reserved for future purposes
379 * 0x04-0x07 Hs-mode master code
380 * 0x78-0x7b 10-bit slave addressing
381 * 0x7c-0x7f Reserved for future purposes
382 */
383 if (addr < 0x08 || addr > 0x77)
384 return -EINVAL;
385 return 0;
386}
387
3b5f794b
JD
388static int __i2c_check_addr_busy(struct device *dev, void *addrp)
389{
390 struct i2c_client *client = i2c_verify_client(dev);
391 int addr = *(int *)addrp;
392
393 if (client && client->addr == addr)
394 return -EBUSY;
395 return 0;
396}
397
0826374b
ML
398/* walk up mux tree */
399static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
400{
97cc4d49 401 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
0826374b
ML
402 int result;
403
404 result = device_for_each_child(&adapter->dev, &addr,
405 __i2c_check_addr_busy);
406
97cc4d49
JD
407 if (!result && parent)
408 result = i2c_check_mux_parents(parent, addr);
0826374b
ML
409
410 return result;
411}
412
413/* recurse down mux tree */
414static int i2c_check_mux_children(struct device *dev, void *addrp)
415{
416 int result;
417
418 if (dev->type == &i2c_adapter_type)
419 result = device_for_each_child(dev, addrp,
420 i2c_check_mux_children);
421 else
422 result = __i2c_check_addr_busy(dev, addrp);
423
424 return result;
425}
426
3b5f794b
JD
427static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
428{
97cc4d49 429 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
0826374b
ML
430 int result = 0;
431
97cc4d49
JD
432 if (parent)
433 result = i2c_check_mux_parents(parent, addr);
0826374b
ML
434
435 if (!result)
436 result = device_for_each_child(&adapter->dev, &addr,
437 i2c_check_mux_children);
438
439 return result;
3b5f794b
JD
440}
441
fe61e07e
JD
442/**
443 * i2c_lock_adapter - Get exclusive access to an I2C bus segment
444 * @adapter: Target I2C bus segment
445 */
446void i2c_lock_adapter(struct i2c_adapter *adapter)
447{
97cc4d49
JD
448 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
449
450 if (parent)
451 i2c_lock_adapter(parent);
0826374b
ML
452 else
453 rt_mutex_lock(&adapter->bus_lock);
fe61e07e
JD
454}
455EXPORT_SYMBOL_GPL(i2c_lock_adapter);
456
457/**
458 * i2c_trylock_adapter - Try to get exclusive access to an I2C bus segment
459 * @adapter: Target I2C bus segment
460 */
461static int i2c_trylock_adapter(struct i2c_adapter *adapter)
462{
97cc4d49
JD
463 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
464
465 if (parent)
466 return i2c_trylock_adapter(parent);
0826374b
ML
467 else
468 return rt_mutex_trylock(&adapter->bus_lock);
fe61e07e
JD
469}
470
471/**
472 * i2c_unlock_adapter - Release exclusive access to an I2C bus segment
473 * @adapter: Target I2C bus segment
474 */
475void i2c_unlock_adapter(struct i2c_adapter *adapter)
476{
97cc4d49
JD
477 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
478
479 if (parent)
480 i2c_unlock_adapter(parent);
0826374b
ML
481 else
482 rt_mutex_unlock(&adapter->bus_lock);
fe61e07e
JD
483}
484EXPORT_SYMBOL_GPL(i2c_unlock_adapter);
485
9c1600ed 486/**
f8a227e8 487 * i2c_new_device - instantiate an i2c device
9c1600ed
DB
488 * @adap: the adapter managing the device
489 * @info: describes one I2C device; bus_num is ignored
d64f73be 490 * Context: can sleep
9c1600ed 491 *
f8a227e8
JD
492 * Create an i2c device. Binding is handled through driver model
493 * probe()/remove() methods. A driver may be bound to this device when we
494 * return from this function, or any later moment (e.g. maybe hotplugging will
495 * load the driver module). This call is not appropriate for use by mainboard
496 * initialization logic, which usually runs during an arch_initcall() long
497 * before any i2c_adapter could exist.
9c1600ed
DB
498 *
499 * This returns the new i2c client, which may be saved for later use with
500 * i2c_unregister_device(); or NULL to indicate an error.
501 */
502struct i2c_client *
503i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
504{
505 struct i2c_client *client;
506 int status;
507
508 client = kzalloc(sizeof *client, GFP_KERNEL);
509 if (!client)
510 return NULL;
511
512 client->adapter = adap;
513
514 client->dev.platform_data = info->platform_data;
3bbb835d 515
11f1f2af
AV
516 if (info->archdata)
517 client->dev.archdata = *info->archdata;
518
ee35425c 519 client->flags = info->flags;
9c1600ed
DB
520 client->addr = info->addr;
521 client->irq = info->irq;
522
9c1600ed
DB
523 strlcpy(client->name, info->type, sizeof(client->name));
524
3a89db5f
JD
525 /* Check for address validity */
526 status = i2c_check_client_addr_validity(client);
527 if (status) {
528 dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
529 client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
530 goto out_err_silent;
531 }
532
f8a227e8 533 /* Check for address business */
3b5f794b 534 status = i2c_check_addr_busy(adap, client->addr);
f8a227e8
JD
535 if (status)
536 goto out_err;
537
538 client->dev.parent = &client->adapter->dev;
539 client->dev.bus = &i2c_bus_type;
51298d12 540 client->dev.type = &i2c_client_type;
d12d42f7 541 client->dev.of_node = info->of_node;
f8a227e8 542
cbb44514 543 /* For 10-bit clients, add an arbitrary offset to avoid collisions */
f8a227e8 544 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
cbb44514
JD
545 client->addr | ((client->flags & I2C_CLIENT_TEN)
546 ? 0xa000 : 0));
f8a227e8
JD
547 status = device_register(&client->dev);
548 if (status)
549 goto out_err;
550
f8a227e8
JD
551 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
552 client->name, dev_name(&client->dev));
553
9c1600ed 554 return client;
f8a227e8
JD
555
556out_err:
557 dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
558 "(%d)\n", client->name, client->addr, status);
3a89db5f 559out_err_silent:
f8a227e8
JD
560 kfree(client);
561 return NULL;
9c1600ed
DB
562}
563EXPORT_SYMBOL_GPL(i2c_new_device);
564
565
566/**
567 * i2c_unregister_device - reverse effect of i2c_new_device()
568 * @client: value returned from i2c_new_device()
d64f73be 569 * Context: can sleep
9c1600ed
DB
570 */
571void i2c_unregister_device(struct i2c_client *client)
a1d9e6e4 572{
a1d9e6e4
DB
573 device_unregister(&client->dev);
574}
9c1600ed 575EXPORT_SYMBOL_GPL(i2c_unregister_device);
a1d9e6e4
DB
576
577
60b129d7
JD
578static const struct i2c_device_id dummy_id[] = {
579 { "dummy", 0 },
580 { },
581};
582
d2653e92
JD
583static int dummy_probe(struct i2c_client *client,
584 const struct i2c_device_id *id)
585{
586 return 0;
587}
588
589static int dummy_remove(struct i2c_client *client)
e9f1373b
DB
590{
591 return 0;
592}
593
594static struct i2c_driver dummy_driver = {
595 .driver.name = "dummy",
d2653e92
JD
596 .probe = dummy_probe,
597 .remove = dummy_remove,
60b129d7 598 .id_table = dummy_id,
e9f1373b
DB
599};
600
601/**
602 * i2c_new_dummy - return a new i2c device bound to a dummy driver
603 * @adapter: the adapter managing the device
604 * @address: seven bit address to be used
e9f1373b
DB
605 * Context: can sleep
606 *
607 * This returns an I2C client bound to the "dummy" driver, intended for use
608 * with devices that consume multiple addresses. Examples of such chips
609 * include various EEPROMS (like 24c04 and 24c08 models).
610 *
611 * These dummy devices have two main uses. First, most I2C and SMBus calls
612 * except i2c_transfer() need a client handle; the dummy will be that handle.
613 * And second, this prevents the specified address from being bound to a
614 * different driver.
615 *
616 * This returns the new i2c client, which should be saved for later use with
617 * i2c_unregister_device(); or NULL to indicate an error.
618 */
09b8ce0a 619struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
e9f1373b
DB
620{
621 struct i2c_board_info info = {
60b129d7 622 I2C_BOARD_INFO("dummy", address),
e9f1373b
DB
623 };
624
e9f1373b
DB
625 return i2c_new_device(adapter, &info);
626}
627EXPORT_SYMBOL_GPL(i2c_new_dummy);
628
f37dd80a
DB
629/* ------------------------------------------------------------------------- */
630
16ffadfc
DB
631/* I2C bus adapters -- one roots each I2C or SMBUS segment */
632
83eaaed0 633static void i2c_adapter_dev_release(struct device *dev)
1da177e4 634{
ef2c8321 635 struct i2c_adapter *adap = to_i2c_adapter(dev);
1da177e4
LT
636 complete(&adap->dev_released);
637}
638
99cd8e25
JD
639/*
640 * Let users instantiate I2C devices through sysfs. This can be used when
641 * platform initialization code doesn't contain the proper data for
642 * whatever reason. Also useful for drivers that do device detection and
643 * detection fails, either because the device uses an unexpected address,
644 * or this is a compatible device with different ID register values.
645 *
646 * Parameter checking may look overzealous, but we really don't want
647 * the user to provide incorrect parameters.
648 */
649static ssize_t
650i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
651 const char *buf, size_t count)
652{
653 struct i2c_adapter *adap = to_i2c_adapter(dev);
654 struct i2c_board_info info;
655 struct i2c_client *client;
656 char *blank, end;
657 int res;
658
99cd8e25
JD
659 memset(&info, 0, sizeof(struct i2c_board_info));
660
661 blank = strchr(buf, ' ');
662 if (!blank) {
663 dev_err(dev, "%s: Missing parameters\n", "new_device");
664 return -EINVAL;
665 }
666 if (blank - buf > I2C_NAME_SIZE - 1) {
667 dev_err(dev, "%s: Invalid device name\n", "new_device");
668 return -EINVAL;
669 }
670 memcpy(info.type, buf, blank - buf);
671
672 /* Parse remaining parameters, reject extra parameters */
673 res = sscanf(++blank, "%hi%c", &info.addr, &end);
674 if (res < 1) {
675 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
676 return -EINVAL;
677 }
678 if (res > 1 && end != '\n') {
679 dev_err(dev, "%s: Extra parameters\n", "new_device");
680 return -EINVAL;
681 }
682
99cd8e25
JD
683 client = i2c_new_device(adap, &info);
684 if (!client)
3a89db5f 685 return -EINVAL;
99cd8e25
JD
686
687 /* Keep track of the added device */
dafc50d1 688 mutex_lock(&adap->userspace_clients_lock);
6629dcff 689 list_add_tail(&client->detected, &adap->userspace_clients);
dafc50d1 690 mutex_unlock(&adap->userspace_clients_lock);
99cd8e25
JD
691 dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
692 info.type, info.addr);
693
694 return count;
695}
696
697/*
698 * And of course let the users delete the devices they instantiated, if
699 * they got it wrong. This interface can only be used to delete devices
700 * instantiated by i2c_sysfs_new_device above. This guarantees that we
701 * don't delete devices to which some kernel code still has references.
702 *
703 * Parameter checking may look overzealous, but we really don't want
704 * the user to delete the wrong device.
705 */
706static ssize_t
707i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
708 const char *buf, size_t count)
709{
710 struct i2c_adapter *adap = to_i2c_adapter(dev);
711 struct i2c_client *client, *next;
712 unsigned short addr;
713 char end;
714 int res;
715
716 /* Parse parameters, reject extra parameters */
717 res = sscanf(buf, "%hi%c", &addr, &end);
718 if (res < 1) {
719 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
720 return -EINVAL;
721 }
722 if (res > 1 && end != '\n') {
723 dev_err(dev, "%s: Extra parameters\n", "delete_device");
724 return -EINVAL;
725 }
726
727 /* Make sure the device was added through sysfs */
728 res = -ENOENT;
dafc50d1 729 mutex_lock(&adap->userspace_clients_lock);
6629dcff
JD
730 list_for_each_entry_safe(client, next, &adap->userspace_clients,
731 detected) {
732 if (client->addr == addr) {
99cd8e25
JD
733 dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
734 "delete_device", client->name, client->addr);
735
736 list_del(&client->detected);
737 i2c_unregister_device(client);
738 res = count;
739 break;
740 }
741 }
dafc50d1 742 mutex_unlock(&adap->userspace_clients_lock);
99cd8e25
JD
743
744 if (res < 0)
745 dev_err(dev, "%s: Can't find device in list\n",
746 "delete_device");
747 return res;
748}
749
4f8cf824
JD
750static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
751static DEVICE_ATTR(delete_device, S_IWUSR, NULL, i2c_sysfs_delete_device);
752
753static struct attribute *i2c_adapter_attrs[] = {
754 &dev_attr_name.attr,
755 &dev_attr_new_device.attr,
756 &dev_attr_delete_device.attr,
757 NULL
758};
759
760static struct attribute_group i2c_adapter_attr_group = {
761 .attrs = i2c_adapter_attrs,
762};
763
764static const struct attribute_group *i2c_adapter_attr_groups[] = {
765 &i2c_adapter_attr_group,
766 NULL
16ffadfc 767};
b119dc3f 768
0826374b 769struct device_type i2c_adapter_type = {
4f8cf824
JD
770 .groups = i2c_adapter_attr_groups,
771 .release = i2c_adapter_dev_release,
1da177e4 772};
0826374b 773EXPORT_SYMBOL_GPL(i2c_adapter_type);
1da177e4 774
643dd09e
SW
775/**
776 * i2c_verify_adapter - return parameter as i2c_adapter or NULL
777 * @dev: device, probably from some driver model iterator
778 *
779 * When traversing the driver model tree, perhaps using driver model
780 * iterators like @device_for_each_child(), you can't assume very much
781 * about the nodes you find. Use this function to avoid oopses caused
782 * by wrongly treating some non-I2C device as an i2c_adapter.
783 */
784struct i2c_adapter *i2c_verify_adapter(struct device *dev)
785{
786 return (dev->type == &i2c_adapter_type)
787 ? to_i2c_adapter(dev)
788 : NULL;
789}
790EXPORT_SYMBOL(i2c_verify_adapter);
791
2bb5095a
JD
792#ifdef CONFIG_I2C_COMPAT
793static struct class_compat *i2c_adapter_compat_class;
794#endif
795
9c1600ed
DB
796static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
797{
798 struct i2c_devinfo *devinfo;
799
f18c41da 800 down_read(&__i2c_board_lock);
9c1600ed
DB
801 list_for_each_entry(devinfo, &__i2c_board_list, list) {
802 if (devinfo->busnum == adapter->nr
803 && !i2c_new_device(adapter,
804 &devinfo->board_info))
09b8ce0a
ZX
805 dev_err(&adapter->dev,
806 "Can't create device at 0x%02x\n",
9c1600ed
DB
807 devinfo->board_info.addr);
808 }
f18c41da 809 up_read(&__i2c_board_lock);
9c1600ed
DB
810}
811
69b0089a
JD
812static int i2c_do_add_adapter(struct i2c_driver *driver,
813 struct i2c_adapter *adap)
026526f5 814{
4735c98f
JD
815 /* Detect supported devices on that bus, and instantiate them */
816 i2c_detect(adap, driver);
817
818 /* Let legacy drivers scan this bus for matching devices */
026526f5 819 if (driver->attach_adapter) {
a920ff41
JD
820 dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
821 driver->driver.name);
fe6fc258
JD
822 dev_warn(&adap->dev, "Please use another way to instantiate "
823 "your i2c_client\n");
026526f5
JD
824 /* We ignore the return code; if it fails, too bad */
825 driver->attach_adapter(adap);
826 }
827 return 0;
828}
829
69b0089a
JD
830static int __process_new_adapter(struct device_driver *d, void *data)
831{
832 return i2c_do_add_adapter(to_i2c_driver(d), data);
833}
834
6e13e641 835static int i2c_register_adapter(struct i2c_adapter *adap)
1da177e4 836{
d6703281 837 int res = 0;
1da177e4 838
1d0b19c9 839 /* Can't register until after driver model init */
35fc37f8
JD
840 if (unlikely(WARN_ON(!i2c_bus_type.p))) {
841 res = -EAGAIN;
842 goto out_list;
843 }
1d0b19c9 844
2236baa7
JD
845 /* Sanity checks */
846 if (unlikely(adap->name[0] == '\0')) {
847 pr_err("i2c-core: Attempt to register an adapter with "
848 "no name!\n");
849 return -EINVAL;
850 }
851 if (unlikely(!adap->algo)) {
852 pr_err("i2c-core: Attempt to register adapter '%s' with "
853 "no algo!\n", adap->name);
854 return -EINVAL;
855 }
856
194684e5 857 rt_mutex_init(&adap->bus_lock);
dafc50d1 858 mutex_init(&adap->userspace_clients_lock);
6629dcff 859 INIT_LIST_HEAD(&adap->userspace_clients);
1da177e4 860
8fcfef6e
JD
861 /* Set default timeout to 1 second if not already set */
862 if (adap->timeout == 0)
863 adap->timeout = HZ;
864
27d9c183 865 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
4f8cf824
JD
866 adap->dev.bus = &i2c_bus_type;
867 adap->dev.type = &i2c_adapter_type;
b119c6c9
JD
868 res = device_register(&adap->dev);
869 if (res)
870 goto out_list;
1da177e4 871
b6d7b3d1
JD
872 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
873
2bb5095a
JD
874#ifdef CONFIG_I2C_COMPAT
875 res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
876 adap->dev.parent);
877 if (res)
878 dev_warn(&adap->dev,
879 "Failed to create compatibility class link\n");
880#endif
881
729d6dd5 882 /* create pre-declared device nodes */
6e13e641
DB
883 if (adap->nr < __i2c_first_dynamic_bus_num)
884 i2c_scan_static_board_info(adap);
885
4735c98f 886 /* Notify drivers */
35fc37f8 887 mutex_lock(&core_lock);
d6703281 888 bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
caada32a 889 mutex_unlock(&core_lock);
35fc37f8
JD
890
891 return 0;
b119c6c9 892
b119c6c9 893out_list:
35fc37f8 894 mutex_lock(&core_lock);
b119c6c9 895 idr_remove(&i2c_adapter_idr, adap->nr);
35fc37f8
JD
896 mutex_unlock(&core_lock);
897 return res;
1da177e4
LT
898}
899
6e13e641
DB
900/**
901 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
902 * @adapter: the adapter to add
d64f73be 903 * Context: can sleep
6e13e641
DB
904 *
905 * This routine is used to declare an I2C adapter when its bus number
906 * doesn't matter. Examples: for I2C adapters dynamically added by
907 * USB links or PCI plugin cards.
908 *
909 * When this returns zero, a new bus number was allocated and stored
910 * in adap->nr, and the specified adapter became available for clients.
911 * Otherwise, a negative errno value is returned.
912 */
913int i2c_add_adapter(struct i2c_adapter *adapter)
914{
915 int id, res = 0;
916
917retry:
918 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
919 return -ENOMEM;
920
caada32a 921 mutex_lock(&core_lock);
6e13e641
DB
922 /* "above" here means "above or equal to", sigh */
923 res = idr_get_new_above(&i2c_adapter_idr, adapter,
924 __i2c_first_dynamic_bus_num, &id);
caada32a 925 mutex_unlock(&core_lock);
6e13e641
DB
926
927 if (res < 0) {
928 if (res == -EAGAIN)
929 goto retry;
930 return res;
931 }
932
933 adapter->nr = id;
934 return i2c_register_adapter(adapter);
935}
936EXPORT_SYMBOL(i2c_add_adapter);
937
938/**
939 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
940 * @adap: the adapter to register (with adap->nr initialized)
d64f73be 941 * Context: can sleep
6e13e641
DB
942 *
943 * This routine is used to declare an I2C adapter when its bus number
8c07e46f
RD
944 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
945 * or otherwise built in to the system's mainboard, and where i2c_board_info
6e13e641
DB
946 * is used to properly configure I2C devices.
947 *
488bf314
GL
948 * If the requested bus number is set to -1, then this function will behave
949 * identically to i2c_add_adapter, and will dynamically assign a bus number.
950 *
6e13e641
DB
951 * If no devices have pre-been declared for this bus, then be sure to
952 * register the adapter before any dynamically allocated ones. Otherwise
953 * the required bus ID may not be available.
954 *
955 * When this returns zero, the specified adapter became available for
956 * clients using the bus number provided in adap->nr. Also, the table
957 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
958 * and the appropriate driver model device nodes are created. Otherwise, a
959 * negative errno value is returned.
960 */
961int i2c_add_numbered_adapter(struct i2c_adapter *adap)
962{
963 int id;
964 int status;
965
488bf314
GL
966 if (adap->nr == -1) /* -1 means dynamically assign bus id */
967 return i2c_add_adapter(adap);
6e13e641
DB
968 if (adap->nr & ~MAX_ID_MASK)
969 return -EINVAL;
970
971retry:
972 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
973 return -ENOMEM;
974
caada32a 975 mutex_lock(&core_lock);
6e13e641
DB
976 /* "above" here means "above or equal to", sigh;
977 * we need the "equal to" result to force the result
978 */
979 status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
980 if (status == 0 && id != adap->nr) {
981 status = -EBUSY;
982 idr_remove(&i2c_adapter_idr, id);
983 }
caada32a 984 mutex_unlock(&core_lock);
6e13e641
DB
985 if (status == -EAGAIN)
986 goto retry;
987
988 if (status == 0)
989 status = i2c_register_adapter(adap);
990 return status;
991}
992EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
993
69b0089a
JD
994static int i2c_do_del_adapter(struct i2c_driver *driver,
995 struct i2c_adapter *adapter)
026526f5 996{
4735c98f 997 struct i2c_client *client, *_n;
026526f5
JD
998 int res;
999
acec211c
JD
1000 /* Remove the devices we created ourselves as the result of hardware
1001 * probing (using a driver's detect method) */
4735c98f
JD
1002 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
1003 if (client->adapter == adapter) {
1004 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
1005 client->name, client->addr);
1006 list_del(&client->detected);
1007 i2c_unregister_device(client);
1008 }
1009 }
1010
026526f5
JD
1011 if (!driver->detach_adapter)
1012 return 0;
a920ff41
JD
1013 dev_warn(&adapter->dev, "%s: detach_adapter method is deprecated\n",
1014 driver->driver.name);
026526f5
JD
1015 res = driver->detach_adapter(adapter);
1016 if (res)
1017 dev_err(&adapter->dev, "detach_adapter failed (%d) "
1018 "for driver [%s]\n", res, driver->driver.name);
1019 return res;
1020}
1021
e549c2b5 1022static int __unregister_client(struct device *dev, void *dummy)
5219bf88
JD
1023{
1024 struct i2c_client *client = i2c_verify_client(dev);
1025 if (client && strcmp(client->name, "dummy"))
1026 i2c_unregister_device(client);
1027 return 0;
1028}
1029
1030static int __unregister_dummy(struct device *dev, void *dummy)
e549c2b5
JD
1031{
1032 struct i2c_client *client = i2c_verify_client(dev);
1033 if (client)
1034 i2c_unregister_device(client);
1035 return 0;
1036}
1037
69b0089a
JD
1038static int __process_removed_adapter(struct device_driver *d, void *data)
1039{
1040 return i2c_do_del_adapter(to_i2c_driver(d), data);
1041}
1042
d64f73be
DB
1043/**
1044 * i2c_del_adapter - unregister I2C adapter
1045 * @adap: the adapter being unregistered
1046 * Context: can sleep
1047 *
1048 * This unregisters an I2C adapter which was previously registered
1049 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
1050 */
1da177e4
LT
1051int i2c_del_adapter(struct i2c_adapter *adap)
1052{
1da177e4 1053 int res = 0;
35fc37f8 1054 struct i2c_adapter *found;
bbd2d9c9 1055 struct i2c_client *client, *next;
1da177e4
LT
1056
1057 /* First make sure that this adapter was ever added */
35fc37f8
JD
1058 mutex_lock(&core_lock);
1059 found = idr_find(&i2c_adapter_idr, adap->nr);
1060 mutex_unlock(&core_lock);
1061 if (found != adap) {
b6d7b3d1
JD
1062 pr_debug("i2c-core: attempting to delete unregistered "
1063 "adapter [%s]\n", adap->name);
35fc37f8 1064 return -EINVAL;
1da177e4
LT
1065 }
1066
026526f5 1067 /* Tell drivers about this removal */
35fc37f8 1068 mutex_lock(&core_lock);
026526f5 1069 res = bus_for_each_drv(&i2c_bus_type, NULL, adap,
69b0089a 1070 __process_removed_adapter);
35fc37f8 1071 mutex_unlock(&core_lock);
026526f5 1072 if (res)
35fc37f8 1073 return res;
1da177e4 1074
bbd2d9c9 1075 /* Remove devices instantiated from sysfs */
dafc50d1 1076 mutex_lock(&adap->userspace_clients_lock);
6629dcff
JD
1077 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1078 detected) {
1079 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
1080 client->addr);
1081 list_del(&client->detected);
1082 i2c_unregister_device(client);
bbd2d9c9 1083 }
dafc50d1 1084 mutex_unlock(&adap->userspace_clients_lock);
bbd2d9c9 1085
e549c2b5 1086 /* Detach any active clients. This can't fail, thus we do not
5219bf88
JD
1087 * check the returned value. This is a two-pass process, because
1088 * we can't remove the dummy devices during the first pass: they
1089 * could have been instantiated by real devices wishing to clean
1090 * them up properly, so we give them a chance to do that first. */
e549c2b5 1091 res = device_for_each_child(&adap->dev, NULL, __unregister_client);
5219bf88 1092 res = device_for_each_child(&adap->dev, NULL, __unregister_dummy);
1da177e4 1093
2bb5095a
JD
1094#ifdef CONFIG_I2C_COMPAT
1095 class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
1096 adap->dev.parent);
1097#endif
1098
c5567521
TLSC
1099 /* device name is gone after device_unregister */
1100 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
1101
1da177e4
LT
1102 /* clean up the sysfs representation */
1103 init_completion(&adap->dev_released);
1da177e4 1104 device_unregister(&adap->dev);
1da177e4
LT
1105
1106 /* wait for sysfs to drop all references */
1107 wait_for_completion(&adap->dev_released);
1da177e4 1108
6e13e641 1109 /* free bus id */
35fc37f8 1110 mutex_lock(&core_lock);
1da177e4 1111 idr_remove(&i2c_adapter_idr, adap->nr);
35fc37f8 1112 mutex_unlock(&core_lock);
1da177e4 1113
bd4bc3db
JD
1114 /* Clear the device structure in case this adapter is ever going to be
1115 added again */
1116 memset(&adap->dev, 0, sizeof(adap->dev));
1117
35fc37f8 1118 return 0;
1da177e4 1119}
c0564606 1120EXPORT_SYMBOL(i2c_del_adapter);
1da177e4
LT
1121
1122
7b4fbc50
DB
1123/* ------------------------------------------------------------------------- */
1124
7ae31482
JD
1125int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
1126{
1127 int res;
1128
1129 mutex_lock(&core_lock);
1130 res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
1131 mutex_unlock(&core_lock);
1132
1133 return res;
1134}
1135EXPORT_SYMBOL_GPL(i2c_for_each_dev);
1136
69b0089a 1137static int __process_new_driver(struct device *dev, void *data)
7f101a97 1138{
4f8cf824
JD
1139 if (dev->type != &i2c_adapter_type)
1140 return 0;
69b0089a 1141 return i2c_do_add_adapter(data, to_i2c_adapter(dev));
7f101a97
DY
1142}
1143
7b4fbc50
DB
1144/*
1145 * An i2c_driver is used with one or more i2c_client (device) nodes to access
729d6dd5 1146 * i2c slave chips, on a bus instance associated with some i2c_adapter.
1da177e4
LT
1147 */
1148
de59cf9e 1149int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
1da177e4 1150{
7eebcb7c 1151 int res;
1da177e4 1152
1d0b19c9
DB
1153 /* Can't register until after driver model init */
1154 if (unlikely(WARN_ON(!i2c_bus_type.p)))
1155 return -EAGAIN;
1156
1da177e4 1157 /* add the driver to the list of i2c drivers in the driver core */
de59cf9e 1158 driver->driver.owner = owner;
1da177e4 1159 driver->driver.bus = &i2c_bus_type;
1da177e4 1160
729d6dd5 1161 /* When registration returns, the driver core
6e13e641
DB
1162 * will have called probe() for all matching-but-unbound devices.
1163 */
1da177e4
LT
1164 res = driver_register(&driver->driver);
1165 if (res)
7eebcb7c 1166 return res;
438d6c2c 1167
f4e8db31
MB
1168 /* Drivers should switch to dev_pm_ops instead. */
1169 if (driver->suspend)
1170 pr_warn("i2c-core: driver [%s] using legacy suspend method\n",
1171 driver->driver.name);
1172 if (driver->resume)
1173 pr_warn("i2c-core: driver [%s] using legacy resume method\n",
1174 driver->driver.name);
1175
35d8b2e6 1176 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
1da177e4 1177
4735c98f
JD
1178 INIT_LIST_HEAD(&driver->clients);
1179 /* Walk the adapters that are already present */
7ae31482 1180 i2c_for_each_dev(driver, __process_new_driver);
35fc37f8 1181
7f101a97
DY
1182 return 0;
1183}
1184EXPORT_SYMBOL(i2c_register_driver);
1185
69b0089a 1186static int __process_removed_driver(struct device *dev, void *data)
7f101a97 1187{
4f8cf824
JD
1188 if (dev->type != &i2c_adapter_type)
1189 return 0;
69b0089a 1190 return i2c_do_del_adapter(data, to_i2c_adapter(dev));
1da177e4
LT
1191}
1192
a1d9e6e4
DB
1193/**
1194 * i2c_del_driver - unregister I2C driver
1195 * @driver: the driver being unregistered
d64f73be 1196 * Context: can sleep
a1d9e6e4 1197 */
b3e82096 1198void i2c_del_driver(struct i2c_driver *driver)
1da177e4 1199{
7ae31482 1200 i2c_for_each_dev(driver, __process_removed_driver);
1da177e4
LT
1201
1202 driver_unregister(&driver->driver);
35d8b2e6 1203 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
1da177e4 1204}
c0564606 1205EXPORT_SYMBOL(i2c_del_driver);
1da177e4 1206
7b4fbc50
DB
1207/* ------------------------------------------------------------------------- */
1208
e48d3319
JD
1209/**
1210 * i2c_use_client - increments the reference count of the i2c client structure
1211 * @client: the client being referenced
1212 *
1213 * Each live reference to a client should be refcounted. The driver model does
1214 * that automatically as part of driver binding, so that most drivers don't
1215 * need to do this explicitly: they hold a reference until they're unbound
1216 * from the device.
1217 *
1218 * A pointer to the client with the incremented reference counter is returned.
1219 */
1220struct i2c_client *i2c_use_client(struct i2c_client *client)
1da177e4 1221{
6ea438ec
DB
1222 if (client && get_device(&client->dev))
1223 return client;
1224 return NULL;
1da177e4 1225}
c0564606 1226EXPORT_SYMBOL(i2c_use_client);
1da177e4 1227
e48d3319
JD
1228/**
1229 * i2c_release_client - release a use of the i2c client structure
1230 * @client: the client being no longer referenced
1231 *
1232 * Must be called when a user of a client is finished with it.
1233 */
1234void i2c_release_client(struct i2c_client *client)
1da177e4 1235{
6ea438ec
DB
1236 if (client)
1237 put_device(&client->dev);
1da177e4 1238}
c0564606 1239EXPORT_SYMBOL(i2c_release_client);
1da177e4 1240
9b766b81
DB
1241struct i2c_cmd_arg {
1242 unsigned cmd;
1243 void *arg;
1244};
1245
1246static int i2c_cmd(struct device *dev, void *_arg)
1247{
1248 struct i2c_client *client = i2c_verify_client(dev);
1249 struct i2c_cmd_arg *arg = _arg;
1250
1251 if (client && client->driver && client->driver->command)
1252 client->driver->command(client, arg->cmd, arg->arg);
1253 return 0;
1254}
1255
1da177e4
LT
1256void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
1257{
9b766b81 1258 struct i2c_cmd_arg cmd_arg;
1da177e4 1259
9b766b81
DB
1260 cmd_arg.cmd = cmd;
1261 cmd_arg.arg = arg;
1262 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
1da177e4 1263}
c0564606 1264EXPORT_SYMBOL(i2c_clients_command);
1da177e4
LT
1265
1266static int __init i2c_init(void)
1267{
1268 int retval;
1269
1270 retval = bus_register(&i2c_bus_type);
1da177e4
LT
1271 if (retval)
1272 return retval;
2bb5095a
JD
1273#ifdef CONFIG_I2C_COMPAT
1274 i2c_adapter_compat_class = class_compat_register("i2c-adapter");
1275 if (!i2c_adapter_compat_class) {
1276 retval = -ENOMEM;
1277 goto bus_err;
1278 }
1279#endif
e9f1373b
DB
1280 retval = i2c_add_driver(&dummy_driver);
1281 if (retval)
2bb5095a 1282 goto class_err;
e9f1373b
DB
1283 return 0;
1284
2bb5095a
JD
1285class_err:
1286#ifdef CONFIG_I2C_COMPAT
1287 class_compat_unregister(i2c_adapter_compat_class);
e9f1373b 1288bus_err:
2bb5095a 1289#endif
e9f1373b
DB
1290 bus_unregister(&i2c_bus_type);
1291 return retval;
1da177e4
LT
1292}
1293
1294static void __exit i2c_exit(void)
1295{
e9f1373b 1296 i2c_del_driver(&dummy_driver);
2bb5095a
JD
1297#ifdef CONFIG_I2C_COMPAT
1298 class_compat_unregister(i2c_adapter_compat_class);
1299#endif
1da177e4
LT
1300 bus_unregister(&i2c_bus_type);
1301}
1302
a10f9e7c
DB
1303/* We must initialize early, because some subsystems register i2c drivers
1304 * in subsys_initcall() code, but are linked (and initialized) before i2c.
1305 */
1306postcore_initcall(i2c_init);
1da177e4
LT
1307module_exit(i2c_exit);
1308
1309/* ----------------------------------------------------
1310 * the functional interface to the i2c busses.
1311 * ----------------------------------------------------
1312 */
1313
a1cdedac
DB
1314/**
1315 * i2c_transfer - execute a single or combined I2C message
1316 * @adap: Handle to I2C bus
1317 * @msgs: One or more messages to execute before STOP is issued to
1318 * terminate the operation; each message begins with a START.
1319 * @num: Number of messages to be executed.
1320 *
1321 * Returns negative errno, else the number of messages executed.
1322 *
1323 * Note that there is no requirement that each message be sent to
1324 * the same slave address, although that is the most common model.
1325 */
09b8ce0a 1326int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
1da177e4 1327{
66b650f0
CW
1328 unsigned long orig_jiffies;
1329 int ret, try;
1da177e4 1330
a1cdedac
DB
1331 /* REVISIT the fault reporting model here is weak:
1332 *
1333 * - When we get an error after receiving N bytes from a slave,
1334 * there is no way to report "N".
1335 *
1336 * - When we get a NAK after transmitting N bytes to a slave,
1337 * there is no way to report "N" ... or to let the master
1338 * continue executing the rest of this combined message, if
1339 * that's the appropriate response.
1340 *
1341 * - When for example "num" is two and we successfully complete
1342 * the first message but get an error part way through the
1343 * second, it's unclear whether that should be reported as
1344 * one (discarding status on the second message) or errno
1345 * (discarding status on the first one).
1346 */
1347
1da177e4
LT
1348 if (adap->algo->master_xfer) {
1349#ifdef DEBUG
1350 for (ret = 0; ret < num; ret++) {
1351 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
209d27c3
JD
1352 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
1353 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
1354 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
1da177e4
LT
1355 }
1356#endif
1357
cea443a8 1358 if (in_atomic() || irqs_disabled()) {
fe61e07e 1359 ret = i2c_trylock_adapter(adap);
cea443a8
MR
1360 if (!ret)
1361 /* I2C activity is ongoing. */
1362 return -EAGAIN;
1363 } else {
fe61e07e 1364 i2c_lock_adapter(adap);
cea443a8
MR
1365 }
1366
66b650f0
CW
1367 /* Retry automatically on arbitration loss */
1368 orig_jiffies = jiffies;
1369 for (ret = 0, try = 0; try <= adap->retries; try++) {
1370 ret = adap->algo->master_xfer(adap, msgs, num);
1371 if (ret != -EAGAIN)
1372 break;
1373 if (time_after(jiffies, orig_jiffies + adap->timeout))
1374 break;
1375 }
fe61e07e 1376 i2c_unlock_adapter(adap);
1da177e4
LT
1377
1378 return ret;
1379 } else {
1380 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
24a5bb7b 1381 return -EOPNOTSUPP;
1da177e4
LT
1382 }
1383}
c0564606 1384EXPORT_SYMBOL(i2c_transfer);
1da177e4 1385
a1cdedac
DB
1386/**
1387 * i2c_master_send - issue a single I2C message in master transmit mode
1388 * @client: Handle to slave device
1389 * @buf: Data that will be written to the slave
0c43ea54 1390 * @count: How many bytes to write, must be less than 64k since msg.len is u16
a1cdedac
DB
1391 *
1392 * Returns negative errno, or else the number of bytes written.
1393 */
0cc43a18 1394int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
1da177e4
LT
1395{
1396 int ret;
7225acf4 1397 struct i2c_adapter *adap = client->adapter;
1da177e4
LT
1398 struct i2c_msg msg;
1399
815f55f2
JD
1400 msg.addr = client->addr;
1401 msg.flags = client->flags & I2C_M_TEN;
1402 msg.len = count;
1403 msg.buf = (char *)buf;
438d6c2c 1404
815f55f2 1405 ret = i2c_transfer(adap, &msg, 1);
1da177e4 1406
834aa6f3
WS
1407 /*
1408 * If everything went ok (i.e. 1 msg transmitted), return #bytes
1409 * transmitted, else error code.
1410 */
815f55f2 1411 return (ret == 1) ? count : ret;
1da177e4 1412}
c0564606 1413EXPORT_SYMBOL(i2c_master_send);
1da177e4 1414
a1cdedac
DB
1415/**
1416 * i2c_master_recv - issue a single I2C message in master receive mode
1417 * @client: Handle to slave device
1418 * @buf: Where to store data read from slave
0c43ea54 1419 * @count: How many bytes to read, must be less than 64k since msg.len is u16
a1cdedac
DB
1420 *
1421 * Returns negative errno, or else the number of bytes read.
1422 */
0cc43a18 1423int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
1da177e4 1424{
7225acf4 1425 struct i2c_adapter *adap = client->adapter;
1da177e4
LT
1426 struct i2c_msg msg;
1427 int ret;
815f55f2
JD
1428
1429 msg.addr = client->addr;
1430 msg.flags = client->flags & I2C_M_TEN;
1431 msg.flags |= I2C_M_RD;
1432 msg.len = count;
1433 msg.buf = buf;
1434
1435 ret = i2c_transfer(adap, &msg, 1);
1436
834aa6f3
WS
1437 /*
1438 * If everything went ok (i.e. 1 msg received), return #bytes received,
1439 * else error code.
1440 */
815f55f2 1441 return (ret == 1) ? count : ret;
1da177e4 1442}
c0564606 1443EXPORT_SYMBOL(i2c_master_recv);
1da177e4 1444
1da177e4
LT
1445/* ----------------------------------------------------
1446 * the i2c address scanning function
1447 * Will not work for 10-bit addresses!
1448 * ----------------------------------------------------
1449 */
1da177e4 1450
63e4e802
JD
1451/*
1452 * Legacy default probe function, mostly relevant for SMBus. The default
1453 * probe method is a quick write, but it is known to corrupt the 24RF08
1454 * EEPROMs due to a state machine bug, and could also irreversibly
1455 * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
1456 * we use a short byte read instead. Also, some bus drivers don't implement
1457 * quick write, so we fallback to a byte read in that case too.
1458 * On x86, there is another special case for FSC hardware monitoring chips,
1459 * which want regular byte reads (address 0x73.) Fortunately, these are the
1460 * only known chips using this I2C address on PC hardware.
1461 * Returns 1 if probe succeeded, 0 if not.
1462 */
1463static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
1464{
1465 int err;
1466 union i2c_smbus_data dummy;
1467
1468#ifdef CONFIG_X86
1469 if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
1470 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
1471 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1472 I2C_SMBUS_BYTE_DATA, &dummy);
1473 else
1474#endif
8031d79b
JD
1475 if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
1476 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
63e4e802
JD
1477 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
1478 I2C_SMBUS_QUICK, NULL);
8031d79b
JD
1479 else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
1480 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1481 I2C_SMBUS_BYTE, &dummy);
1482 else {
1483 dev_warn(&adap->dev, "No suitable probing method supported\n");
1484 err = -EOPNOTSUPP;
1485 }
63e4e802
JD
1486
1487 return err >= 0;
1488}
1489
ccfbbd08 1490static int i2c_detect_address(struct i2c_client *temp_client,
4735c98f
JD
1491 struct i2c_driver *driver)
1492{
1493 struct i2c_board_info info;
1494 struct i2c_adapter *adapter = temp_client->adapter;
1495 int addr = temp_client->addr;
1496 int err;
1497
1498 /* Make sure the address is valid */
656b8761
JD
1499 err = i2c_check_addr_validity(addr);
1500 if (err) {
4735c98f
JD
1501 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1502 addr);
656b8761 1503 return err;
4735c98f
JD
1504 }
1505
1506 /* Skip if already in use */
3b5f794b 1507 if (i2c_check_addr_busy(adapter, addr))
4735c98f
JD
1508 return 0;
1509
ccfbbd08 1510 /* Make sure there is something at this address */
63e4e802
JD
1511 if (!i2c_default_probe(adapter, addr))
1512 return 0;
4735c98f
JD
1513
1514 /* Finally call the custom detection function */
1515 memset(&info, 0, sizeof(struct i2c_board_info));
1516 info.addr = addr;
310ec792 1517 err = driver->detect(temp_client, &info);
4735c98f
JD
1518 if (err) {
1519 /* -ENODEV is returned if the detection fails. We catch it
1520 here as this isn't an error. */
1521 return err == -ENODEV ? 0 : err;
1522 }
1523
1524 /* Consistency check */
1525 if (info.type[0] == '\0') {
1526 dev_err(&adapter->dev, "%s detection function provided "
1527 "no name for 0x%x\n", driver->driver.name,
1528 addr);
1529 } else {
1530 struct i2c_client *client;
1531
1532 /* Detection succeeded, instantiate the device */
1533 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
1534 info.type, info.addr);
1535 client = i2c_new_device(adapter, &info);
1536 if (client)
1537 list_add_tail(&client->detected, &driver->clients);
1538 else
1539 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
1540 info.type, info.addr);
1541 }
1542 return 0;
1543}
1544
1545static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
1546{
c3813d6a 1547 const unsigned short *address_list;
4735c98f
JD
1548 struct i2c_client *temp_client;
1549 int i, err = 0;
1550 int adap_id = i2c_adapter_id(adapter);
1551
c3813d6a
JD
1552 address_list = driver->address_list;
1553 if (!driver->detect || !address_list)
4735c98f
JD
1554 return 0;
1555
51b54ba9
JD
1556 /* Stop here if the classes do not match */
1557 if (!(adapter->class & driver->class))
1558 return 0;
1559
4735c98f
JD
1560 /* Set up a temporary client to help detect callback */
1561 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
1562 if (!temp_client)
1563 return -ENOMEM;
1564 temp_client->adapter = adapter;
1565
c3813d6a 1566 for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
4735c98f 1567 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
c3813d6a
JD
1568 "addr 0x%02x\n", adap_id, address_list[i]);
1569 temp_client->addr = address_list[i];
ccfbbd08 1570 err = i2c_detect_address(temp_client, driver);
51b54ba9
JD
1571 if (unlikely(err))
1572 break;
4735c98f
JD
1573 }
1574
4735c98f
JD
1575 kfree(temp_client);
1576 return err;
1577}
1578
d44f19d5
JD
1579int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
1580{
1581 return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1582 I2C_SMBUS_QUICK, NULL) >= 0;
1583}
1584EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
1585
12b5053a
JD
1586struct i2c_client *
1587i2c_new_probed_device(struct i2c_adapter *adap,
1588 struct i2c_board_info *info,
9a94241a
JD
1589 unsigned short const *addr_list,
1590 int (*probe)(struct i2c_adapter *, unsigned short addr))
12b5053a
JD
1591{
1592 int i;
1593
8031d79b 1594 if (!probe)
9a94241a 1595 probe = i2c_default_probe;
12b5053a 1596
12b5053a
JD
1597 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1598 /* Check address validity */
656b8761 1599 if (i2c_check_addr_validity(addr_list[i]) < 0) {
12b5053a
JD
1600 dev_warn(&adap->dev, "Invalid 7-bit address "
1601 "0x%02x\n", addr_list[i]);
1602 continue;
1603 }
1604
1605 /* Check address availability */
3b5f794b 1606 if (i2c_check_addr_busy(adap, addr_list[i])) {
12b5053a
JD
1607 dev_dbg(&adap->dev, "Address 0x%02x already in "
1608 "use, not probing\n", addr_list[i]);
1609 continue;
1610 }
1611
63e4e802 1612 /* Test address responsiveness */
9a94241a 1613 if (probe(adap, addr_list[i]))
63e4e802 1614 break;
12b5053a 1615 }
12b5053a
JD
1616
1617 if (addr_list[i] == I2C_CLIENT_END) {
1618 dev_dbg(&adap->dev, "Probing failed, no device found\n");
1619 return NULL;
1620 }
1621
1622 info->addr = addr_list[i];
1623 return i2c_new_device(adap, info);
1624}
1625EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1626
d735b34d 1627struct i2c_adapter *i2c_get_adapter(int nr)
1da177e4 1628{
1da177e4 1629 struct i2c_adapter *adapter;
438d6c2c 1630
caada32a 1631 mutex_lock(&core_lock);
d735b34d 1632 adapter = idr_find(&i2c_adapter_idr, nr);
a0920e10
MH
1633 if (adapter && !try_module_get(adapter->owner))
1634 adapter = NULL;
1635
caada32a 1636 mutex_unlock(&core_lock);
a0920e10 1637 return adapter;
1da177e4 1638}
c0564606 1639EXPORT_SYMBOL(i2c_get_adapter);
1da177e4
LT
1640
1641void i2c_put_adapter(struct i2c_adapter *adap)
1642{
1643 module_put(adap->owner);
1644}
c0564606 1645EXPORT_SYMBOL(i2c_put_adapter);
1da177e4
LT
1646
1647/* The SMBus parts */
1648
438d6c2c 1649#define POLY (0x1070U << 3)
09b8ce0a 1650static u8 crc8(u16 data)
1da177e4
LT
1651{
1652 int i;
438d6c2c 1653
7225acf4 1654 for (i = 0; i < 8; i++) {
438d6c2c 1655 if (data & 0x8000)
1da177e4
LT
1656 data = data ^ POLY;
1657 data = data << 1;
1658 }
1659 return (u8)(data >> 8);
1660}
1661
421ef47b
JD
1662/* Incremental CRC8 over count bytes in the array pointed to by p */
1663static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
1da177e4
LT
1664{
1665 int i;
1666
7225acf4 1667 for (i = 0; i < count; i++)
421ef47b 1668 crc = crc8((crc ^ p[i]) << 8);
1da177e4
LT
1669 return crc;
1670}
1671
421ef47b
JD
1672/* Assume a 7-bit address, which is reasonable for SMBus */
1673static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
1da177e4 1674{
421ef47b
JD
1675 /* The address will be sent first */
1676 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1677 pec = i2c_smbus_pec(pec, &addr, 1);
1678
1679 /* The data buffer follows */
1680 return i2c_smbus_pec(pec, msg->buf, msg->len);
1da177e4
LT
1681}
1682
421ef47b
JD
1683/* Used for write only transactions */
1684static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
1da177e4 1685{
421ef47b
JD
1686 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1687 msg->len++;
1da177e4
LT
1688}
1689
421ef47b
JD
1690/* Return <0 on CRC error
1691 If there was a write before this read (most cases) we need to take the
1692 partial CRC from the write part into account.
1693 Note that this function does modify the message (we need to decrease the
1694 message length to hide the CRC byte from the caller). */
1695static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
1da177e4 1696{
421ef47b
JD
1697 u8 rpec = msg->buf[--msg->len];
1698 cpec = i2c_smbus_msg_pec(cpec, msg);
1da177e4 1699
1da177e4
LT
1700 if (rpec != cpec) {
1701 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1702 rpec, cpec);
24a5bb7b 1703 return -EBADMSG;
1da177e4 1704 }
438d6c2c 1705 return 0;
1da177e4
LT
1706}
1707
a1cdedac
DB
1708/**
1709 * i2c_smbus_read_byte - SMBus "receive byte" protocol
1710 * @client: Handle to slave device
1711 *
1712 * This executes the SMBus "receive byte" protocol, returning negative errno
1713 * else the byte received from the device.
1714 */
0cc43a18 1715s32 i2c_smbus_read_byte(const struct i2c_client *client)
1da177e4
LT
1716{
1717 union i2c_smbus_data data;
24a5bb7b
DB
1718 int status;
1719
1720 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1721 I2C_SMBUS_READ, 0,
1722 I2C_SMBUS_BYTE, &data);
1723 return (status < 0) ? status : data.byte;
1da177e4 1724}
c0564606 1725EXPORT_SYMBOL(i2c_smbus_read_byte);
1da177e4 1726
a1cdedac
DB
1727/**
1728 * i2c_smbus_write_byte - SMBus "send byte" protocol
1729 * @client: Handle to slave device
1730 * @value: Byte to be sent
1731 *
1732 * This executes the SMBus "send byte" protocol, returning negative errno
1733 * else zero on success.
1734 */
0cc43a18 1735s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
1da177e4 1736{
7225acf4 1737 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
421ef47b 1738 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
1da177e4 1739}
c0564606 1740EXPORT_SYMBOL(i2c_smbus_write_byte);
1da177e4 1741
a1cdedac
DB
1742/**
1743 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
1744 * @client: Handle to slave device
1745 * @command: Byte interpreted by slave
1746 *
1747 * This executes the SMBus "read byte" protocol, returning negative errno
1748 * else a data byte received from the device.
1749 */
0cc43a18 1750s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
1da177e4
LT
1751{
1752 union i2c_smbus_data data;
24a5bb7b
DB
1753 int status;
1754
1755 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1756 I2C_SMBUS_READ, command,
1757 I2C_SMBUS_BYTE_DATA, &data);
1758 return (status < 0) ? status : data.byte;
1da177e4 1759}
c0564606 1760EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1da177e4 1761
a1cdedac
DB
1762/**
1763 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
1764 * @client: Handle to slave device
1765 * @command: Byte interpreted by slave
1766 * @value: Byte being written
1767 *
1768 * This executes the SMBus "write byte" protocol, returning negative errno
1769 * else zero on success.
1770 */
0cc43a18
JD
1771s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
1772 u8 value)
1da177e4
LT
1773{
1774 union i2c_smbus_data data;
1775 data.byte = value;
7225acf4
FH
1776 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1777 I2C_SMBUS_WRITE, command,
1778 I2C_SMBUS_BYTE_DATA, &data);
1da177e4 1779}
c0564606 1780EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1da177e4 1781
a1cdedac
DB
1782/**
1783 * i2c_smbus_read_word_data - SMBus "read word" protocol
1784 * @client: Handle to slave device
1785 * @command: Byte interpreted by slave
1786 *
1787 * This executes the SMBus "read word" protocol, returning negative errno
1788 * else a 16-bit unsigned "word" received from the device.
1789 */
0cc43a18 1790s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
1da177e4
LT
1791{
1792 union i2c_smbus_data data;
24a5bb7b
DB
1793 int status;
1794
1795 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1796 I2C_SMBUS_READ, command,
1797 I2C_SMBUS_WORD_DATA, &data);
1798 return (status < 0) ? status : data.word;
1da177e4 1799}
c0564606 1800EXPORT_SYMBOL(i2c_smbus_read_word_data);
1da177e4 1801
a1cdedac
DB
1802/**
1803 * i2c_smbus_write_word_data - SMBus "write word" protocol
1804 * @client: Handle to slave device
1805 * @command: Byte interpreted by slave
1806 * @value: 16-bit "word" being written
1807 *
1808 * This executes the SMBus "write word" protocol, returning negative errno
1809 * else zero on success.
1810 */
0cc43a18
JD
1811s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
1812 u16 value)
1da177e4
LT
1813{
1814 union i2c_smbus_data data;
1815 data.word = value;
7225acf4
FH
1816 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1817 I2C_SMBUS_WRITE, command,
1818 I2C_SMBUS_WORD_DATA, &data);
1da177e4 1819}
c0564606 1820EXPORT_SYMBOL(i2c_smbus_write_word_data);
1da177e4 1821
596c88f4
PM
1822/**
1823 * i2c_smbus_process_call - SMBus "process call" protocol
1824 * @client: Handle to slave device
1825 * @command: Byte interpreted by slave
1826 * @value: 16-bit "word" being written
1827 *
1828 * This executes the SMBus "process call" protocol, returning negative errno
1829 * else a 16-bit unsigned "word" received from the device.
1830 */
0cc43a18
JD
1831s32 i2c_smbus_process_call(const struct i2c_client *client, u8 command,
1832 u16 value)
596c88f4
PM
1833{
1834 union i2c_smbus_data data;
1835 int status;
1836 data.word = value;
1837
1838 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1839 I2C_SMBUS_WRITE, command,
1840 I2C_SMBUS_PROC_CALL, &data);
1841 return (status < 0) ? status : data.word;
1842}
1843EXPORT_SYMBOL(i2c_smbus_process_call);
1844
a64ec07d 1845/**
a1cdedac 1846 * i2c_smbus_read_block_data - SMBus "block read" protocol
a64ec07d 1847 * @client: Handle to slave device
a1cdedac 1848 * @command: Byte interpreted by slave
a64ec07d
DB
1849 * @values: Byte array into which data will be read; big enough to hold
1850 * the data returned by the slave. SMBus allows at most 32 bytes.
1851 *
a1cdedac
DB
1852 * This executes the SMBus "block read" protocol, returning negative errno
1853 * else the number of data bytes in the slave's response.
a64ec07d
DB
1854 *
1855 * Note that using this function requires that the client's adapter support
1856 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
1857 * support this; its emulation through I2C messaging relies on a specific
1858 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
1859 */
0cc43a18 1860s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
b86a1bc8
JD
1861 u8 *values)
1862{
1863 union i2c_smbus_data data;
24a5bb7b 1864 int status;
b86a1bc8 1865
24a5bb7b
DB
1866 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1867 I2C_SMBUS_READ, command,
1868 I2C_SMBUS_BLOCK_DATA, &data);
1869 if (status)
1870 return status;
b86a1bc8
JD
1871
1872 memcpy(values, &data.block[1], data.block[0]);
1873 return data.block[0];
1874}
1875EXPORT_SYMBOL(i2c_smbus_read_block_data);
1876
a1cdedac
DB
1877/**
1878 * i2c_smbus_write_block_data - SMBus "block write" protocol
1879 * @client: Handle to slave device
1880 * @command: Byte interpreted by slave
1881 * @length: Size of data block; SMBus allows at most 32 bytes
1882 * @values: Byte array which will be written.
1883 *
1884 * This executes the SMBus "block write" protocol, returning negative errno
1885 * else zero on success.
1886 */
0cc43a18 1887s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
46f5ed75 1888 u8 length, const u8 *values)
1da177e4
LT
1889{
1890 union i2c_smbus_data data;
7656032b 1891
1da177e4
LT
1892 if (length > I2C_SMBUS_BLOCK_MAX)
1893 length = I2C_SMBUS_BLOCK_MAX;
1da177e4 1894 data.block[0] = length;
7656032b 1895 memcpy(&data.block[1], values, length);
7225acf4
FH
1896 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1897 I2C_SMBUS_WRITE, command,
1898 I2C_SMBUS_BLOCK_DATA, &data);
1da177e4 1899}
c0564606 1900EXPORT_SYMBOL(i2c_smbus_write_block_data);
1da177e4
LT
1901
1902/* Returns the number of read bytes */
0cc43a18 1903s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
4b2643d7 1904 u8 length, u8 *values)
1da177e4
LT
1905{
1906 union i2c_smbus_data data;
24a5bb7b 1907 int status;
7656032b 1908
4b2643d7
JD
1909 if (length > I2C_SMBUS_BLOCK_MAX)
1910 length = I2C_SMBUS_BLOCK_MAX;
1911 data.block[0] = length;
24a5bb7b
DB
1912 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1913 I2C_SMBUS_READ, command,
1914 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1915 if (status < 0)
1916 return status;
7656032b
JD
1917
1918 memcpy(values, &data.block[1], data.block[0]);
1919 return data.block[0];
1da177e4 1920}
c0564606 1921EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1da177e4 1922
0cc43a18 1923s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
46f5ed75 1924 u8 length, const u8 *values)
21bbd691
JD
1925{
1926 union i2c_smbus_data data;
1927
1928 if (length > I2C_SMBUS_BLOCK_MAX)
1929 length = I2C_SMBUS_BLOCK_MAX;
1930 data.block[0] = length;
1931 memcpy(data.block + 1, values, length);
1932 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1933 I2C_SMBUS_WRITE, command,
1934 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1935}
c0564606 1936EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
21bbd691 1937
438d6c2c 1938/* Simulate a SMBus command using the i2c protocol
1da177e4 1939 No checking of parameters is done! */
7225acf4
FH
1940static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
1941 unsigned short flags,
1942 char read_write, u8 command, int size,
1943 union i2c_smbus_data *data)
1da177e4
LT
1944{
1945 /* So we need to generate a series of msgs. In the case of writing, we
1946 need to use only one message; when reading, we need two. We initialize
1947 most things with sane defaults, to keep the code below somewhat
1948 simpler. */
5c50d188
HI
1949 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1950 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
7225acf4 1951 int num = read_write == I2C_SMBUS_READ ? 2 : 1;
438d6c2c 1952 struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
1da177e4
LT
1953 { addr, flags | I2C_M_RD, 0, msgbuf1 }
1954 };
1955 int i;
421ef47b 1956 u8 partial_pec = 0;
24a5bb7b 1957 int status;
1da177e4
LT
1958
1959 msgbuf0[0] = command;
7225acf4 1960 switch (size) {
1da177e4
LT
1961 case I2C_SMBUS_QUICK:
1962 msg[0].len = 0;
1963 /* Special case: The read/write field is used as data */
f29d2e02
RK
1964 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
1965 I2C_M_RD : 0);
1da177e4
LT
1966 num = 1;
1967 break;
1968 case I2C_SMBUS_BYTE:
1969 if (read_write == I2C_SMBUS_READ) {
1970 /* Special case: only a read! */
1971 msg[0].flags = I2C_M_RD | flags;
1972 num = 1;
1973 }
1974 break;
1975 case I2C_SMBUS_BYTE_DATA:
1976 if (read_write == I2C_SMBUS_READ)
1977 msg[1].len = 1;
1978 else {
1979 msg[0].len = 2;
1980 msgbuf0[1] = data->byte;
1981 }
1982 break;
1983 case I2C_SMBUS_WORD_DATA:
1984 if (read_write == I2C_SMBUS_READ)
1985 msg[1].len = 2;
1986 else {
7225acf4 1987 msg[0].len = 3;
1da177e4 1988 msgbuf0[1] = data->word & 0xff;
7eff82c8 1989 msgbuf0[2] = data->word >> 8;
1da177e4
LT
1990 }
1991 break;
1992 case I2C_SMBUS_PROC_CALL:
1993 num = 2; /* Special case */
1994 read_write = I2C_SMBUS_READ;
1995 msg[0].len = 3;
1996 msg[1].len = 2;
1997 msgbuf0[1] = data->word & 0xff;
7eff82c8 1998 msgbuf0[2] = data->word >> 8;
1da177e4
LT
1999 break;
2000 case I2C_SMBUS_BLOCK_DATA:
1da177e4 2001 if (read_write == I2C_SMBUS_READ) {
209d27c3
JD
2002 msg[1].flags |= I2C_M_RECV_LEN;
2003 msg[1].len = 1; /* block length will be added by
2004 the underlying bus driver */
1da177e4
LT
2005 } else {
2006 msg[0].len = data->block[0] + 2;
2007 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
24a5bb7b
DB
2008 dev_err(&adapter->dev,
2009 "Invalid block write size %d\n",
2010 data->block[0]);
2011 return -EINVAL;
1da177e4 2012 }
5c50d188 2013 for (i = 1; i < msg[0].len; i++)
1da177e4
LT
2014 msgbuf0[i] = data->block[i-1];
2015 }
2016 break;
2017 case I2C_SMBUS_BLOCK_PROC_CALL:
209d27c3
JD
2018 num = 2; /* Another special case */
2019 read_write = I2C_SMBUS_READ;
2020 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
24a5bb7b
DB
2021 dev_err(&adapter->dev,
2022 "Invalid block write size %d\n",
209d27c3 2023 data->block[0]);
24a5bb7b 2024 return -EINVAL;
209d27c3
JD
2025 }
2026 msg[0].len = data->block[0] + 2;
2027 for (i = 1; i < msg[0].len; i++)
2028 msgbuf0[i] = data->block[i-1];
2029 msg[1].flags |= I2C_M_RECV_LEN;
2030 msg[1].len = 1; /* block length will be added by
2031 the underlying bus driver */
2032 break;
1da177e4
LT
2033 case I2C_SMBUS_I2C_BLOCK_DATA:
2034 if (read_write == I2C_SMBUS_READ) {
4b2643d7 2035 msg[1].len = data->block[0];
1da177e4
LT
2036 } else {
2037 msg[0].len = data->block[0] + 1;
30dac746 2038 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
24a5bb7b
DB
2039 dev_err(&adapter->dev,
2040 "Invalid block write size %d\n",
2041 data->block[0]);
2042 return -EINVAL;
1da177e4
LT
2043 }
2044 for (i = 1; i <= data->block[0]; i++)
2045 msgbuf0[i] = data->block[i];
2046 }
2047 break;
2048 default:
24a5bb7b
DB
2049 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
2050 return -EOPNOTSUPP;
1da177e4
LT
2051 }
2052
421ef47b
JD
2053 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
2054 && size != I2C_SMBUS_I2C_BLOCK_DATA);
2055 if (i) {
2056 /* Compute PEC if first message is a write */
2057 if (!(msg[0].flags & I2C_M_RD)) {
438d6c2c 2058 if (num == 1) /* Write only */
421ef47b
JD
2059 i2c_smbus_add_pec(&msg[0]);
2060 else /* Write followed by read */
2061 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
2062 }
2063 /* Ask for PEC if last message is a read */
2064 if (msg[num-1].flags & I2C_M_RD)
438d6c2c 2065 msg[num-1].len++;
421ef47b
JD
2066 }
2067
24a5bb7b
DB
2068 status = i2c_transfer(adapter, msg, num);
2069 if (status < 0)
2070 return status;
1da177e4 2071
421ef47b
JD
2072 /* Check PEC if last message is a read */
2073 if (i && (msg[num-1].flags & I2C_M_RD)) {
24a5bb7b
DB
2074 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
2075 if (status < 0)
2076 return status;
421ef47b
JD
2077 }
2078
1da177e4 2079 if (read_write == I2C_SMBUS_READ)
7225acf4
FH
2080 switch (size) {
2081 case I2C_SMBUS_BYTE:
2082 data->byte = msgbuf0[0];
2083 break;
2084 case I2C_SMBUS_BYTE_DATA:
2085 data->byte = msgbuf1[0];
2086 break;
2087 case I2C_SMBUS_WORD_DATA:
2088 case I2C_SMBUS_PROC_CALL:
2089 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
2090 break;
2091 case I2C_SMBUS_I2C_BLOCK_DATA:
2092 for (i = 0; i < data->block[0]; i++)
2093 data->block[i+1] = msgbuf1[i];
2094 break;
2095 case I2C_SMBUS_BLOCK_DATA:
2096 case I2C_SMBUS_BLOCK_PROC_CALL:
2097 for (i = 0; i < msgbuf1[0] + 1; i++)
2098 data->block[i] = msgbuf1[i];
2099 break;
1da177e4
LT
2100 }
2101 return 0;
2102}
2103
a1cdedac
DB
2104/**
2105 * i2c_smbus_xfer - execute SMBus protocol operations
2106 * @adapter: Handle to I2C bus
2107 * @addr: Address of SMBus slave on that bus
2108 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
2109 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
2110 * @command: Byte interpreted by slave, for protocols which use such bytes
2111 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
2112 * @data: Data to be read or written
2113 *
2114 * This executes an SMBus protocol operation, and returns a negative
2115 * errno code else zero on success.
2116 */
09b8ce0a 2117s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
a1cdedac 2118 char read_write, u8 command, int protocol,
09b8ce0a 2119 union i2c_smbus_data *data)
1da177e4 2120{
66b650f0
CW
2121 unsigned long orig_jiffies;
2122 int try;
1da177e4 2123 s32 res;
1da177e4
LT
2124
2125 flags &= I2C_M_TEN | I2C_CLIENT_PEC;
1da177e4
LT
2126
2127 if (adapter->algo->smbus_xfer) {
fe61e07e 2128 i2c_lock_adapter(adapter);
66b650f0
CW
2129
2130 /* Retry automatically on arbitration loss */
2131 orig_jiffies = jiffies;
2132 for (res = 0, try = 0; try <= adapter->retries; try++) {
2133 res = adapter->algo->smbus_xfer(adapter, addr, flags,
2134 read_write, command,
2135 protocol, data);
2136 if (res != -EAGAIN)
2137 break;
2138 if (time_after(jiffies,
2139 orig_jiffies + adapter->timeout))
2140 break;
2141 }
fe61e07e 2142 i2c_unlock_adapter(adapter);
1da177e4 2143 } else
7225acf4 2144 res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
a1cdedac 2145 command, protocol, data);
1da177e4 2146
1da177e4
LT
2147 return res;
2148}
1da177e4 2149EXPORT_SYMBOL(i2c_smbus_xfer);
1da177e4
LT
2150
2151MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
2152MODULE_DESCRIPTION("I2C-Bus main module");
2153MODULE_LICENSE("GPL");
This page took 1.190803 seconds and 5 git commands to generate.