blob: 70c30e6bce0b2efcfbdee8f90bfd620d62319bd9 [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
Mark Brownd529de22011-01-14 22:03:49 +0100199 if (pm)
200 return pm_generic_suspend(dev);
201 else
202 return i2c_legacy_suspend(dev, PMSG_SUSPEND);
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200203}
204
205static int i2c_device_pm_resume(struct device *dev)
206{
207 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200208
209 if (pm)
Mark Brownd529de22011-01-14 22:03:49 +0100210 return pm_generic_resume(dev);
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200211 else
Mark Brownd529de22011-01-14 22:03:49 +0100212 return i2c_legacy_resume(dev);
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200213}
214
215static int i2c_device_pm_freeze(struct device *dev)
216{
217 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
218
Mark Brownd529de22011-01-14 22:03:49 +0100219 if (pm)
220 return pm_generic_freeze(dev);
221 else
222 return i2c_legacy_suspend(dev, PMSG_FREEZE);
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200223}
224
225static int i2c_device_pm_thaw(struct device *dev)
226{
227 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
228
Mark Brownd529de22011-01-14 22:03:49 +0100229 if (pm)
230 return pm_generic_thaw(dev);
231 else
232 return i2c_legacy_resume(dev);
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200233}
234
235static int i2c_device_pm_poweroff(struct device *dev)
236{
237 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
238
Mark Brownd529de22011-01-14 22:03:49 +0100239 if (pm)
240 return pm_generic_poweroff(dev);
241 else
242 return i2c_legacy_suspend(dev, PMSG_HIBERNATE);
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200243}
244
245static int i2c_device_pm_restore(struct device *dev)
246{
247 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200248
249 if (pm)
Mark Brownd529de22011-01-14 22:03:49 +0100250 return pm_generic_restore(dev);
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200251 else
Mark Brownd529de22011-01-14 22:03:49 +0100252 return i2c_legacy_resume(dev);
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200253}
254#else /* !CONFIG_PM_SLEEP */
255#define i2c_device_pm_suspend NULL
256#define i2c_device_pm_resume NULL
257#define i2c_device_pm_freeze NULL
258#define i2c_device_pm_thaw NULL
259#define i2c_device_pm_poweroff NULL
260#define i2c_device_pm_restore NULL
261#endif /* !CONFIG_PM_SLEEP */
262
David Brownell9c1600e2007-05-01 23:26:31 +0200263static void i2c_client_dev_release(struct device *dev)
264{
265 kfree(to_i2c_client(dev));
266}
267
Zhenwen Xu09b8ce02009-03-28 21:34:46 +0100268static ssize_t
Jean Delvare4f8cf822009-09-18 22:45:46 +0200269show_name(struct device *dev, struct device_attribute *attr, char *buf)
David Brownell7b4fbc52007-05-01 23:26:30 +0200270{
Jean Delvare4f8cf822009-09-18 22:45:46 +0200271 return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
272 to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
David Brownell7b4fbc52007-05-01 23:26:30 +0200273}
274
Zhenwen Xu09b8ce02009-03-28 21:34:46 +0100275static ssize_t
276show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
David Brownell7b4fbc52007-05-01 23:26:30 +0200277{
278 struct i2c_client *client = to_i2c_client(dev);
Jean Delvareeb8a7902008-05-18 20:49:41 +0200279 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
David Brownell7b4fbc52007-05-01 23:26:30 +0200280}
281
Jean Delvare4f8cf822009-09-18 22:45:46 +0200282static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
Jean Delvare51298d12009-09-18 22:45:45 +0200283static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
284
285static struct attribute *i2c_dev_attrs[] = {
286 &dev_attr_name.attr,
David Brownell7b4fbc52007-05-01 23:26:30 +0200287 /* modalias helps coldplug: modprobe $(cat .../modalias) */
Jean Delvare51298d12009-09-18 22:45:45 +0200288 &dev_attr_modalias.attr,
289 NULL
290};
291
292static struct attribute_group i2c_dev_attr_group = {
293 .attrs = i2c_dev_attrs,
294};
295
296static const struct attribute_group *i2c_dev_attr_groups[] = {
297 &i2c_dev_attr_group,
298 NULL
David Brownell7b4fbc52007-05-01 23:26:30 +0200299};
300
Tobias Klauser0b2c3682010-01-16 20:43:12 +0100301static const struct dev_pm_ops i2c_device_pm_ops = {
sonic zhang54067ee2009-12-14 21:17:30 +0100302 .suspend = i2c_device_pm_suspend,
303 .resume = i2c_device_pm_resume,
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200304 .freeze = i2c_device_pm_freeze,
305 .thaw = i2c_device_pm_thaw,
306 .poweroff = i2c_device_pm_poweroff,
307 .restore = i2c_device_pm_restore,
308 SET_RUNTIME_PM_OPS(
309 pm_generic_runtime_suspend,
310 pm_generic_runtime_resume,
311 pm_generic_runtime_idle
312 )
sonic zhang54067ee2009-12-14 21:17:30 +0100313};
314
Jon Smirle9ca9eb2008-07-14 22:38:35 +0200315struct bus_type i2c_bus_type = {
David Brownellf37dd802007-02-13 22:09:00 +0100316 .name = "i2c",
317 .match = i2c_device_match,
318 .probe = i2c_device_probe,
319 .remove = i2c_device_remove,
320 .shutdown = i2c_device_shutdown,
sonic zhang54067ee2009-12-14 21:17:30 +0100321 .pm = &i2c_device_pm_ops,
Russell Kingb864c7d2006-01-05 14:37:50 +0000322};
Jon Smirle9ca9eb2008-07-14 22:38:35 +0200323EXPORT_SYMBOL_GPL(i2c_bus_type);
Russell Kingb864c7d2006-01-05 14:37:50 +0000324
Jean Delvare51298d12009-09-18 22:45:45 +0200325static struct device_type i2c_client_type = {
326 .groups = i2c_dev_attr_groups,
327 .uevent = i2c_device_uevent,
328 .release = i2c_client_dev_release,
329};
330
David Brownell9b766b82008-01-27 18:14:51 +0100331
332/**
333 * i2c_verify_client - return parameter as i2c_client, or NULL
334 * @dev: device, probably from some driver model iterator
335 *
336 * When traversing the driver model tree, perhaps using driver model
337 * iterators like @device_for_each_child(), you can't assume very much
338 * about the nodes you find. Use this function to avoid oopses caused
339 * by wrongly treating some non-I2C device as an i2c_client.
340 */
341struct i2c_client *i2c_verify_client(struct device *dev)
342{
Jean Delvare51298d12009-09-18 22:45:45 +0200343 return (dev->type == &i2c_client_type)
David Brownell9b766b82008-01-27 18:14:51 +0100344 ? to_i2c_client(dev)
345 : NULL;
346}
347EXPORT_SYMBOL(i2c_verify_client);
348
349
Jean Delvare3a89db52010-06-03 11:33:52 +0200350/* This is a permissive address validity check, I2C address map constraints
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300351 * are purposely not enforced, except for the general call address. */
Jean Delvare3a89db52010-06-03 11:33:52 +0200352static int i2c_check_client_addr_validity(const struct i2c_client *client)
353{
354 if (client->flags & I2C_CLIENT_TEN) {
355 /* 10-bit address, all values are valid */
356 if (client->addr > 0x3ff)
357 return -EINVAL;
358 } else {
359 /* 7-bit address, reject the general call address */
360 if (client->addr == 0x00 || client->addr > 0x7f)
361 return -EINVAL;
362 }
363 return 0;
364}
365
Jean Delvare656b8762010-06-03 11:33:53 +0200366/* And this is a strict address validity check, used when probing. If a
367 * device uses a reserved address, then it shouldn't be probed. 7-bit
368 * addressing is assumed, 10-bit address devices are rare and should be
369 * explicitly enumerated. */
370static int i2c_check_addr_validity(unsigned short addr)
371{
372 /*
373 * Reserved addresses per I2C specification:
374 * 0x00 General call address / START byte
375 * 0x01 CBUS address
376 * 0x02 Reserved for different bus format
377 * 0x03 Reserved for future purposes
378 * 0x04-0x07 Hs-mode master code
379 * 0x78-0x7b 10-bit slave addressing
380 * 0x7c-0x7f Reserved for future purposes
381 */
382 if (addr < 0x08 || addr > 0x77)
383 return -EINVAL;
384 return 0;
385}
386
Jean Delvare3b5f7942010-06-03 11:33:55 +0200387static int __i2c_check_addr_busy(struct device *dev, void *addrp)
388{
389 struct i2c_client *client = i2c_verify_client(dev);
390 int addr = *(int *)addrp;
391
392 if (client && client->addr == addr)
393 return -EBUSY;
394 return 0;
395}
396
Michael Lawnick08263742010-08-11 18:21:02 +0200397/* walk up mux tree */
398static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
399{
Jean Delvare97cc4d42010-10-24 18:16:57 +0200400 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
Michael Lawnick08263742010-08-11 18:21:02 +0200401 int result;
402
403 result = device_for_each_child(&adapter->dev, &addr,
404 __i2c_check_addr_busy);
405
Jean Delvare97cc4d42010-10-24 18:16:57 +0200406 if (!result && parent)
407 result = i2c_check_mux_parents(parent, addr);
Michael Lawnick08263742010-08-11 18:21:02 +0200408
409 return result;
410}
411
412/* recurse down mux tree */
413static int i2c_check_mux_children(struct device *dev, void *addrp)
414{
415 int result;
416
417 if (dev->type == &i2c_adapter_type)
418 result = device_for_each_child(dev, addrp,
419 i2c_check_mux_children);
420 else
421 result = __i2c_check_addr_busy(dev, addrp);
422
423 return result;
424}
425
Jean Delvare3b5f7942010-06-03 11:33:55 +0200426static int i2c_check_addr_busy(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 = 0;
430
Jean Delvare97cc4d42010-10-24 18:16:57 +0200431 if (parent)
432 result = i2c_check_mux_parents(parent, addr);
Michael Lawnick08263742010-08-11 18:21:02 +0200433
434 if (!result)
435 result = device_for_each_child(&adapter->dev, &addr,
436 i2c_check_mux_children);
437
438 return result;
Jean Delvare3b5f7942010-06-03 11:33:55 +0200439}
440
David Brownell9c1600e2007-05-01 23:26:31 +0200441/**
Jean Delvarefe61e072010-08-11 18:20:58 +0200442 * i2c_lock_adapter - Get exclusive access to an I2C bus segment
443 * @adapter: Target I2C bus segment
444 */
445void i2c_lock_adapter(struct i2c_adapter *adapter)
446{
Jean Delvare97cc4d42010-10-24 18:16:57 +0200447 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
448
449 if (parent)
450 i2c_lock_adapter(parent);
Michael Lawnick08263742010-08-11 18:21:02 +0200451 else
452 rt_mutex_lock(&adapter->bus_lock);
Jean Delvarefe61e072010-08-11 18:20:58 +0200453}
454EXPORT_SYMBOL_GPL(i2c_lock_adapter);
455
456/**
457 * i2c_trylock_adapter - Try to get exclusive access to an I2C bus segment
458 * @adapter: Target I2C bus segment
459 */
460static int i2c_trylock_adapter(struct i2c_adapter *adapter)
461{
Jean Delvare97cc4d42010-10-24 18:16:57 +0200462 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
463
464 if (parent)
465 return i2c_trylock_adapter(parent);
Michael Lawnick08263742010-08-11 18:21:02 +0200466 else
467 return rt_mutex_trylock(&adapter->bus_lock);
Jean Delvarefe61e072010-08-11 18:20:58 +0200468}
469
470/**
471 * i2c_unlock_adapter - Release exclusive access to an I2C bus segment
472 * @adapter: Target I2C bus segment
473 */
474void i2c_unlock_adapter(struct i2c_adapter *adapter)
475{
Jean Delvare97cc4d42010-10-24 18:16:57 +0200476 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
477
478 if (parent)
479 i2c_unlock_adapter(parent);
Michael Lawnick08263742010-08-11 18:21:02 +0200480 else
481 rt_mutex_unlock(&adapter->bus_lock);
Jean Delvarefe61e072010-08-11 18:20:58 +0200482}
483EXPORT_SYMBOL_GPL(i2c_unlock_adapter);
484
485/**
Jean Delvaref8a227e2009-06-19 16:58:18 +0200486 * i2c_new_device - instantiate an i2c device
David Brownell9c1600e2007-05-01 23:26:31 +0200487 * @adap: the adapter managing the device
488 * @info: describes one I2C device; bus_num is ignored
David Brownelld64f73b2007-07-12 14:12:28 +0200489 * Context: can sleep
David Brownell9c1600e2007-05-01 23:26:31 +0200490 *
Jean Delvaref8a227e2009-06-19 16:58:18 +0200491 * Create an i2c device. Binding is handled through driver model
492 * probe()/remove() methods. A driver may be bound to this device when we
493 * return from this function, or any later moment (e.g. maybe hotplugging will
494 * load the driver module). This call is not appropriate for use by mainboard
495 * initialization logic, which usually runs during an arch_initcall() long
496 * before any i2c_adapter could exist.
David Brownell9c1600e2007-05-01 23:26:31 +0200497 *
498 * This returns the new i2c client, which may be saved for later use with
499 * i2c_unregister_device(); or NULL to indicate an error.
500 */
501struct i2c_client *
502i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
503{
504 struct i2c_client *client;
505 int status;
506
507 client = kzalloc(sizeof *client, GFP_KERNEL);
508 if (!client)
509 return NULL;
510
511 client->adapter = adap;
512
513 client->dev.platform_data = info->platform_data;
David Brownell3bbb8352007-10-13 23:56:29 +0200514
Anton Vorontsov11f1f2a2008-10-22 20:21:33 +0200515 if (info->archdata)
516 client->dev.archdata = *info->archdata;
517
Marc Pignatee354252008-08-28 08:33:22 +0200518 client->flags = info->flags;
David Brownell9c1600e2007-05-01 23:26:31 +0200519 client->addr = info->addr;
520 client->irq = info->irq;
521
David Brownell9c1600e2007-05-01 23:26:31 +0200522 strlcpy(client->name, info->type, sizeof(client->name));
523
Jean Delvare3a89db52010-06-03 11:33:52 +0200524 /* Check for address validity */
525 status = i2c_check_client_addr_validity(client);
526 if (status) {
527 dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
528 client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
529 goto out_err_silent;
530 }
531
Jean Delvaref8a227e2009-06-19 16:58:18 +0200532 /* Check for address business */
Jean Delvare3b5f7942010-06-03 11:33:55 +0200533 status = i2c_check_addr_busy(adap, client->addr);
Jean Delvaref8a227e2009-06-19 16:58:18 +0200534 if (status)
535 goto out_err;
536
537 client->dev.parent = &client->adapter->dev;
538 client->dev.bus = &i2c_bus_type;
Jean Delvare51298d12009-09-18 22:45:45 +0200539 client->dev.type = &i2c_client_type;
Grant Likelyd12d42f2010-04-13 16:12:28 -0700540 client->dev.of_node = info->of_node;
Jean Delvaref8a227e2009-06-19 16:58:18 +0200541
542 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
543 client->addr);
544 status = device_register(&client->dev);
545 if (status)
546 goto out_err;
547
Jean Delvaref8a227e2009-06-19 16:58:18 +0200548 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
549 client->name, dev_name(&client->dev));
550
David Brownell9c1600e2007-05-01 23:26:31 +0200551 return client;
Jean Delvaref8a227e2009-06-19 16:58:18 +0200552
553out_err:
554 dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
555 "(%d)\n", client->name, client->addr, status);
Jean Delvare3a89db52010-06-03 11:33:52 +0200556out_err_silent:
Jean Delvaref8a227e2009-06-19 16:58:18 +0200557 kfree(client);
558 return NULL;
David Brownell9c1600e2007-05-01 23:26:31 +0200559}
560EXPORT_SYMBOL_GPL(i2c_new_device);
561
562
563/**
564 * i2c_unregister_device - reverse effect of i2c_new_device()
565 * @client: value returned from i2c_new_device()
David Brownelld64f73b2007-07-12 14:12:28 +0200566 * Context: can sleep
David Brownell9c1600e2007-05-01 23:26:31 +0200567 */
568void i2c_unregister_device(struct i2c_client *client)
David Brownella1d9e6e2007-05-01 23:26:30 +0200569{
David Brownella1d9e6e2007-05-01 23:26:30 +0200570 device_unregister(&client->dev);
571}
David Brownell9c1600e2007-05-01 23:26:31 +0200572EXPORT_SYMBOL_GPL(i2c_unregister_device);
David Brownella1d9e6e2007-05-01 23:26:30 +0200573
574
Jean Delvare60b129d2008-05-11 20:37:06 +0200575static const struct i2c_device_id dummy_id[] = {
576 { "dummy", 0 },
577 { },
578};
579
Jean Delvared2653e92008-04-29 23:11:39 +0200580static int dummy_probe(struct i2c_client *client,
581 const struct i2c_device_id *id)
582{
583 return 0;
584}
585
586static int dummy_remove(struct i2c_client *client)
David Brownelle9f13732008-01-27 18:14:52 +0100587{
588 return 0;
589}
590
591static struct i2c_driver dummy_driver = {
592 .driver.name = "dummy",
Jean Delvared2653e92008-04-29 23:11:39 +0200593 .probe = dummy_probe,
594 .remove = dummy_remove,
Jean Delvare60b129d2008-05-11 20:37:06 +0200595 .id_table = dummy_id,
David Brownelle9f13732008-01-27 18:14:52 +0100596};
597
598/**
599 * i2c_new_dummy - return a new i2c device bound to a dummy driver
600 * @adapter: the adapter managing the device
601 * @address: seven bit address to be used
David Brownelle9f13732008-01-27 18:14:52 +0100602 * Context: can sleep
603 *
604 * This returns an I2C client bound to the "dummy" driver, intended for use
605 * with devices that consume multiple addresses. Examples of such chips
606 * include various EEPROMS (like 24c04 and 24c08 models).
607 *
608 * These dummy devices have two main uses. First, most I2C and SMBus calls
609 * except i2c_transfer() need a client handle; the dummy will be that handle.
610 * And second, this prevents the specified address from being bound to a
611 * different driver.
612 *
613 * This returns the new i2c client, which should be saved for later use with
614 * i2c_unregister_device(); or NULL to indicate an error.
615 */
Zhenwen Xu09b8ce02009-03-28 21:34:46 +0100616struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
David Brownelle9f13732008-01-27 18:14:52 +0100617{
618 struct i2c_board_info info = {
Jean Delvare60b129d2008-05-11 20:37:06 +0200619 I2C_BOARD_INFO("dummy", address),
David Brownelle9f13732008-01-27 18:14:52 +0100620 };
621
David Brownelle9f13732008-01-27 18:14:52 +0100622 return i2c_new_device(adapter, &info);
623}
624EXPORT_SYMBOL_GPL(i2c_new_dummy);
625
David Brownellf37dd802007-02-13 22:09:00 +0100626/* ------------------------------------------------------------------------- */
627
David Brownell16ffadf2007-05-01 23:26:28 +0200628/* I2C bus adapters -- one roots each I2C or SMBUS segment */
629
Adrian Bunk83eaaed2007-10-13 23:56:30 +0200630static void i2c_adapter_dev_release(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631{
David Brownellef2c83212007-05-01 23:26:28 +0200632 struct i2c_adapter *adap = to_i2c_adapter(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 complete(&adap->dev_released);
634}
635
Jean Delvare99cd8e22009-06-19 16:58:20 +0200636/*
637 * Let users instantiate I2C devices through sysfs. This can be used when
638 * platform initialization code doesn't contain the proper data for
639 * whatever reason. Also useful for drivers that do device detection and
640 * detection fails, either because the device uses an unexpected address,
641 * or this is a compatible device with different ID register values.
642 *
643 * Parameter checking may look overzealous, but we really don't want
644 * the user to provide incorrect parameters.
645 */
646static ssize_t
647i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
648 const char *buf, size_t count)
649{
650 struct i2c_adapter *adap = to_i2c_adapter(dev);
651 struct i2c_board_info info;
652 struct i2c_client *client;
653 char *blank, end;
654 int res;
655
Jean Delvare99cd8e22009-06-19 16:58:20 +0200656 memset(&info, 0, sizeof(struct i2c_board_info));
657
658 blank = strchr(buf, ' ');
659 if (!blank) {
660 dev_err(dev, "%s: Missing parameters\n", "new_device");
661 return -EINVAL;
662 }
663 if (blank - buf > I2C_NAME_SIZE - 1) {
664 dev_err(dev, "%s: Invalid device name\n", "new_device");
665 return -EINVAL;
666 }
667 memcpy(info.type, buf, blank - buf);
668
669 /* Parse remaining parameters, reject extra parameters */
670 res = sscanf(++blank, "%hi%c", &info.addr, &end);
671 if (res < 1) {
672 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
673 return -EINVAL;
674 }
675 if (res > 1 && end != '\n') {
676 dev_err(dev, "%s: Extra parameters\n", "new_device");
677 return -EINVAL;
678 }
679
Jean Delvare99cd8e22009-06-19 16:58:20 +0200680 client = i2c_new_device(adap, &info);
681 if (!client)
Jean Delvare3a89db52010-06-03 11:33:52 +0200682 return -EINVAL;
Jean Delvare99cd8e22009-06-19 16:58:20 +0200683
684 /* Keep track of the added device */
Jean Delvaredafc50d2010-08-11 18:21:01 +0200685 mutex_lock(&adap->userspace_clients_lock);
Jean Delvare6629dcf2010-05-04 11:09:28 +0200686 list_add_tail(&client->detected, &adap->userspace_clients);
Jean Delvaredafc50d2010-08-11 18:21:01 +0200687 mutex_unlock(&adap->userspace_clients_lock);
Jean Delvare99cd8e22009-06-19 16:58:20 +0200688 dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
689 info.type, info.addr);
690
691 return count;
692}
693
694/*
695 * And of course let the users delete the devices they instantiated, if
696 * they got it wrong. This interface can only be used to delete devices
697 * instantiated by i2c_sysfs_new_device above. This guarantees that we
698 * don't delete devices to which some kernel code still has references.
699 *
700 * Parameter checking may look overzealous, but we really don't want
701 * the user to delete the wrong device.
702 */
703static ssize_t
704i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
705 const char *buf, size_t count)
706{
707 struct i2c_adapter *adap = to_i2c_adapter(dev);
708 struct i2c_client *client, *next;
709 unsigned short addr;
710 char end;
711 int res;
712
713 /* Parse parameters, reject extra parameters */
714 res = sscanf(buf, "%hi%c", &addr, &end);
715 if (res < 1) {
716 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
717 return -EINVAL;
718 }
719 if (res > 1 && end != '\n') {
720 dev_err(dev, "%s: Extra parameters\n", "delete_device");
721 return -EINVAL;
722 }
723
724 /* Make sure the device was added through sysfs */
725 res = -ENOENT;
Jean Delvaredafc50d2010-08-11 18:21:01 +0200726 mutex_lock(&adap->userspace_clients_lock);
Jean Delvare6629dcf2010-05-04 11:09:28 +0200727 list_for_each_entry_safe(client, next, &adap->userspace_clients,
728 detected) {
729 if (client->addr == addr) {
Jean Delvare99cd8e22009-06-19 16:58:20 +0200730 dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
731 "delete_device", client->name, client->addr);
732
733 list_del(&client->detected);
734 i2c_unregister_device(client);
735 res = count;
736 break;
737 }
738 }
Jean Delvaredafc50d2010-08-11 18:21:01 +0200739 mutex_unlock(&adap->userspace_clients_lock);
Jean Delvare99cd8e22009-06-19 16:58:20 +0200740
741 if (res < 0)
742 dev_err(dev, "%s: Can't find device in list\n",
743 "delete_device");
744 return res;
745}
746
Jean Delvare4f8cf822009-09-18 22:45:46 +0200747static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
748static DEVICE_ATTR(delete_device, S_IWUSR, NULL, i2c_sysfs_delete_device);
749
750static struct attribute *i2c_adapter_attrs[] = {
751 &dev_attr_name.attr,
752 &dev_attr_new_device.attr,
753 &dev_attr_delete_device.attr,
754 NULL
David Brownell16ffadf2007-05-01 23:26:28 +0200755};
756
Jean Delvare4f8cf822009-09-18 22:45:46 +0200757static struct attribute_group i2c_adapter_attr_group = {
758 .attrs = i2c_adapter_attrs,
759};
760
761static const struct attribute_group *i2c_adapter_attr_groups[] = {
762 &i2c_adapter_attr_group,
763 NULL
764};
765
Michael Lawnick08263742010-08-11 18:21:02 +0200766struct device_type i2c_adapter_type = {
Jean Delvare4f8cf822009-09-18 22:45:46 +0200767 .groups = i2c_adapter_attr_groups,
768 .release = i2c_adapter_dev_release,
David Brownell16ffadf2007-05-01 23:26:28 +0200769};
Michael Lawnick08263742010-08-11 18:21:02 +0200770EXPORT_SYMBOL_GPL(i2c_adapter_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771
Jean Delvare2bb50952009-09-18 22:45:46 +0200772#ifdef CONFIG_I2C_COMPAT
773static struct class_compat *i2c_adapter_compat_class;
774#endif
775
David Brownell9c1600e2007-05-01 23:26:31 +0200776static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
777{
778 struct i2c_devinfo *devinfo;
779
Rodolfo Giomettif18c41d2009-06-19 16:58:20 +0200780 down_read(&__i2c_board_lock);
David Brownell9c1600e2007-05-01 23:26:31 +0200781 list_for_each_entry(devinfo, &__i2c_board_list, list) {
782 if (devinfo->busnum == adapter->nr
783 && !i2c_new_device(adapter,
784 &devinfo->board_info))
Zhenwen Xu09b8ce02009-03-28 21:34:46 +0100785 dev_err(&adapter->dev,
786 "Can't create device at 0x%02x\n",
David Brownell9c1600e2007-05-01 23:26:31 +0200787 devinfo->board_info.addr);
788 }
Rodolfo Giomettif18c41d2009-06-19 16:58:20 +0200789 up_read(&__i2c_board_lock);
David Brownell9c1600e2007-05-01 23:26:31 +0200790}
791
Jean Delvare69b00892009-12-06 17:06:27 +0100792static int i2c_do_add_adapter(struct i2c_driver *driver,
793 struct i2c_adapter *adap)
Jean Delvare026526f2008-01-27 18:14:49 +0100794{
Jean Delvare4735c982008-07-14 22:38:36 +0200795 /* Detect supported devices on that bus, and instantiate them */
796 i2c_detect(adap, driver);
797
798 /* Let legacy drivers scan this bus for matching devices */
Jean Delvare026526f2008-01-27 18:14:49 +0100799 if (driver->attach_adapter) {
Jean Delvarefe6fc252011-03-20 14:50:53 +0100800 dev_warn(&adap->dev, "attach_adapter method is deprecated\n");
801 dev_warn(&adap->dev, "Please use another way to instantiate "
802 "your i2c_client\n");
Jean Delvare026526f2008-01-27 18:14:49 +0100803 /* We ignore the return code; if it fails, too bad */
804 driver->attach_adapter(adap);
805 }
806 return 0;
807}
808
Jean Delvare69b00892009-12-06 17:06:27 +0100809static int __process_new_adapter(struct device_driver *d, void *data)
810{
811 return i2c_do_add_adapter(to_i2c_driver(d), data);
812}
813
David Brownell6e13e642007-05-01 23:26:31 +0200814static int i2c_register_adapter(struct i2c_adapter *adap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815{
Jean Delvared6703282010-08-11 18:20:59 +0200816 int res = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817
David Brownell1d0b19c2008-10-14 17:30:05 +0200818 /* Can't register until after driver model init */
Jean Delvare35fc37f2009-06-19 16:58:19 +0200819 if (unlikely(WARN_ON(!i2c_bus_type.p))) {
820 res = -EAGAIN;
821 goto out_list;
822 }
David Brownell1d0b19c2008-10-14 17:30:05 +0200823
Jean Delvare2236baa2010-11-15 22:40:38 +0100824 /* Sanity checks */
825 if (unlikely(adap->name[0] == '\0')) {
826 pr_err("i2c-core: Attempt to register an adapter with "
827 "no name!\n");
828 return -EINVAL;
829 }
830 if (unlikely(!adap->algo)) {
831 pr_err("i2c-core: Attempt to register adapter '%s' with "
832 "no algo!\n", adap->name);
833 return -EINVAL;
834 }
835
Mika Kuoppala194684e2009-12-06 17:06:22 +0100836 rt_mutex_init(&adap->bus_lock);
Jean Delvaredafc50d2010-08-11 18:21:01 +0200837 mutex_init(&adap->userspace_clients_lock);
Jean Delvare6629dcf2010-05-04 11:09:28 +0200838 INIT_LIST_HEAD(&adap->userspace_clients);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839
Jean Delvare8fcfef62009-03-28 21:34:43 +0100840 /* Set default timeout to 1 second if not already set */
841 if (adap->timeout == 0)
842 adap->timeout = HZ;
843
Kay Sievers27d9c182009-01-07 14:29:16 +0100844 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
Jean Delvare4f8cf822009-09-18 22:45:46 +0200845 adap->dev.bus = &i2c_bus_type;
846 adap->dev.type = &i2c_adapter_type;
Jean Delvareb119c6c2006-08-15 18:26:30 +0200847 res = device_register(&adap->dev);
848 if (res)
849 goto out_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850
Jean Delvareb6d7b3d2005-07-31 19:02:53 +0200851 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
852
Jean Delvare2bb50952009-09-18 22:45:46 +0200853#ifdef CONFIG_I2C_COMPAT
854 res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
855 adap->dev.parent);
856 if (res)
857 dev_warn(&adap->dev,
858 "Failed to create compatibility class link\n");
859#endif
860
Jean Delvare729d6dd2009-06-19 16:58:18 +0200861 /* create pre-declared device nodes */
David Brownell6e13e642007-05-01 23:26:31 +0200862 if (adap->nr < __i2c_first_dynamic_bus_num)
863 i2c_scan_static_board_info(adap);
864
Jean Delvare4735c982008-07-14 22:38:36 +0200865 /* Notify drivers */
Jean Delvare35fc37f2009-06-19 16:58:19 +0200866 mutex_lock(&core_lock);
Jean Delvared6703282010-08-11 18:20:59 +0200867 bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
Jean Delvarecaada322008-01-27 18:14:49 +0100868 mutex_unlock(&core_lock);
Jean Delvare35fc37f2009-06-19 16:58:19 +0200869
870 return 0;
Jean Delvareb119c6c2006-08-15 18:26:30 +0200871
Jean Delvareb119c6c2006-08-15 18:26:30 +0200872out_list:
Jean Delvare35fc37f2009-06-19 16:58:19 +0200873 mutex_lock(&core_lock);
Jean Delvareb119c6c2006-08-15 18:26:30 +0200874 idr_remove(&i2c_adapter_idr, adap->nr);
Jean Delvare35fc37f2009-06-19 16:58:19 +0200875 mutex_unlock(&core_lock);
876 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877}
878
David Brownell6e13e642007-05-01 23:26:31 +0200879/**
880 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
881 * @adapter: the adapter to add
David Brownelld64f73b2007-07-12 14:12:28 +0200882 * Context: can sleep
David Brownell6e13e642007-05-01 23:26:31 +0200883 *
884 * This routine is used to declare an I2C adapter when its bus number
885 * doesn't matter. Examples: for I2C adapters dynamically added by
886 * USB links or PCI plugin cards.
887 *
888 * When this returns zero, a new bus number was allocated and stored
889 * in adap->nr, and the specified adapter became available for clients.
890 * Otherwise, a negative errno value is returned.
891 */
892int i2c_add_adapter(struct i2c_adapter *adapter)
893{
894 int id, res = 0;
895
896retry:
897 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
898 return -ENOMEM;
899
Jean Delvarecaada322008-01-27 18:14:49 +0100900 mutex_lock(&core_lock);
David Brownell6e13e642007-05-01 23:26:31 +0200901 /* "above" here means "above or equal to", sigh */
902 res = idr_get_new_above(&i2c_adapter_idr, adapter,
903 __i2c_first_dynamic_bus_num, &id);
Jean Delvarecaada322008-01-27 18:14:49 +0100904 mutex_unlock(&core_lock);
David Brownell6e13e642007-05-01 23:26:31 +0200905
906 if (res < 0) {
907 if (res == -EAGAIN)
908 goto retry;
909 return res;
910 }
911
912 adapter->nr = id;
913 return i2c_register_adapter(adapter);
914}
915EXPORT_SYMBOL(i2c_add_adapter);
916
917/**
918 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
919 * @adap: the adapter to register (with adap->nr initialized)
David Brownelld64f73b2007-07-12 14:12:28 +0200920 * Context: can sleep
David Brownell6e13e642007-05-01 23:26:31 +0200921 *
922 * This routine is used to declare an I2C adapter when its bus number
Randy Dunlap8c07e462008-03-23 20:28:20 +0100923 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
924 * or otherwise built in to the system's mainboard, and where i2c_board_info
David Brownell6e13e642007-05-01 23:26:31 +0200925 * is used to properly configure I2C devices.
926 *
927 * If no devices have pre-been declared for this bus, then be sure to
928 * register the adapter before any dynamically allocated ones. Otherwise
929 * the required bus ID may not be available.
930 *
931 * When this returns zero, the specified adapter became available for
932 * clients using the bus number provided in adap->nr. Also, the table
933 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
934 * and the appropriate driver model device nodes are created. Otherwise, a
935 * negative errno value is returned.
936 */
937int i2c_add_numbered_adapter(struct i2c_adapter *adap)
938{
939 int id;
940 int status;
941
942 if (adap->nr & ~MAX_ID_MASK)
943 return -EINVAL;
944
945retry:
946 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
947 return -ENOMEM;
948
Jean Delvarecaada322008-01-27 18:14:49 +0100949 mutex_lock(&core_lock);
David Brownell6e13e642007-05-01 23:26:31 +0200950 /* "above" here means "above or equal to", sigh;
951 * we need the "equal to" result to force the result
952 */
953 status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
954 if (status == 0 && id != adap->nr) {
955 status = -EBUSY;
956 idr_remove(&i2c_adapter_idr, id);
957 }
Jean Delvarecaada322008-01-27 18:14:49 +0100958 mutex_unlock(&core_lock);
David Brownell6e13e642007-05-01 23:26:31 +0200959 if (status == -EAGAIN)
960 goto retry;
961
962 if (status == 0)
963 status = i2c_register_adapter(adap);
964 return status;
965}
966EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
967
Jean Delvare69b00892009-12-06 17:06:27 +0100968static int i2c_do_del_adapter(struct i2c_driver *driver,
969 struct i2c_adapter *adapter)
Jean Delvare026526f2008-01-27 18:14:49 +0100970{
Jean Delvare4735c982008-07-14 22:38:36 +0200971 struct i2c_client *client, *_n;
Jean Delvare026526f2008-01-27 18:14:49 +0100972 int res;
973
Jean Delvareacec2112009-03-28 21:34:40 +0100974 /* Remove the devices we created ourselves as the result of hardware
975 * probing (using a driver's detect method) */
Jean Delvare4735c982008-07-14 22:38:36 +0200976 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
977 if (client->adapter == adapter) {
978 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
979 client->name, client->addr);
980 list_del(&client->detected);
981 i2c_unregister_device(client);
982 }
983 }
984
Jean Delvare026526f2008-01-27 18:14:49 +0100985 if (!driver->detach_adapter)
986 return 0;
Jean Delvarefe6fc252011-03-20 14:50:53 +0100987 dev_warn(&adapter->dev, "detach_adapter method is deprecated\n");
Jean Delvare026526f2008-01-27 18:14:49 +0100988 res = driver->detach_adapter(adapter);
989 if (res)
990 dev_err(&adapter->dev, "detach_adapter failed (%d) "
991 "for driver [%s]\n", res, driver->driver.name);
992 return res;
993}
994
Jean Delvaree549c2b2009-06-19 16:58:19 +0200995static int __unregister_client(struct device *dev, void *dummy)
996{
997 struct i2c_client *client = i2c_verify_client(dev);
Jean Delvare5219bf82011-01-14 22:03:49 +0100998 if (client && strcmp(client->name, "dummy"))
999 i2c_unregister_device(client);
1000 return 0;
1001}
1002
1003static int __unregister_dummy(struct device *dev, void *dummy)
1004{
1005 struct i2c_client *client = i2c_verify_client(dev);
Jean Delvaree549c2b2009-06-19 16:58:19 +02001006 if (client)
1007 i2c_unregister_device(client);
1008 return 0;
1009}
1010
Jean Delvare69b00892009-12-06 17:06:27 +01001011static int __process_removed_adapter(struct device_driver *d, void *data)
1012{
1013 return i2c_do_del_adapter(to_i2c_driver(d), data);
1014}
1015
David Brownelld64f73b2007-07-12 14:12:28 +02001016/**
1017 * i2c_del_adapter - unregister I2C adapter
1018 * @adap: the adapter being unregistered
1019 * Context: can sleep
1020 *
1021 * This unregisters an I2C adapter which was previously registered
1022 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
1023 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024int i2c_del_adapter(struct i2c_adapter *adap)
1025{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 int res = 0;
Jean Delvare35fc37f2009-06-19 16:58:19 +02001027 struct i2c_adapter *found;
Jean Delvarebbd2d9c2009-11-26 09:22:33 +01001028 struct i2c_client *client, *next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029
1030 /* First make sure that this adapter was ever added */
Jean Delvare35fc37f2009-06-19 16:58:19 +02001031 mutex_lock(&core_lock);
1032 found = idr_find(&i2c_adapter_idr, adap->nr);
1033 mutex_unlock(&core_lock);
1034 if (found != adap) {
Jean Delvareb6d7b3d2005-07-31 19:02:53 +02001035 pr_debug("i2c-core: attempting to delete unregistered "
1036 "adapter [%s]\n", adap->name);
Jean Delvare35fc37f2009-06-19 16:58:19 +02001037 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 }
1039
Jean Delvare026526f2008-01-27 18:14:49 +01001040 /* Tell drivers about this removal */
Jean Delvare35fc37f2009-06-19 16:58:19 +02001041 mutex_lock(&core_lock);
Jean Delvare026526f2008-01-27 18:14:49 +01001042 res = bus_for_each_drv(&i2c_bus_type, NULL, adap,
Jean Delvare69b00892009-12-06 17:06:27 +01001043 __process_removed_adapter);
Jean Delvare35fc37f2009-06-19 16:58:19 +02001044 mutex_unlock(&core_lock);
Jean Delvare026526f2008-01-27 18:14:49 +01001045 if (res)
Jean Delvare35fc37f2009-06-19 16:58:19 +02001046 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047
Jean Delvarebbd2d9c2009-11-26 09:22:33 +01001048 /* Remove devices instantiated from sysfs */
Jean Delvaredafc50d2010-08-11 18:21:01 +02001049 mutex_lock(&adap->userspace_clients_lock);
Jean Delvare6629dcf2010-05-04 11:09:28 +02001050 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1051 detected) {
1052 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
1053 client->addr);
1054 list_del(&client->detected);
1055 i2c_unregister_device(client);
Jean Delvarebbd2d9c2009-11-26 09:22:33 +01001056 }
Jean Delvaredafc50d2010-08-11 18:21:01 +02001057 mutex_unlock(&adap->userspace_clients_lock);
Jean Delvarebbd2d9c2009-11-26 09:22:33 +01001058
Jean Delvaree549c2b2009-06-19 16:58:19 +02001059 /* Detach any active clients. This can't fail, thus we do not
Jean Delvare5219bf82011-01-14 22:03:49 +01001060 * check the returned value. This is a two-pass process, because
1061 * we can't remove the dummy devices during the first pass: they
1062 * could have been instantiated by real devices wishing to clean
1063 * them up properly, so we give them a chance to do that first. */
Jean Delvaree549c2b2009-06-19 16:58:19 +02001064 res = device_for_each_child(&adap->dev, NULL, __unregister_client);
Jean Delvare5219bf82011-01-14 22:03:49 +01001065 res = device_for_each_child(&adap->dev, NULL, __unregister_dummy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066
Jean Delvare2bb50952009-09-18 22:45:46 +02001067#ifdef CONFIG_I2C_COMPAT
1068 class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
1069 adap->dev.parent);
1070#endif
1071
Thadeu Lima de Souza Cascardoc5567522010-01-16 20:43:13 +01001072 /* device name is gone after device_unregister */
1073 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
1074
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 /* clean up the sysfs representation */
1076 init_completion(&adap->dev_released);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 device_unregister(&adap->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078
1079 /* wait for sysfs to drop all references */
1080 wait_for_completion(&adap->dev_released);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081
David Brownell6e13e642007-05-01 23:26:31 +02001082 /* free bus id */
Jean Delvare35fc37f2009-06-19 16:58:19 +02001083 mutex_lock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084 idr_remove(&i2c_adapter_idr, adap->nr);
Jean Delvare35fc37f2009-06-19 16:58:19 +02001085 mutex_unlock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086
Jean Delvarebd4bc3db2008-07-16 19:30:05 +02001087 /* Clear the device structure in case this adapter is ever going to be
1088 added again */
1089 memset(&adap->dev, 0, sizeof(adap->dev));
1090
Jean Delvare35fc37f2009-06-19 16:58:19 +02001091 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092}
David Brownellc0564602007-05-01 23:26:31 +02001093EXPORT_SYMBOL(i2c_del_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094
1095
David Brownell7b4fbc52007-05-01 23:26:30 +02001096/* ------------------------------------------------------------------------- */
1097
Jean Delvare7ae31482011-03-20 14:50:52 +01001098int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
1099{
1100 int res;
1101
1102 mutex_lock(&core_lock);
1103 res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
1104 mutex_unlock(&core_lock);
1105
1106 return res;
1107}
1108EXPORT_SYMBOL_GPL(i2c_for_each_dev);
1109
Jean Delvare69b00892009-12-06 17:06:27 +01001110static int __process_new_driver(struct device *dev, void *data)
Dave Young7f101a92008-07-14 22:38:19 +02001111{
Jean Delvare4f8cf822009-09-18 22:45:46 +02001112 if (dev->type != &i2c_adapter_type)
1113 return 0;
Jean Delvare69b00892009-12-06 17:06:27 +01001114 return i2c_do_add_adapter(data, to_i2c_adapter(dev));
Dave Young7f101a92008-07-14 22:38:19 +02001115}
1116
David Brownell7b4fbc52007-05-01 23:26:30 +02001117/*
1118 * An i2c_driver is used with one or more i2c_client (device) nodes to access
Jean Delvare729d6dd2009-06-19 16:58:18 +02001119 * i2c slave chips, on a bus instance associated with some i2c_adapter.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120 */
1121
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -08001122int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123{
Jean Delvare7eebcb72006-02-05 23:28:21 +01001124 int res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125
David Brownell1d0b19c2008-10-14 17:30:05 +02001126 /* Can't register until after driver model init */
1127 if (unlikely(WARN_ON(!i2c_bus_type.p)))
1128 return -EAGAIN;
1129
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 /* add the driver to the list of i2c drivers in the driver core */
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -08001131 driver->driver.owner = owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 driver->driver.bus = &i2c_bus_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133
Jean Delvare729d6dd2009-06-19 16:58:18 +02001134 /* When registration returns, the driver core
David Brownell6e13e642007-05-01 23:26:31 +02001135 * will have called probe() for all matching-but-unbound devices.
1136 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 res = driver_register(&driver->driver);
1138 if (res)
Jean Delvare7eebcb72006-02-05 23:28:21 +01001139 return res;
David Brownell438d6c22006-12-10 21:21:31 +01001140
Mark Brownf4e8db32011-01-14 22:03:50 +01001141 /* Drivers should switch to dev_pm_ops instead. */
1142 if (driver->suspend)
1143 pr_warn("i2c-core: driver [%s] using legacy suspend method\n",
1144 driver->driver.name);
1145 if (driver->resume)
1146 pr_warn("i2c-core: driver [%s] using legacy resume method\n",
1147 driver->driver.name);
1148
Laurent Riffard35d8b2e2005-11-26 20:34:05 +01001149 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150
Jean Delvare4735c982008-07-14 22:38:36 +02001151 INIT_LIST_HEAD(&driver->clients);
1152 /* Walk the adapters that are already present */
Jean Delvare7ae31482011-03-20 14:50:52 +01001153 i2c_for_each_dev(driver, __process_new_driver);
Jean Delvare35fc37f2009-06-19 16:58:19 +02001154
Jean Delvare7eebcb72006-02-05 23:28:21 +01001155 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156}
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -08001157EXPORT_SYMBOL(i2c_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158
Jean Delvare69b00892009-12-06 17:06:27 +01001159static int __process_removed_driver(struct device *dev, void *data)
Dave Young7f101a92008-07-14 22:38:19 +02001160{
Jean Delvare4f8cf822009-09-18 22:45:46 +02001161 if (dev->type != &i2c_adapter_type)
1162 return 0;
Jean Delvare69b00892009-12-06 17:06:27 +01001163 return i2c_do_del_adapter(data, to_i2c_adapter(dev));
Dave Young7f101a92008-07-14 22:38:19 +02001164}
1165
David Brownella1d9e6e2007-05-01 23:26:30 +02001166/**
1167 * i2c_del_driver - unregister I2C driver
1168 * @driver: the driver being unregistered
David Brownelld64f73b2007-07-12 14:12:28 +02001169 * Context: can sleep
David Brownella1d9e6e2007-05-01 23:26:30 +02001170 */
Jean Delvareb3e82092007-05-01 23:26:32 +02001171void i2c_del_driver(struct i2c_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172{
Jean Delvare7ae31482011-03-20 14:50:52 +01001173 i2c_for_each_dev(driver, __process_removed_driver);
David Brownella1d9e6e2007-05-01 23:26:30 +02001174
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175 driver_unregister(&driver->driver);
Laurent Riffard35d8b2e2005-11-26 20:34:05 +01001176 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177}
David Brownellc0564602007-05-01 23:26:31 +02001178EXPORT_SYMBOL(i2c_del_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179
David Brownell7b4fbc52007-05-01 23:26:30 +02001180/* ------------------------------------------------------------------------- */
1181
Jean Delvaree48d3312008-01-27 18:14:48 +01001182/**
1183 * i2c_use_client - increments the reference count of the i2c client structure
1184 * @client: the client being referenced
1185 *
1186 * Each live reference to a client should be refcounted. The driver model does
1187 * that automatically as part of driver binding, so that most drivers don't
1188 * need to do this explicitly: they hold a reference until they're unbound
1189 * from the device.
1190 *
1191 * A pointer to the client with the incremented reference counter is returned.
1192 */
1193struct i2c_client *i2c_use_client(struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194{
David Brownell6ea438e2008-07-14 22:38:24 +02001195 if (client && get_device(&client->dev))
1196 return client;
1197 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198}
David Brownellc0564602007-05-01 23:26:31 +02001199EXPORT_SYMBOL(i2c_use_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200
Jean Delvaree48d3312008-01-27 18:14:48 +01001201/**
1202 * i2c_release_client - release a use of the i2c client structure
1203 * @client: the client being no longer referenced
1204 *
1205 * Must be called when a user of a client is finished with it.
1206 */
1207void i2c_release_client(struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208{
David Brownell6ea438e2008-07-14 22:38:24 +02001209 if (client)
1210 put_device(&client->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211}
David Brownellc0564602007-05-01 23:26:31 +02001212EXPORT_SYMBOL(i2c_release_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213
David Brownell9b766b82008-01-27 18:14:51 +01001214struct i2c_cmd_arg {
1215 unsigned cmd;
1216 void *arg;
1217};
1218
1219static int i2c_cmd(struct device *dev, void *_arg)
1220{
1221 struct i2c_client *client = i2c_verify_client(dev);
1222 struct i2c_cmd_arg *arg = _arg;
1223
1224 if (client && client->driver && client->driver->command)
1225 client->driver->command(client, arg->cmd, arg->arg);
1226 return 0;
1227}
1228
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
1230{
David Brownell9b766b82008-01-27 18:14:51 +01001231 struct i2c_cmd_arg cmd_arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232
David Brownell9b766b82008-01-27 18:14:51 +01001233 cmd_arg.cmd = cmd;
1234 cmd_arg.arg = arg;
1235 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236}
David Brownellc0564602007-05-01 23:26:31 +02001237EXPORT_SYMBOL(i2c_clients_command);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238
1239static int __init i2c_init(void)
1240{
1241 int retval;
1242
1243 retval = bus_register(&i2c_bus_type);
1244 if (retval)
1245 return retval;
Jean Delvare2bb50952009-09-18 22:45:46 +02001246#ifdef CONFIG_I2C_COMPAT
1247 i2c_adapter_compat_class = class_compat_register("i2c-adapter");
1248 if (!i2c_adapter_compat_class) {
1249 retval = -ENOMEM;
1250 goto bus_err;
1251 }
1252#endif
David Brownelle9f13732008-01-27 18:14:52 +01001253 retval = i2c_add_driver(&dummy_driver);
1254 if (retval)
Jean Delvare2bb50952009-09-18 22:45:46 +02001255 goto class_err;
David Brownelle9f13732008-01-27 18:14:52 +01001256 return 0;
1257
Jean Delvare2bb50952009-09-18 22:45:46 +02001258class_err:
1259#ifdef CONFIG_I2C_COMPAT
1260 class_compat_unregister(i2c_adapter_compat_class);
David Brownelle9f13732008-01-27 18:14:52 +01001261bus_err:
Jean Delvare2bb50952009-09-18 22:45:46 +02001262#endif
David Brownelle9f13732008-01-27 18:14:52 +01001263 bus_unregister(&i2c_bus_type);
1264 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265}
1266
1267static void __exit i2c_exit(void)
1268{
David Brownelle9f13732008-01-27 18:14:52 +01001269 i2c_del_driver(&dummy_driver);
Jean Delvare2bb50952009-09-18 22:45:46 +02001270#ifdef CONFIG_I2C_COMPAT
1271 class_compat_unregister(i2c_adapter_compat_class);
1272#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273 bus_unregister(&i2c_bus_type);
1274}
1275
David Brownella10f9e72008-10-14 17:30:06 +02001276/* We must initialize early, because some subsystems register i2c drivers
1277 * in subsys_initcall() code, but are linked (and initialized) before i2c.
1278 */
1279postcore_initcall(i2c_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280module_exit(i2c_exit);
1281
1282/* ----------------------------------------------------
1283 * the functional interface to the i2c busses.
1284 * ----------------------------------------------------
1285 */
1286
David Brownella1cdeda2008-07-14 22:38:24 +02001287/**
1288 * i2c_transfer - execute a single or combined I2C message
1289 * @adap: Handle to I2C bus
1290 * @msgs: One or more messages to execute before STOP is issued to
1291 * terminate the operation; each message begins with a START.
1292 * @num: Number of messages to be executed.
1293 *
1294 * Returns negative errno, else the number of messages executed.
1295 *
1296 * Note that there is no requirement that each message be sent to
1297 * the same slave address, although that is the most common model.
1298 */
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01001299int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300{
Clifford Wolf66b650f2009-06-15 18:01:46 +02001301 unsigned long orig_jiffies;
1302 int ret, try;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303
David Brownella1cdeda2008-07-14 22:38:24 +02001304 /* REVISIT the fault reporting model here is weak:
1305 *
1306 * - When we get an error after receiving N bytes from a slave,
1307 * there is no way to report "N".
1308 *
1309 * - When we get a NAK after transmitting N bytes to a slave,
1310 * there is no way to report "N" ... or to let the master
1311 * continue executing the rest of this combined message, if
1312 * that's the appropriate response.
1313 *
1314 * - When for example "num" is two and we successfully complete
1315 * the first message but get an error part way through the
1316 * second, it's unclear whether that should be reported as
1317 * one (discarding status on the second message) or errno
1318 * (discarding status on the first one).
1319 */
1320
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 if (adap->algo->master_xfer) {
1322#ifdef DEBUG
1323 for (ret = 0; ret < num; ret++) {
1324 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
Jean Delvare209d27c2007-05-01 23:26:29 +02001325 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
1326 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
1327 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328 }
1329#endif
1330
Mike Rapoportcea443a2008-01-27 18:14:50 +01001331 if (in_atomic() || irqs_disabled()) {
Jean Delvarefe61e072010-08-11 18:20:58 +02001332 ret = i2c_trylock_adapter(adap);
Mike Rapoportcea443a2008-01-27 18:14:50 +01001333 if (!ret)
1334 /* I2C activity is ongoing. */
1335 return -EAGAIN;
1336 } else {
Jean Delvarefe61e072010-08-11 18:20:58 +02001337 i2c_lock_adapter(adap);
Mike Rapoportcea443a2008-01-27 18:14:50 +01001338 }
1339
Clifford Wolf66b650f2009-06-15 18:01:46 +02001340 /* Retry automatically on arbitration loss */
1341 orig_jiffies = jiffies;
1342 for (ret = 0, try = 0; try <= adap->retries; try++) {
1343 ret = adap->algo->master_xfer(adap, msgs, num);
1344 if (ret != -EAGAIN)
1345 break;
1346 if (time_after(jiffies, orig_jiffies + adap->timeout))
1347 break;
1348 }
Jean Delvarefe61e072010-08-11 18:20:58 +02001349 i2c_unlock_adapter(adap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350
1351 return ret;
1352 } else {
1353 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
David Brownell24a5bb72008-07-14 22:38:23 +02001354 return -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 }
1356}
David Brownellc0564602007-05-01 23:26:31 +02001357EXPORT_SYMBOL(i2c_transfer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358
David Brownella1cdeda2008-07-14 22:38:24 +02001359/**
1360 * i2c_master_send - issue a single I2C message in master transmit mode
1361 * @client: Handle to slave device
1362 * @buf: Data that will be written to the slave
Zhangfei Gao0c43ea52010-03-02 12:23:49 +01001363 * @count: How many bytes to write, must be less than 64k since msg.len is u16
David Brownella1cdeda2008-07-14 22:38:24 +02001364 *
1365 * Returns negative errno, or else the number of bytes written.
1366 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01001367int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368{
1369 int ret;
Farid Hammane7225acf2010-05-21 18:40:58 +02001370 struct i2c_adapter *adap = client->adapter;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371 struct i2c_msg msg;
1372
Jean Delvare815f55f2005-05-07 22:58:46 +02001373 msg.addr = client->addr;
1374 msg.flags = client->flags & I2C_M_TEN;
1375 msg.len = count;
1376 msg.buf = (char *)buf;
David Brownell438d6c22006-12-10 21:21:31 +01001377
Jean Delvare815f55f2005-05-07 22:58:46 +02001378 ret = i2c_transfer(adap, &msg, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379
Jean Delvare815f55f2005-05-07 22:58:46 +02001380 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1381 transmitted, else error code. */
1382 return (ret == 1) ? count : ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383}
David Brownellc0564602007-05-01 23:26:31 +02001384EXPORT_SYMBOL(i2c_master_send);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385
David Brownella1cdeda2008-07-14 22:38:24 +02001386/**
1387 * i2c_master_recv - issue a single I2C message in master receive mode
1388 * @client: Handle to slave device
1389 * @buf: Where to store data read from slave
Zhangfei Gao0c43ea52010-03-02 12:23:49 +01001390 * @count: How many bytes to read, must be less than 64k since msg.len is u16
David Brownella1cdeda2008-07-14 22:38:24 +02001391 *
1392 * Returns negative errno, or else the number of bytes read.
1393 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01001394int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395{
Farid Hammane7225acf2010-05-21 18:40:58 +02001396 struct i2c_adapter *adap = client->adapter;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397 struct i2c_msg msg;
1398 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399
Jean Delvare815f55f2005-05-07 22:58:46 +02001400 msg.addr = client->addr;
1401 msg.flags = client->flags & I2C_M_TEN;
1402 msg.flags |= I2C_M_RD;
1403 msg.len = count;
1404 msg.buf = buf;
1405
1406 ret = i2c_transfer(adap, &msg, 1);
1407
1408 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1409 transmitted, else error code. */
1410 return (ret == 1) ? count : ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411}
David Brownellc0564602007-05-01 23:26:31 +02001412EXPORT_SYMBOL(i2c_master_recv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414/* ----------------------------------------------------
1415 * the i2c address scanning function
1416 * Will not work for 10-bit addresses!
1417 * ----------------------------------------------------
1418 */
Jean Delvare9fc6adf2005-07-31 21:20:43 +02001419
Jean Delvare63e4e802010-06-03 11:33:51 +02001420/*
1421 * Legacy default probe function, mostly relevant for SMBus. The default
1422 * probe method is a quick write, but it is known to corrupt the 24RF08
1423 * EEPROMs due to a state machine bug, and could also irreversibly
1424 * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
1425 * we use a short byte read instead. Also, some bus drivers don't implement
1426 * quick write, so we fallback to a byte read in that case too.
1427 * On x86, there is another special case for FSC hardware monitoring chips,
1428 * which want regular byte reads (address 0x73.) Fortunately, these are the
1429 * only known chips using this I2C address on PC hardware.
1430 * Returns 1 if probe succeeded, 0 if not.
1431 */
1432static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
1433{
1434 int err;
1435 union i2c_smbus_data dummy;
1436
1437#ifdef CONFIG_X86
1438 if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
1439 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
1440 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1441 I2C_SMBUS_BYTE_DATA, &dummy);
1442 else
1443#endif
Jean Delvare8031d792010-08-11 18:21:00 +02001444 if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
1445 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
Jean Delvare63e4e802010-06-03 11:33:51 +02001446 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
1447 I2C_SMBUS_QUICK, NULL);
Jean Delvare8031d792010-08-11 18:21:00 +02001448 else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
1449 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1450 I2C_SMBUS_BYTE, &dummy);
1451 else {
1452 dev_warn(&adap->dev, "No suitable probing method supported\n");
1453 err = -EOPNOTSUPP;
1454 }
Jean Delvare63e4e802010-06-03 11:33:51 +02001455
1456 return err >= 0;
1457}
1458
Jean Delvareccfbbd02009-12-06 17:06:25 +01001459static int i2c_detect_address(struct i2c_client *temp_client,
Jean Delvare4735c982008-07-14 22:38:36 +02001460 struct i2c_driver *driver)
1461{
1462 struct i2c_board_info info;
1463 struct i2c_adapter *adapter = temp_client->adapter;
1464 int addr = temp_client->addr;
1465 int err;
1466
1467 /* Make sure the address is valid */
Jean Delvare656b8762010-06-03 11:33:53 +02001468 err = i2c_check_addr_validity(addr);
1469 if (err) {
Jean Delvare4735c982008-07-14 22:38:36 +02001470 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1471 addr);
Jean Delvare656b8762010-06-03 11:33:53 +02001472 return err;
Jean Delvare4735c982008-07-14 22:38:36 +02001473 }
1474
1475 /* Skip if already in use */
Jean Delvare3b5f7942010-06-03 11:33:55 +02001476 if (i2c_check_addr_busy(adapter, addr))
Jean Delvare4735c982008-07-14 22:38:36 +02001477 return 0;
1478
Jean Delvareccfbbd02009-12-06 17:06:25 +01001479 /* Make sure there is something at this address */
Jean Delvare63e4e802010-06-03 11:33:51 +02001480 if (!i2c_default_probe(adapter, addr))
1481 return 0;
Jean Delvare4735c982008-07-14 22:38:36 +02001482
1483 /* Finally call the custom detection function */
1484 memset(&info, 0, sizeof(struct i2c_board_info));
1485 info.addr = addr;
Jean Delvare310ec792009-12-14 21:17:23 +01001486 err = driver->detect(temp_client, &info);
Jean Delvare4735c982008-07-14 22:38:36 +02001487 if (err) {
1488 /* -ENODEV is returned if the detection fails. We catch it
1489 here as this isn't an error. */
1490 return err == -ENODEV ? 0 : err;
1491 }
1492
1493 /* Consistency check */
1494 if (info.type[0] == '\0') {
1495 dev_err(&adapter->dev, "%s detection function provided "
1496 "no name for 0x%x\n", driver->driver.name,
1497 addr);
1498 } else {
1499 struct i2c_client *client;
1500
1501 /* Detection succeeded, instantiate the device */
1502 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
1503 info.type, info.addr);
1504 client = i2c_new_device(adapter, &info);
1505 if (client)
1506 list_add_tail(&client->detected, &driver->clients);
1507 else
1508 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
1509 info.type, info.addr);
1510 }
1511 return 0;
1512}
1513
1514static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
1515{
Jean Delvarec3813d62009-12-14 21:17:25 +01001516 const unsigned short *address_list;
Jean Delvare4735c982008-07-14 22:38:36 +02001517 struct i2c_client *temp_client;
1518 int i, err = 0;
1519 int adap_id = i2c_adapter_id(adapter);
1520
Jean Delvarec3813d62009-12-14 21:17:25 +01001521 address_list = driver->address_list;
1522 if (!driver->detect || !address_list)
Jean Delvare4735c982008-07-14 22:38:36 +02001523 return 0;
1524
Jean Delvare51b54ba2010-10-24 18:16:58 +02001525 /* Stop here if the classes do not match */
1526 if (!(adapter->class & driver->class))
1527 return 0;
1528
Jean Delvare4735c982008-07-14 22:38:36 +02001529 /* Set up a temporary client to help detect callback */
1530 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
1531 if (!temp_client)
1532 return -ENOMEM;
1533 temp_client->adapter = adapter;
1534
Jean Delvarec3813d62009-12-14 21:17:25 +01001535 for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
Jean Delvare4735c982008-07-14 22:38:36 +02001536 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
Jean Delvarec3813d62009-12-14 21:17:25 +01001537 "addr 0x%02x\n", adap_id, address_list[i]);
1538 temp_client->addr = address_list[i];
Jean Delvareccfbbd02009-12-06 17:06:25 +01001539 err = i2c_detect_address(temp_client, driver);
Jean Delvare51b54ba2010-10-24 18:16:58 +02001540 if (unlikely(err))
1541 break;
Jean Delvare4735c982008-07-14 22:38:36 +02001542 }
1543
Jean Delvare4735c982008-07-14 22:38:36 +02001544 kfree(temp_client);
1545 return err;
1546}
1547
Jean Delvared44f19d2010-08-11 18:20:57 +02001548int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
1549{
1550 return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1551 I2C_SMBUS_QUICK, NULL) >= 0;
1552}
1553EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
1554
Jean Delvare12b5053a2007-05-01 23:26:31 +02001555struct i2c_client *
1556i2c_new_probed_device(struct i2c_adapter *adap,
1557 struct i2c_board_info *info,
Jean Delvare9a942412010-08-11 18:20:56 +02001558 unsigned short const *addr_list,
1559 int (*probe)(struct i2c_adapter *, unsigned short addr))
Jean Delvare12b5053a2007-05-01 23:26:31 +02001560{
1561 int i;
1562
Jean Delvare8031d792010-08-11 18:21:00 +02001563 if (!probe)
Jean Delvare9a942412010-08-11 18:20:56 +02001564 probe = i2c_default_probe;
Jean Delvare12b5053a2007-05-01 23:26:31 +02001565
Jean Delvare12b5053a2007-05-01 23:26:31 +02001566 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1567 /* Check address validity */
Jean Delvare656b8762010-06-03 11:33:53 +02001568 if (i2c_check_addr_validity(addr_list[i]) < 0) {
Jean Delvare12b5053a2007-05-01 23:26:31 +02001569 dev_warn(&adap->dev, "Invalid 7-bit address "
1570 "0x%02x\n", addr_list[i]);
1571 continue;
1572 }
1573
1574 /* Check address availability */
Jean Delvare3b5f7942010-06-03 11:33:55 +02001575 if (i2c_check_addr_busy(adap, addr_list[i])) {
Jean Delvare12b5053a2007-05-01 23:26:31 +02001576 dev_dbg(&adap->dev, "Address 0x%02x already in "
1577 "use, not probing\n", addr_list[i]);
1578 continue;
1579 }
1580
Jean Delvare63e4e802010-06-03 11:33:51 +02001581 /* Test address responsiveness */
Jean Delvare9a942412010-08-11 18:20:56 +02001582 if (probe(adap, addr_list[i]))
Jean Delvare63e4e802010-06-03 11:33:51 +02001583 break;
Jean Delvare12b5053a2007-05-01 23:26:31 +02001584 }
Jean Delvare12b5053a2007-05-01 23:26:31 +02001585
1586 if (addr_list[i] == I2C_CLIENT_END) {
1587 dev_dbg(&adap->dev, "Probing failed, no device found\n");
1588 return NULL;
1589 }
1590
1591 info->addr = addr_list[i];
1592 return i2c_new_device(adap, info);
1593}
1594EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1595
Jean Delvared735b342011-03-20 14:50:52 +01001596struct i2c_adapter *i2c_get_adapter(int nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598 struct i2c_adapter *adapter;
David Brownell438d6c22006-12-10 21:21:31 +01001599
Jean Delvarecaada322008-01-27 18:14:49 +01001600 mutex_lock(&core_lock);
Jean Delvared735b342011-03-20 14:50:52 +01001601 adapter = idr_find(&i2c_adapter_idr, nr);
Mark M. Hoffmana0920e12005-06-28 00:21:30 -04001602 if (adapter && !try_module_get(adapter->owner))
1603 adapter = NULL;
1604
Jean Delvarecaada322008-01-27 18:14:49 +01001605 mutex_unlock(&core_lock);
Mark M. Hoffmana0920e12005-06-28 00:21:30 -04001606 return adapter;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607}
David Brownellc0564602007-05-01 23:26:31 +02001608EXPORT_SYMBOL(i2c_get_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609
1610void i2c_put_adapter(struct i2c_adapter *adap)
1611{
1612 module_put(adap->owner);
1613}
David Brownellc0564602007-05-01 23:26:31 +02001614EXPORT_SYMBOL(i2c_put_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615
1616/* The SMBus parts */
1617
David Brownell438d6c22006-12-10 21:21:31 +01001618#define POLY (0x1070U << 3)
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01001619static u8 crc8(u16 data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620{
1621 int i;
David Brownell438d6c22006-12-10 21:21:31 +01001622
Farid Hammane7225acf2010-05-21 18:40:58 +02001623 for (i = 0; i < 8; i++) {
David Brownell438d6c22006-12-10 21:21:31 +01001624 if (data & 0x8000)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625 data = data ^ POLY;
1626 data = data << 1;
1627 }
1628 return (u8)(data >> 8);
1629}
1630
Jean Delvare421ef472005-10-26 21:28:55 +02001631/* Incremental CRC8 over count bytes in the array pointed to by p */
1632static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633{
1634 int i;
1635
Farid Hammane7225acf2010-05-21 18:40:58 +02001636 for (i = 0; i < count; i++)
Jean Delvare421ef472005-10-26 21:28:55 +02001637 crc = crc8((crc ^ p[i]) << 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638 return crc;
1639}
1640
Jean Delvare421ef472005-10-26 21:28:55 +02001641/* Assume a 7-bit address, which is reasonable for SMBus */
1642static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643{
Jean Delvare421ef472005-10-26 21:28:55 +02001644 /* The address will be sent first */
1645 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1646 pec = i2c_smbus_pec(pec, &addr, 1);
1647
1648 /* The data buffer follows */
1649 return i2c_smbus_pec(pec, msg->buf, msg->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650}
1651
Jean Delvare421ef472005-10-26 21:28:55 +02001652/* Used for write only transactions */
1653static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654{
Jean Delvare421ef472005-10-26 21:28:55 +02001655 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1656 msg->len++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657}
1658
Jean Delvare421ef472005-10-26 21:28:55 +02001659/* Return <0 on CRC error
1660 If there was a write before this read (most cases) we need to take the
1661 partial CRC from the write part into account.
1662 Note that this function does modify the message (we need to decrease the
1663 message length to hide the CRC byte from the caller). */
1664static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665{
Jean Delvare421ef472005-10-26 21:28:55 +02001666 u8 rpec = msg->buf[--msg->len];
1667 cpec = i2c_smbus_msg_pec(cpec, msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669 if (rpec != cpec) {
1670 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1671 rpec, cpec);
David Brownell24a5bb72008-07-14 22:38:23 +02001672 return -EBADMSG;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673 }
David Brownell438d6c22006-12-10 21:21:31 +01001674 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675}
1676
David Brownella1cdeda2008-07-14 22:38:24 +02001677/**
1678 * i2c_smbus_read_byte - SMBus "receive byte" protocol
1679 * @client: Handle to slave device
1680 *
1681 * This executes the SMBus "receive byte" protocol, returning negative errno
1682 * else the byte received from the device.
1683 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01001684s32 i2c_smbus_read_byte(const struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685{
1686 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02001687 int status;
1688
1689 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1690 I2C_SMBUS_READ, 0,
1691 I2C_SMBUS_BYTE, &data);
1692 return (status < 0) ? status : data.byte;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693}
David Brownellc0564602007-05-01 23:26:31 +02001694EXPORT_SYMBOL(i2c_smbus_read_byte);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695
David Brownella1cdeda2008-07-14 22:38:24 +02001696/**
1697 * i2c_smbus_write_byte - SMBus "send byte" protocol
1698 * @client: Handle to slave device
1699 * @value: Byte to be sent
1700 *
1701 * This executes the SMBus "send byte" protocol, returning negative errno
1702 * else zero on success.
1703 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01001704s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705{
Farid Hammane7225acf2010-05-21 18:40:58 +02001706 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
Jean Delvare421ef472005-10-26 21:28:55 +02001707 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001708}
David Brownellc0564602007-05-01 23:26:31 +02001709EXPORT_SYMBOL(i2c_smbus_write_byte);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001710
David Brownella1cdeda2008-07-14 22:38:24 +02001711/**
1712 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
1713 * @client: Handle to slave device
1714 * @command: Byte interpreted by slave
1715 *
1716 * This executes the SMBus "read byte" protocol, returning negative errno
1717 * else a data byte received from the device.
1718 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01001719s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720{
1721 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02001722 int status;
1723
1724 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1725 I2C_SMBUS_READ, command,
1726 I2C_SMBUS_BYTE_DATA, &data);
1727 return (status < 0) ? status : data.byte;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728}
David Brownellc0564602007-05-01 23:26:31 +02001729EXPORT_SYMBOL(i2c_smbus_read_byte_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730
David Brownella1cdeda2008-07-14 22:38:24 +02001731/**
1732 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
1733 * @client: Handle to slave device
1734 * @command: Byte interpreted by slave
1735 * @value: Byte being written
1736 *
1737 * This executes the SMBus "write byte" protocol, returning negative errno
1738 * else zero on success.
1739 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01001740s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
1741 u8 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742{
1743 union i2c_smbus_data data;
1744 data.byte = value;
Farid Hammane7225acf2010-05-21 18:40:58 +02001745 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1746 I2C_SMBUS_WRITE, command,
1747 I2C_SMBUS_BYTE_DATA, &data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748}
David Brownellc0564602007-05-01 23:26:31 +02001749EXPORT_SYMBOL(i2c_smbus_write_byte_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750
David Brownella1cdeda2008-07-14 22:38:24 +02001751/**
1752 * i2c_smbus_read_word_data - SMBus "read word" protocol
1753 * @client: Handle to slave device
1754 * @command: Byte interpreted by slave
1755 *
1756 * This executes the SMBus "read word" protocol, returning negative errno
1757 * else a 16-bit unsigned "word" received from the device.
1758 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01001759s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760{
1761 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02001762 int status;
1763
1764 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1765 I2C_SMBUS_READ, command,
1766 I2C_SMBUS_WORD_DATA, &data);
1767 return (status < 0) ? status : data.word;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768}
David Brownellc0564602007-05-01 23:26:31 +02001769EXPORT_SYMBOL(i2c_smbus_read_word_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770
David Brownella1cdeda2008-07-14 22:38:24 +02001771/**
1772 * i2c_smbus_write_word_data - SMBus "write word" protocol
1773 * @client: Handle to slave device
1774 * @command: Byte interpreted by slave
1775 * @value: 16-bit "word" being written
1776 *
1777 * This executes the SMBus "write word" protocol, returning negative errno
1778 * else zero on success.
1779 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01001780s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
1781 u16 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782{
1783 union i2c_smbus_data data;
1784 data.word = value;
Farid Hammane7225acf2010-05-21 18:40:58 +02001785 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1786 I2C_SMBUS_WRITE, command,
1787 I2C_SMBUS_WORD_DATA, &data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788}
David Brownellc0564602007-05-01 23:26:31 +02001789EXPORT_SYMBOL(i2c_smbus_write_word_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790
David Brownella64ec072007-10-13 23:56:31 +02001791/**
Prakash Mortha596c88f2008-10-14 17:30:06 +02001792 * i2c_smbus_process_call - SMBus "process call" protocol
1793 * @client: Handle to slave device
1794 * @command: Byte interpreted by slave
1795 * @value: 16-bit "word" being written
1796 *
1797 * This executes the SMBus "process call" protocol, returning negative errno
1798 * else a 16-bit unsigned "word" received from the device.
1799 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01001800s32 i2c_smbus_process_call(const struct i2c_client *client, u8 command,
1801 u16 value)
Prakash Mortha596c88f2008-10-14 17:30:06 +02001802{
1803 union i2c_smbus_data data;
1804 int status;
1805 data.word = value;
1806
1807 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1808 I2C_SMBUS_WRITE, command,
1809 I2C_SMBUS_PROC_CALL, &data);
1810 return (status < 0) ? status : data.word;
1811}
1812EXPORT_SYMBOL(i2c_smbus_process_call);
1813
1814/**
David Brownella1cdeda2008-07-14 22:38:24 +02001815 * i2c_smbus_read_block_data - SMBus "block read" protocol
David Brownella64ec072007-10-13 23:56:31 +02001816 * @client: Handle to slave device
David Brownella1cdeda2008-07-14 22:38:24 +02001817 * @command: Byte interpreted by slave
David Brownella64ec072007-10-13 23:56:31 +02001818 * @values: Byte array into which data will be read; big enough to hold
1819 * the data returned by the slave. SMBus allows at most 32 bytes.
1820 *
David Brownella1cdeda2008-07-14 22:38:24 +02001821 * This executes the SMBus "block read" protocol, returning negative errno
1822 * else the number of data bytes in the slave's response.
David Brownella64ec072007-10-13 23:56:31 +02001823 *
1824 * Note that using this function requires that the client's adapter support
1825 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
1826 * support this; its emulation through I2C messaging relies on a specific
1827 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
1828 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01001829s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
Jean Delvareb86a1bc2007-05-01 23:26:34 +02001830 u8 *values)
1831{
1832 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02001833 int status;
Jean Delvareb86a1bc2007-05-01 23:26:34 +02001834
David Brownell24a5bb72008-07-14 22:38:23 +02001835 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1836 I2C_SMBUS_READ, command,
1837 I2C_SMBUS_BLOCK_DATA, &data);
1838 if (status)
1839 return status;
Jean Delvareb86a1bc2007-05-01 23:26:34 +02001840
1841 memcpy(values, &data.block[1], data.block[0]);
1842 return data.block[0];
1843}
1844EXPORT_SYMBOL(i2c_smbus_read_block_data);
1845
David Brownella1cdeda2008-07-14 22:38:24 +02001846/**
1847 * i2c_smbus_write_block_data - SMBus "block write" protocol
1848 * @client: Handle to slave device
1849 * @command: Byte interpreted by slave
1850 * @length: Size of data block; SMBus allows at most 32 bytes
1851 * @values: Byte array which will be written.
1852 *
1853 * This executes the SMBus "block write" protocol, returning negative errno
1854 * else zero on success.
1855 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01001856s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
Krzysztof Halasa46f5ed72006-06-12 21:42:20 +02001857 u8 length, const u8 *values)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001858{
1859 union i2c_smbus_data data;
Jean Delvare76560322006-01-18 23:14:55 +01001860
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861 if (length > I2C_SMBUS_BLOCK_MAX)
1862 length = I2C_SMBUS_BLOCK_MAX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001863 data.block[0] = length;
Jean Delvare76560322006-01-18 23:14:55 +01001864 memcpy(&data.block[1], values, length);
Farid Hammane7225acf2010-05-21 18:40:58 +02001865 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1866 I2C_SMBUS_WRITE, command,
1867 I2C_SMBUS_BLOCK_DATA, &data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001868}
David Brownellc0564602007-05-01 23:26:31 +02001869EXPORT_SYMBOL(i2c_smbus_write_block_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870
1871/* Returns the number of read bytes */
Jean Delvare0cc43a12011-01-10 22:11:23 +01001872s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
Jean Delvare4b2643d2007-07-12 14:12:29 +02001873 u8 length, u8 *values)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874{
1875 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02001876 int status;
Jean Delvare76560322006-01-18 23:14:55 +01001877
Jean Delvare4b2643d2007-07-12 14:12:29 +02001878 if (length > I2C_SMBUS_BLOCK_MAX)
1879 length = I2C_SMBUS_BLOCK_MAX;
1880 data.block[0] = length;
David Brownell24a5bb72008-07-14 22:38:23 +02001881 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1882 I2C_SMBUS_READ, command,
1883 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1884 if (status < 0)
1885 return status;
Jean Delvare76560322006-01-18 23:14:55 +01001886
1887 memcpy(values, &data.block[1], data.block[0]);
1888 return data.block[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889}
David Brownellc0564602007-05-01 23:26:31 +02001890EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891
Jean Delvare0cc43a12011-01-10 22:11:23 +01001892s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
Krzysztof Halasa46f5ed72006-06-12 21:42:20 +02001893 u8 length, const u8 *values)
Jean Delvare21bbd692006-01-09 15:19:18 +11001894{
1895 union i2c_smbus_data data;
1896
1897 if (length > I2C_SMBUS_BLOCK_MAX)
1898 length = I2C_SMBUS_BLOCK_MAX;
1899 data.block[0] = length;
1900 memcpy(data.block + 1, values, length);
1901 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1902 I2C_SMBUS_WRITE, command,
1903 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1904}
David Brownellc0564602007-05-01 23:26:31 +02001905EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
Jean Delvare21bbd692006-01-09 15:19:18 +11001906
David Brownell438d6c22006-12-10 21:21:31 +01001907/* Simulate a SMBus command using the i2c protocol
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908 No checking of parameters is done! */
Farid Hammane7225acf2010-05-21 18:40:58 +02001909static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
1910 unsigned short flags,
1911 char read_write, u8 command, int size,
1912 union i2c_smbus_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913{
1914 /* So we need to generate a series of msgs. In the case of writing, we
1915 need to use only one message; when reading, we need two. We initialize
1916 most things with sane defaults, to keep the code below somewhat
1917 simpler. */
Hideki Iwamoto5c50d182005-09-25 17:01:11 +02001918 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1919 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
Farid Hammane7225acf2010-05-21 18:40:58 +02001920 int num = read_write == I2C_SMBUS_READ ? 2 : 1;
David Brownell438d6c22006-12-10 21:21:31 +01001921 struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922 { addr, flags | I2C_M_RD, 0, msgbuf1 }
1923 };
1924 int i;
Jean Delvare421ef472005-10-26 21:28:55 +02001925 u8 partial_pec = 0;
David Brownell24a5bb72008-07-14 22:38:23 +02001926 int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001927
1928 msgbuf0[0] = command;
Farid Hammane7225acf2010-05-21 18:40:58 +02001929 switch (size) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930 case I2C_SMBUS_QUICK:
1931 msg[0].len = 0;
1932 /* Special case: The read/write field is used as data */
Roel Kluinf29d2e02009-02-24 19:19:48 +01001933 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
1934 I2C_M_RD : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935 num = 1;
1936 break;
1937 case I2C_SMBUS_BYTE:
1938 if (read_write == I2C_SMBUS_READ) {
1939 /* Special case: only a read! */
1940 msg[0].flags = I2C_M_RD | flags;
1941 num = 1;
1942 }
1943 break;
1944 case I2C_SMBUS_BYTE_DATA:
1945 if (read_write == I2C_SMBUS_READ)
1946 msg[1].len = 1;
1947 else {
1948 msg[0].len = 2;
1949 msgbuf0[1] = data->byte;
1950 }
1951 break;
1952 case I2C_SMBUS_WORD_DATA:
1953 if (read_write == I2C_SMBUS_READ)
1954 msg[1].len = 2;
1955 else {
Farid Hammane7225acf2010-05-21 18:40:58 +02001956 msg[0].len = 3;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957 msgbuf0[1] = data->word & 0xff;
Jean Delvare7eff82c2006-09-03 22:24:00 +02001958 msgbuf0[2] = data->word >> 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959 }
1960 break;
1961 case I2C_SMBUS_PROC_CALL:
1962 num = 2; /* Special case */
1963 read_write = I2C_SMBUS_READ;
1964 msg[0].len = 3;
1965 msg[1].len = 2;
1966 msgbuf0[1] = data->word & 0xff;
Jean Delvare7eff82c2006-09-03 22:24:00 +02001967 msgbuf0[2] = data->word >> 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968 break;
1969 case I2C_SMBUS_BLOCK_DATA:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970 if (read_write == I2C_SMBUS_READ) {
Jean Delvare209d27c2007-05-01 23:26:29 +02001971 msg[1].flags |= I2C_M_RECV_LEN;
1972 msg[1].len = 1; /* block length will be added by
1973 the underlying bus driver */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001974 } else {
1975 msg[0].len = data->block[0] + 2;
1976 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
David Brownell24a5bb72008-07-14 22:38:23 +02001977 dev_err(&adapter->dev,
1978 "Invalid block write size %d\n",
1979 data->block[0]);
1980 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981 }
Hideki Iwamoto5c50d182005-09-25 17:01:11 +02001982 for (i = 1; i < msg[0].len; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983 msgbuf0[i] = data->block[i-1];
1984 }
1985 break;
1986 case I2C_SMBUS_BLOCK_PROC_CALL:
Jean Delvare209d27c2007-05-01 23:26:29 +02001987 num = 2; /* Another special case */
1988 read_write = I2C_SMBUS_READ;
1989 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
David Brownell24a5bb72008-07-14 22:38:23 +02001990 dev_err(&adapter->dev,
1991 "Invalid block write size %d\n",
Jean Delvare209d27c2007-05-01 23:26:29 +02001992 data->block[0]);
David Brownell24a5bb72008-07-14 22:38:23 +02001993 return -EINVAL;
Jean Delvare209d27c2007-05-01 23:26:29 +02001994 }
1995 msg[0].len = data->block[0] + 2;
1996 for (i = 1; i < msg[0].len; i++)
1997 msgbuf0[i] = data->block[i-1];
1998 msg[1].flags |= I2C_M_RECV_LEN;
1999 msg[1].len = 1; /* block length will be added by
2000 the underlying bus driver */
2001 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002 case I2C_SMBUS_I2C_BLOCK_DATA:
2003 if (read_write == I2C_SMBUS_READ) {
Jean Delvare4b2643d2007-07-12 14:12:29 +02002004 msg[1].len = data->block[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005 } else {
2006 msg[0].len = data->block[0] + 1;
Jean Delvare30dac742005-10-08 00:15:59 +02002007 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
David Brownell24a5bb72008-07-14 22:38:23 +02002008 dev_err(&adapter->dev,
2009 "Invalid block write size %d\n",
2010 data->block[0]);
2011 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002012 }
2013 for (i = 1; i <= data->block[0]; i++)
2014 msgbuf0[i] = data->block[i];
2015 }
2016 break;
2017 default:
David Brownell24a5bb72008-07-14 22:38:23 +02002018 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
2019 return -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002020 }
2021
Jean Delvare421ef472005-10-26 21:28:55 +02002022 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
2023 && size != I2C_SMBUS_I2C_BLOCK_DATA);
2024 if (i) {
2025 /* Compute PEC if first message is a write */
2026 if (!(msg[0].flags & I2C_M_RD)) {
David Brownell438d6c22006-12-10 21:21:31 +01002027 if (num == 1) /* Write only */
Jean Delvare421ef472005-10-26 21:28:55 +02002028 i2c_smbus_add_pec(&msg[0]);
2029 else /* Write followed by read */
2030 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
2031 }
2032 /* Ask for PEC if last message is a read */
2033 if (msg[num-1].flags & I2C_M_RD)
David Brownell438d6c22006-12-10 21:21:31 +01002034 msg[num-1].len++;
Jean Delvare421ef472005-10-26 21:28:55 +02002035 }
2036
David Brownell24a5bb72008-07-14 22:38:23 +02002037 status = i2c_transfer(adapter, msg, num);
2038 if (status < 0)
2039 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040
Jean Delvare421ef472005-10-26 21:28:55 +02002041 /* Check PEC if last message is a read */
2042 if (i && (msg[num-1].flags & I2C_M_RD)) {
David Brownell24a5bb72008-07-14 22:38:23 +02002043 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
2044 if (status < 0)
2045 return status;
Jean Delvare421ef472005-10-26 21:28:55 +02002046 }
2047
Linus Torvalds1da177e2005-04-16 15:20:36 -07002048 if (read_write == I2C_SMBUS_READ)
Farid Hammane7225acf2010-05-21 18:40:58 +02002049 switch (size) {
2050 case I2C_SMBUS_BYTE:
2051 data->byte = msgbuf0[0];
2052 break;
2053 case I2C_SMBUS_BYTE_DATA:
2054 data->byte = msgbuf1[0];
2055 break;
2056 case I2C_SMBUS_WORD_DATA:
2057 case I2C_SMBUS_PROC_CALL:
2058 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
2059 break;
2060 case I2C_SMBUS_I2C_BLOCK_DATA:
2061 for (i = 0; i < data->block[0]; i++)
2062 data->block[i+1] = msgbuf1[i];
2063 break;
2064 case I2C_SMBUS_BLOCK_DATA:
2065 case I2C_SMBUS_BLOCK_PROC_CALL:
2066 for (i = 0; i < msgbuf1[0] + 1; i++)
2067 data->block[i] = msgbuf1[i];
2068 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002069 }
2070 return 0;
2071}
2072
David Brownella1cdeda2008-07-14 22:38:24 +02002073/**
2074 * i2c_smbus_xfer - execute SMBus protocol operations
2075 * @adapter: Handle to I2C bus
2076 * @addr: Address of SMBus slave on that bus
2077 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
2078 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
2079 * @command: Byte interpreted by slave, for protocols which use such bytes
2080 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
2081 * @data: Data to be read or written
2082 *
2083 * This executes an SMBus protocol operation, and returns a negative
2084 * errno code else zero on success.
2085 */
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01002086s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
David Brownella1cdeda2008-07-14 22:38:24 +02002087 char read_write, u8 command, int protocol,
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01002088 union i2c_smbus_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002089{
Clifford Wolf66b650f2009-06-15 18:01:46 +02002090 unsigned long orig_jiffies;
2091 int try;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002092 s32 res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002093
2094 flags &= I2C_M_TEN | I2C_CLIENT_PEC;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095
2096 if (adapter->algo->smbus_xfer) {
Jean Delvarefe61e072010-08-11 18:20:58 +02002097 i2c_lock_adapter(adapter);
Clifford Wolf66b650f2009-06-15 18:01:46 +02002098
2099 /* Retry automatically on arbitration loss */
2100 orig_jiffies = jiffies;
2101 for (res = 0, try = 0; try <= adapter->retries; try++) {
2102 res = adapter->algo->smbus_xfer(adapter, addr, flags,
2103 read_write, command,
2104 protocol, data);
2105 if (res != -EAGAIN)
2106 break;
2107 if (time_after(jiffies,
2108 orig_jiffies + adapter->timeout))
2109 break;
2110 }
Jean Delvarefe61e072010-08-11 18:20:58 +02002111 i2c_unlock_adapter(adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002112 } else
Farid Hammane7225acf2010-05-21 18:40:58 +02002113 res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
David Brownella1cdeda2008-07-14 22:38:24 +02002114 command, protocol, data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002115
Linus Torvalds1da177e2005-04-16 15:20:36 -07002116 return res;
2117}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002118EXPORT_SYMBOL(i2c_smbus_xfer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002119
2120MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
2121MODULE_DESCRIPTION("I2C-Bus main module");
2122MODULE_LICENSE("GPL");