blob: 5ed622ee65c3bfaa45e3adc0481cfb6bc1a0c55c [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
23 Jean Delvare <khali@linux-fr.org> */
Linus Torvalds1da177e2005-04-16 15:20:36 -070024
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include <linux/module.h>
26#include <linux/kernel.h>
27#include <linux/errno.h>
28#include <linux/slab.h>
29#include <linux/i2c.h>
30#include <linux/init.h>
31#include <linux/idr.h>
Arjan van de Venb3585e42006-01-11 10:50:26 +010032#include <linux/mutex.h>
Jean Delvareb8d6f452007-02-13 22:09:00 +010033#include <linux/completion.h>
Mike Rapoportcea443a2008-01-27 18:14:50 +010034#include <linux/hardirq.h>
35#include <linux/irqflags.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include <asm/uaccess.h>
37
David Brownell9c1600e2007-05-01 23:26:31 +020038#include "i2c-core.h"
39
Linus Torvalds1da177e2005-04-16 15:20:36 -070040
Jean Delvarecaada322008-01-27 18:14:49 +010041static DEFINE_MUTEX(core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070042static DEFINE_IDR(i2c_adapter_idr);
43
Jean Delvare4735c982008-07-14 22:38:36 +020044#define is_newstyle_driver(d) ((d)->probe || (d)->remove || (d)->detect)
45
46static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
David Brownellf37dd802007-02-13 22:09:00 +010047
48/* ------------------------------------------------------------------------- */
49
Jean Delvared2653e92008-04-29 23:11:39 +020050static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
51 const struct i2c_client *client)
52{
53 while (id->name[0]) {
54 if (strcmp(client->name, id->name) == 0)
55 return id;
56 id++;
57 }
58 return NULL;
59}
60
Linus Torvalds1da177e2005-04-16 15:20:36 -070061static int i2c_device_match(struct device *dev, struct device_driver *drv)
62{
David Brownell7b4fbc52007-05-01 23:26:30 +020063 struct i2c_client *client = to_i2c_client(dev);
64 struct i2c_driver *driver = to_i2c_driver(drv);
65
66 /* make legacy i2c drivers bypass driver model probing entirely;
67 * such drivers scan each i2c adapter/bus themselves.
68 */
David Brownella1d9e6e2007-05-01 23:26:30 +020069 if (!is_newstyle_driver(driver))
David Brownell7b4fbc52007-05-01 23:26:30 +020070 return 0;
71
Jean Delvared2653e92008-04-29 23:11:39 +020072 /* match on an id table if there is one */
73 if (driver->id_table)
74 return i2c_match_id(driver->id_table, client) != NULL;
75
Jean Delvareeb8a7902008-05-18 20:49:41 +020076 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070077}
78
David Brownell7b4fbc52007-05-01 23:26:30 +020079#ifdef CONFIG_HOTPLUG
80
81/* uevent helps with hotplug: modprobe -q $(MODALIAS) */
Kay Sievers7eff2e72007-08-14 15:15:12 +020082static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
David Brownell7b4fbc52007-05-01 23:26:30 +020083{
84 struct i2c_client *client = to_i2c_client(dev);
David Brownell7b4fbc52007-05-01 23:26:30 +020085
86 /* by definition, legacy drivers can't hotplug */
Jean Delvared2653e92008-04-29 23:11:39 +020087 if (dev->driver)
David Brownell7b4fbc52007-05-01 23:26:30 +020088 return 0;
89
Jean Delvareeb8a7902008-05-18 20:49:41 +020090 if (add_uevent_var(env, "MODALIAS=%s%s",
91 I2C_MODULE_PREFIX, client->name))
92 return -ENOMEM;
David Brownell7b4fbc52007-05-01 23:26:30 +020093 dev_dbg(dev, "uevent\n");
94 return 0;
95}
96
97#else
98#define i2c_device_uevent NULL
99#endif /* CONFIG_HOTPLUG */
100
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101static int i2c_device_probe(struct device *dev)
102{
David Brownell7b4fbc52007-05-01 23:26:30 +0200103 struct i2c_client *client = to_i2c_client(dev);
104 struct i2c_driver *driver = to_i2c_driver(dev->driver);
Hans Verkuil50c33042008-03-12 14:15:00 +0100105 int status;
David Brownell7b4fbc52007-05-01 23:26:30 +0200106
Jean Delvaree0457442008-07-14 22:38:30 +0200107 if (!driver->probe || !driver->id_table)
David Brownell7b4fbc52007-05-01 23:26:30 +0200108 return -ENODEV;
109 client->driver = driver;
Marc Pignatee354252008-08-28 08:33:22 +0200110 if (!device_can_wakeup(&client->dev))
111 device_init_wakeup(&client->dev,
112 client->flags & I2C_CLIENT_WAKE);
David Brownell7b4fbc52007-05-01 23:26:30 +0200113 dev_dbg(dev, "probe\n");
Jean Delvared2653e92008-04-29 23:11:39 +0200114
Jean Delvaree0457442008-07-14 22:38:30 +0200115 status = driver->probe(client, i2c_match_id(driver->id_table, client));
Hans Verkuil50c33042008-03-12 14:15:00 +0100116 if (status)
117 client->driver = NULL;
118 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119}
120
121static int i2c_device_remove(struct device *dev)
122{
David Brownella1d9e6e2007-05-01 23:26:30 +0200123 struct i2c_client *client = to_i2c_client(dev);
124 struct i2c_driver *driver;
125 int status;
126
127 if (!dev->driver)
128 return 0;
129
130 driver = to_i2c_driver(dev->driver);
131 if (driver->remove) {
132 dev_dbg(dev, "remove\n");
133 status = driver->remove(client);
134 } else {
135 dev->driver = NULL;
136 status = 0;
137 }
138 if (status == 0)
139 client->driver = NULL;
140 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141}
142
David Brownellf37dd802007-02-13 22:09:00 +0100143static void i2c_device_shutdown(struct device *dev)
144{
145 struct i2c_driver *driver;
146
147 if (!dev->driver)
148 return;
149 driver = to_i2c_driver(dev->driver);
150 if (driver->shutdown)
151 driver->shutdown(to_i2c_client(dev));
152}
153
Zhenwen Xu09b8ce02009-03-28 21:34:46 +0100154static int i2c_device_suspend(struct device *dev, pm_message_t mesg)
David Brownellf37dd802007-02-13 22:09:00 +0100155{
156 struct i2c_driver *driver;
157
158 if (!dev->driver)
159 return 0;
160 driver = to_i2c_driver(dev->driver);
161 if (!driver->suspend)
162 return 0;
163 return driver->suspend(to_i2c_client(dev), mesg);
164}
165
Zhenwen Xu09b8ce02009-03-28 21:34:46 +0100166static int i2c_device_resume(struct device *dev)
David Brownellf37dd802007-02-13 22:09:00 +0100167{
168 struct i2c_driver *driver;
169
170 if (!dev->driver)
171 return 0;
172 driver = to_i2c_driver(dev->driver);
173 if (!driver->resume)
174 return 0;
175 return driver->resume(to_i2c_client(dev));
176}
177
David Brownell7b4fbc52007-05-01 23:26:30 +0200178static void i2c_client_release(struct device *dev)
179{
180 struct i2c_client *client = to_i2c_client(dev);
181 complete(&client->released);
182}
183
David Brownell9c1600e2007-05-01 23:26:31 +0200184static void i2c_client_dev_release(struct device *dev)
185{
186 kfree(to_i2c_client(dev));
187}
188
Zhenwen Xu09b8ce02009-03-28 21:34:46 +0100189static ssize_t
190show_client_name(struct device *dev, struct device_attribute *attr, char *buf)
David Brownell7b4fbc52007-05-01 23:26:30 +0200191{
192 struct i2c_client *client = to_i2c_client(dev);
193 return sprintf(buf, "%s\n", client->name);
194}
195
Zhenwen Xu09b8ce02009-03-28 21:34:46 +0100196static ssize_t
197show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
David Brownell7b4fbc52007-05-01 23:26:30 +0200198{
199 struct i2c_client *client = to_i2c_client(dev);
Jean Delvareeb8a7902008-05-18 20:49:41 +0200200 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
David Brownell7b4fbc52007-05-01 23:26:30 +0200201}
202
203static struct device_attribute i2c_dev_attrs[] = {
204 __ATTR(name, S_IRUGO, show_client_name, NULL),
205 /* modalias helps coldplug: modprobe $(cat .../modalias) */
206 __ATTR(modalias, S_IRUGO, show_modalias, NULL),
207 { },
208};
209
Jon Smirle9ca9eb2008-07-14 22:38:35 +0200210struct bus_type i2c_bus_type = {
David Brownellf37dd802007-02-13 22:09:00 +0100211 .name = "i2c",
David Brownell7b4fbc52007-05-01 23:26:30 +0200212 .dev_attrs = i2c_dev_attrs,
David Brownellf37dd802007-02-13 22:09:00 +0100213 .match = i2c_device_match,
David Brownell7b4fbc52007-05-01 23:26:30 +0200214 .uevent = i2c_device_uevent,
David Brownellf37dd802007-02-13 22:09:00 +0100215 .probe = i2c_device_probe,
216 .remove = i2c_device_remove,
217 .shutdown = i2c_device_shutdown,
218 .suspend = i2c_device_suspend,
219 .resume = i2c_device_resume,
Russell Kingb864c7d2006-01-05 14:37:50 +0000220};
Jon Smirle9ca9eb2008-07-14 22:38:35 +0200221EXPORT_SYMBOL_GPL(i2c_bus_type);
Russell Kingb864c7d2006-01-05 14:37:50 +0000222
David Brownell9b766b82008-01-27 18:14:51 +0100223
224/**
225 * i2c_verify_client - return parameter as i2c_client, or NULL
226 * @dev: device, probably from some driver model iterator
227 *
228 * When traversing the driver model tree, perhaps using driver model
229 * iterators like @device_for_each_child(), you can't assume very much
230 * about the nodes you find. Use this function to avoid oopses caused
231 * by wrongly treating some non-I2C device as an i2c_client.
232 */
233struct i2c_client *i2c_verify_client(struct device *dev)
234{
235 return (dev->bus == &i2c_bus_type)
236 ? to_i2c_client(dev)
237 : NULL;
238}
239EXPORT_SYMBOL(i2c_verify_client);
240
241
David Brownell9c1600e2007-05-01 23:26:31 +0200242/**
243 * i2c_new_device - instantiate an i2c device for use with a new style driver
244 * @adap: the adapter managing the device
245 * @info: describes one I2C device; bus_num is ignored
David Brownelld64f73b2007-07-12 14:12:28 +0200246 * Context: can sleep
David Brownell9c1600e2007-05-01 23:26:31 +0200247 *
248 * Create a device to work with a new style i2c driver, where binding is
249 * handled through driver model probe()/remove() methods. This call is not
250 * appropriate for use by mainboad initialization logic, which usually runs
251 * during an arch_initcall() long before any i2c_adapter could exist.
252 *
253 * This returns the new i2c client, which may be saved for later use with
254 * i2c_unregister_device(); or NULL to indicate an error.
255 */
256struct i2c_client *
257i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
258{
259 struct i2c_client *client;
260 int status;
261
262 client = kzalloc(sizeof *client, GFP_KERNEL);
263 if (!client)
264 return NULL;
265
266 client->adapter = adap;
267
268 client->dev.platform_data = info->platform_data;
David Brownell3bbb8352007-10-13 23:56:29 +0200269
Anton Vorontsov11f1f2a2008-10-22 20:21:33 +0200270 if (info->archdata)
271 client->dev.archdata = *info->archdata;
272
Marc Pignatee354252008-08-28 08:33:22 +0200273 client->flags = info->flags;
David Brownell9c1600e2007-05-01 23:26:31 +0200274 client->addr = info->addr;
275 client->irq = info->irq;
276
David Brownell9c1600e2007-05-01 23:26:31 +0200277 strlcpy(client->name, info->type, sizeof(client->name));
278
279 /* a new style driver may be bound to this device when we
280 * return from this function, or any later moment (e.g. maybe
281 * hotplugging will load the driver module). and the device
282 * refcount model is the standard driver model one.
283 */
284 status = i2c_attach_client(client);
285 if (status < 0) {
286 kfree(client);
287 client = NULL;
288 }
289 return client;
290}
291EXPORT_SYMBOL_GPL(i2c_new_device);
292
293
294/**
295 * i2c_unregister_device - reverse effect of i2c_new_device()
296 * @client: value returned from i2c_new_device()
David Brownelld64f73b2007-07-12 14:12:28 +0200297 * Context: can sleep
David Brownell9c1600e2007-05-01 23:26:31 +0200298 */
299void i2c_unregister_device(struct i2c_client *client)
David Brownella1d9e6e2007-05-01 23:26:30 +0200300{
301 struct i2c_adapter *adapter = client->adapter;
302 struct i2c_driver *driver = client->driver;
303
304 if (driver && !is_newstyle_driver(driver)) {
305 dev_err(&client->dev, "can't unregister devices "
306 "with legacy drivers\n");
307 WARN_ON(1);
308 return;
309 }
310
Jean Delvare85081592008-07-14 22:38:36 +0200311 if (adapter->client_unregister) {
312 if (adapter->client_unregister(client)) {
313 dev_warn(&client->dev,
314 "client_unregister [%s] failed\n",
315 client->name);
316 }
317 }
318
David Brownella1d9e6e2007-05-01 23:26:30 +0200319 mutex_lock(&adapter->clist_lock);
320 list_del(&client->list);
321 mutex_unlock(&adapter->clist_lock);
322
323 device_unregister(&client->dev);
324}
David Brownell9c1600e2007-05-01 23:26:31 +0200325EXPORT_SYMBOL_GPL(i2c_unregister_device);
David Brownella1d9e6e2007-05-01 23:26:30 +0200326
327
Jean Delvare60b129d2008-05-11 20:37:06 +0200328static const struct i2c_device_id dummy_id[] = {
329 { "dummy", 0 },
330 { },
331};
332
Jean Delvared2653e92008-04-29 23:11:39 +0200333static int dummy_probe(struct i2c_client *client,
334 const struct i2c_device_id *id)
335{
336 return 0;
337}
338
339static int dummy_remove(struct i2c_client *client)
David Brownelle9f13732008-01-27 18:14:52 +0100340{
341 return 0;
342}
343
344static struct i2c_driver dummy_driver = {
345 .driver.name = "dummy",
Jean Delvared2653e92008-04-29 23:11:39 +0200346 .probe = dummy_probe,
347 .remove = dummy_remove,
Jean Delvare60b129d2008-05-11 20:37:06 +0200348 .id_table = dummy_id,
David Brownelle9f13732008-01-27 18:14:52 +0100349};
350
351/**
352 * i2c_new_dummy - return a new i2c device bound to a dummy driver
353 * @adapter: the adapter managing the device
354 * @address: seven bit address to be used
David Brownelle9f13732008-01-27 18:14:52 +0100355 * Context: can sleep
356 *
357 * This returns an I2C client bound to the "dummy" driver, intended for use
358 * with devices that consume multiple addresses. Examples of such chips
359 * include various EEPROMS (like 24c04 and 24c08 models).
360 *
361 * These dummy devices have two main uses. First, most I2C and SMBus calls
362 * except i2c_transfer() need a client handle; the dummy will be that handle.
363 * And second, this prevents the specified address from being bound to a
364 * different driver.
365 *
366 * This returns the new i2c client, which should be saved for later use with
367 * i2c_unregister_device(); or NULL to indicate an error.
368 */
Zhenwen Xu09b8ce02009-03-28 21:34:46 +0100369struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
David Brownelle9f13732008-01-27 18:14:52 +0100370{
371 struct i2c_board_info info = {
Jean Delvare60b129d2008-05-11 20:37:06 +0200372 I2C_BOARD_INFO("dummy", address),
David Brownelle9f13732008-01-27 18:14:52 +0100373 };
374
David Brownelle9f13732008-01-27 18:14:52 +0100375 return i2c_new_device(adapter, &info);
376}
377EXPORT_SYMBOL_GPL(i2c_new_dummy);
378
David Brownellf37dd802007-02-13 22:09:00 +0100379/* ------------------------------------------------------------------------- */
380
David Brownell16ffadf2007-05-01 23:26:28 +0200381/* I2C bus adapters -- one roots each I2C or SMBUS segment */
382
Adrian Bunk83eaaed2007-10-13 23:56:30 +0200383static void i2c_adapter_dev_release(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384{
David Brownellef2c83212007-05-01 23:26:28 +0200385 struct i2c_adapter *adap = to_i2c_adapter(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 complete(&adap->dev_released);
387}
388
David Brownell16ffadf2007-05-01 23:26:28 +0200389static ssize_t
390show_adapter_name(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391{
David Brownellef2c83212007-05-01 23:26:28 +0200392 struct i2c_adapter *adap = to_i2c_adapter(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 return sprintf(buf, "%s\n", adap->name);
394}
David Brownell16ffadf2007-05-01 23:26:28 +0200395
396static struct device_attribute i2c_adapter_attrs[] = {
397 __ATTR(name, S_IRUGO, show_adapter_name, NULL),
398 { },
399};
400
Adrian Bunk83eaaed2007-10-13 23:56:30 +0200401static struct class i2c_adapter_class = {
David Brownell16ffadf2007-05-01 23:26:28 +0200402 .owner = THIS_MODULE,
403 .name = "i2c-adapter",
404 .dev_attrs = i2c_adapter_attrs,
405};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406
David Brownell9c1600e2007-05-01 23:26:31 +0200407static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
408{
409 struct i2c_devinfo *devinfo;
410
411 mutex_lock(&__i2c_board_lock);
412 list_for_each_entry(devinfo, &__i2c_board_list, list) {
413 if (devinfo->busnum == adapter->nr
414 && !i2c_new_device(adapter,
415 &devinfo->board_info))
Zhenwen Xu09b8ce02009-03-28 21:34:46 +0100416 dev_err(&adapter->dev,
417 "Can't create device at 0x%02x\n",
David Brownell9c1600e2007-05-01 23:26:31 +0200418 devinfo->board_info.addr);
419 }
420 mutex_unlock(&__i2c_board_lock);
421}
422
Jean Delvare026526f2008-01-27 18:14:49 +0100423static int i2c_do_add_adapter(struct device_driver *d, void *data)
424{
425 struct i2c_driver *driver = to_i2c_driver(d);
426 struct i2c_adapter *adap = data;
427
Jean Delvare4735c982008-07-14 22:38:36 +0200428 /* Detect supported devices on that bus, and instantiate them */
429 i2c_detect(adap, driver);
430
431 /* Let legacy drivers scan this bus for matching devices */
Jean Delvare026526f2008-01-27 18:14:49 +0100432 if (driver->attach_adapter) {
433 /* We ignore the return code; if it fails, too bad */
434 driver->attach_adapter(adap);
435 }
436 return 0;
437}
438
David Brownell6e13e642007-05-01 23:26:31 +0200439static int i2c_register_adapter(struct i2c_adapter *adap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440{
Jean Delvare026526f2008-01-27 18:14:49 +0100441 int res = 0, dummy;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442
David Brownell1d0b19c2008-10-14 17:30:05 +0200443 /* Can't register until after driver model init */
444 if (unlikely(WARN_ON(!i2c_bus_type.p)))
445 return -EAGAIN;
446
Ingo Molnar5c085d32006-01-18 23:16:04 +0100447 mutex_init(&adap->bus_lock);
448 mutex_init(&adap->clist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 INIT_LIST_HEAD(&adap->clients);
450
Jean Delvarecaada322008-01-27 18:14:49 +0100451 mutex_lock(&core_lock);
David Brownell6e13e642007-05-01 23:26:31 +0200452
Jean Delvare8fcfef62009-03-28 21:34:43 +0100453 /* Set default timeout to 1 second if not already set */
454 if (adap->timeout == 0)
455 adap->timeout = HZ;
456
Kay Sievers27d9c182009-01-07 14:29:16 +0100457 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 adap->dev.release = &i2c_adapter_dev_release;
Jean Delvarefccb56e2007-05-01 23:26:27 +0200459 adap->dev.class = &i2c_adapter_class;
Jean Delvareb119c6c2006-08-15 18:26:30 +0200460 res = device_register(&adap->dev);
461 if (res)
462 goto out_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463
Jean Delvareb6d7b3d2005-07-31 19:02:53 +0200464 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
465
David Brownell6e13e642007-05-01 23:26:31 +0200466 /* create pre-declared device nodes for new-style drivers */
467 if (adap->nr < __i2c_first_dynamic_bus_num)
468 i2c_scan_static_board_info(adap);
469
Jean Delvare4735c982008-07-14 22:38:36 +0200470 /* Notify drivers */
Jean Delvare026526f2008-01-27 18:14:49 +0100471 dummy = bus_for_each_drv(&i2c_bus_type, NULL, adap,
472 i2c_do_add_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474out_unlock:
Jean Delvarecaada322008-01-27 18:14:49 +0100475 mutex_unlock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 return res;
Jean Delvareb119c6c2006-08-15 18:26:30 +0200477
Jean Delvareb119c6c2006-08-15 18:26:30 +0200478out_list:
Jean Delvareb119c6c2006-08-15 18:26:30 +0200479 idr_remove(&i2c_adapter_idr, adap->nr);
480 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481}
482
David Brownell6e13e642007-05-01 23:26:31 +0200483/**
484 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
485 * @adapter: the adapter to add
David Brownelld64f73b2007-07-12 14:12:28 +0200486 * Context: can sleep
David Brownell6e13e642007-05-01 23:26:31 +0200487 *
488 * This routine is used to declare an I2C adapter when its bus number
489 * doesn't matter. Examples: for I2C adapters dynamically added by
490 * USB links or PCI plugin cards.
491 *
492 * When this returns zero, a new bus number was allocated and stored
493 * in adap->nr, and the specified adapter became available for clients.
494 * Otherwise, a negative errno value is returned.
495 */
496int i2c_add_adapter(struct i2c_adapter *adapter)
497{
498 int id, res = 0;
499
500retry:
501 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
502 return -ENOMEM;
503
Jean Delvarecaada322008-01-27 18:14:49 +0100504 mutex_lock(&core_lock);
David Brownell6e13e642007-05-01 23:26:31 +0200505 /* "above" here means "above or equal to", sigh */
506 res = idr_get_new_above(&i2c_adapter_idr, adapter,
507 __i2c_first_dynamic_bus_num, &id);
Jean Delvarecaada322008-01-27 18:14:49 +0100508 mutex_unlock(&core_lock);
David Brownell6e13e642007-05-01 23:26:31 +0200509
510 if (res < 0) {
511 if (res == -EAGAIN)
512 goto retry;
513 return res;
514 }
515
516 adapter->nr = id;
517 return i2c_register_adapter(adapter);
518}
519EXPORT_SYMBOL(i2c_add_adapter);
520
521/**
522 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
523 * @adap: the adapter to register (with adap->nr initialized)
David Brownelld64f73b2007-07-12 14:12:28 +0200524 * Context: can sleep
David Brownell6e13e642007-05-01 23:26:31 +0200525 *
526 * This routine is used to declare an I2C adapter when its bus number
Randy Dunlap8c07e462008-03-23 20:28:20 +0100527 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
528 * or otherwise built in to the system's mainboard, and where i2c_board_info
David Brownell6e13e642007-05-01 23:26:31 +0200529 * is used to properly configure I2C devices.
530 *
531 * If no devices have pre-been declared for this bus, then be sure to
532 * register the adapter before any dynamically allocated ones. Otherwise
533 * the required bus ID may not be available.
534 *
535 * When this returns zero, the specified adapter became available for
536 * clients using the bus number provided in adap->nr. Also, the table
537 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
538 * and the appropriate driver model device nodes are created. Otherwise, a
539 * negative errno value is returned.
540 */
541int i2c_add_numbered_adapter(struct i2c_adapter *adap)
542{
543 int id;
544 int status;
545
546 if (adap->nr & ~MAX_ID_MASK)
547 return -EINVAL;
548
549retry:
550 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
551 return -ENOMEM;
552
Jean Delvarecaada322008-01-27 18:14:49 +0100553 mutex_lock(&core_lock);
David Brownell6e13e642007-05-01 23:26:31 +0200554 /* "above" here means "above or equal to", sigh;
555 * we need the "equal to" result to force the result
556 */
557 status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
558 if (status == 0 && id != adap->nr) {
559 status = -EBUSY;
560 idr_remove(&i2c_adapter_idr, id);
561 }
Jean Delvarecaada322008-01-27 18:14:49 +0100562 mutex_unlock(&core_lock);
David Brownell6e13e642007-05-01 23:26:31 +0200563 if (status == -EAGAIN)
564 goto retry;
565
566 if (status == 0)
567 status = i2c_register_adapter(adap);
568 return status;
569}
570EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
571
Jean Delvare026526f2008-01-27 18:14:49 +0100572static int i2c_do_del_adapter(struct device_driver *d, void *data)
573{
574 struct i2c_driver *driver = to_i2c_driver(d);
575 struct i2c_adapter *adapter = data;
Jean Delvare4735c982008-07-14 22:38:36 +0200576 struct i2c_client *client, *_n;
Jean Delvare026526f2008-01-27 18:14:49 +0100577 int res;
578
Jean Delvareacec2112009-03-28 21:34:40 +0100579 /* Remove the devices we created ourselves as the result of hardware
580 * probing (using a driver's detect method) */
Jean Delvare4735c982008-07-14 22:38:36 +0200581 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
582 if (client->adapter == adapter) {
583 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
584 client->name, client->addr);
585 list_del(&client->detected);
586 i2c_unregister_device(client);
587 }
588 }
589
Jean Delvare026526f2008-01-27 18:14:49 +0100590 if (!driver->detach_adapter)
591 return 0;
592 res = driver->detach_adapter(adapter);
593 if (res)
594 dev_err(&adapter->dev, "detach_adapter failed (%d) "
595 "for driver [%s]\n", res, driver->driver.name);
596 return res;
597}
598
David Brownelld64f73b2007-07-12 14:12:28 +0200599/**
600 * i2c_del_adapter - unregister I2C adapter
601 * @adap: the adapter being unregistered
602 * Context: can sleep
603 *
604 * This unregisters an I2C adapter which was previously registered
605 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
606 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607int i2c_del_adapter(struct i2c_adapter *adap)
608{
Matthias Kaehlcke6a03cd92008-07-14 22:38:26 +0200609 struct i2c_client *client, *_n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 int res = 0;
611
Jean Delvarecaada322008-01-27 18:14:49 +0100612 mutex_lock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613
614 /* First make sure that this adapter was ever added */
Jean Delvare87c6c222008-01-27 18:14:48 +0100615 if (idr_find(&i2c_adapter_idr, adap->nr) != adap) {
Jean Delvareb6d7b3d2005-07-31 19:02:53 +0200616 pr_debug("i2c-core: attempting to delete unregistered "
617 "adapter [%s]\n", adap->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 res = -EINVAL;
619 goto out_unlock;
620 }
621
Jean Delvare026526f2008-01-27 18:14:49 +0100622 /* Tell drivers about this removal */
623 res = bus_for_each_drv(&i2c_bus_type, NULL, adap,
624 i2c_do_del_adapter);
625 if (res)
626 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627
628 /* detach any active clients. This must be done first, because
Tobias Klausera551acc2005-05-19 21:40:38 +0200629 * it can fail; in which case we give up. */
Jean Delvare79b93e12008-11-28 15:24:38 +0100630 list_for_each_entry_safe_reverse(client, _n, &adap->clients, list) {
David Brownella1d9e6e2007-05-01 23:26:30 +0200631 struct i2c_driver *driver;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632
David Brownella1d9e6e2007-05-01 23:26:30 +0200633 driver = client->driver;
634
635 /* new style, follow standard driver model */
636 if (!driver || is_newstyle_driver(driver)) {
637 i2c_unregister_device(client);
638 continue;
639 }
640
641 /* legacy drivers create and remove clients themselves */
642 if ((res = driver->detach_client(client))) {
Jean Delvareb6d7b3d2005-07-31 19:02:53 +0200643 dev_err(&adap->dev, "detach_client failed for client "
644 "[%s] at address 0x%02x\n", client->name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 client->addr);
646 goto out_unlock;
647 }
648 }
649
650 /* clean up the sysfs representation */
651 init_completion(&adap->dev_released);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 device_unregister(&adap->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653
654 /* wait for sysfs to drop all references */
655 wait_for_completion(&adap->dev_released);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656
David Brownell6e13e642007-05-01 23:26:31 +0200657 /* free bus id */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 idr_remove(&i2c_adapter_idr, adap->nr);
659
Jean Delvareb6d7b3d2005-07-31 19:02:53 +0200660 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661
Jean Delvarebd4bc3db2008-07-16 19:30:05 +0200662 /* Clear the device structure in case this adapter is ever going to be
663 added again */
664 memset(&adap->dev, 0, sizeof(adap->dev));
665
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 out_unlock:
Jean Delvarecaada322008-01-27 18:14:49 +0100667 mutex_unlock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 return res;
669}
David Brownellc0564602007-05-01 23:26:31 +0200670EXPORT_SYMBOL(i2c_del_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671
672
David Brownell7b4fbc52007-05-01 23:26:30 +0200673/* ------------------------------------------------------------------------- */
674
Dave Young7f101a92008-07-14 22:38:19 +0200675static int __attach_adapter(struct device *dev, void *data)
676{
677 struct i2c_adapter *adapter = to_i2c_adapter(dev);
678 struct i2c_driver *driver = data;
679
Jean Delvare4735c982008-07-14 22:38:36 +0200680 i2c_detect(adapter, driver);
681
682 /* Legacy drivers scan i2c busses directly */
683 if (driver->attach_adapter)
684 driver->attach_adapter(adapter);
Dave Young7f101a92008-07-14 22:38:19 +0200685
686 return 0;
687}
688
David Brownell7b4fbc52007-05-01 23:26:30 +0200689/*
690 * An i2c_driver is used with one or more i2c_client (device) nodes to access
691 * i2c slave chips, on a bus instance associated with some i2c_adapter. There
692 * are two models for binding the driver to its device: "new style" drivers
693 * follow the standard Linux driver model and just respond to probe() calls
694 * issued if the driver core sees they match(); "legacy" drivers create device
695 * nodes themselves.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 */
697
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -0800698int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699{
Jean Delvare7eebcb72006-02-05 23:28:21 +0100700 int res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701
David Brownell1d0b19c2008-10-14 17:30:05 +0200702 /* Can't register until after driver model init */
703 if (unlikely(WARN_ON(!i2c_bus_type.p)))
704 return -EAGAIN;
705
David Brownell7b4fbc52007-05-01 23:26:30 +0200706 /* new style driver methods can't mix with legacy ones */
David Brownella1d9e6e2007-05-01 23:26:30 +0200707 if (is_newstyle_driver(driver)) {
Jean Delvare93529862009-04-13 17:02:14 +0200708 if (driver->detach_adapter || driver->detach_client) {
David Brownell7b4fbc52007-05-01 23:26:30 +0200709 printk(KERN_WARNING
710 "i2c-core: driver [%s] is confused\n",
711 driver->driver.name);
712 return -EINVAL;
713 }
714 }
715
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 /* add the driver to the list of i2c drivers in the driver core */
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -0800717 driver->driver.owner = owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 driver->driver.bus = &i2c_bus_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719
David Brownell6e13e642007-05-01 23:26:31 +0200720 /* for new style drivers, when registration returns the driver core
721 * will have called probe() for all matching-but-unbound devices.
722 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 res = driver_register(&driver->driver);
724 if (res)
Jean Delvare7eebcb72006-02-05 23:28:21 +0100725 return res;
David Brownell438d6c22006-12-10 21:21:31 +0100726
Jean Delvarecaada322008-01-27 18:14:49 +0100727 mutex_lock(&core_lock);
Jean Delvare7eebcb72006-02-05 23:28:21 +0100728
Laurent Riffard35d8b2e2005-11-26 20:34:05 +0100729 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730
Jean Delvare4735c982008-07-14 22:38:36 +0200731 INIT_LIST_HEAD(&driver->clients);
732 /* Walk the adapters that are already present */
Greg Kroah-Hartman93562b52008-05-22 17:21:08 -0400733 class_for_each_device(&i2c_adapter_class, NULL, driver,
734 __attach_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735
Jean Delvarecaada322008-01-27 18:14:49 +0100736 mutex_unlock(&core_lock);
Jean Delvare7eebcb72006-02-05 23:28:21 +0100737 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738}
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -0800739EXPORT_SYMBOL(i2c_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740
Dave Young7f101a92008-07-14 22:38:19 +0200741static int __detach_adapter(struct device *dev, void *data)
742{
743 struct i2c_adapter *adapter = to_i2c_adapter(dev);
744 struct i2c_driver *driver = data;
Jean Delvare4735c982008-07-14 22:38:36 +0200745 struct i2c_client *client, *_n;
746
Jean Delvareacec2112009-03-28 21:34:40 +0100747 /* Remove the devices we created ourselves as the result of hardware
748 * probing (using a driver's detect method) */
Jean Delvare4735c982008-07-14 22:38:36 +0200749 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
750 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
751 client->name, client->addr);
752 list_del(&client->detected);
753 i2c_unregister_device(client);
754 }
755
756 if (is_newstyle_driver(driver))
757 return 0;
Dave Young7f101a92008-07-14 22:38:19 +0200758
759 /* Have a look at each adapter, if clients of this driver are still
760 * attached. If so, detach them to be able to kill the driver
761 * afterwards.
762 */
763 if (driver->detach_adapter) {
764 if (driver->detach_adapter(adapter))
765 dev_err(&adapter->dev,
766 "detach_adapter failed for driver [%s]\n",
767 driver->driver.name);
768 } else {
Matthias Kaehlcke6a03cd92008-07-14 22:38:26 +0200769 struct i2c_client *client, *_n;
Dave Young7f101a92008-07-14 22:38:19 +0200770
Matthias Kaehlcke6a03cd92008-07-14 22:38:26 +0200771 list_for_each_entry_safe(client, _n, &adapter->clients, list) {
Dave Young7f101a92008-07-14 22:38:19 +0200772 if (client->driver != driver)
773 continue;
774 dev_dbg(&adapter->dev,
775 "detaching client [%s] at 0x%02x\n",
776 client->name, client->addr);
777 if (driver->detach_client(client))
778 dev_err(&adapter->dev, "detach_client "
779 "failed for client [%s] at 0x%02x\n",
780 client->name, client->addr);
781 }
782 }
783
784 return 0;
785}
786
David Brownella1d9e6e2007-05-01 23:26:30 +0200787/**
788 * i2c_del_driver - unregister I2C driver
789 * @driver: the driver being unregistered
David Brownelld64f73b2007-07-12 14:12:28 +0200790 * Context: can sleep
David Brownella1d9e6e2007-05-01 23:26:30 +0200791 */
Jean Delvareb3e82092007-05-01 23:26:32 +0200792void i2c_del_driver(struct i2c_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793{
Jean Delvarecaada322008-01-27 18:14:49 +0100794 mutex_lock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795
Greg Kroah-Hartman93562b52008-05-22 17:21:08 -0400796 class_for_each_device(&i2c_adapter_class, NULL, driver,
797 __detach_adapter);
David Brownella1d9e6e2007-05-01 23:26:30 +0200798
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 driver_unregister(&driver->driver);
Laurent Riffard35d8b2e2005-11-26 20:34:05 +0100800 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801
Jean Delvarecaada322008-01-27 18:14:49 +0100802 mutex_unlock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803}
David Brownellc0564602007-05-01 23:26:31 +0200804EXPORT_SYMBOL(i2c_del_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805
David Brownell7b4fbc52007-05-01 23:26:30 +0200806/* ------------------------------------------------------------------------- */
807
David Brownell9b766b82008-01-27 18:14:51 +0100808static int __i2c_check_addr(struct device *dev, void *addrp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809{
David Brownell9b766b82008-01-27 18:14:51 +0100810 struct i2c_client *client = i2c_verify_client(dev);
811 int addr = *(int *)addrp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812
David Brownell9b766b82008-01-27 18:14:51 +0100813 if (client && client->addr == addr)
814 return -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 return 0;
816}
817
Jean Delvare5e31c2b2007-11-15 19:24:02 +0100818static int i2c_check_addr(struct i2c_adapter *adapter, int addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819{
David Brownell9b766b82008-01-27 18:14:51 +0100820 return device_for_each_child(&adapter->dev, &addr, __i2c_check_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821}
822
823int i2c_attach_client(struct i2c_client *client)
824{
825 struct i2c_adapter *adapter = client->adapter;
Jean Delvarec1159f92008-08-10 22:56:16 +0200826 int res;
827
828 /* Check for address business */
829 res = i2c_check_addr(adapter, client->addr);
830 if (res)
831 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 client->dev.parent = &client->adapter->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 client->dev.bus = &i2c_bus_type;
David Brownell9c1600e2007-05-01 23:26:31 +0200835
836 if (client->driver)
837 client->dev.driver = &client->driver->driver;
838
David Brownellde81d2a2007-05-22 19:49:16 +0200839 if (client->driver && !is_newstyle_driver(client->driver)) {
David Brownell9c1600e2007-05-01 23:26:31 +0200840 client->dev.release = i2c_client_release;
Ming Leif67f1292009-03-01 21:10:49 +0800841 dev_set_uevent_suppress(&client->dev, 1);
David Brownellde81d2a2007-05-22 19:49:16 +0200842 } else
David Brownell9c1600e2007-05-01 23:26:31 +0200843 client->dev.release = i2c_client_dev_release;
David Brownell438d6c22006-12-10 21:21:31 +0100844
Kay Sievers27d9c182009-01-07 14:29:16 +0100845 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adapter),
846 client->addr);
Jean Delvareb119c6c2006-08-15 18:26:30 +0200847 res = device_register(&client->dev);
848 if (res)
David Brownell86ec5ec2008-01-27 18:14:51 +0100849 goto out_err;
850
851 mutex_lock(&adapter->clist_lock);
852 list_add_tail(&client->list, &adapter->clients);
Jean Delvareb119c6c2006-08-15 18:26:30 +0200853 mutex_unlock(&adapter->clist_lock);
Jean Delvare77ed74d2006-09-30 17:18:59 +0200854
David Brownell86ec5ec2008-01-27 18:14:51 +0100855 dev_dbg(&adapter->dev, "client [%s] registered with bus id %s\n",
Kay Sievers27d9c182009-01-07 14:29:16 +0100856 client->name, dev_name(&client->dev));
David Brownell86ec5ec2008-01-27 18:14:51 +0100857
Jean Delvare77ed74d2006-09-30 17:18:59 +0200858 if (adapter->client_register) {
859 if (adapter->client_register(client)) {
860 dev_dbg(&adapter->dev, "client_register "
861 "failed for client [%s] at 0x%02x\n",
862 client->name, client->addr);
863 }
864 }
865
866 return 0;
Jean Delvareb119c6c2006-08-15 18:26:30 +0200867
David Brownell86ec5ec2008-01-27 18:14:51 +0100868out_err:
Jean Delvareb119c6c2006-08-15 18:26:30 +0200869 dev_err(&adapter->dev, "Failed to attach i2c client %s at 0x%02x "
870 "(%d)\n", client->name, client->addr, res);
Jean Delvare77ed74d2006-09-30 17:18:59 +0200871 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872}
David Brownellc0564602007-05-01 23:26:31 +0200873EXPORT_SYMBOL(i2c_attach_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874
875int i2c_detach_client(struct i2c_client *client)
876{
877 struct i2c_adapter *adapter = client->adapter;
878 int res = 0;
David Brownell438d6c22006-12-10 21:21:31 +0100879
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 if (adapter->client_unregister) {
881 res = adapter->client_unregister(client);
882 if (res) {
883 dev_err(&client->dev,
Jean Delvare86749e82005-07-29 12:15:29 -0700884 "client_unregister [%s] failed, "
885 "client not detached\n", client->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 goto out;
887 }
888 }
889
Ingo Molnar5c085d32006-01-18 23:16:04 +0100890 mutex_lock(&adapter->clist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 list_del(&client->list);
Jean Delvare9ddced12008-01-27 18:14:51 +0100892 mutex_unlock(&adapter->clist_lock);
893
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 init_completion(&client->released);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 device_unregister(&client->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 wait_for_completion(&client->released);
897
898 out:
899 return res;
900}
David Brownellc0564602007-05-01 23:26:31 +0200901EXPORT_SYMBOL(i2c_detach_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902
Jean Delvaree48d3312008-01-27 18:14:48 +0100903/**
904 * i2c_use_client - increments the reference count of the i2c client structure
905 * @client: the client being referenced
906 *
907 * Each live reference to a client should be refcounted. The driver model does
908 * that automatically as part of driver binding, so that most drivers don't
909 * need to do this explicitly: they hold a reference until they're unbound
910 * from the device.
911 *
912 * A pointer to the client with the incremented reference counter is returned.
913 */
914struct i2c_client *i2c_use_client(struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915{
David Brownell6ea438e2008-07-14 22:38:24 +0200916 if (client && get_device(&client->dev))
917 return client;
918 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919}
David Brownellc0564602007-05-01 23:26:31 +0200920EXPORT_SYMBOL(i2c_use_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921
Jean Delvaree48d3312008-01-27 18:14:48 +0100922/**
923 * i2c_release_client - release a use of the i2c client structure
924 * @client: the client being no longer referenced
925 *
926 * Must be called when a user of a client is finished with it.
927 */
928void i2c_release_client(struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929{
David Brownell6ea438e2008-07-14 22:38:24 +0200930 if (client)
931 put_device(&client->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932}
David Brownellc0564602007-05-01 23:26:31 +0200933EXPORT_SYMBOL(i2c_release_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934
David Brownell9b766b82008-01-27 18:14:51 +0100935struct i2c_cmd_arg {
936 unsigned cmd;
937 void *arg;
938};
939
940static int i2c_cmd(struct device *dev, void *_arg)
941{
942 struct i2c_client *client = i2c_verify_client(dev);
943 struct i2c_cmd_arg *arg = _arg;
944
945 if (client && client->driver && client->driver->command)
946 client->driver->command(client, arg->cmd, arg->arg);
947 return 0;
948}
949
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
951{
David Brownell9b766b82008-01-27 18:14:51 +0100952 struct i2c_cmd_arg cmd_arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953
David Brownell9b766b82008-01-27 18:14:51 +0100954 cmd_arg.cmd = cmd;
955 cmd_arg.arg = arg;
956 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957}
David Brownellc0564602007-05-01 23:26:31 +0200958EXPORT_SYMBOL(i2c_clients_command);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959
960static int __init i2c_init(void)
961{
962 int retval;
963
964 retval = bus_register(&i2c_bus_type);
965 if (retval)
966 return retval;
David Brownelle9f13732008-01-27 18:14:52 +0100967 retval = class_register(&i2c_adapter_class);
968 if (retval)
969 goto bus_err;
970 retval = i2c_add_driver(&dummy_driver);
971 if (retval)
972 goto class_err;
973 return 0;
974
975class_err:
976 class_unregister(&i2c_adapter_class);
977bus_err:
978 bus_unregister(&i2c_bus_type);
979 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980}
981
982static void __exit i2c_exit(void)
983{
David Brownelle9f13732008-01-27 18:14:52 +0100984 i2c_del_driver(&dummy_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 class_unregister(&i2c_adapter_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 bus_unregister(&i2c_bus_type);
987}
988
David Brownella10f9e72008-10-14 17:30:06 +0200989/* We must initialize early, because some subsystems register i2c drivers
990 * in subsys_initcall() code, but are linked (and initialized) before i2c.
991 */
992postcore_initcall(i2c_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993module_exit(i2c_exit);
994
995/* ----------------------------------------------------
996 * the functional interface to the i2c busses.
997 * ----------------------------------------------------
998 */
999
David Brownella1cdeda2008-07-14 22:38:24 +02001000/**
1001 * i2c_transfer - execute a single or combined I2C message
1002 * @adap: Handle to I2C bus
1003 * @msgs: One or more messages to execute before STOP is issued to
1004 * terminate the operation; each message begins with a START.
1005 * @num: Number of messages to be executed.
1006 *
1007 * Returns negative errno, else the number of messages executed.
1008 *
1009 * Note that there is no requirement that each message be sent to
1010 * the same slave address, although that is the most common model.
1011 */
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01001012int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013{
Clifford Wolf66b650f2009-06-15 18:01:46 +02001014 unsigned long orig_jiffies;
1015 int ret, try;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016
David Brownella1cdeda2008-07-14 22:38:24 +02001017 /* REVISIT the fault reporting model here is weak:
1018 *
1019 * - When we get an error after receiving N bytes from a slave,
1020 * there is no way to report "N".
1021 *
1022 * - When we get a NAK after transmitting N bytes to a slave,
1023 * there is no way to report "N" ... or to let the master
1024 * continue executing the rest of this combined message, if
1025 * that's the appropriate response.
1026 *
1027 * - When for example "num" is two and we successfully complete
1028 * the first message but get an error part way through the
1029 * second, it's unclear whether that should be reported as
1030 * one (discarding status on the second message) or errno
1031 * (discarding status on the first one).
1032 */
1033
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 if (adap->algo->master_xfer) {
1035#ifdef DEBUG
1036 for (ret = 0; ret < num; ret++) {
1037 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
Jean Delvare209d27c2007-05-01 23:26:29 +02001038 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
1039 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
1040 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 }
1042#endif
1043
Mike Rapoportcea443a2008-01-27 18:14:50 +01001044 if (in_atomic() || irqs_disabled()) {
1045 ret = mutex_trylock(&adap->bus_lock);
1046 if (!ret)
1047 /* I2C activity is ongoing. */
1048 return -EAGAIN;
1049 } else {
1050 mutex_lock_nested(&adap->bus_lock, adap->level);
1051 }
1052
Clifford Wolf66b650f2009-06-15 18:01:46 +02001053 /* Retry automatically on arbitration loss */
1054 orig_jiffies = jiffies;
1055 for (ret = 0, try = 0; try <= adap->retries; try++) {
1056 ret = adap->algo->master_xfer(adap, msgs, num);
1057 if (ret != -EAGAIN)
1058 break;
1059 if (time_after(jiffies, orig_jiffies + adap->timeout))
1060 break;
1061 }
Ingo Molnar5c085d32006-01-18 23:16:04 +01001062 mutex_unlock(&adap->bus_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063
1064 return ret;
1065 } else {
1066 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
David Brownell24a5bb72008-07-14 22:38:23 +02001067 return -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 }
1069}
David Brownellc0564602007-05-01 23:26:31 +02001070EXPORT_SYMBOL(i2c_transfer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071
David Brownella1cdeda2008-07-14 22:38:24 +02001072/**
1073 * i2c_master_send - issue a single I2C message in master transmit mode
1074 * @client: Handle to slave device
1075 * @buf: Data that will be written to the slave
1076 * @count: How many bytes to write
1077 *
1078 * Returns negative errno, or else the number of bytes written.
1079 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
1081{
1082 int ret;
1083 struct i2c_adapter *adap=client->adapter;
1084 struct i2c_msg msg;
1085
Jean Delvare815f55f2005-05-07 22:58:46 +02001086 msg.addr = client->addr;
1087 msg.flags = client->flags & I2C_M_TEN;
1088 msg.len = count;
1089 msg.buf = (char *)buf;
David Brownell438d6c22006-12-10 21:21:31 +01001090
Jean Delvare815f55f2005-05-07 22:58:46 +02001091 ret = i2c_transfer(adap, &msg, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092
Jean Delvare815f55f2005-05-07 22:58:46 +02001093 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1094 transmitted, else error code. */
1095 return (ret == 1) ? count : ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096}
David Brownellc0564602007-05-01 23:26:31 +02001097EXPORT_SYMBOL(i2c_master_send);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098
David Brownella1cdeda2008-07-14 22:38:24 +02001099/**
1100 * i2c_master_recv - issue a single I2C message in master receive mode
1101 * @client: Handle to slave device
1102 * @buf: Where to store data read from slave
1103 * @count: How many bytes to read
1104 *
1105 * Returns negative errno, or else the number of bytes read.
1106 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
1108{
1109 struct i2c_adapter *adap=client->adapter;
1110 struct i2c_msg msg;
1111 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112
Jean Delvare815f55f2005-05-07 22:58:46 +02001113 msg.addr = client->addr;
1114 msg.flags = client->flags & I2C_M_TEN;
1115 msg.flags |= I2C_M_RD;
1116 msg.len = count;
1117 msg.buf = buf;
1118
1119 ret = i2c_transfer(adap, &msg, 1);
1120
1121 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1122 transmitted, else error code. */
1123 return (ret == 1) ? count : ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124}
David Brownellc0564602007-05-01 23:26:31 +02001125EXPORT_SYMBOL(i2c_master_recv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127/* ----------------------------------------------------
1128 * the i2c address scanning function
1129 * Will not work for 10-bit addresses!
1130 * ----------------------------------------------------
1131 */
Jean Delvarea89ba0b2005-08-09 20:17:55 +02001132static int i2c_probe_address(struct i2c_adapter *adapter, int addr, int kind,
1133 int (*found_proc) (struct i2c_adapter *, int, int))
Jean Delvare9fc6adf2005-07-31 21:20:43 +02001134{
Jean Delvarea89ba0b2005-08-09 20:17:55 +02001135 int err;
Jean Delvare9fc6adf2005-07-31 21:20:43 +02001136
Jean Delvarea89ba0b2005-08-09 20:17:55 +02001137 /* Make sure the address is valid */
1138 if (addr < 0x03 || addr > 0x77) {
1139 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1140 addr);
1141 return -EINVAL;
Jean Delvare9fc6adf2005-07-31 21:20:43 +02001142 }
1143
Jean Delvarea89ba0b2005-08-09 20:17:55 +02001144 /* Skip if already in use */
1145 if (i2c_check_addr(adapter, addr))
1146 return 0;
1147
1148 /* Make sure there is something at this address, unless forced */
Jean Delvare4c9337d2005-08-09 20:28:10 +02001149 if (kind < 0) {
1150 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1151 I2C_SMBUS_QUICK, NULL) < 0)
1152 return 0;
1153
1154 /* prevent 24RF08 corruption */
1155 if ((addr & ~0x0f) == 0x50)
1156 i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1157 I2C_SMBUS_QUICK, NULL);
1158 }
Jean Delvarea89ba0b2005-08-09 20:17:55 +02001159
1160 /* Finally call the custom detection function */
1161 err = found_proc(adapter, addr, kind);
Jean Delvarea89ba0b2005-08-09 20:17:55 +02001162 /* -ENODEV can be returned if there is a chip at the given address
1163 but it isn't supported by this chip driver. We catch it here as
1164 this isn't an error. */
Jean Delvare114fd182006-09-03 22:25:04 +02001165 if (err == -ENODEV)
1166 err = 0;
1167
1168 if (err)
1169 dev_warn(&adapter->dev, "Client creation failed at 0x%x (%d)\n",
1170 addr, err);
1171 return err;
Jean Delvare9fc6adf2005-07-31 21:20:43 +02001172}
1173
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174int i2c_probe(struct i2c_adapter *adapter,
Mark M. Hoffmanbfb6df22008-01-27 18:14:46 +01001175 const struct i2c_client_address_data *address_data,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 int (*found_proc) (struct i2c_adapter *, int, int))
1177{
Jean Delvarea89ba0b2005-08-09 20:17:55 +02001178 int i, err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179 int adap_id = i2c_adapter_id(adapter);
1180
Jean Delvarea89ba0b2005-08-09 20:17:55 +02001181 /* Force entries are done first, and are not affected by ignore
1182 entries */
1183 if (address_data->forces) {
Mark M. Hoffmanbfb6df22008-01-27 18:14:46 +01001184 const unsigned short * const *forces = address_data->forces;
Jean Delvarea89ba0b2005-08-09 20:17:55 +02001185 int kind;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186
Jean Delvarea89ba0b2005-08-09 20:17:55 +02001187 for (kind = 0; forces[kind]; kind++) {
1188 for (i = 0; forces[kind][i] != I2C_CLIENT_END;
1189 i += 2) {
1190 if (forces[kind][i] == adap_id
1191 || forces[kind][i] == ANY_I2C_BUS) {
1192 dev_dbg(&adapter->dev, "found force "
1193 "parameter for adapter %d, "
1194 "addr 0x%02x, kind %d\n",
1195 adap_id, forces[kind][i + 1],
1196 kind);
1197 err = i2c_probe_address(adapter,
1198 forces[kind][i + 1],
1199 kind, found_proc);
1200 if (err)
1201 return err;
1202 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203 }
1204 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 }
Jean Delvarea89ba0b2005-08-09 20:17:55 +02001206
Jean Delvare4366dc92005-09-25 16:50:06 +02001207 /* Stop here if we can't use SMBUS_QUICK */
1208 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
1209 if (address_data->probe[0] == I2C_CLIENT_END
1210 && address_data->normal_i2c[0] == I2C_CLIENT_END)
David Brownell438d6c22006-12-10 21:21:31 +01001211 return 0;
Jean Delvare4366dc92005-09-25 16:50:06 +02001212
Jean Delvare4329cf82008-08-28 08:33:23 +02001213 dev_dbg(&adapter->dev, "SMBus Quick command not supported, "
1214 "can't probe for chips\n");
David Brownell24a5bb72008-07-14 22:38:23 +02001215 return -EOPNOTSUPP;
Jean Delvare4366dc92005-09-25 16:50:06 +02001216 }
1217
Jean Delvarea89ba0b2005-08-09 20:17:55 +02001218 /* Probe entries are done second, and are not affected by ignore
1219 entries either */
1220 for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
1221 if (address_data->probe[i] == adap_id
1222 || address_data->probe[i] == ANY_I2C_BUS) {
1223 dev_dbg(&adapter->dev, "found probe parameter for "
1224 "adapter %d, addr 0x%02x\n", adap_id,
1225 address_data->probe[i + 1]);
1226 err = i2c_probe_address(adapter,
1227 address_data->probe[i + 1],
1228 -1, found_proc);
1229 if (err)
1230 return err;
1231 }
1232 }
1233
1234 /* Normal entries are done last, unless shadowed by an ignore entry */
1235 for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
1236 int j, ignore;
1237
1238 ignore = 0;
1239 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
1240 j += 2) {
1241 if ((address_data->ignore[j] == adap_id ||
1242 address_data->ignore[j] == ANY_I2C_BUS)
1243 && address_data->ignore[j + 1]
1244 == address_data->normal_i2c[i]) {
1245 dev_dbg(&adapter->dev, "found ignore "
1246 "parameter for adapter %d, "
1247 "addr 0x%02x\n", adap_id,
1248 address_data->ignore[j + 1]);
Mark M. Hoffman2369df92006-07-01 17:01:59 +02001249 ignore = 1;
1250 break;
Jean Delvarea89ba0b2005-08-09 20:17:55 +02001251 }
Jean Delvarea89ba0b2005-08-09 20:17:55 +02001252 }
1253 if (ignore)
1254 continue;
1255
1256 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1257 "addr 0x%02x\n", adap_id,
1258 address_data->normal_i2c[i]);
1259 err = i2c_probe_address(adapter, address_data->normal_i2c[i],
1260 -1, found_proc);
1261 if (err)
1262 return err;
1263 }
1264
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 return 0;
1266}
David Brownellc0564602007-05-01 23:26:31 +02001267EXPORT_SYMBOL(i2c_probe);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268
Jean Delvare4735c982008-07-14 22:38:36 +02001269/* Separate detection function for new-style drivers */
1270static int i2c_detect_address(struct i2c_client *temp_client, int kind,
1271 struct i2c_driver *driver)
1272{
1273 struct i2c_board_info info;
1274 struct i2c_adapter *adapter = temp_client->adapter;
1275 int addr = temp_client->addr;
1276 int err;
1277
1278 /* Make sure the address is valid */
1279 if (addr < 0x03 || addr > 0x77) {
1280 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1281 addr);
1282 return -EINVAL;
1283 }
1284
1285 /* Skip if already in use */
1286 if (i2c_check_addr(adapter, addr))
1287 return 0;
1288
1289 /* Make sure there is something at this address, unless forced */
1290 if (kind < 0) {
1291 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1292 I2C_SMBUS_QUICK, NULL) < 0)
1293 return 0;
1294
1295 /* prevent 24RF08 corruption */
1296 if ((addr & ~0x0f) == 0x50)
1297 i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1298 I2C_SMBUS_QUICK, NULL);
1299 }
1300
1301 /* Finally call the custom detection function */
1302 memset(&info, 0, sizeof(struct i2c_board_info));
1303 info.addr = addr;
1304 err = driver->detect(temp_client, kind, &info);
1305 if (err) {
1306 /* -ENODEV is returned if the detection fails. We catch it
1307 here as this isn't an error. */
1308 return err == -ENODEV ? 0 : err;
1309 }
1310
1311 /* Consistency check */
1312 if (info.type[0] == '\0') {
1313 dev_err(&adapter->dev, "%s detection function provided "
1314 "no name for 0x%x\n", driver->driver.name,
1315 addr);
1316 } else {
1317 struct i2c_client *client;
1318
1319 /* Detection succeeded, instantiate the device */
1320 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
1321 info.type, info.addr);
1322 client = i2c_new_device(adapter, &info);
1323 if (client)
1324 list_add_tail(&client->detected, &driver->clients);
1325 else
1326 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
1327 info.type, info.addr);
1328 }
1329 return 0;
1330}
1331
1332static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
1333{
1334 const struct i2c_client_address_data *address_data;
1335 struct i2c_client *temp_client;
1336 int i, err = 0;
1337 int adap_id = i2c_adapter_id(adapter);
1338
1339 address_data = driver->address_data;
1340 if (!driver->detect || !address_data)
1341 return 0;
1342
1343 /* Set up a temporary client to help detect callback */
1344 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
1345 if (!temp_client)
1346 return -ENOMEM;
1347 temp_client->adapter = adapter;
1348
1349 /* Force entries are done first, and are not affected by ignore
1350 entries */
1351 if (address_data->forces) {
1352 const unsigned short * const *forces = address_data->forces;
1353 int kind;
1354
1355 for (kind = 0; forces[kind]; kind++) {
1356 for (i = 0; forces[kind][i] != I2C_CLIENT_END;
1357 i += 2) {
1358 if (forces[kind][i] == adap_id
1359 || forces[kind][i] == ANY_I2C_BUS) {
1360 dev_dbg(&adapter->dev, "found force "
1361 "parameter for adapter %d, "
1362 "addr 0x%02x, kind %d\n",
1363 adap_id, forces[kind][i + 1],
1364 kind);
1365 temp_client->addr = forces[kind][i + 1];
1366 err = i2c_detect_address(temp_client,
1367 kind, driver);
1368 if (err)
1369 goto exit_free;
1370 }
1371 }
1372 }
1373 }
1374
Jean Delvare4329cf82008-08-28 08:33:23 +02001375 /* Stop here if the classes do not match */
1376 if (!(adapter->class & driver->class))
1377 goto exit_free;
1378
Jean Delvare4735c982008-07-14 22:38:36 +02001379 /* Stop here if we can't use SMBUS_QUICK */
1380 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
1381 if (address_data->probe[0] == I2C_CLIENT_END
1382 && address_data->normal_i2c[0] == I2C_CLIENT_END)
1383 goto exit_free;
1384
1385 dev_warn(&adapter->dev, "SMBus Quick command not supported, "
1386 "can't probe for chips\n");
1387 err = -EOPNOTSUPP;
1388 goto exit_free;
1389 }
1390
Jean Delvare4735c982008-07-14 22:38:36 +02001391 /* Probe entries are done second, and are not affected by ignore
1392 entries either */
1393 for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
1394 if (address_data->probe[i] == adap_id
1395 || address_data->probe[i] == ANY_I2C_BUS) {
1396 dev_dbg(&adapter->dev, "found probe parameter for "
1397 "adapter %d, addr 0x%02x\n", adap_id,
1398 address_data->probe[i + 1]);
1399 temp_client->addr = address_data->probe[i + 1];
1400 err = i2c_detect_address(temp_client, -1, driver);
1401 if (err)
1402 goto exit_free;
1403 }
1404 }
1405
1406 /* Normal entries are done last, unless shadowed by an ignore entry */
1407 for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
1408 int j, ignore;
1409
1410 ignore = 0;
1411 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
1412 j += 2) {
1413 if ((address_data->ignore[j] == adap_id ||
1414 address_data->ignore[j] == ANY_I2C_BUS)
1415 && address_data->ignore[j + 1]
1416 == address_data->normal_i2c[i]) {
1417 dev_dbg(&adapter->dev, "found ignore "
1418 "parameter for adapter %d, "
1419 "addr 0x%02x\n", adap_id,
1420 address_data->ignore[j + 1]);
1421 ignore = 1;
1422 break;
1423 }
1424 }
1425 if (ignore)
1426 continue;
1427
1428 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1429 "addr 0x%02x\n", adap_id,
1430 address_data->normal_i2c[i]);
1431 temp_client->addr = address_data->normal_i2c[i];
1432 err = i2c_detect_address(temp_client, -1, driver);
1433 if (err)
1434 goto exit_free;
1435 }
1436
1437 exit_free:
1438 kfree(temp_client);
1439 return err;
1440}
1441
Jean Delvare12b5053a2007-05-01 23:26:31 +02001442struct i2c_client *
1443i2c_new_probed_device(struct i2c_adapter *adap,
1444 struct i2c_board_info *info,
1445 unsigned short const *addr_list)
1446{
1447 int i;
1448
1449 /* Stop here if the bus doesn't support probing */
1450 if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE)) {
1451 dev_err(&adap->dev, "Probing not supported\n");
1452 return NULL;
1453 }
1454
Jean Delvare12b5053a2007-05-01 23:26:31 +02001455 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1456 /* Check address validity */
1457 if (addr_list[i] < 0x03 || addr_list[i] > 0x77) {
1458 dev_warn(&adap->dev, "Invalid 7-bit address "
1459 "0x%02x\n", addr_list[i]);
1460 continue;
1461 }
1462
1463 /* Check address availability */
David Brownell9b766b82008-01-27 18:14:51 +01001464 if (i2c_check_addr(adap, addr_list[i])) {
Jean Delvare12b5053a2007-05-01 23:26:31 +02001465 dev_dbg(&adap->dev, "Address 0x%02x already in "
1466 "use, not probing\n", addr_list[i]);
1467 continue;
1468 }
1469
1470 /* Test address responsiveness
1471 The default probe method is a quick write, but it is known
1472 to corrupt the 24RF08 EEPROMs due to a state machine bug,
1473 and could also irreversibly write-protect some EEPROMs, so
1474 for address ranges 0x30-0x37 and 0x50-0x5f, we use a byte
1475 read instead. Also, some bus drivers don't implement
1476 quick write, so we fallback to a byte read it that case
1477 too. */
1478 if ((addr_list[i] & ~0x07) == 0x30
1479 || (addr_list[i] & ~0x0f) == 0x50
1480 || !i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK)) {
Hans Verkuilb25b7912008-08-10 22:56:15 +02001481 union i2c_smbus_data data;
1482
Jean Delvare12b5053a2007-05-01 23:26:31 +02001483 if (i2c_smbus_xfer(adap, addr_list[i], 0,
1484 I2C_SMBUS_READ, 0,
Hans Verkuilb25b7912008-08-10 22:56:15 +02001485 I2C_SMBUS_BYTE, &data) >= 0)
Jean Delvare12b5053a2007-05-01 23:26:31 +02001486 break;
1487 } else {
1488 if (i2c_smbus_xfer(adap, addr_list[i], 0,
1489 I2C_SMBUS_WRITE, 0,
1490 I2C_SMBUS_QUICK, NULL) >= 0)
1491 break;
1492 }
1493 }
Jean Delvare12b5053a2007-05-01 23:26:31 +02001494
1495 if (addr_list[i] == I2C_CLIENT_END) {
1496 dev_dbg(&adap->dev, "Probing failed, no device found\n");
1497 return NULL;
1498 }
1499
1500 info->addr = addr_list[i];
1501 return i2c_new_device(adap, info);
1502}
1503EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1504
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505struct i2c_adapter* i2c_get_adapter(int id)
1506{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507 struct i2c_adapter *adapter;
David Brownell438d6c22006-12-10 21:21:31 +01001508
Jean Delvarecaada322008-01-27 18:14:49 +01001509 mutex_lock(&core_lock);
Jack Stone1cf92b42009-06-15 18:01:46 +02001510 adapter = idr_find(&i2c_adapter_idr, id);
Mark M. Hoffmana0920e12005-06-28 00:21:30 -04001511 if (adapter && !try_module_get(adapter->owner))
1512 adapter = NULL;
1513
Jean Delvarecaada322008-01-27 18:14:49 +01001514 mutex_unlock(&core_lock);
Mark M. Hoffmana0920e12005-06-28 00:21:30 -04001515 return adapter;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516}
David Brownellc0564602007-05-01 23:26:31 +02001517EXPORT_SYMBOL(i2c_get_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518
1519void i2c_put_adapter(struct i2c_adapter *adap)
1520{
1521 module_put(adap->owner);
1522}
David Brownellc0564602007-05-01 23:26:31 +02001523EXPORT_SYMBOL(i2c_put_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524
1525/* The SMBus parts */
1526
David Brownell438d6c22006-12-10 21:21:31 +01001527#define POLY (0x1070U << 3)
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01001528static u8 crc8(u16 data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529{
1530 int i;
David Brownell438d6c22006-12-10 21:21:31 +01001531
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532 for(i = 0; i < 8; i++) {
David Brownell438d6c22006-12-10 21:21:31 +01001533 if (data & 0x8000)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534 data = data ^ POLY;
1535 data = data << 1;
1536 }
1537 return (u8)(data >> 8);
1538}
1539
Jean Delvare421ef472005-10-26 21:28:55 +02001540/* Incremental CRC8 over count bytes in the array pointed to by p */
1541static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542{
1543 int i;
1544
1545 for(i = 0; i < count; i++)
Jean Delvare421ef472005-10-26 21:28:55 +02001546 crc = crc8((crc ^ p[i]) << 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547 return crc;
1548}
1549
Jean Delvare421ef472005-10-26 21:28:55 +02001550/* Assume a 7-bit address, which is reasonable for SMBus */
1551static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552{
Jean Delvare421ef472005-10-26 21:28:55 +02001553 /* The address will be sent first */
1554 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1555 pec = i2c_smbus_pec(pec, &addr, 1);
1556
1557 /* The data buffer follows */
1558 return i2c_smbus_pec(pec, msg->buf, msg->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559}
1560
Jean Delvare421ef472005-10-26 21:28:55 +02001561/* Used for write only transactions */
1562static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563{
Jean Delvare421ef472005-10-26 21:28:55 +02001564 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1565 msg->len++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566}
1567
Jean Delvare421ef472005-10-26 21:28:55 +02001568/* Return <0 on CRC error
1569 If there was a write before this read (most cases) we need to take the
1570 partial CRC from the write part into account.
1571 Note that this function does modify the message (we need to decrease the
1572 message length to hide the CRC byte from the caller). */
1573static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574{
Jean Delvare421ef472005-10-26 21:28:55 +02001575 u8 rpec = msg->buf[--msg->len];
1576 cpec = i2c_smbus_msg_pec(cpec, msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578 if (rpec != cpec) {
1579 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1580 rpec, cpec);
David Brownell24a5bb72008-07-14 22:38:23 +02001581 return -EBADMSG;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582 }
David Brownell438d6c22006-12-10 21:21:31 +01001583 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584}
1585
David Brownella1cdeda2008-07-14 22:38:24 +02001586/**
1587 * i2c_smbus_read_byte - SMBus "receive byte" protocol
1588 * @client: Handle to slave device
1589 *
1590 * This executes the SMBus "receive byte" protocol, returning negative errno
1591 * else the byte received from the device.
1592 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593s32 i2c_smbus_read_byte(struct i2c_client *client)
1594{
1595 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02001596 int status;
1597
1598 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1599 I2C_SMBUS_READ, 0,
1600 I2C_SMBUS_BYTE, &data);
1601 return (status < 0) ? status : data.byte;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602}
David Brownellc0564602007-05-01 23:26:31 +02001603EXPORT_SYMBOL(i2c_smbus_read_byte);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604
David Brownella1cdeda2008-07-14 22:38:24 +02001605/**
1606 * i2c_smbus_write_byte - SMBus "send byte" protocol
1607 * @client: Handle to slave device
1608 * @value: Byte to be sent
1609 *
1610 * This executes the SMBus "send byte" protocol, returning negative errno
1611 * else zero on success.
1612 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
1614{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
Jean Delvare421ef472005-10-26 21:28:55 +02001616 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617}
David Brownellc0564602007-05-01 23:26:31 +02001618EXPORT_SYMBOL(i2c_smbus_write_byte);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619
David Brownella1cdeda2008-07-14 22:38:24 +02001620/**
1621 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
1622 * @client: Handle to slave device
1623 * @command: Byte interpreted by slave
1624 *
1625 * This executes the SMBus "read byte" protocol, returning negative errno
1626 * else a data byte received from the device.
1627 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
1629{
1630 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02001631 int status;
1632
1633 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1634 I2C_SMBUS_READ, command,
1635 I2C_SMBUS_BYTE_DATA, &data);
1636 return (status < 0) ? status : data.byte;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637}
David Brownellc0564602007-05-01 23:26:31 +02001638EXPORT_SYMBOL(i2c_smbus_read_byte_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639
David Brownella1cdeda2008-07-14 22:38:24 +02001640/**
1641 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
1642 * @client: Handle to slave device
1643 * @command: Byte interpreted by slave
1644 * @value: Byte being written
1645 *
1646 * This executes the SMBus "write byte" protocol, returning negative errno
1647 * else zero on success.
1648 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
1650{
1651 union i2c_smbus_data data;
1652 data.byte = value;
1653 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1654 I2C_SMBUS_WRITE,command,
1655 I2C_SMBUS_BYTE_DATA,&data);
1656}
David Brownellc0564602007-05-01 23:26:31 +02001657EXPORT_SYMBOL(i2c_smbus_write_byte_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658
David Brownella1cdeda2008-07-14 22:38:24 +02001659/**
1660 * i2c_smbus_read_word_data - SMBus "read word" protocol
1661 * @client: Handle to slave device
1662 * @command: Byte interpreted by slave
1663 *
1664 * This executes the SMBus "read word" protocol, returning negative errno
1665 * else a 16-bit unsigned "word" received from the device.
1666 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
1668{
1669 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02001670 int status;
1671
1672 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1673 I2C_SMBUS_READ, command,
1674 I2C_SMBUS_WORD_DATA, &data);
1675 return (status < 0) ? status : data.word;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676}
David Brownellc0564602007-05-01 23:26:31 +02001677EXPORT_SYMBOL(i2c_smbus_read_word_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678
David Brownella1cdeda2008-07-14 22:38:24 +02001679/**
1680 * i2c_smbus_write_word_data - SMBus "write word" protocol
1681 * @client: Handle to slave device
1682 * @command: Byte interpreted by slave
1683 * @value: 16-bit "word" being written
1684 *
1685 * This executes the SMBus "write word" protocol, returning negative errno
1686 * else zero on success.
1687 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
1689{
1690 union i2c_smbus_data data;
1691 data.word = value;
1692 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1693 I2C_SMBUS_WRITE,command,
1694 I2C_SMBUS_WORD_DATA,&data);
1695}
David Brownellc0564602007-05-01 23:26:31 +02001696EXPORT_SYMBOL(i2c_smbus_write_word_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697
David Brownella64ec072007-10-13 23:56:31 +02001698/**
Prakash Mortha596c88f2008-10-14 17:30:06 +02001699 * i2c_smbus_process_call - SMBus "process call" protocol
1700 * @client: Handle to slave device
1701 * @command: Byte interpreted by slave
1702 * @value: 16-bit "word" being written
1703 *
1704 * This executes the SMBus "process call" protocol, returning negative errno
1705 * else a 16-bit unsigned "word" received from the device.
1706 */
1707s32 i2c_smbus_process_call(struct i2c_client *client, u8 command, u16 value)
1708{
1709 union i2c_smbus_data data;
1710 int status;
1711 data.word = value;
1712
1713 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1714 I2C_SMBUS_WRITE, command,
1715 I2C_SMBUS_PROC_CALL, &data);
1716 return (status < 0) ? status : data.word;
1717}
1718EXPORT_SYMBOL(i2c_smbus_process_call);
1719
1720/**
David Brownella1cdeda2008-07-14 22:38:24 +02001721 * i2c_smbus_read_block_data - SMBus "block read" protocol
David Brownella64ec072007-10-13 23:56:31 +02001722 * @client: Handle to slave device
David Brownella1cdeda2008-07-14 22:38:24 +02001723 * @command: Byte interpreted by slave
David Brownella64ec072007-10-13 23:56:31 +02001724 * @values: Byte array into which data will be read; big enough to hold
1725 * the data returned by the slave. SMBus allows at most 32 bytes.
1726 *
David Brownella1cdeda2008-07-14 22:38:24 +02001727 * This executes the SMBus "block read" protocol, returning negative errno
1728 * else the number of data bytes in the slave's response.
David Brownella64ec072007-10-13 23:56:31 +02001729 *
1730 * Note that using this function requires that the client's adapter support
1731 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
1732 * support this; its emulation through I2C messaging relies on a specific
1733 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
1734 */
Jean Delvareb86a1bc2007-05-01 23:26:34 +02001735s32 i2c_smbus_read_block_data(struct i2c_client *client, u8 command,
1736 u8 *values)
1737{
1738 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02001739 int status;
Jean Delvareb86a1bc2007-05-01 23:26:34 +02001740
David Brownell24a5bb72008-07-14 22:38:23 +02001741 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1742 I2C_SMBUS_READ, command,
1743 I2C_SMBUS_BLOCK_DATA, &data);
1744 if (status)
1745 return status;
Jean Delvareb86a1bc2007-05-01 23:26:34 +02001746
1747 memcpy(values, &data.block[1], data.block[0]);
1748 return data.block[0];
1749}
1750EXPORT_SYMBOL(i2c_smbus_read_block_data);
1751
David Brownella1cdeda2008-07-14 22:38:24 +02001752/**
1753 * i2c_smbus_write_block_data - SMBus "block write" protocol
1754 * @client: Handle to slave device
1755 * @command: Byte interpreted by slave
1756 * @length: Size of data block; SMBus allows at most 32 bytes
1757 * @values: Byte array which will be written.
1758 *
1759 * This executes the SMBus "block write" protocol, returning negative errno
1760 * else zero on success.
1761 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
Krzysztof Halasa46f5ed72006-06-12 21:42:20 +02001763 u8 length, const u8 *values)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764{
1765 union i2c_smbus_data data;
Jean Delvare76560322006-01-18 23:14:55 +01001766
Linus Torvalds1da177e2005-04-16 15:20:36 -07001767 if (length > I2C_SMBUS_BLOCK_MAX)
1768 length = I2C_SMBUS_BLOCK_MAX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769 data.block[0] = length;
Jean Delvare76560322006-01-18 23:14:55 +01001770 memcpy(&data.block[1], values, length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1772 I2C_SMBUS_WRITE,command,
1773 I2C_SMBUS_BLOCK_DATA,&data);
1774}
David Brownellc0564602007-05-01 23:26:31 +02001775EXPORT_SYMBOL(i2c_smbus_write_block_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776
1777/* Returns the number of read bytes */
Jean Delvare4b2643d2007-07-12 14:12:29 +02001778s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command,
1779 u8 length, u8 *values)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780{
1781 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02001782 int status;
Jean Delvare76560322006-01-18 23:14:55 +01001783
Jean Delvare4b2643d2007-07-12 14:12:29 +02001784 if (length > I2C_SMBUS_BLOCK_MAX)
1785 length = I2C_SMBUS_BLOCK_MAX;
1786 data.block[0] = length;
David Brownell24a5bb72008-07-14 22:38:23 +02001787 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1788 I2C_SMBUS_READ, command,
1789 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1790 if (status < 0)
1791 return status;
Jean Delvare76560322006-01-18 23:14:55 +01001792
1793 memcpy(values, &data.block[1], data.block[0]);
1794 return data.block[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001795}
David Brownellc0564602007-05-01 23:26:31 +02001796EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797
Jean Delvare21bbd692006-01-09 15:19:18 +11001798s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, u8 command,
Krzysztof Halasa46f5ed72006-06-12 21:42:20 +02001799 u8 length, const u8 *values)
Jean Delvare21bbd692006-01-09 15:19:18 +11001800{
1801 union i2c_smbus_data data;
1802
1803 if (length > I2C_SMBUS_BLOCK_MAX)
1804 length = I2C_SMBUS_BLOCK_MAX;
1805 data.block[0] = length;
1806 memcpy(data.block + 1, values, length);
1807 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1808 I2C_SMBUS_WRITE, command,
1809 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1810}
David Brownellc0564602007-05-01 23:26:31 +02001811EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
Jean Delvare21bbd692006-01-09 15:19:18 +11001812
David Brownell438d6c22006-12-10 21:21:31 +01001813/* Simulate a SMBus command using the i2c protocol
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814 No checking of parameters is done! */
David Brownell438d6c22006-12-10 21:21:31 +01001815static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816 unsigned short flags,
David Brownell438d6c22006-12-10 21:21:31 +01001817 char read_write, u8 command, int size,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818 union i2c_smbus_data * data)
1819{
1820 /* So we need to generate a series of msgs. In the case of writing, we
1821 need to use only one message; when reading, we need two. We initialize
1822 most things with sane defaults, to keep the code below somewhat
1823 simpler. */
Hideki Iwamoto5c50d182005-09-25 17:01:11 +02001824 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1825 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 int num = read_write == I2C_SMBUS_READ?2:1;
David Brownell438d6c22006-12-10 21:21:31 +01001827 struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828 { addr, flags | I2C_M_RD, 0, msgbuf1 }
1829 };
1830 int i;
Jean Delvare421ef472005-10-26 21:28:55 +02001831 u8 partial_pec = 0;
David Brownell24a5bb72008-07-14 22:38:23 +02001832 int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001833
1834 msgbuf0[0] = command;
1835 switch(size) {
1836 case I2C_SMBUS_QUICK:
1837 msg[0].len = 0;
1838 /* Special case: The read/write field is used as data */
Roel Kluinf29d2e02009-02-24 19:19:48 +01001839 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
1840 I2C_M_RD : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001841 num = 1;
1842 break;
1843 case I2C_SMBUS_BYTE:
1844 if (read_write == I2C_SMBUS_READ) {
1845 /* Special case: only a read! */
1846 msg[0].flags = I2C_M_RD | flags;
1847 num = 1;
1848 }
1849 break;
1850 case I2C_SMBUS_BYTE_DATA:
1851 if (read_write == I2C_SMBUS_READ)
1852 msg[1].len = 1;
1853 else {
1854 msg[0].len = 2;
1855 msgbuf0[1] = data->byte;
1856 }
1857 break;
1858 case I2C_SMBUS_WORD_DATA:
1859 if (read_write == I2C_SMBUS_READ)
1860 msg[1].len = 2;
1861 else {
1862 msg[0].len=3;
1863 msgbuf0[1] = data->word & 0xff;
Jean Delvare7eff82c2006-09-03 22:24:00 +02001864 msgbuf0[2] = data->word >> 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865 }
1866 break;
1867 case I2C_SMBUS_PROC_CALL:
1868 num = 2; /* Special case */
1869 read_write = I2C_SMBUS_READ;
1870 msg[0].len = 3;
1871 msg[1].len = 2;
1872 msgbuf0[1] = data->word & 0xff;
Jean Delvare7eff82c2006-09-03 22:24:00 +02001873 msgbuf0[2] = data->word >> 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874 break;
1875 case I2C_SMBUS_BLOCK_DATA:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001876 if (read_write == I2C_SMBUS_READ) {
Jean Delvare209d27c2007-05-01 23:26:29 +02001877 msg[1].flags |= I2C_M_RECV_LEN;
1878 msg[1].len = 1; /* block length will be added by
1879 the underlying bus driver */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880 } else {
1881 msg[0].len = data->block[0] + 2;
1882 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
David Brownell24a5bb72008-07-14 22:38:23 +02001883 dev_err(&adapter->dev,
1884 "Invalid block write size %d\n",
1885 data->block[0]);
1886 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887 }
Hideki Iwamoto5c50d182005-09-25 17:01:11 +02001888 for (i = 1; i < msg[0].len; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889 msgbuf0[i] = data->block[i-1];
1890 }
1891 break;
1892 case I2C_SMBUS_BLOCK_PROC_CALL:
Jean Delvare209d27c2007-05-01 23:26:29 +02001893 num = 2; /* Another special case */
1894 read_write = I2C_SMBUS_READ;
1895 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
David Brownell24a5bb72008-07-14 22:38:23 +02001896 dev_err(&adapter->dev,
1897 "Invalid block write size %d\n",
Jean Delvare209d27c2007-05-01 23:26:29 +02001898 data->block[0]);
David Brownell24a5bb72008-07-14 22:38:23 +02001899 return -EINVAL;
Jean Delvare209d27c2007-05-01 23:26:29 +02001900 }
1901 msg[0].len = data->block[0] + 2;
1902 for (i = 1; i < msg[0].len; i++)
1903 msgbuf0[i] = data->block[i-1];
1904 msg[1].flags |= I2C_M_RECV_LEN;
1905 msg[1].len = 1; /* block length will be added by
1906 the underlying bus driver */
1907 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908 case I2C_SMBUS_I2C_BLOCK_DATA:
1909 if (read_write == I2C_SMBUS_READ) {
Jean Delvare4b2643d2007-07-12 14:12:29 +02001910 msg[1].len = data->block[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001911 } else {
1912 msg[0].len = data->block[0] + 1;
Jean Delvare30dac742005-10-08 00:15:59 +02001913 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
David Brownell24a5bb72008-07-14 22:38:23 +02001914 dev_err(&adapter->dev,
1915 "Invalid block write size %d\n",
1916 data->block[0]);
1917 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 }
1919 for (i = 1; i <= data->block[0]; i++)
1920 msgbuf0[i] = data->block[i];
1921 }
1922 break;
1923 default:
David Brownell24a5bb72008-07-14 22:38:23 +02001924 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
1925 return -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 }
1927
Jean Delvare421ef472005-10-26 21:28:55 +02001928 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
1929 && size != I2C_SMBUS_I2C_BLOCK_DATA);
1930 if (i) {
1931 /* Compute PEC if first message is a write */
1932 if (!(msg[0].flags & I2C_M_RD)) {
David Brownell438d6c22006-12-10 21:21:31 +01001933 if (num == 1) /* Write only */
Jean Delvare421ef472005-10-26 21:28:55 +02001934 i2c_smbus_add_pec(&msg[0]);
1935 else /* Write followed by read */
1936 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
1937 }
1938 /* Ask for PEC if last message is a read */
1939 if (msg[num-1].flags & I2C_M_RD)
David Brownell438d6c22006-12-10 21:21:31 +01001940 msg[num-1].len++;
Jean Delvare421ef472005-10-26 21:28:55 +02001941 }
1942
David Brownell24a5bb72008-07-14 22:38:23 +02001943 status = i2c_transfer(adapter, msg, num);
1944 if (status < 0)
1945 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946
Jean Delvare421ef472005-10-26 21:28:55 +02001947 /* Check PEC if last message is a read */
1948 if (i && (msg[num-1].flags & I2C_M_RD)) {
David Brownell24a5bb72008-07-14 22:38:23 +02001949 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
1950 if (status < 0)
1951 return status;
Jean Delvare421ef472005-10-26 21:28:55 +02001952 }
1953
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954 if (read_write == I2C_SMBUS_READ)
1955 switch(size) {
1956 case I2C_SMBUS_BYTE:
1957 data->byte = msgbuf0[0];
1958 break;
1959 case I2C_SMBUS_BYTE_DATA:
1960 data->byte = msgbuf1[0];
1961 break;
David Brownell438d6c22006-12-10 21:21:31 +01001962 case I2C_SMBUS_WORD_DATA:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963 case I2C_SMBUS_PROC_CALL:
1964 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
1965 break;
1966 case I2C_SMBUS_I2C_BLOCK_DATA:
Jean Delvare4b2643d2007-07-12 14:12:29 +02001967 for (i = 0; i < data->block[0]; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968 data->block[i+1] = msgbuf1[i];
1969 break;
Jean Delvare209d27c2007-05-01 23:26:29 +02001970 case I2C_SMBUS_BLOCK_DATA:
1971 case I2C_SMBUS_BLOCK_PROC_CALL:
1972 for (i = 0; i < msgbuf1[0] + 1; i++)
1973 data->block[i] = msgbuf1[i];
1974 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975 }
1976 return 0;
1977}
1978
David Brownella1cdeda2008-07-14 22:38:24 +02001979/**
1980 * i2c_smbus_xfer - execute SMBus protocol operations
1981 * @adapter: Handle to I2C bus
1982 * @addr: Address of SMBus slave on that bus
1983 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
1984 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
1985 * @command: Byte interpreted by slave, for protocols which use such bytes
1986 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
1987 * @data: Data to be read or written
1988 *
1989 * This executes an SMBus protocol operation, and returns a negative
1990 * errno code else zero on success.
1991 */
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01001992s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
David Brownella1cdeda2008-07-14 22:38:24 +02001993 char read_write, u8 command, int protocol,
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01001994 union i2c_smbus_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995{
Clifford Wolf66b650f2009-06-15 18:01:46 +02001996 unsigned long orig_jiffies;
1997 int try;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998 s32 res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999
2000 flags &= I2C_M_TEN | I2C_CLIENT_PEC;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002001
2002 if (adapter->algo->smbus_xfer) {
Ingo Molnar5c085d32006-01-18 23:16:04 +01002003 mutex_lock(&adapter->bus_lock);
Clifford Wolf66b650f2009-06-15 18:01:46 +02002004
2005 /* Retry automatically on arbitration loss */
2006 orig_jiffies = jiffies;
2007 for (res = 0, try = 0; try <= adapter->retries; try++) {
2008 res = adapter->algo->smbus_xfer(adapter, addr, flags,
2009 read_write, command,
2010 protocol, data);
2011 if (res != -EAGAIN)
2012 break;
2013 if (time_after(jiffies,
2014 orig_jiffies + adapter->timeout))
2015 break;
2016 }
Ingo Molnar5c085d32006-01-18 23:16:04 +01002017 mutex_unlock(&adapter->bus_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002018 } else
2019 res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
David Brownella1cdeda2008-07-14 22:38:24 +02002020 command, protocol, data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002021
Linus Torvalds1da177e2005-04-16 15:20:36 -07002022 return res;
2023}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024EXPORT_SYMBOL(i2c_smbus_xfer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002025
2026MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
2027MODULE_DESCRIPTION("I2C-Bus main module");
2028MODULE_LICENSE("GPL");