blob: bdadfaf3fe106f8dfb2a0ae04845d367e8361bae [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* 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
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
18/* ------------------------------------------------------------------------- */
19
Jan Engelhardt96de0e22007-10-19 23:21:04 +020020/* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi>.
Linus Torvalds1da177e2005-04-16 15:20:36 -070021 All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl>
Jean Delvare421ef472005-10-26 21:28:55 +020022 SMBus 2.0 support by Mark Studebaker <mdsxyz123@yahoo.com> and
Michael Lawnick08263742010-08-11 18:21:02 +020023 Jean Delvare <khali@linux-fr.org>
24 Mux support by Rodolfo Giometti <giometti@enneenne.com> and
25 Michael Lawnick <michael.lawnick.ext@nsn.com> */
Linus Torvalds1da177e2005-04-16 15:20:36 -070026
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#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>
Arjan van de Venb3585e42006-01-11 10:50:26 +010034#include <linux/mutex.h>
Grant Likely959e85f2010-06-08 07:48:19 -060035#include <linux/of_device.h>
Jean Delvareb8d6f452007-02-13 22:09:00 +010036#include <linux/completion.h>
Mike Rapoportcea443a2008-01-27 18:14:50 +010037#include <linux/hardirq.h>
38#include <linux/irqflags.h>
Rodolfo Giomettif18c41d2009-06-19 16:58:20 +020039#include <linux/rwsem.h>
Mark Brown6de468a2010-03-02 12:23:46 +010040#include <linux/pm_runtime.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include <asm/uaccess.h>
42
David Brownell9c1600e2007-05-01 23:26:31 +020043#include "i2c-core.h"
44
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
Jean Delvare6629dcf2010-05-04 11:09:28 +020046/* core_lock protects i2c_adapter_idr, and guarantees
Jean Delvare35fc37f2009-06-19 16:58:19 +020047 that device detection, deletion of detected devices, and attach_adapter
48 and detach_adapter calls are serialized */
Jean Delvarecaada322008-01-27 18:14:49 +010049static DEFINE_MUTEX(core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070050static DEFINE_IDR(i2c_adapter_idr);
51
Jean Delvare4f8cf822009-09-18 22:45:46 +020052static struct device_type i2c_client_type;
Jean Delvare4735c982008-07-14 22:38:36 +020053static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
David Brownellf37dd802007-02-13 22:09:00 +010054
55/* ------------------------------------------------------------------------- */
56
Jean Delvared2653e92008-04-29 23:11:39 +020057static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
58 const struct i2c_client *client)
59{
60 while (id->name[0]) {
61 if (strcmp(client->name, id->name) == 0)
62 return id;
63 id++;
64 }
65 return NULL;
66}
67
Linus Torvalds1da177e2005-04-16 15:20:36 -070068static int i2c_device_match(struct device *dev, struct device_driver *drv)
69{
Jean Delvare51298d12009-09-18 22:45:45 +020070 struct i2c_client *client = i2c_verify_client(dev);
71 struct i2c_driver *driver;
David Brownell7b4fbc52007-05-01 23:26:30 +020072
Jean Delvare51298d12009-09-18 22:45:45 +020073 if (!client)
74 return 0;
75
Grant Likely959e85f2010-06-08 07:48:19 -060076 /* Attempt an OF style match */
77 if (of_driver_match_device(dev, drv))
78 return 1;
79
Jean Delvare51298d12009-09-18 22:45:45 +020080 driver = to_i2c_driver(drv);
Jean Delvared2653e92008-04-29 23:11:39 +020081 /* match on an id table if there is one */
82 if (driver->id_table)
83 return i2c_match_id(driver->id_table, client) != NULL;
84
Jean Delvareeb8a7902008-05-18 20:49:41 +020085 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070086}
87
David Brownell7b4fbc52007-05-01 23:26:30 +020088#ifdef CONFIG_HOTPLUG
89
90/* uevent helps with hotplug: modprobe -q $(MODALIAS) */
Kay Sievers7eff2e72007-08-14 15:15:12 +020091static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
David Brownell7b4fbc52007-05-01 23:26:30 +020092{
93 struct i2c_client *client = to_i2c_client(dev);
David Brownell7b4fbc52007-05-01 23:26:30 +020094
Jean Delvareeb8a7902008-05-18 20:49:41 +020095 if (add_uevent_var(env, "MODALIAS=%s%s",
96 I2C_MODULE_PREFIX, client->name))
97 return -ENOMEM;
David Brownell7b4fbc52007-05-01 23:26:30 +020098 dev_dbg(dev, "uevent\n");
99 return 0;
100}
101
102#else
103#define i2c_device_uevent NULL
104#endif /* CONFIG_HOTPLUG */
105
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106static int i2c_device_probe(struct device *dev)
107{
Jean Delvare51298d12009-09-18 22:45:45 +0200108 struct i2c_client *client = i2c_verify_client(dev);
109 struct i2c_driver *driver;
Hans Verkuil50c33042008-03-12 14:15:00 +0100110 int status;
David Brownell7b4fbc52007-05-01 23:26:30 +0200111
Jean Delvare51298d12009-09-18 22:45:45 +0200112 if (!client)
113 return 0;
114
115 driver = to_i2c_driver(dev->driver);
Jean Delvaree0457442008-07-14 22:38:30 +0200116 if (!driver->probe || !driver->id_table)
David Brownell7b4fbc52007-05-01 23:26:30 +0200117 return -ENODEV;
118 client->driver = driver;
Marc Pignatee354252008-08-28 08:33:22 +0200119 if (!device_can_wakeup(&client->dev))
120 device_init_wakeup(&client->dev,
121 client->flags & I2C_CLIENT_WAKE);
David Brownell7b4fbc52007-05-01 23:26:30 +0200122 dev_dbg(dev, "probe\n");
Jean Delvared2653e92008-04-29 23:11:39 +0200123
Jean Delvaree0457442008-07-14 22:38:30 +0200124 status = driver->probe(client, i2c_match_id(driver->id_table, client));
Wolfram Sange4a7b9b2010-05-04 11:09:27 +0200125 if (status) {
Hans Verkuil50c33042008-03-12 14:15:00 +0100126 client->driver = NULL;
Wolfram Sange4a7b9b2010-05-04 11:09:27 +0200127 i2c_set_clientdata(client, NULL);
128 }
Hans Verkuil50c33042008-03-12 14:15:00 +0100129 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130}
131
132static int i2c_device_remove(struct device *dev)
133{
Jean Delvare51298d12009-09-18 22:45:45 +0200134 struct i2c_client *client = i2c_verify_client(dev);
David Brownella1d9e6e2007-05-01 23:26:30 +0200135 struct i2c_driver *driver;
136 int status;
137
Jean Delvare51298d12009-09-18 22:45:45 +0200138 if (!client || !dev->driver)
David Brownella1d9e6e2007-05-01 23:26:30 +0200139 return 0;
140
141 driver = to_i2c_driver(dev->driver);
142 if (driver->remove) {
143 dev_dbg(dev, "remove\n");
144 status = driver->remove(client);
145 } else {
146 dev->driver = NULL;
147 status = 0;
148 }
Wolfram Sange4a7b9b2010-05-04 11:09:27 +0200149 if (status == 0) {
David Brownella1d9e6e2007-05-01 23:26:30 +0200150 client->driver = NULL;
Wolfram Sange4a7b9b2010-05-04 11:09:27 +0200151 i2c_set_clientdata(client, NULL);
152 }
David Brownella1d9e6e2007-05-01 23:26:30 +0200153 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154}
155
David Brownellf37dd802007-02-13 22:09:00 +0100156static void i2c_device_shutdown(struct device *dev)
157{
Jean Delvare51298d12009-09-18 22:45:45 +0200158 struct i2c_client *client = i2c_verify_client(dev);
David Brownellf37dd802007-02-13 22:09:00 +0100159 struct i2c_driver *driver;
160
Jean Delvare51298d12009-09-18 22:45:45 +0200161 if (!client || !dev->driver)
David Brownellf37dd802007-02-13 22:09:00 +0100162 return;
163 driver = to_i2c_driver(dev->driver);
164 if (driver->shutdown)
Jean Delvare51298d12009-09-18 22:45:45 +0200165 driver->shutdown(client);
David Brownellf37dd802007-02-13 22:09:00 +0100166}
167
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200168#ifdef CONFIG_PM_SLEEP
169static int i2c_legacy_suspend(struct device *dev, pm_message_t mesg)
David Brownellf37dd802007-02-13 22:09:00 +0100170{
Jean Delvare51298d12009-09-18 22:45:45 +0200171 struct i2c_client *client = i2c_verify_client(dev);
David Brownellf37dd802007-02-13 22:09:00 +0100172 struct i2c_driver *driver;
173
Jean Delvare51298d12009-09-18 22:45:45 +0200174 if (!client || !dev->driver)
David Brownellf37dd802007-02-13 22:09:00 +0100175 return 0;
176 driver = to_i2c_driver(dev->driver);
177 if (!driver->suspend)
178 return 0;
Jean Delvare51298d12009-09-18 22:45:45 +0200179 return driver->suspend(client, mesg);
David Brownellf37dd802007-02-13 22:09:00 +0100180}
181
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200182static int i2c_legacy_resume(struct device *dev)
David Brownellf37dd802007-02-13 22:09:00 +0100183{
Jean Delvare51298d12009-09-18 22:45:45 +0200184 struct i2c_client *client = i2c_verify_client(dev);
David Brownellf37dd802007-02-13 22:09:00 +0100185 struct i2c_driver *driver;
186
Jean Delvare51298d12009-09-18 22:45:45 +0200187 if (!client || !dev->driver)
David Brownellf37dd802007-02-13 22:09:00 +0100188 return 0;
189 driver = to_i2c_driver(dev->driver);
190 if (!driver->resume)
191 return 0;
Jean Delvare51298d12009-09-18 22:45:45 +0200192 return driver->resume(client);
David Brownellf37dd802007-02-13 22:09:00 +0100193}
194
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200195static int i2c_device_pm_suspend(struct device *dev)
196{
197 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
198
Rajendra Nayak64b47822010-09-30 14:14:22 +0200199 if (pm) {
200 if (pm_runtime_suspended(dev))
201 return 0;
202 else
203 return pm->suspend ? pm->suspend(dev) : 0;
204 }
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200205
206 return i2c_legacy_suspend(dev, PMSG_SUSPEND);
207}
208
209static int i2c_device_pm_resume(struct device *dev)
210{
211 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
212 int ret;
213
214 if (pm)
215 ret = pm->resume ? pm->resume(dev) : 0;
216 else
217 ret = i2c_legacy_resume(dev);
218
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200219 return ret;
220}
221
222static int i2c_device_pm_freeze(struct device *dev)
223{
224 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
225
Rajendra Nayak64b47822010-09-30 14:14:22 +0200226 if (pm) {
227 if (pm_runtime_suspended(dev))
228 return 0;
229 else
230 return pm->freeze ? pm->freeze(dev) : 0;
231 }
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200232
233 return i2c_legacy_suspend(dev, PMSG_FREEZE);
234}
235
236static int i2c_device_pm_thaw(struct device *dev)
237{
238 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
239
Rajendra Nayak64b47822010-09-30 14:14:22 +0200240 if (pm) {
241 if (pm_runtime_suspended(dev))
242 return 0;
243 else
244 return pm->thaw ? pm->thaw(dev) : 0;
245 }
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200246
247 return i2c_legacy_resume(dev);
248}
249
250static int i2c_device_pm_poweroff(struct device *dev)
251{
252 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
253
Rajendra Nayak64b47822010-09-30 14:14:22 +0200254 if (pm) {
255 if (pm_runtime_suspended(dev))
256 return 0;
257 else
258 return pm->poweroff ? pm->poweroff(dev) : 0;
259 }
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200260
261 return i2c_legacy_suspend(dev, PMSG_HIBERNATE);
262}
263
264static int i2c_device_pm_restore(struct device *dev)
265{
266 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
267 int ret;
268
269 if (pm)
270 ret = pm->restore ? pm->restore(dev) : 0;
271 else
272 ret = i2c_legacy_resume(dev);
273
274 if (!ret) {
275 pm_runtime_disable(dev);
276 pm_runtime_set_active(dev);
277 pm_runtime_enable(dev);
278 }
279
280 return ret;
281}
282#else /* !CONFIG_PM_SLEEP */
283#define i2c_device_pm_suspend NULL
284#define i2c_device_pm_resume NULL
285#define i2c_device_pm_freeze NULL
286#define i2c_device_pm_thaw NULL
287#define i2c_device_pm_poweroff NULL
288#define i2c_device_pm_restore NULL
289#endif /* !CONFIG_PM_SLEEP */
290
David Brownell9c1600e2007-05-01 23:26:31 +0200291static void i2c_client_dev_release(struct device *dev)
292{
293 kfree(to_i2c_client(dev));
294}
295
Zhenwen Xu09b8ce02009-03-28 21:34:46 +0100296static ssize_t
Jean Delvare4f8cf822009-09-18 22:45:46 +0200297show_name(struct device *dev, struct device_attribute *attr, char *buf)
David Brownell7b4fbc52007-05-01 23:26:30 +0200298{
Jean Delvare4f8cf822009-09-18 22:45:46 +0200299 return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
300 to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
David Brownell7b4fbc52007-05-01 23:26:30 +0200301}
302
Zhenwen Xu09b8ce02009-03-28 21:34:46 +0100303static ssize_t
304show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
David Brownell7b4fbc52007-05-01 23:26:30 +0200305{
306 struct i2c_client *client = to_i2c_client(dev);
Jean Delvareeb8a7902008-05-18 20:49:41 +0200307 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
David Brownell7b4fbc52007-05-01 23:26:30 +0200308}
309
Jean Delvare4f8cf822009-09-18 22:45:46 +0200310static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
Jean Delvare51298d12009-09-18 22:45:45 +0200311static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
312
313static struct attribute *i2c_dev_attrs[] = {
314 &dev_attr_name.attr,
David Brownell7b4fbc52007-05-01 23:26:30 +0200315 /* modalias helps coldplug: modprobe $(cat .../modalias) */
Jean Delvare51298d12009-09-18 22:45:45 +0200316 &dev_attr_modalias.attr,
317 NULL
318};
319
320static struct attribute_group i2c_dev_attr_group = {
321 .attrs = i2c_dev_attrs,
322};
323
324static const struct attribute_group *i2c_dev_attr_groups[] = {
325 &i2c_dev_attr_group,
326 NULL
David Brownell7b4fbc52007-05-01 23:26:30 +0200327};
328
Tobias Klauser0b2c3682010-01-16 20:43:12 +0100329static const struct dev_pm_ops i2c_device_pm_ops = {
sonic zhang54067ee2009-12-14 21:17:30 +0100330 .suspend = i2c_device_pm_suspend,
331 .resume = i2c_device_pm_resume,
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200332 .freeze = i2c_device_pm_freeze,
333 .thaw = i2c_device_pm_thaw,
334 .poweroff = i2c_device_pm_poweroff,
335 .restore = i2c_device_pm_restore,
336 SET_RUNTIME_PM_OPS(
337 pm_generic_runtime_suspend,
338 pm_generic_runtime_resume,
339 pm_generic_runtime_idle
340 )
sonic zhang54067ee2009-12-14 21:17:30 +0100341};
342
Jon Smirle9ca9eb2008-07-14 22:38:35 +0200343struct bus_type i2c_bus_type = {
David Brownellf37dd802007-02-13 22:09:00 +0100344 .name = "i2c",
345 .match = i2c_device_match,
346 .probe = i2c_device_probe,
347 .remove = i2c_device_remove,
348 .shutdown = i2c_device_shutdown,
sonic zhang54067ee2009-12-14 21:17:30 +0100349 .pm = &i2c_device_pm_ops,
Russell Kingb864c7d2006-01-05 14:37:50 +0000350};
Jon Smirle9ca9eb2008-07-14 22:38:35 +0200351EXPORT_SYMBOL_GPL(i2c_bus_type);
Russell Kingb864c7d2006-01-05 14:37:50 +0000352
Jean Delvare51298d12009-09-18 22:45:45 +0200353static struct device_type i2c_client_type = {
354 .groups = i2c_dev_attr_groups,
355 .uevent = i2c_device_uevent,
356 .release = i2c_client_dev_release,
357};
358
David Brownell9b766b82008-01-27 18:14:51 +0100359
360/**
361 * i2c_verify_client - return parameter as i2c_client, or NULL
362 * @dev: device, probably from some driver model iterator
363 *
364 * When traversing the driver model tree, perhaps using driver model
365 * iterators like @device_for_each_child(), you can't assume very much
366 * about the nodes you find. Use this function to avoid oopses caused
367 * by wrongly treating some non-I2C device as an i2c_client.
368 */
369struct i2c_client *i2c_verify_client(struct device *dev)
370{
Jean Delvare51298d12009-09-18 22:45:45 +0200371 return (dev->type == &i2c_client_type)
David Brownell9b766b82008-01-27 18:14:51 +0100372 ? to_i2c_client(dev)
373 : NULL;
374}
375EXPORT_SYMBOL(i2c_verify_client);
376
377
Jean Delvare3a89db52010-06-03 11:33:52 +0200378/* This is a permissive address validity check, I2C address map constraints
379 * are purposedly not enforced, except for the general call address. */
380static int i2c_check_client_addr_validity(const struct i2c_client *client)
381{
382 if (client->flags & I2C_CLIENT_TEN) {
383 /* 10-bit address, all values are valid */
384 if (client->addr > 0x3ff)
385 return -EINVAL;
386 } else {
387 /* 7-bit address, reject the general call address */
388 if (client->addr == 0x00 || client->addr > 0x7f)
389 return -EINVAL;
390 }
391 return 0;
392}
393
Jean Delvare656b8762010-06-03 11:33:53 +0200394/* And this is a strict address validity check, used when probing. If a
395 * device uses a reserved address, then it shouldn't be probed. 7-bit
396 * addressing is assumed, 10-bit address devices are rare and should be
397 * explicitly enumerated. */
398static int i2c_check_addr_validity(unsigned short addr)
399{
400 /*
401 * Reserved addresses per I2C specification:
402 * 0x00 General call address / START byte
403 * 0x01 CBUS address
404 * 0x02 Reserved for different bus format
405 * 0x03 Reserved for future purposes
406 * 0x04-0x07 Hs-mode master code
407 * 0x78-0x7b 10-bit slave addressing
408 * 0x7c-0x7f Reserved for future purposes
409 */
410 if (addr < 0x08 || addr > 0x77)
411 return -EINVAL;
412 return 0;
413}
414
Jean Delvare3b5f7942010-06-03 11:33:55 +0200415static int __i2c_check_addr_busy(struct device *dev, void *addrp)
416{
417 struct i2c_client *client = i2c_verify_client(dev);
418 int addr = *(int *)addrp;
419
420 if (client && client->addr == addr)
421 return -EBUSY;
422 return 0;
423}
424
Michael Lawnick08263742010-08-11 18:21:02 +0200425/* walk up mux tree */
426static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
427{
Jean Delvare97cc4d42010-10-24 18:16:57 +0200428 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
Michael Lawnick08263742010-08-11 18:21:02 +0200429 int result;
430
431 result = device_for_each_child(&adapter->dev, &addr,
432 __i2c_check_addr_busy);
433
Jean Delvare97cc4d42010-10-24 18:16:57 +0200434 if (!result && parent)
435 result = i2c_check_mux_parents(parent, addr);
Michael Lawnick08263742010-08-11 18:21:02 +0200436
437 return result;
438}
439
440/* recurse down mux tree */
441static int i2c_check_mux_children(struct device *dev, void *addrp)
442{
443 int result;
444
445 if (dev->type == &i2c_adapter_type)
446 result = device_for_each_child(dev, addrp,
447 i2c_check_mux_children);
448 else
449 result = __i2c_check_addr_busy(dev, addrp);
450
451 return result;
452}
453
Jean Delvare3b5f7942010-06-03 11:33:55 +0200454static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
455{
Jean Delvare97cc4d42010-10-24 18:16:57 +0200456 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
Michael Lawnick08263742010-08-11 18:21:02 +0200457 int result = 0;
458
Jean Delvare97cc4d42010-10-24 18:16:57 +0200459 if (parent)
460 result = i2c_check_mux_parents(parent, addr);
Michael Lawnick08263742010-08-11 18:21:02 +0200461
462 if (!result)
463 result = device_for_each_child(&adapter->dev, &addr,
464 i2c_check_mux_children);
465
466 return result;
Jean Delvare3b5f7942010-06-03 11:33:55 +0200467}
468
David Brownell9c1600e2007-05-01 23:26:31 +0200469/**
Jean Delvarefe61e072010-08-11 18:20:58 +0200470 * i2c_lock_adapter - Get exclusive access to an I2C bus segment
471 * @adapter: Target I2C bus segment
472 */
473void i2c_lock_adapter(struct i2c_adapter *adapter)
474{
Jean Delvare97cc4d42010-10-24 18:16:57 +0200475 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
476
477 if (parent)
478 i2c_lock_adapter(parent);
Michael Lawnick08263742010-08-11 18:21:02 +0200479 else
480 rt_mutex_lock(&adapter->bus_lock);
Jean Delvarefe61e072010-08-11 18:20:58 +0200481}
482EXPORT_SYMBOL_GPL(i2c_lock_adapter);
483
484/**
485 * i2c_trylock_adapter - Try to get exclusive access to an I2C bus segment
486 * @adapter: Target I2C bus segment
487 */
488static int i2c_trylock_adapter(struct i2c_adapter *adapter)
489{
Jean Delvare97cc4d42010-10-24 18:16:57 +0200490 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
491
492 if (parent)
493 return i2c_trylock_adapter(parent);
Michael Lawnick08263742010-08-11 18:21:02 +0200494 else
495 return rt_mutex_trylock(&adapter->bus_lock);
Jean Delvarefe61e072010-08-11 18:20:58 +0200496}
497
498/**
499 * i2c_unlock_adapter - Release exclusive access to an I2C bus segment
500 * @adapter: Target I2C bus segment
501 */
502void i2c_unlock_adapter(struct i2c_adapter *adapter)
503{
Jean Delvare97cc4d42010-10-24 18:16:57 +0200504 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
505
506 if (parent)
507 i2c_unlock_adapter(parent);
Michael Lawnick08263742010-08-11 18:21:02 +0200508 else
509 rt_mutex_unlock(&adapter->bus_lock);
Jean Delvarefe61e072010-08-11 18:20:58 +0200510}
511EXPORT_SYMBOL_GPL(i2c_unlock_adapter);
512
513/**
Jean Delvaref8a227e2009-06-19 16:58:18 +0200514 * i2c_new_device - instantiate an i2c device
David Brownell9c1600e2007-05-01 23:26:31 +0200515 * @adap: the adapter managing the device
516 * @info: describes one I2C device; bus_num is ignored
David Brownelld64f73b2007-07-12 14:12:28 +0200517 * Context: can sleep
David Brownell9c1600e2007-05-01 23:26:31 +0200518 *
Jean Delvaref8a227e2009-06-19 16:58:18 +0200519 * Create an i2c device. Binding is handled through driver model
520 * probe()/remove() methods. A driver may be bound to this device when we
521 * return from this function, or any later moment (e.g. maybe hotplugging will
522 * load the driver module). This call is not appropriate for use by mainboard
523 * initialization logic, which usually runs during an arch_initcall() long
524 * before any i2c_adapter could exist.
David Brownell9c1600e2007-05-01 23:26:31 +0200525 *
526 * This returns the new i2c client, which may be saved for later use with
527 * i2c_unregister_device(); or NULL to indicate an error.
528 */
529struct i2c_client *
530i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
531{
532 struct i2c_client *client;
533 int status;
534
535 client = kzalloc(sizeof *client, GFP_KERNEL);
536 if (!client)
537 return NULL;
538
539 client->adapter = adap;
540
541 client->dev.platform_data = info->platform_data;
David Brownell3bbb8352007-10-13 23:56:29 +0200542
Anton Vorontsov11f1f2a2008-10-22 20:21:33 +0200543 if (info->archdata)
544 client->dev.archdata = *info->archdata;
545
Marc Pignatee354252008-08-28 08:33:22 +0200546 client->flags = info->flags;
David Brownell9c1600e2007-05-01 23:26:31 +0200547 client->addr = info->addr;
548 client->irq = info->irq;
549
David Brownell9c1600e2007-05-01 23:26:31 +0200550 strlcpy(client->name, info->type, sizeof(client->name));
551
Jean Delvare3a89db52010-06-03 11:33:52 +0200552 /* Check for address validity */
553 status = i2c_check_client_addr_validity(client);
554 if (status) {
555 dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
556 client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
557 goto out_err_silent;
558 }
559
Jean Delvaref8a227e2009-06-19 16:58:18 +0200560 /* Check for address business */
Jean Delvare3b5f7942010-06-03 11:33:55 +0200561 status = i2c_check_addr_busy(adap, client->addr);
Jean Delvaref8a227e2009-06-19 16:58:18 +0200562 if (status)
563 goto out_err;
564
565 client->dev.parent = &client->adapter->dev;
566 client->dev.bus = &i2c_bus_type;
Jean Delvare51298d12009-09-18 22:45:45 +0200567 client->dev.type = &i2c_client_type;
Grant Likelyd12d42f2010-04-13 16:12:28 -0700568#ifdef CONFIG_OF
569 client->dev.of_node = info->of_node;
570#endif
Jean Delvaref8a227e2009-06-19 16:58:18 +0200571
572 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
573 client->addr);
574 status = device_register(&client->dev);
575 if (status)
576 goto out_err;
577
Jean Delvaref8a227e2009-06-19 16:58:18 +0200578 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
579 client->name, dev_name(&client->dev));
580
David Brownell9c1600e2007-05-01 23:26:31 +0200581 return client;
Jean Delvaref8a227e2009-06-19 16:58:18 +0200582
583out_err:
584 dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
585 "(%d)\n", client->name, client->addr, status);
Jean Delvare3a89db52010-06-03 11:33:52 +0200586out_err_silent:
Jean Delvaref8a227e2009-06-19 16:58:18 +0200587 kfree(client);
588 return NULL;
David Brownell9c1600e2007-05-01 23:26:31 +0200589}
590EXPORT_SYMBOL_GPL(i2c_new_device);
591
592
593/**
594 * i2c_unregister_device - reverse effect of i2c_new_device()
595 * @client: value returned from i2c_new_device()
David Brownelld64f73b2007-07-12 14:12:28 +0200596 * Context: can sleep
David Brownell9c1600e2007-05-01 23:26:31 +0200597 */
598void i2c_unregister_device(struct i2c_client *client)
David Brownella1d9e6e2007-05-01 23:26:30 +0200599{
David Brownella1d9e6e2007-05-01 23:26:30 +0200600 device_unregister(&client->dev);
601}
David Brownell9c1600e2007-05-01 23:26:31 +0200602EXPORT_SYMBOL_GPL(i2c_unregister_device);
David Brownella1d9e6e2007-05-01 23:26:30 +0200603
604
Jean Delvare60b129d2008-05-11 20:37:06 +0200605static const struct i2c_device_id dummy_id[] = {
606 { "dummy", 0 },
607 { },
608};
609
Jean Delvared2653e92008-04-29 23:11:39 +0200610static int dummy_probe(struct i2c_client *client,
611 const struct i2c_device_id *id)
612{
613 return 0;
614}
615
616static int dummy_remove(struct i2c_client *client)
David Brownelle9f13732008-01-27 18:14:52 +0100617{
618 return 0;
619}
620
621static struct i2c_driver dummy_driver = {
622 .driver.name = "dummy",
Jean Delvared2653e92008-04-29 23:11:39 +0200623 .probe = dummy_probe,
624 .remove = dummy_remove,
Jean Delvare60b129d2008-05-11 20:37:06 +0200625 .id_table = dummy_id,
David Brownelle9f13732008-01-27 18:14:52 +0100626};
627
628/**
629 * i2c_new_dummy - return a new i2c device bound to a dummy driver
630 * @adapter: the adapter managing the device
631 * @address: seven bit address to be used
David Brownelle9f13732008-01-27 18:14:52 +0100632 * Context: can sleep
633 *
634 * This returns an I2C client bound to the "dummy" driver, intended for use
635 * with devices that consume multiple addresses. Examples of such chips
636 * include various EEPROMS (like 24c04 and 24c08 models).
637 *
638 * These dummy devices have two main uses. First, most I2C and SMBus calls
639 * except i2c_transfer() need a client handle; the dummy will be that handle.
640 * And second, this prevents the specified address from being bound to a
641 * different driver.
642 *
643 * This returns the new i2c client, which should be saved for later use with
644 * i2c_unregister_device(); or NULL to indicate an error.
645 */
Zhenwen Xu09b8ce02009-03-28 21:34:46 +0100646struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
David Brownelle9f13732008-01-27 18:14:52 +0100647{
648 struct i2c_board_info info = {
Jean Delvare60b129d2008-05-11 20:37:06 +0200649 I2C_BOARD_INFO("dummy", address),
David Brownelle9f13732008-01-27 18:14:52 +0100650 };
651
David Brownelle9f13732008-01-27 18:14:52 +0100652 return i2c_new_device(adapter, &info);
653}
654EXPORT_SYMBOL_GPL(i2c_new_dummy);
655
David Brownellf37dd802007-02-13 22:09:00 +0100656/* ------------------------------------------------------------------------- */
657
David Brownell16ffadf2007-05-01 23:26:28 +0200658/* I2C bus adapters -- one roots each I2C or SMBUS segment */
659
Adrian Bunk83eaaed2007-10-13 23:56:30 +0200660static void i2c_adapter_dev_release(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661{
David Brownellef2c8322007-05-01 23:26:28 +0200662 struct i2c_adapter *adap = to_i2c_adapter(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 complete(&adap->dev_released);
664}
665
Jean Delvare99cd8e22009-06-19 16:58:20 +0200666/*
667 * Let users instantiate I2C devices through sysfs. This can be used when
668 * platform initialization code doesn't contain the proper data for
669 * whatever reason. Also useful for drivers that do device detection and
670 * detection fails, either because the device uses an unexpected address,
671 * or this is a compatible device with different ID register values.
672 *
673 * Parameter checking may look overzealous, but we really don't want
674 * the user to provide incorrect parameters.
675 */
676static ssize_t
677i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
678 const char *buf, size_t count)
679{
680 struct i2c_adapter *adap = to_i2c_adapter(dev);
681 struct i2c_board_info info;
682 struct i2c_client *client;
683 char *blank, end;
684 int res;
685
Jean Delvare99cd8e22009-06-19 16:58:20 +0200686 memset(&info, 0, sizeof(struct i2c_board_info));
687
688 blank = strchr(buf, ' ');
689 if (!blank) {
690 dev_err(dev, "%s: Missing parameters\n", "new_device");
691 return -EINVAL;
692 }
693 if (blank - buf > I2C_NAME_SIZE - 1) {
694 dev_err(dev, "%s: Invalid device name\n", "new_device");
695 return -EINVAL;
696 }
697 memcpy(info.type, buf, blank - buf);
698
699 /* Parse remaining parameters, reject extra parameters */
700 res = sscanf(++blank, "%hi%c", &info.addr, &end);
701 if (res < 1) {
702 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
703 return -EINVAL;
704 }
705 if (res > 1 && end != '\n') {
706 dev_err(dev, "%s: Extra parameters\n", "new_device");
707 return -EINVAL;
708 }
709
Jean Delvare99cd8e22009-06-19 16:58:20 +0200710 client = i2c_new_device(adap, &info);
711 if (!client)
Jean Delvare3a89db52010-06-03 11:33:52 +0200712 return -EINVAL;
Jean Delvare99cd8e22009-06-19 16:58:20 +0200713
714 /* Keep track of the added device */
Jean Delvaredafc50d2010-08-11 18:21:01 +0200715 mutex_lock(&adap->userspace_clients_lock);
Jean Delvare6629dcf2010-05-04 11:09:28 +0200716 list_add_tail(&client->detected, &adap->userspace_clients);
Jean Delvaredafc50d2010-08-11 18:21:01 +0200717 mutex_unlock(&adap->userspace_clients_lock);
Jean Delvare99cd8e22009-06-19 16:58:20 +0200718 dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
719 info.type, info.addr);
720
721 return count;
722}
723
724/*
725 * And of course let the users delete the devices they instantiated, if
726 * they got it wrong. This interface can only be used to delete devices
727 * instantiated by i2c_sysfs_new_device above. This guarantees that we
728 * don't delete devices to which some kernel code still has references.
729 *
730 * Parameter checking may look overzealous, but we really don't want
731 * the user to delete the wrong device.
732 */
733static ssize_t
734i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
735 const char *buf, size_t count)
736{
737 struct i2c_adapter *adap = to_i2c_adapter(dev);
738 struct i2c_client *client, *next;
739 unsigned short addr;
740 char end;
741 int res;
742
743 /* Parse parameters, reject extra parameters */
744 res = sscanf(buf, "%hi%c", &addr, &end);
745 if (res < 1) {
746 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
747 return -EINVAL;
748 }
749 if (res > 1 && end != '\n') {
750 dev_err(dev, "%s: Extra parameters\n", "delete_device");
751 return -EINVAL;
752 }
753
754 /* Make sure the device was added through sysfs */
755 res = -ENOENT;
Jean Delvaredafc50d2010-08-11 18:21:01 +0200756 mutex_lock(&adap->userspace_clients_lock);
Jean Delvare6629dcf2010-05-04 11:09:28 +0200757 list_for_each_entry_safe(client, next, &adap->userspace_clients,
758 detected) {
759 if (client->addr == addr) {
Jean Delvare99cd8e22009-06-19 16:58:20 +0200760 dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
761 "delete_device", client->name, client->addr);
762
763 list_del(&client->detected);
764 i2c_unregister_device(client);
765 res = count;
766 break;
767 }
768 }
Jean Delvaredafc50d2010-08-11 18:21:01 +0200769 mutex_unlock(&adap->userspace_clients_lock);
Jean Delvare99cd8e22009-06-19 16:58:20 +0200770
771 if (res < 0)
772 dev_err(dev, "%s: Can't find device in list\n",
773 "delete_device");
774 return res;
775}
776
Jean Delvare4f8cf822009-09-18 22:45:46 +0200777static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
778static DEVICE_ATTR(delete_device, S_IWUSR, NULL, i2c_sysfs_delete_device);
779
780static struct attribute *i2c_adapter_attrs[] = {
781 &dev_attr_name.attr,
782 &dev_attr_new_device.attr,
783 &dev_attr_delete_device.attr,
784 NULL
David Brownell16ffadf2007-05-01 23:26:28 +0200785};
786
Jean Delvare4f8cf822009-09-18 22:45:46 +0200787static struct attribute_group i2c_adapter_attr_group = {
788 .attrs = i2c_adapter_attrs,
789};
790
791static const struct attribute_group *i2c_adapter_attr_groups[] = {
792 &i2c_adapter_attr_group,
793 NULL
794};
795
Michael Lawnick08263742010-08-11 18:21:02 +0200796struct device_type i2c_adapter_type = {
Jean Delvare4f8cf822009-09-18 22:45:46 +0200797 .groups = i2c_adapter_attr_groups,
798 .release = i2c_adapter_dev_release,
David Brownell16ffadf2007-05-01 23:26:28 +0200799};
Michael Lawnick08263742010-08-11 18:21:02 +0200800EXPORT_SYMBOL_GPL(i2c_adapter_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801
Jean Delvare2bb50952009-09-18 22:45:46 +0200802#ifdef CONFIG_I2C_COMPAT
803static struct class_compat *i2c_adapter_compat_class;
804#endif
805
David Brownell9c1600e2007-05-01 23:26:31 +0200806static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
807{
808 struct i2c_devinfo *devinfo;
809
Rodolfo Giomettif18c41d2009-06-19 16:58:20 +0200810 down_read(&__i2c_board_lock);
David Brownell9c1600e2007-05-01 23:26:31 +0200811 list_for_each_entry(devinfo, &__i2c_board_list, list) {
812 if (devinfo->busnum == adapter->nr
813 && !i2c_new_device(adapter,
814 &devinfo->board_info))
Zhenwen Xu09b8ce02009-03-28 21:34:46 +0100815 dev_err(&adapter->dev,
816 "Can't create device at 0x%02x\n",
David Brownell9c1600e2007-05-01 23:26:31 +0200817 devinfo->board_info.addr);
818 }
Rodolfo Giomettif18c41d2009-06-19 16:58:20 +0200819 up_read(&__i2c_board_lock);
David Brownell9c1600e2007-05-01 23:26:31 +0200820}
821
Jean Delvare69b00892009-12-06 17:06:27 +0100822static int i2c_do_add_adapter(struct i2c_driver *driver,
823 struct i2c_adapter *adap)
Jean Delvare026526f2008-01-27 18:14:49 +0100824{
Jean Delvare4735c982008-07-14 22:38:36 +0200825 /* Detect supported devices on that bus, and instantiate them */
826 i2c_detect(adap, driver);
827
828 /* Let legacy drivers scan this bus for matching devices */
Jean Delvare026526f2008-01-27 18:14:49 +0100829 if (driver->attach_adapter) {
830 /* We ignore the return code; if it fails, too bad */
831 driver->attach_adapter(adap);
832 }
833 return 0;
834}
835
Jean Delvare69b00892009-12-06 17:06:27 +0100836static int __process_new_adapter(struct device_driver *d, void *data)
837{
838 return i2c_do_add_adapter(to_i2c_driver(d), data);
839}
840
David Brownell6e13e642007-05-01 23:26:31 +0200841static int i2c_register_adapter(struct i2c_adapter *adap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842{
Jean Delvared6703282010-08-11 18:20:59 +0200843 int res = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844
David Brownell1d0b19c2008-10-14 17:30:05 +0200845 /* Can't register until after driver model init */
Jean Delvare35fc37f2009-06-19 16:58:19 +0200846 if (unlikely(WARN_ON(!i2c_bus_type.p))) {
847 res = -EAGAIN;
848 goto out_list;
849 }
David Brownell1d0b19c2008-10-14 17:30:05 +0200850
Mika Kuoppala194684e2009-12-06 17:06:22 +0100851 rt_mutex_init(&adap->bus_lock);
Jean Delvaredafc50d2010-08-11 18:21:01 +0200852 mutex_init(&adap->userspace_clients_lock);
Jean Delvare6629dcf2010-05-04 11:09:28 +0200853 INIT_LIST_HEAD(&adap->userspace_clients);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854
Jean Delvare8fcfef62009-03-28 21:34:43 +0100855 /* Set default timeout to 1 second if not already set */
856 if (adap->timeout == 0)
857 adap->timeout = HZ;
858
Kay Sievers27d9c182009-01-07 14:29:16 +0100859 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
Jean Delvare4f8cf822009-09-18 22:45:46 +0200860 adap->dev.bus = &i2c_bus_type;
861 adap->dev.type = &i2c_adapter_type;
Jean Delvareb119c6c2006-08-15 18:26:30 +0200862 res = device_register(&adap->dev);
863 if (res)
864 goto out_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865
Jean Delvareb6d7b3d2005-07-31 19:02:53 +0200866 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
867
Jean Delvare2bb50952009-09-18 22:45:46 +0200868#ifdef CONFIG_I2C_COMPAT
869 res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
870 adap->dev.parent);
871 if (res)
872 dev_warn(&adap->dev,
873 "Failed to create compatibility class link\n");
874#endif
875
Jean Delvare729d6dd2009-06-19 16:58:18 +0200876 /* create pre-declared device nodes */
David Brownell6e13e642007-05-01 23:26:31 +0200877 if (adap->nr < __i2c_first_dynamic_bus_num)
878 i2c_scan_static_board_info(adap);
879
Jean Delvare4735c982008-07-14 22:38:36 +0200880 /* Notify drivers */
Jean Delvare35fc37f2009-06-19 16:58:19 +0200881 mutex_lock(&core_lock);
Jean Delvared6703282010-08-11 18:20:59 +0200882 bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
Jean Delvarecaada322008-01-27 18:14:49 +0100883 mutex_unlock(&core_lock);
Jean Delvare35fc37f2009-06-19 16:58:19 +0200884
885 return 0;
Jean Delvareb119c6c2006-08-15 18:26:30 +0200886
Jean Delvareb119c6c2006-08-15 18:26:30 +0200887out_list:
Jean Delvare35fc37f2009-06-19 16:58:19 +0200888 mutex_lock(&core_lock);
Jean Delvareb119c6c2006-08-15 18:26:30 +0200889 idr_remove(&i2c_adapter_idr, adap->nr);
Jean Delvare35fc37f2009-06-19 16:58:19 +0200890 mutex_unlock(&core_lock);
891 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892}
893
David Brownell6e13e642007-05-01 23:26:31 +0200894/**
895 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
896 * @adapter: the adapter to add
David Brownelld64f73b2007-07-12 14:12:28 +0200897 * Context: can sleep
David Brownell6e13e642007-05-01 23:26:31 +0200898 *
899 * This routine is used to declare an I2C adapter when its bus number
900 * doesn't matter. Examples: for I2C adapters dynamically added by
901 * USB links or PCI plugin cards.
902 *
903 * When this returns zero, a new bus number was allocated and stored
904 * in adap->nr, and the specified adapter became available for clients.
905 * Otherwise, a negative errno value is returned.
906 */
907int i2c_add_adapter(struct i2c_adapter *adapter)
908{
909 int id, res = 0;
910
911retry:
912 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
913 return -ENOMEM;
914
Jean Delvarecaada322008-01-27 18:14:49 +0100915 mutex_lock(&core_lock);
David Brownell6e13e642007-05-01 23:26:31 +0200916 /* "above" here means "above or equal to", sigh */
917 res = idr_get_new_above(&i2c_adapter_idr, adapter,
918 __i2c_first_dynamic_bus_num, &id);
Jean Delvarecaada322008-01-27 18:14:49 +0100919 mutex_unlock(&core_lock);
David Brownell6e13e642007-05-01 23:26:31 +0200920
921 if (res < 0) {
922 if (res == -EAGAIN)
923 goto retry;
924 return res;
925 }
926
927 adapter->nr = id;
928 return i2c_register_adapter(adapter);
929}
930EXPORT_SYMBOL(i2c_add_adapter);
931
932/**
933 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
934 * @adap: the adapter to register (with adap->nr initialized)
David Brownelld64f73b2007-07-12 14:12:28 +0200935 * Context: can sleep
David Brownell6e13e642007-05-01 23:26:31 +0200936 *
937 * This routine is used to declare an I2C adapter when its bus number
Randy Dunlap8c07e462008-03-23 20:28:20 +0100938 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
939 * or otherwise built in to the system's mainboard, and where i2c_board_info
David Brownell6e13e642007-05-01 23:26:31 +0200940 * is used to properly configure I2C devices.
941 *
942 * If no devices have pre-been declared for this bus, then be sure to
943 * register the adapter before any dynamically allocated ones. Otherwise
944 * the required bus ID may not be available.
945 *
946 * When this returns zero, the specified adapter became available for
947 * clients using the bus number provided in adap->nr. Also, the table
948 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
949 * and the appropriate driver model device nodes are created. Otherwise, a
950 * negative errno value is returned.
951 */
952int i2c_add_numbered_adapter(struct i2c_adapter *adap)
953{
954 int id;
955 int status;
956
957 if (adap->nr & ~MAX_ID_MASK)
958 return -EINVAL;
959
960retry:
961 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
962 return -ENOMEM;
963
Jean Delvarecaada322008-01-27 18:14:49 +0100964 mutex_lock(&core_lock);
David Brownell6e13e642007-05-01 23:26:31 +0200965 /* "above" here means "above or equal to", sigh;
966 * we need the "equal to" result to force the result
967 */
968 status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
969 if (status == 0 && id != adap->nr) {
970 status = -EBUSY;
971 idr_remove(&i2c_adapter_idr, id);
972 }
Jean Delvarecaada322008-01-27 18:14:49 +0100973 mutex_unlock(&core_lock);
David Brownell6e13e642007-05-01 23:26:31 +0200974 if (status == -EAGAIN)
975 goto retry;
976
977 if (status == 0)
978 status = i2c_register_adapter(adap);
979 return status;
980}
981EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
982
Jean Delvare69b00892009-12-06 17:06:27 +0100983static int i2c_do_del_adapter(struct i2c_driver *driver,
984 struct i2c_adapter *adapter)
Jean Delvare026526f2008-01-27 18:14:49 +0100985{
Jean Delvare4735c982008-07-14 22:38:36 +0200986 struct i2c_client *client, *_n;
Jean Delvare026526f2008-01-27 18:14:49 +0100987 int res;
988
Jean Delvareacec2112009-03-28 21:34:40 +0100989 /* Remove the devices we created ourselves as the result of hardware
990 * probing (using a driver's detect method) */
Jean Delvare4735c982008-07-14 22:38:36 +0200991 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
992 if (client->adapter == adapter) {
993 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
994 client->name, client->addr);
995 list_del(&client->detected);
996 i2c_unregister_device(client);
997 }
998 }
999
Jean Delvare026526f2008-01-27 18:14:49 +01001000 if (!driver->detach_adapter)
1001 return 0;
1002 res = driver->detach_adapter(adapter);
1003 if (res)
1004 dev_err(&adapter->dev, "detach_adapter failed (%d) "
1005 "for driver [%s]\n", res, driver->driver.name);
1006 return res;
1007}
1008
Jean Delvaree549c2b2009-06-19 16:58:19 +02001009static int __unregister_client(struct device *dev, void *dummy)
1010{
1011 struct i2c_client *client = i2c_verify_client(dev);
1012 if (client)
1013 i2c_unregister_device(client);
1014 return 0;
1015}
1016
Jean Delvare69b00892009-12-06 17:06:27 +01001017static int __process_removed_adapter(struct device_driver *d, void *data)
1018{
1019 return i2c_do_del_adapter(to_i2c_driver(d), data);
1020}
1021
David Brownelld64f73b2007-07-12 14:12:28 +02001022/**
1023 * i2c_del_adapter - unregister I2C adapter
1024 * @adap: the adapter being unregistered
1025 * Context: can sleep
1026 *
1027 * This unregisters an I2C adapter which was previously registered
1028 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
1029 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030int i2c_del_adapter(struct i2c_adapter *adap)
1031{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 int res = 0;
Jean Delvare35fc37f2009-06-19 16:58:19 +02001033 struct i2c_adapter *found;
Jean Delvarebbd2d9c2009-11-26 09:22:33 +01001034 struct i2c_client *client, *next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035
1036 /* First make sure that this adapter was ever added */
Jean Delvare35fc37f2009-06-19 16:58:19 +02001037 mutex_lock(&core_lock);
1038 found = idr_find(&i2c_adapter_idr, adap->nr);
1039 mutex_unlock(&core_lock);
1040 if (found != adap) {
Jean Delvareb6d7b3d2005-07-31 19:02:53 +02001041 pr_debug("i2c-core: attempting to delete unregistered "
1042 "adapter [%s]\n", adap->name);
Jean Delvare35fc37f2009-06-19 16:58:19 +02001043 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044 }
1045
Jean Delvare026526f2008-01-27 18:14:49 +01001046 /* Tell drivers about this removal */
Jean Delvare35fc37f2009-06-19 16:58:19 +02001047 mutex_lock(&core_lock);
Jean Delvare026526f2008-01-27 18:14:49 +01001048 res = bus_for_each_drv(&i2c_bus_type, NULL, adap,
Jean Delvare69b00892009-12-06 17:06:27 +01001049 __process_removed_adapter);
Jean Delvare35fc37f2009-06-19 16:58:19 +02001050 mutex_unlock(&core_lock);
Jean Delvare026526f2008-01-27 18:14:49 +01001051 if (res)
Jean Delvare35fc37f2009-06-19 16:58:19 +02001052 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053
Jean Delvarebbd2d9c2009-11-26 09:22:33 +01001054 /* Remove devices instantiated from sysfs */
Jean Delvaredafc50d2010-08-11 18:21:01 +02001055 mutex_lock(&adap->userspace_clients_lock);
Jean Delvare6629dcf2010-05-04 11:09:28 +02001056 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1057 detected) {
1058 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
1059 client->addr);
1060 list_del(&client->detected);
1061 i2c_unregister_device(client);
Jean Delvarebbd2d9c2009-11-26 09:22:33 +01001062 }
Jean Delvaredafc50d2010-08-11 18:21:01 +02001063 mutex_unlock(&adap->userspace_clients_lock);
Jean Delvarebbd2d9c2009-11-26 09:22:33 +01001064
Jean Delvaree549c2b2009-06-19 16:58:19 +02001065 /* Detach any active clients. This can't fail, thus we do not
1066 checking the returned value. */
1067 res = device_for_each_child(&adap->dev, NULL, __unregister_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068
Jean Delvare2bb50952009-09-18 22:45:46 +02001069#ifdef CONFIG_I2C_COMPAT
1070 class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
1071 adap->dev.parent);
1072#endif
1073
Thadeu Lima de Souza Cascardoc5567522010-01-16 20:43:13 +01001074 /* device name is gone after device_unregister */
1075 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
1076
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 /* clean up the sysfs representation */
1078 init_completion(&adap->dev_released);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 device_unregister(&adap->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080
1081 /* wait for sysfs to drop all references */
1082 wait_for_completion(&adap->dev_released);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083
David Brownell6e13e642007-05-01 23:26:31 +02001084 /* free bus id */
Jean Delvare35fc37f2009-06-19 16:58:19 +02001085 mutex_lock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 idr_remove(&i2c_adapter_idr, adap->nr);
Jean Delvare35fc37f2009-06-19 16:58:19 +02001087 mutex_unlock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088
Jean Delvarebd4bc3d2008-07-16 19:30:05 +02001089 /* Clear the device structure in case this adapter is ever going to be
1090 added again */
1091 memset(&adap->dev, 0, sizeof(adap->dev));
1092
Jean Delvare35fc37f2009-06-19 16:58:19 +02001093 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094}
David Brownellc0564602007-05-01 23:26:31 +02001095EXPORT_SYMBOL(i2c_del_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096
1097
David Brownell7b4fbc52007-05-01 23:26:30 +02001098/* ------------------------------------------------------------------------- */
1099
Jean Delvare69b00892009-12-06 17:06:27 +01001100static int __process_new_driver(struct device *dev, void *data)
Dave Young7f101a92008-07-14 22:38:19 +02001101{
Jean Delvare4f8cf822009-09-18 22:45:46 +02001102 if (dev->type != &i2c_adapter_type)
1103 return 0;
Jean Delvare69b00892009-12-06 17:06:27 +01001104 return i2c_do_add_adapter(data, to_i2c_adapter(dev));
Dave Young7f101a92008-07-14 22:38:19 +02001105}
1106
David Brownell7b4fbc52007-05-01 23:26:30 +02001107/*
1108 * An i2c_driver is used with one or more i2c_client (device) nodes to access
Jean Delvare729d6dd2009-06-19 16:58:18 +02001109 * i2c slave chips, on a bus instance associated with some i2c_adapter.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110 */
1111
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -08001112int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113{
Jean Delvare7eebcb72006-02-05 23:28:21 +01001114 int res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115
David Brownell1d0b19c2008-10-14 17:30:05 +02001116 /* Can't register until after driver model init */
1117 if (unlikely(WARN_ON(!i2c_bus_type.p)))
1118 return -EAGAIN;
1119
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120 /* add the driver to the list of i2c drivers in the driver core */
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -08001121 driver->driver.owner = owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122 driver->driver.bus = &i2c_bus_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123
Jean Delvare729d6dd2009-06-19 16:58:18 +02001124 /* When registration returns, the driver core
David Brownell6e13e642007-05-01 23:26:31 +02001125 * will have called probe() for all matching-but-unbound devices.
1126 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 res = driver_register(&driver->driver);
1128 if (res)
Jean Delvare7eebcb72006-02-05 23:28:21 +01001129 return res;
David Brownell438d6c22006-12-10 21:21:31 +01001130
Laurent Riffard35d8b2e2005-11-26 20:34:05 +01001131 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132
Jean Delvare4735c982008-07-14 22:38:36 +02001133 INIT_LIST_HEAD(&driver->clients);
1134 /* Walk the adapters that are already present */
Jean Delvare35fc37f2009-06-19 16:58:19 +02001135 mutex_lock(&core_lock);
Jean Delvare69b00892009-12-06 17:06:27 +01001136 bus_for_each_dev(&i2c_bus_type, NULL, driver, __process_new_driver);
Jean Delvarecaada322008-01-27 18:14:49 +01001137 mutex_unlock(&core_lock);
Jean Delvare35fc37f2009-06-19 16:58:19 +02001138
Jean Delvare7eebcb72006-02-05 23:28:21 +01001139 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140}
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -08001141EXPORT_SYMBOL(i2c_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142
Jean Delvare69b00892009-12-06 17:06:27 +01001143static int __process_removed_driver(struct device *dev, void *data)
Dave Young7f101a92008-07-14 22:38:19 +02001144{
Jean Delvare4f8cf822009-09-18 22:45:46 +02001145 if (dev->type != &i2c_adapter_type)
1146 return 0;
Jean Delvare69b00892009-12-06 17:06:27 +01001147 return i2c_do_del_adapter(data, to_i2c_adapter(dev));
Dave Young7f101a92008-07-14 22:38:19 +02001148}
1149
David Brownella1d9e6e2007-05-01 23:26:30 +02001150/**
1151 * i2c_del_driver - unregister I2C driver
1152 * @driver: the driver being unregistered
David Brownelld64f73b2007-07-12 14:12:28 +02001153 * Context: can sleep
David Brownella1d9e6e2007-05-01 23:26:30 +02001154 */
Jean Delvareb3e82092007-05-01 23:26:32 +02001155void i2c_del_driver(struct i2c_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156{
Jean Delvarecaada322008-01-27 18:14:49 +01001157 mutex_lock(&core_lock);
Jean Delvare69b00892009-12-06 17:06:27 +01001158 bus_for_each_dev(&i2c_bus_type, NULL, driver, __process_removed_driver);
Jean Delvare35fc37f2009-06-19 16:58:19 +02001159 mutex_unlock(&core_lock);
David Brownella1d9e6e2007-05-01 23:26:30 +02001160
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 driver_unregister(&driver->driver);
Laurent Riffard35d8b2e2005-11-26 20:34:05 +01001162 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163}
David Brownellc0564602007-05-01 23:26:31 +02001164EXPORT_SYMBOL(i2c_del_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165
David Brownell7b4fbc52007-05-01 23:26:30 +02001166/* ------------------------------------------------------------------------- */
1167
Jean Delvaree48d3312008-01-27 18:14:48 +01001168/**
1169 * i2c_use_client - increments the reference count of the i2c client structure
1170 * @client: the client being referenced
1171 *
1172 * Each live reference to a client should be refcounted. The driver model does
1173 * that automatically as part of driver binding, so that most drivers don't
1174 * need to do this explicitly: they hold a reference until they're unbound
1175 * from the device.
1176 *
1177 * A pointer to the client with the incremented reference counter is returned.
1178 */
1179struct i2c_client *i2c_use_client(struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180{
David Brownell6ea438e2008-07-14 22:38:24 +02001181 if (client && get_device(&client->dev))
1182 return client;
1183 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184}
David Brownellc0564602007-05-01 23:26:31 +02001185EXPORT_SYMBOL(i2c_use_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186
Jean Delvaree48d3312008-01-27 18:14:48 +01001187/**
1188 * i2c_release_client - release a use of the i2c client structure
1189 * @client: the client being no longer referenced
1190 *
1191 * Must be called when a user of a client is finished with it.
1192 */
1193void i2c_release_client(struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194{
David Brownell6ea438e2008-07-14 22:38:24 +02001195 if (client)
1196 put_device(&client->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197}
David Brownellc0564602007-05-01 23:26:31 +02001198EXPORT_SYMBOL(i2c_release_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199
David Brownell9b766b82008-01-27 18:14:51 +01001200struct i2c_cmd_arg {
1201 unsigned cmd;
1202 void *arg;
1203};
1204
1205static int i2c_cmd(struct device *dev, void *_arg)
1206{
1207 struct i2c_client *client = i2c_verify_client(dev);
1208 struct i2c_cmd_arg *arg = _arg;
1209
1210 if (client && client->driver && client->driver->command)
1211 client->driver->command(client, arg->cmd, arg->arg);
1212 return 0;
1213}
1214
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
1216{
David Brownell9b766b82008-01-27 18:14:51 +01001217 struct i2c_cmd_arg cmd_arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218
David Brownell9b766b82008-01-27 18:14:51 +01001219 cmd_arg.cmd = cmd;
1220 cmd_arg.arg = arg;
1221 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222}
David Brownellc0564602007-05-01 23:26:31 +02001223EXPORT_SYMBOL(i2c_clients_command);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224
1225static int __init i2c_init(void)
1226{
1227 int retval;
1228
1229 retval = bus_register(&i2c_bus_type);
1230 if (retval)
1231 return retval;
Jean Delvare2bb50952009-09-18 22:45:46 +02001232#ifdef CONFIG_I2C_COMPAT
1233 i2c_adapter_compat_class = class_compat_register("i2c-adapter");
1234 if (!i2c_adapter_compat_class) {
1235 retval = -ENOMEM;
1236 goto bus_err;
1237 }
1238#endif
David Brownelle9f13732008-01-27 18:14:52 +01001239 retval = i2c_add_driver(&dummy_driver);
1240 if (retval)
Jean Delvare2bb50952009-09-18 22:45:46 +02001241 goto class_err;
David Brownelle9f13732008-01-27 18:14:52 +01001242 return 0;
1243
Jean Delvare2bb50952009-09-18 22:45:46 +02001244class_err:
1245#ifdef CONFIG_I2C_COMPAT
1246 class_compat_unregister(i2c_adapter_compat_class);
David Brownelle9f13732008-01-27 18:14:52 +01001247bus_err:
Jean Delvare2bb50952009-09-18 22:45:46 +02001248#endif
David Brownelle9f13732008-01-27 18:14:52 +01001249 bus_unregister(&i2c_bus_type);
1250 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251}
1252
1253static void __exit i2c_exit(void)
1254{
David Brownelle9f13732008-01-27 18:14:52 +01001255 i2c_del_driver(&dummy_driver);
Jean Delvare2bb50952009-09-18 22:45:46 +02001256#ifdef CONFIG_I2C_COMPAT
1257 class_compat_unregister(i2c_adapter_compat_class);
1258#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259 bus_unregister(&i2c_bus_type);
1260}
1261
David Brownella10f9e72008-10-14 17:30:06 +02001262/* We must initialize early, because some subsystems register i2c drivers
1263 * in subsys_initcall() code, but are linked (and initialized) before i2c.
1264 */
1265postcore_initcall(i2c_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266module_exit(i2c_exit);
1267
1268/* ----------------------------------------------------
1269 * the functional interface to the i2c busses.
1270 * ----------------------------------------------------
1271 */
1272
David Brownella1cdeda2008-07-14 22:38:24 +02001273/**
1274 * i2c_transfer - execute a single or combined I2C message
1275 * @adap: Handle to I2C bus
1276 * @msgs: One or more messages to execute before STOP is issued to
1277 * terminate the operation; each message begins with a START.
1278 * @num: Number of messages to be executed.
1279 *
1280 * Returns negative errno, else the number of messages executed.
1281 *
1282 * Note that there is no requirement that each message be sent to
1283 * the same slave address, although that is the most common model.
1284 */
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01001285int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286{
Clifford Wolf66b650f2009-06-15 18:01:46 +02001287 unsigned long orig_jiffies;
1288 int ret, try;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289
David Brownella1cdeda2008-07-14 22:38:24 +02001290 /* REVISIT the fault reporting model here is weak:
1291 *
1292 * - When we get an error after receiving N bytes from a slave,
1293 * there is no way to report "N".
1294 *
1295 * - When we get a NAK after transmitting N bytes to a slave,
1296 * there is no way to report "N" ... or to let the master
1297 * continue executing the rest of this combined message, if
1298 * that's the appropriate response.
1299 *
1300 * - When for example "num" is two and we successfully complete
1301 * the first message but get an error part way through the
1302 * second, it's unclear whether that should be reported as
1303 * one (discarding status on the second message) or errno
1304 * (discarding status on the first one).
1305 */
1306
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307 if (adap->algo->master_xfer) {
1308#ifdef DEBUG
1309 for (ret = 0; ret < num; ret++) {
1310 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
Jean Delvare209d27c2007-05-01 23:26:29 +02001311 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
1312 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
1313 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314 }
1315#endif
1316
Mike Rapoportcea443a2008-01-27 18:14:50 +01001317 if (in_atomic() || irqs_disabled()) {
Jean Delvarefe61e072010-08-11 18:20:58 +02001318 ret = i2c_trylock_adapter(adap);
Mike Rapoportcea443a2008-01-27 18:14:50 +01001319 if (!ret)
1320 /* I2C activity is ongoing. */
1321 return -EAGAIN;
1322 } else {
Jean Delvarefe61e072010-08-11 18:20:58 +02001323 i2c_lock_adapter(adap);
Mike Rapoportcea443a2008-01-27 18:14:50 +01001324 }
1325
Clifford Wolf66b650f2009-06-15 18:01:46 +02001326 /* Retry automatically on arbitration loss */
1327 orig_jiffies = jiffies;
1328 for (ret = 0, try = 0; try <= adap->retries; try++) {
1329 ret = adap->algo->master_xfer(adap, msgs, num);
1330 if (ret != -EAGAIN)
1331 break;
1332 if (time_after(jiffies, orig_jiffies + adap->timeout))
1333 break;
1334 }
Jean Delvarefe61e072010-08-11 18:20:58 +02001335 i2c_unlock_adapter(adap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336
1337 return ret;
1338 } else {
1339 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
David Brownell24a5bb72008-07-14 22:38:23 +02001340 return -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 }
1342}
David Brownellc0564602007-05-01 23:26:31 +02001343EXPORT_SYMBOL(i2c_transfer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344
David Brownella1cdeda2008-07-14 22:38:24 +02001345/**
1346 * i2c_master_send - issue a single I2C message in master transmit mode
1347 * @client: Handle to slave device
1348 * @buf: Data that will be written to the slave
Zhangfei Gao0c43ea52010-03-02 12:23:49 +01001349 * @count: How many bytes to write, must be less than 64k since msg.len is u16
David Brownella1cdeda2008-07-14 22:38:24 +02001350 *
1351 * Returns negative errno, or else the number of bytes written.
1352 */
Farid Hammane7225acf2010-05-21 18:40:58 +02001353int i2c_master_send(struct i2c_client *client, const char *buf, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354{
1355 int ret;
Farid Hammane7225acf2010-05-21 18:40:58 +02001356 struct i2c_adapter *adap = client->adapter;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 struct i2c_msg msg;
1358
Jean Delvare815f55f2005-05-07 22:58:46 +02001359 msg.addr = client->addr;
1360 msg.flags = client->flags & I2C_M_TEN;
1361 msg.len = count;
1362 msg.buf = (char *)buf;
David Brownell438d6c22006-12-10 21:21:31 +01001363
Jean Delvare815f55f2005-05-07 22:58:46 +02001364 ret = i2c_transfer(adap, &msg, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365
Jean Delvare815f55f2005-05-07 22:58:46 +02001366 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1367 transmitted, else error code. */
1368 return (ret == 1) ? count : ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369}
David Brownellc0564602007-05-01 23:26:31 +02001370EXPORT_SYMBOL(i2c_master_send);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371
David Brownella1cdeda2008-07-14 22:38:24 +02001372/**
1373 * i2c_master_recv - issue a single I2C message in master receive mode
1374 * @client: Handle to slave device
1375 * @buf: Where to store data read from slave
Zhangfei Gao0c43ea52010-03-02 12:23:49 +01001376 * @count: How many bytes to read, must be less than 64k since msg.len is u16
David Brownella1cdeda2008-07-14 22:38:24 +02001377 *
1378 * Returns negative errno, or else the number of bytes read.
1379 */
Farid Hammane7225acf2010-05-21 18:40:58 +02001380int i2c_master_recv(struct i2c_client *client, char *buf, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381{
Farid Hammane7225acf2010-05-21 18:40:58 +02001382 struct i2c_adapter *adap = client->adapter;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 struct i2c_msg msg;
1384 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385
Jean Delvare815f55f2005-05-07 22:58:46 +02001386 msg.addr = client->addr;
1387 msg.flags = client->flags & I2C_M_TEN;
1388 msg.flags |= I2C_M_RD;
1389 msg.len = count;
1390 msg.buf = buf;
1391
1392 ret = i2c_transfer(adap, &msg, 1);
1393
1394 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1395 transmitted, else error code. */
1396 return (ret == 1) ? count : ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397}
David Brownellc0564602007-05-01 23:26:31 +02001398EXPORT_SYMBOL(i2c_master_recv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400/* ----------------------------------------------------
1401 * the i2c address scanning function
1402 * Will not work for 10-bit addresses!
1403 * ----------------------------------------------------
1404 */
Jean Delvare9fc6adf2005-07-31 21:20:43 +02001405
Jean Delvare63e4e802010-06-03 11:33:51 +02001406/*
1407 * Legacy default probe function, mostly relevant for SMBus. The default
1408 * probe method is a quick write, but it is known to corrupt the 24RF08
1409 * EEPROMs due to a state machine bug, and could also irreversibly
1410 * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
1411 * we use a short byte read instead. Also, some bus drivers don't implement
1412 * quick write, so we fallback to a byte read in that case too.
1413 * On x86, there is another special case for FSC hardware monitoring chips,
1414 * which want regular byte reads (address 0x73.) Fortunately, these are the
1415 * only known chips using this I2C address on PC hardware.
1416 * Returns 1 if probe succeeded, 0 if not.
1417 */
1418static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
1419{
1420 int err;
1421 union i2c_smbus_data dummy;
1422
1423#ifdef CONFIG_X86
1424 if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
1425 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
1426 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1427 I2C_SMBUS_BYTE_DATA, &dummy);
1428 else
1429#endif
Jean Delvare8031d792010-08-11 18:21:00 +02001430 if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
1431 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
Jean Delvare63e4e802010-06-03 11:33:51 +02001432 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
1433 I2C_SMBUS_QUICK, NULL);
Jean Delvare8031d792010-08-11 18:21:00 +02001434 else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
1435 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1436 I2C_SMBUS_BYTE, &dummy);
1437 else {
1438 dev_warn(&adap->dev, "No suitable probing method supported\n");
1439 err = -EOPNOTSUPP;
1440 }
Jean Delvare63e4e802010-06-03 11:33:51 +02001441
1442 return err >= 0;
1443}
1444
Jean Delvareccfbbd02009-12-06 17:06:25 +01001445static int i2c_detect_address(struct i2c_client *temp_client,
Jean Delvare4735c982008-07-14 22:38:36 +02001446 struct i2c_driver *driver)
1447{
1448 struct i2c_board_info info;
1449 struct i2c_adapter *adapter = temp_client->adapter;
1450 int addr = temp_client->addr;
1451 int err;
1452
1453 /* Make sure the address is valid */
Jean Delvare656b8762010-06-03 11:33:53 +02001454 err = i2c_check_addr_validity(addr);
1455 if (err) {
Jean Delvare4735c982008-07-14 22:38:36 +02001456 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1457 addr);
Jean Delvare656b8762010-06-03 11:33:53 +02001458 return err;
Jean Delvare4735c982008-07-14 22:38:36 +02001459 }
1460
1461 /* Skip if already in use */
Jean Delvare3b5f7942010-06-03 11:33:55 +02001462 if (i2c_check_addr_busy(adapter, addr))
Jean Delvare4735c982008-07-14 22:38:36 +02001463 return 0;
1464
Jean Delvareccfbbd02009-12-06 17:06:25 +01001465 /* Make sure there is something at this address */
Jean Delvare63e4e802010-06-03 11:33:51 +02001466 if (!i2c_default_probe(adapter, addr))
1467 return 0;
Jean Delvare4735c982008-07-14 22:38:36 +02001468
1469 /* Finally call the custom detection function */
1470 memset(&info, 0, sizeof(struct i2c_board_info));
1471 info.addr = addr;
Jean Delvare310ec792009-12-14 21:17:23 +01001472 err = driver->detect(temp_client, &info);
Jean Delvare4735c982008-07-14 22:38:36 +02001473 if (err) {
1474 /* -ENODEV is returned if the detection fails. We catch it
1475 here as this isn't an error. */
1476 return err == -ENODEV ? 0 : err;
1477 }
1478
1479 /* Consistency check */
1480 if (info.type[0] == '\0') {
1481 dev_err(&adapter->dev, "%s detection function provided "
1482 "no name for 0x%x\n", driver->driver.name,
1483 addr);
1484 } else {
1485 struct i2c_client *client;
1486
1487 /* Detection succeeded, instantiate the device */
1488 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
1489 info.type, info.addr);
1490 client = i2c_new_device(adapter, &info);
1491 if (client)
1492 list_add_tail(&client->detected, &driver->clients);
1493 else
1494 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
1495 info.type, info.addr);
1496 }
1497 return 0;
1498}
1499
1500static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
1501{
Jean Delvarec3813d62009-12-14 21:17:25 +01001502 const unsigned short *address_list;
Jean Delvare4735c982008-07-14 22:38:36 +02001503 struct i2c_client *temp_client;
1504 int i, err = 0;
1505 int adap_id = i2c_adapter_id(adapter);
1506
Jean Delvarec3813d62009-12-14 21:17:25 +01001507 address_list = driver->address_list;
1508 if (!driver->detect || !address_list)
Jean Delvare4735c982008-07-14 22:38:36 +02001509 return 0;
1510
1511 /* Set up a temporary client to help detect callback */
1512 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
1513 if (!temp_client)
1514 return -ENOMEM;
1515 temp_client->adapter = adapter;
1516
Jean Delvare4329cf82008-08-28 08:33:23 +02001517 /* Stop here if the classes do not match */
1518 if (!(adapter->class & driver->class))
1519 goto exit_free;
1520
Jean Delvarec3813d62009-12-14 21:17:25 +01001521 for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
Jean Delvare4735c982008-07-14 22:38:36 +02001522 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
Jean Delvarec3813d62009-12-14 21:17:25 +01001523 "addr 0x%02x\n", adap_id, address_list[i]);
1524 temp_client->addr = address_list[i];
Jean Delvareccfbbd02009-12-06 17:06:25 +01001525 err = i2c_detect_address(temp_client, driver);
Jean Delvare4735c982008-07-14 22:38:36 +02001526 if (err)
1527 goto exit_free;
1528 }
1529
1530 exit_free:
1531 kfree(temp_client);
1532 return err;
1533}
1534
Jean Delvared44f19d2010-08-11 18:20:57 +02001535int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
1536{
1537 return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1538 I2C_SMBUS_QUICK, NULL) >= 0;
1539}
1540EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
1541
Jean Delvare12b50532007-05-01 23:26:31 +02001542struct i2c_client *
1543i2c_new_probed_device(struct i2c_adapter *adap,
1544 struct i2c_board_info *info,
Jean Delvare9a942412010-08-11 18:20:56 +02001545 unsigned short const *addr_list,
1546 int (*probe)(struct i2c_adapter *, unsigned short addr))
Jean Delvare12b50532007-05-01 23:26:31 +02001547{
1548 int i;
1549
Jean Delvare8031d792010-08-11 18:21:00 +02001550 if (!probe)
Jean Delvare9a942412010-08-11 18:20:56 +02001551 probe = i2c_default_probe;
Jean Delvare12b50532007-05-01 23:26:31 +02001552
Jean Delvare12b50532007-05-01 23:26:31 +02001553 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1554 /* Check address validity */
Jean Delvare656b8762010-06-03 11:33:53 +02001555 if (i2c_check_addr_validity(addr_list[i]) < 0) {
Jean Delvare12b50532007-05-01 23:26:31 +02001556 dev_warn(&adap->dev, "Invalid 7-bit address "
1557 "0x%02x\n", addr_list[i]);
1558 continue;
1559 }
1560
1561 /* Check address availability */
Jean Delvare3b5f7942010-06-03 11:33:55 +02001562 if (i2c_check_addr_busy(adap, addr_list[i])) {
Jean Delvare12b50532007-05-01 23:26:31 +02001563 dev_dbg(&adap->dev, "Address 0x%02x already in "
1564 "use, not probing\n", addr_list[i]);
1565 continue;
1566 }
1567
Jean Delvare63e4e802010-06-03 11:33:51 +02001568 /* Test address responsiveness */
Jean Delvare9a942412010-08-11 18:20:56 +02001569 if (probe(adap, addr_list[i]))
Jean Delvare63e4e802010-06-03 11:33:51 +02001570 break;
Jean Delvare12b50532007-05-01 23:26:31 +02001571 }
Jean Delvare12b50532007-05-01 23:26:31 +02001572
1573 if (addr_list[i] == I2C_CLIENT_END) {
1574 dev_dbg(&adap->dev, "Probing failed, no device found\n");
1575 return NULL;
1576 }
1577
1578 info->addr = addr_list[i];
1579 return i2c_new_device(adap, info);
1580}
1581EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1582
Farid Hammane7225acf2010-05-21 18:40:58 +02001583struct i2c_adapter *i2c_get_adapter(int id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585 struct i2c_adapter *adapter;
David Brownell438d6c22006-12-10 21:21:31 +01001586
Jean Delvarecaada322008-01-27 18:14:49 +01001587 mutex_lock(&core_lock);
Jack Stone1cf92b42009-06-15 18:01:46 +02001588 adapter = idr_find(&i2c_adapter_idr, id);
Mark M. Hoffmana0920e12005-06-28 00:21:30 -04001589 if (adapter && !try_module_get(adapter->owner))
1590 adapter = NULL;
1591
Jean Delvarecaada322008-01-27 18:14:49 +01001592 mutex_unlock(&core_lock);
Mark M. Hoffmana0920e12005-06-28 00:21:30 -04001593 return adapter;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594}
David Brownellc0564602007-05-01 23:26:31 +02001595EXPORT_SYMBOL(i2c_get_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596
1597void i2c_put_adapter(struct i2c_adapter *adap)
1598{
1599 module_put(adap->owner);
1600}
David Brownellc0564602007-05-01 23:26:31 +02001601EXPORT_SYMBOL(i2c_put_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602
1603/* The SMBus parts */
1604
David Brownell438d6c22006-12-10 21:21:31 +01001605#define POLY (0x1070U << 3)
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01001606static u8 crc8(u16 data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607{
1608 int i;
David Brownell438d6c22006-12-10 21:21:31 +01001609
Farid Hammane7225acf2010-05-21 18:40:58 +02001610 for (i = 0; i < 8; i++) {
David Brownell438d6c22006-12-10 21:21:31 +01001611 if (data & 0x8000)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612 data = data ^ POLY;
1613 data = data << 1;
1614 }
1615 return (u8)(data >> 8);
1616}
1617
Jean Delvare421ef472005-10-26 21:28:55 +02001618/* Incremental CRC8 over count bytes in the array pointed to by p */
1619static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620{
1621 int i;
1622
Farid Hammane7225acf2010-05-21 18:40:58 +02001623 for (i = 0; i < count; i++)
Jean Delvare421ef472005-10-26 21:28:55 +02001624 crc = crc8((crc ^ p[i]) << 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625 return crc;
1626}
1627
Jean Delvare421ef472005-10-26 21:28:55 +02001628/* Assume a 7-bit address, which is reasonable for SMBus */
1629static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630{
Jean Delvare421ef472005-10-26 21:28:55 +02001631 /* The address will be sent first */
1632 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1633 pec = i2c_smbus_pec(pec, &addr, 1);
1634
1635 /* The data buffer follows */
1636 return i2c_smbus_pec(pec, msg->buf, msg->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637}
1638
Jean Delvare421ef472005-10-26 21:28:55 +02001639/* Used for write only transactions */
1640static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641{
Jean Delvare421ef472005-10-26 21:28:55 +02001642 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1643 msg->len++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644}
1645
Jean Delvare421ef472005-10-26 21:28:55 +02001646/* Return <0 on CRC error
1647 If there was a write before this read (most cases) we need to take the
1648 partial CRC from the write part into account.
1649 Note that this function does modify the message (we need to decrease the
1650 message length to hide the CRC byte from the caller). */
1651static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652{
Jean Delvare421ef472005-10-26 21:28:55 +02001653 u8 rpec = msg->buf[--msg->len];
1654 cpec = i2c_smbus_msg_pec(cpec, msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 if (rpec != cpec) {
1657 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1658 rpec, cpec);
David Brownell24a5bb72008-07-14 22:38:23 +02001659 return -EBADMSG;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660 }
David Brownell438d6c22006-12-10 21:21:31 +01001661 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662}
1663
David Brownella1cdeda2008-07-14 22:38:24 +02001664/**
1665 * i2c_smbus_read_byte - SMBus "receive byte" protocol
1666 * @client: Handle to slave device
1667 *
1668 * This executes the SMBus "receive byte" protocol, returning negative errno
1669 * else the byte received from the device.
1670 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671s32 i2c_smbus_read_byte(struct i2c_client *client)
1672{
1673 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02001674 int status;
1675
1676 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1677 I2C_SMBUS_READ, 0,
1678 I2C_SMBUS_BYTE, &data);
1679 return (status < 0) ? status : data.byte;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680}
David Brownellc0564602007-05-01 23:26:31 +02001681EXPORT_SYMBOL(i2c_smbus_read_byte);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682
David Brownella1cdeda2008-07-14 22:38:24 +02001683/**
1684 * i2c_smbus_write_byte - SMBus "send byte" protocol
1685 * @client: Handle to slave device
1686 * @value: Byte to be sent
1687 *
1688 * This executes the SMBus "send byte" protocol, returning negative errno
1689 * else zero on success.
1690 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
1692{
Farid Hammane7225acf2010-05-21 18:40:58 +02001693 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
Jean Delvare421ef472005-10-26 21:28:55 +02001694 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695}
David Brownellc0564602007-05-01 23:26:31 +02001696EXPORT_SYMBOL(i2c_smbus_write_byte);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697
David Brownella1cdeda2008-07-14 22:38:24 +02001698/**
1699 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
1700 * @client: Handle to slave device
1701 * @command: Byte interpreted by slave
1702 *
1703 * This executes the SMBus "read byte" protocol, returning negative errno
1704 * else a data byte received from the device.
1705 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001706s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
1707{
1708 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02001709 int status;
1710
1711 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1712 I2C_SMBUS_READ, command,
1713 I2C_SMBUS_BYTE_DATA, &data);
1714 return (status < 0) ? status : data.byte;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715}
David Brownellc0564602007-05-01 23:26:31 +02001716EXPORT_SYMBOL(i2c_smbus_read_byte_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717
David Brownella1cdeda2008-07-14 22:38:24 +02001718/**
1719 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
1720 * @client: Handle to slave device
1721 * @command: Byte interpreted by slave
1722 * @value: Byte being written
1723 *
1724 * This executes the SMBus "write byte" protocol, returning negative errno
1725 * else zero on success.
1726 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
1728{
1729 union i2c_smbus_data data;
1730 data.byte = value;
Farid Hammane7225acf2010-05-21 18:40:58 +02001731 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1732 I2C_SMBUS_WRITE, command,
1733 I2C_SMBUS_BYTE_DATA, &data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734}
David Brownellc0564602007-05-01 23:26:31 +02001735EXPORT_SYMBOL(i2c_smbus_write_byte_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736
David Brownella1cdeda2008-07-14 22:38:24 +02001737/**
1738 * i2c_smbus_read_word_data - SMBus "read word" protocol
1739 * @client: Handle to slave device
1740 * @command: Byte interpreted by slave
1741 *
1742 * This executes the SMBus "read word" protocol, returning negative errno
1743 * else a 16-bit unsigned "word" received from the device.
1744 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
1746{
1747 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02001748 int status;
1749
1750 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1751 I2C_SMBUS_READ, command,
1752 I2C_SMBUS_WORD_DATA, &data);
1753 return (status < 0) ? status : data.word;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754}
David Brownellc0564602007-05-01 23:26:31 +02001755EXPORT_SYMBOL(i2c_smbus_read_word_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756
David Brownella1cdeda2008-07-14 22:38:24 +02001757/**
1758 * i2c_smbus_write_word_data - SMBus "write word" protocol
1759 * @client: Handle to slave device
1760 * @command: Byte interpreted by slave
1761 * @value: 16-bit "word" being written
1762 *
1763 * This executes the SMBus "write word" protocol, returning negative errno
1764 * else zero on success.
1765 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
1767{
1768 union i2c_smbus_data data;
1769 data.word = value;
Farid Hammane7225acf2010-05-21 18:40:58 +02001770 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1771 I2C_SMBUS_WRITE, command,
1772 I2C_SMBUS_WORD_DATA, &data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773}
David Brownellc0564602007-05-01 23:26:31 +02001774EXPORT_SYMBOL(i2c_smbus_write_word_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775
David Brownella64ec072007-10-13 23:56:31 +02001776/**
Prakash Mortha596c88f2008-10-14 17:30:06 +02001777 * i2c_smbus_process_call - SMBus "process call" protocol
1778 * @client: Handle to slave device
1779 * @command: Byte interpreted by slave
1780 * @value: 16-bit "word" being written
1781 *
1782 * This executes the SMBus "process call" protocol, returning negative errno
1783 * else a 16-bit unsigned "word" received from the device.
1784 */
1785s32 i2c_smbus_process_call(struct i2c_client *client, u8 command, u16 value)
1786{
1787 union i2c_smbus_data data;
1788 int status;
1789 data.word = value;
1790
1791 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1792 I2C_SMBUS_WRITE, command,
1793 I2C_SMBUS_PROC_CALL, &data);
1794 return (status < 0) ? status : data.word;
1795}
1796EXPORT_SYMBOL(i2c_smbus_process_call);
1797
1798/**
David Brownella1cdeda2008-07-14 22:38:24 +02001799 * i2c_smbus_read_block_data - SMBus "block read" protocol
David Brownella64ec072007-10-13 23:56:31 +02001800 * @client: Handle to slave device
David Brownella1cdeda2008-07-14 22:38:24 +02001801 * @command: Byte interpreted by slave
David Brownella64ec072007-10-13 23:56:31 +02001802 * @values: Byte array into which data will be read; big enough to hold
1803 * the data returned by the slave. SMBus allows at most 32 bytes.
1804 *
David Brownella1cdeda2008-07-14 22:38:24 +02001805 * This executes the SMBus "block read" protocol, returning negative errno
1806 * else the number of data bytes in the slave's response.
David Brownella64ec072007-10-13 23:56:31 +02001807 *
1808 * Note that using this function requires that the client's adapter support
1809 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
1810 * support this; its emulation through I2C messaging relies on a specific
1811 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
1812 */
Jean Delvareb86a1bc2007-05-01 23:26:34 +02001813s32 i2c_smbus_read_block_data(struct i2c_client *client, u8 command,
1814 u8 *values)
1815{
1816 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02001817 int status;
Jean Delvareb86a1bc2007-05-01 23:26:34 +02001818
David Brownell24a5bb72008-07-14 22:38:23 +02001819 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1820 I2C_SMBUS_READ, command,
1821 I2C_SMBUS_BLOCK_DATA, &data);
1822 if (status)
1823 return status;
Jean Delvareb86a1bc2007-05-01 23:26:34 +02001824
1825 memcpy(values, &data.block[1], data.block[0]);
1826 return data.block[0];
1827}
1828EXPORT_SYMBOL(i2c_smbus_read_block_data);
1829
David Brownella1cdeda2008-07-14 22:38:24 +02001830/**
1831 * i2c_smbus_write_block_data - SMBus "block write" protocol
1832 * @client: Handle to slave device
1833 * @command: Byte interpreted by slave
1834 * @length: Size of data block; SMBus allows at most 32 bytes
1835 * @values: Byte array which will be written.
1836 *
1837 * This executes the SMBus "block write" protocol, returning negative errno
1838 * else zero on success.
1839 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001840s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
Krzysztof Halasa46f5ed72006-06-12 21:42:20 +02001841 u8 length, const u8 *values)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842{
1843 union i2c_smbus_data data;
Jean Delvare76560322006-01-18 23:14:55 +01001844
Linus Torvalds1da177e2005-04-16 15:20:36 -07001845 if (length > I2C_SMBUS_BLOCK_MAX)
1846 length = I2C_SMBUS_BLOCK_MAX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847 data.block[0] = length;
Jean Delvare76560322006-01-18 23:14:55 +01001848 memcpy(&data.block[1], values, length);
Farid Hammane7225acf2010-05-21 18:40:58 +02001849 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1850 I2C_SMBUS_WRITE, command,
1851 I2C_SMBUS_BLOCK_DATA, &data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852}
David Brownellc0564602007-05-01 23:26:31 +02001853EXPORT_SYMBOL(i2c_smbus_write_block_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854
1855/* Returns the number of read bytes */
Jean Delvare4b2643d2007-07-12 14:12:29 +02001856s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command,
1857 u8 length, u8 *values)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001858{
1859 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02001860 int status;
Jean Delvare76560322006-01-18 23:14:55 +01001861
Jean Delvare4b2643d2007-07-12 14:12:29 +02001862 if (length > I2C_SMBUS_BLOCK_MAX)
1863 length = I2C_SMBUS_BLOCK_MAX;
1864 data.block[0] = length;
David Brownell24a5bb72008-07-14 22:38:23 +02001865 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1866 I2C_SMBUS_READ, command,
1867 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1868 if (status < 0)
1869 return status;
Jean Delvare76560322006-01-18 23:14:55 +01001870
1871 memcpy(values, &data.block[1], data.block[0]);
1872 return data.block[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873}
David Brownellc0564602007-05-01 23:26:31 +02001874EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875
Jean Delvare21bbd692006-01-09 15:19:18 +11001876s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, u8 command,
Krzysztof Halasa46f5ed72006-06-12 21:42:20 +02001877 u8 length, const u8 *values)
Jean Delvare21bbd692006-01-09 15:19:18 +11001878{
1879 union i2c_smbus_data data;
1880
1881 if (length > I2C_SMBUS_BLOCK_MAX)
1882 length = I2C_SMBUS_BLOCK_MAX;
1883 data.block[0] = length;
1884 memcpy(data.block + 1, values, length);
1885 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1886 I2C_SMBUS_WRITE, command,
1887 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1888}
David Brownellc0564602007-05-01 23:26:31 +02001889EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
Jean Delvare21bbd692006-01-09 15:19:18 +11001890
David Brownell438d6c22006-12-10 21:21:31 +01001891/* Simulate a SMBus command using the i2c protocol
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892 No checking of parameters is done! */
Farid Hammane7225acf2010-05-21 18:40:58 +02001893static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
1894 unsigned short flags,
1895 char read_write, u8 command, int size,
1896 union i2c_smbus_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897{
1898 /* So we need to generate a series of msgs. In the case of writing, we
1899 need to use only one message; when reading, we need two. We initialize
1900 most things with sane defaults, to keep the code below somewhat
1901 simpler. */
Hideki Iwamoto5c50d182005-09-25 17:01:11 +02001902 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1903 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
Farid Hammane7225acf2010-05-21 18:40:58 +02001904 int num = read_write == I2C_SMBUS_READ ? 2 : 1;
David Brownell438d6c22006-12-10 21:21:31 +01001905 struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906 { addr, flags | I2C_M_RD, 0, msgbuf1 }
1907 };
1908 int i;
Jean Delvare421ef472005-10-26 21:28:55 +02001909 u8 partial_pec = 0;
David Brownell24a5bb72008-07-14 22:38:23 +02001910 int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001911
1912 msgbuf0[0] = command;
Farid Hammane7225acf2010-05-21 18:40:58 +02001913 switch (size) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914 case I2C_SMBUS_QUICK:
1915 msg[0].len = 0;
1916 /* Special case: The read/write field is used as data */
Roel Kluinf29d2e02009-02-24 19:19:48 +01001917 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
1918 I2C_M_RD : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919 num = 1;
1920 break;
1921 case I2C_SMBUS_BYTE:
1922 if (read_write == I2C_SMBUS_READ) {
1923 /* Special case: only a read! */
1924 msg[0].flags = I2C_M_RD | flags;
1925 num = 1;
1926 }
1927 break;
1928 case I2C_SMBUS_BYTE_DATA:
1929 if (read_write == I2C_SMBUS_READ)
1930 msg[1].len = 1;
1931 else {
1932 msg[0].len = 2;
1933 msgbuf0[1] = data->byte;
1934 }
1935 break;
1936 case I2C_SMBUS_WORD_DATA:
1937 if (read_write == I2C_SMBUS_READ)
1938 msg[1].len = 2;
1939 else {
Farid Hammane7225acf2010-05-21 18:40:58 +02001940 msg[0].len = 3;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001941 msgbuf0[1] = data->word & 0xff;
Jean Delvare7eff82c2006-09-03 22:24:00 +02001942 msgbuf0[2] = data->word >> 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943 }
1944 break;
1945 case I2C_SMBUS_PROC_CALL:
1946 num = 2; /* Special case */
1947 read_write = I2C_SMBUS_READ;
1948 msg[0].len = 3;
1949 msg[1].len = 2;
1950 msgbuf0[1] = data->word & 0xff;
Jean Delvare7eff82c2006-09-03 22:24:00 +02001951 msgbuf0[2] = data->word >> 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001952 break;
1953 case I2C_SMBUS_BLOCK_DATA:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954 if (read_write == I2C_SMBUS_READ) {
Jean Delvare209d27c2007-05-01 23:26:29 +02001955 msg[1].flags |= I2C_M_RECV_LEN;
1956 msg[1].len = 1; /* block length will be added by
1957 the underlying bus driver */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958 } else {
1959 msg[0].len = data->block[0] + 2;
1960 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
David Brownell24a5bb72008-07-14 22:38:23 +02001961 dev_err(&adapter->dev,
1962 "Invalid block write size %d\n",
1963 data->block[0]);
1964 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965 }
Hideki Iwamoto5c50d182005-09-25 17:01:11 +02001966 for (i = 1; i < msg[0].len; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967 msgbuf0[i] = data->block[i-1];
1968 }
1969 break;
1970 case I2C_SMBUS_BLOCK_PROC_CALL:
Jean Delvare209d27c2007-05-01 23:26:29 +02001971 num = 2; /* Another special case */
1972 read_write = I2C_SMBUS_READ;
1973 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
David Brownell24a5bb72008-07-14 22:38:23 +02001974 dev_err(&adapter->dev,
1975 "Invalid block write size %d\n",
Jean Delvare209d27c2007-05-01 23:26:29 +02001976 data->block[0]);
David Brownell24a5bb72008-07-14 22:38:23 +02001977 return -EINVAL;
Jean Delvare209d27c2007-05-01 23:26:29 +02001978 }
1979 msg[0].len = data->block[0] + 2;
1980 for (i = 1; i < msg[0].len; i++)
1981 msgbuf0[i] = data->block[i-1];
1982 msg[1].flags |= I2C_M_RECV_LEN;
1983 msg[1].len = 1; /* block length will be added by
1984 the underlying bus driver */
1985 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001986 case I2C_SMBUS_I2C_BLOCK_DATA:
1987 if (read_write == I2C_SMBUS_READ) {
Jean Delvare4b2643d2007-07-12 14:12:29 +02001988 msg[1].len = data->block[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989 } else {
1990 msg[0].len = data->block[0] + 1;
Jean Delvare30dac742005-10-08 00:15:59 +02001991 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
David Brownell24a5bb72008-07-14 22:38:23 +02001992 dev_err(&adapter->dev,
1993 "Invalid block write size %d\n",
1994 data->block[0]);
1995 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996 }
1997 for (i = 1; i <= data->block[0]; i++)
1998 msgbuf0[i] = data->block[i];
1999 }
2000 break;
2001 default:
David Brownell24a5bb72008-07-14 22:38:23 +02002002 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
2003 return -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004 }
2005
Jean Delvare421ef472005-10-26 21:28:55 +02002006 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
2007 && size != I2C_SMBUS_I2C_BLOCK_DATA);
2008 if (i) {
2009 /* Compute PEC if first message is a write */
2010 if (!(msg[0].flags & I2C_M_RD)) {
David Brownell438d6c22006-12-10 21:21:31 +01002011 if (num == 1) /* Write only */
Jean Delvare421ef472005-10-26 21:28:55 +02002012 i2c_smbus_add_pec(&msg[0]);
2013 else /* Write followed by read */
2014 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
2015 }
2016 /* Ask for PEC if last message is a read */
2017 if (msg[num-1].flags & I2C_M_RD)
David Brownell438d6c22006-12-10 21:21:31 +01002018 msg[num-1].len++;
Jean Delvare421ef472005-10-26 21:28:55 +02002019 }
2020
David Brownell24a5bb72008-07-14 22:38:23 +02002021 status = i2c_transfer(adapter, msg, num);
2022 if (status < 0)
2023 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024
Jean Delvare421ef472005-10-26 21:28:55 +02002025 /* Check PEC if last message is a read */
2026 if (i && (msg[num-1].flags & I2C_M_RD)) {
David Brownell24a5bb72008-07-14 22:38:23 +02002027 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
2028 if (status < 0)
2029 return status;
Jean Delvare421ef472005-10-26 21:28:55 +02002030 }
2031
Linus Torvalds1da177e2005-04-16 15:20:36 -07002032 if (read_write == I2C_SMBUS_READ)
Farid Hammane7225acf2010-05-21 18:40:58 +02002033 switch (size) {
2034 case I2C_SMBUS_BYTE:
2035 data->byte = msgbuf0[0];
2036 break;
2037 case I2C_SMBUS_BYTE_DATA:
2038 data->byte = msgbuf1[0];
2039 break;
2040 case I2C_SMBUS_WORD_DATA:
2041 case I2C_SMBUS_PROC_CALL:
2042 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
2043 break;
2044 case I2C_SMBUS_I2C_BLOCK_DATA:
2045 for (i = 0; i < data->block[0]; i++)
2046 data->block[i+1] = msgbuf1[i];
2047 break;
2048 case I2C_SMBUS_BLOCK_DATA:
2049 case I2C_SMBUS_BLOCK_PROC_CALL:
2050 for (i = 0; i < msgbuf1[0] + 1; i++)
2051 data->block[i] = msgbuf1[i];
2052 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002053 }
2054 return 0;
2055}
2056
David Brownella1cdeda2008-07-14 22:38:24 +02002057/**
2058 * i2c_smbus_xfer - execute SMBus protocol operations
2059 * @adapter: Handle to I2C bus
2060 * @addr: Address of SMBus slave on that bus
2061 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
2062 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
2063 * @command: Byte interpreted by slave, for protocols which use such bytes
2064 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
2065 * @data: Data to be read or written
2066 *
2067 * This executes an SMBus protocol operation, and returns a negative
2068 * errno code else zero on success.
2069 */
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01002070s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
David Brownella1cdeda2008-07-14 22:38:24 +02002071 char read_write, u8 command, int protocol,
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01002072 union i2c_smbus_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002073{
Clifford Wolf66b650f2009-06-15 18:01:46 +02002074 unsigned long orig_jiffies;
2075 int try;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076 s32 res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077
2078 flags &= I2C_M_TEN | I2C_CLIENT_PEC;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002079
2080 if (adapter->algo->smbus_xfer) {
Jean Delvarefe61e072010-08-11 18:20:58 +02002081 i2c_lock_adapter(adapter);
Clifford Wolf66b650f2009-06-15 18:01:46 +02002082
2083 /* Retry automatically on arbitration loss */
2084 orig_jiffies = jiffies;
2085 for (res = 0, try = 0; try <= adapter->retries; try++) {
2086 res = adapter->algo->smbus_xfer(adapter, addr, flags,
2087 read_write, command,
2088 protocol, data);
2089 if (res != -EAGAIN)
2090 break;
2091 if (time_after(jiffies,
2092 orig_jiffies + adapter->timeout))
2093 break;
2094 }
Jean Delvarefe61e072010-08-11 18:20:58 +02002095 i2c_unlock_adapter(adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002096 } else
Farid Hammane7225acf2010-05-21 18:40:58 +02002097 res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
David Brownella1cdeda2008-07-14 22:38:24 +02002098 command, protocol, data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002099
Linus Torvalds1da177e2005-04-16 15:20:36 -07002100 return res;
2101}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002102EXPORT_SYMBOL(i2c_smbus_xfer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002103
2104MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
2105MODULE_DESCRIPTION("I2C-Bus main module");
2106MODULE_LICENSE("GPL");