blob: 7bf38c418086e45aee6f7d6ba47f256eb65e47f6 [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>
Russell Kingd052d1b2005-10-29 19:07:23 +010032#include <linux/platform_device.h>
Arjan van de Venb3585e42006-01-11 10:50:26 +010033#include <linux/mutex.h>
Jean Delvareb8d6f452007-02-13 22:09:00 +010034#include <linux/completion.h>
Mike Rapoportcea443a2008-01-27 18:14:50 +010035#include <linux/hardirq.h>
36#include <linux/irqflags.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <asm/uaccess.h>
38
David Brownell9c1600e2007-05-01 23:26:31 +020039#include "i2c-core.h"
40
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
Jean Delvarecaada322008-01-27 18:14:49 +010042static DEFINE_MUTEX(core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070043static DEFINE_IDR(i2c_adapter_idr);
44
Jean Delvare4735c982008-07-14 22:38:36 +020045#define is_newstyle_driver(d) ((d)->probe || (d)->remove || (d)->detect)
46
47static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
David Brownellf37dd802007-02-13 22:09:00 +010048
49/* ------------------------------------------------------------------------- */
50
Jean Delvared2653e92008-04-29 23:11:39 +020051static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
52 const struct i2c_client *client)
53{
54 while (id->name[0]) {
55 if (strcmp(client->name, id->name) == 0)
56 return id;
57 id++;
58 }
59 return NULL;
60}
61
Linus Torvalds1da177e2005-04-16 15:20:36 -070062static int i2c_device_match(struct device *dev, struct device_driver *drv)
63{
David Brownell7b4fbc52007-05-01 23:26:30 +020064 struct i2c_client *client = to_i2c_client(dev);
65 struct i2c_driver *driver = to_i2c_driver(drv);
66
67 /* make legacy i2c drivers bypass driver model probing entirely;
68 * such drivers scan each i2c adapter/bus themselves.
69 */
David Brownella1d9e6e2007-05-01 23:26:30 +020070 if (!is_newstyle_driver(driver))
David Brownell7b4fbc52007-05-01 23:26:30 +020071 return 0;
72
Jean Delvared2653e92008-04-29 23:11:39 +020073 /* match on an id table if there is one */
74 if (driver->id_table)
75 return i2c_match_id(driver->id_table, client) != NULL;
76
Jean Delvareeb8a7902008-05-18 20:49:41 +020077 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070078}
79
David Brownell7b4fbc52007-05-01 23:26:30 +020080#ifdef CONFIG_HOTPLUG
81
82/* uevent helps with hotplug: modprobe -q $(MODALIAS) */
Kay Sievers7eff2e72007-08-14 15:15:12 +020083static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
David Brownell7b4fbc52007-05-01 23:26:30 +020084{
85 struct i2c_client *client = to_i2c_client(dev);
David Brownell7b4fbc52007-05-01 23:26:30 +020086
87 /* by definition, legacy drivers can't hotplug */
Jean Delvared2653e92008-04-29 23:11:39 +020088 if (dev->driver)
David Brownell7b4fbc52007-05-01 23:26:30 +020089 return 0;
90
Jean Delvareeb8a7902008-05-18 20:49:41 +020091 if (add_uevent_var(env, "MODALIAS=%s%s",
92 I2C_MODULE_PREFIX, client->name))
93 return -ENOMEM;
David Brownell7b4fbc52007-05-01 23:26:30 +020094 dev_dbg(dev, "uevent\n");
95 return 0;
96}
97
98#else
99#define i2c_device_uevent NULL
100#endif /* CONFIG_HOTPLUG */
101
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102static int i2c_device_probe(struct device *dev)
103{
David Brownell7b4fbc52007-05-01 23:26:30 +0200104 struct i2c_client *client = to_i2c_client(dev);
105 struct i2c_driver *driver = to_i2c_driver(dev->driver);
Hans Verkuil50c33042008-03-12 14:15:00 +0100106 int status;
David Brownell7b4fbc52007-05-01 23:26:30 +0200107
Jean Delvaree0457442008-07-14 22:38:30 +0200108 if (!driver->probe || !driver->id_table)
David Brownell7b4fbc52007-05-01 23:26:30 +0200109 return -ENODEV;
110 client->driver = driver;
111 dev_dbg(dev, "probe\n");
Jean Delvared2653e92008-04-29 23:11:39 +0200112
Jean Delvaree0457442008-07-14 22:38:30 +0200113 status = driver->probe(client, i2c_match_id(driver->id_table, client));
Hans Verkuil50c33042008-03-12 14:15:00 +0100114 if (status)
115 client->driver = NULL;
116 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117}
118
119static int i2c_device_remove(struct device *dev)
120{
David Brownella1d9e6e2007-05-01 23:26:30 +0200121 struct i2c_client *client = to_i2c_client(dev);
122 struct i2c_driver *driver;
123 int status;
124
125 if (!dev->driver)
126 return 0;
127
128 driver = to_i2c_driver(dev->driver);
129 if (driver->remove) {
130 dev_dbg(dev, "remove\n");
131 status = driver->remove(client);
132 } else {
133 dev->driver = NULL;
134 status = 0;
135 }
136 if (status == 0)
137 client->driver = NULL;
138 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139}
140
David Brownellf37dd802007-02-13 22:09:00 +0100141static void i2c_device_shutdown(struct device *dev)
142{
143 struct i2c_driver *driver;
144
145 if (!dev->driver)
146 return;
147 driver = to_i2c_driver(dev->driver);
148 if (driver->shutdown)
149 driver->shutdown(to_i2c_client(dev));
150}
151
152static int i2c_device_suspend(struct device * dev, pm_message_t mesg)
153{
154 struct i2c_driver *driver;
155
156 if (!dev->driver)
157 return 0;
158 driver = to_i2c_driver(dev->driver);
159 if (!driver->suspend)
160 return 0;
161 return driver->suspend(to_i2c_client(dev), mesg);
162}
163
164static int i2c_device_resume(struct device * dev)
165{
166 struct i2c_driver *driver;
167
168 if (!dev->driver)
169 return 0;
170 driver = to_i2c_driver(dev->driver);
171 if (!driver->resume)
172 return 0;
173 return driver->resume(to_i2c_client(dev));
174}
175
David Brownell7b4fbc52007-05-01 23:26:30 +0200176static void i2c_client_release(struct device *dev)
177{
178 struct i2c_client *client = to_i2c_client(dev);
179 complete(&client->released);
180}
181
David Brownell9c1600e2007-05-01 23:26:31 +0200182static void i2c_client_dev_release(struct device *dev)
183{
184 kfree(to_i2c_client(dev));
185}
186
David Brownell7b4fbc52007-05-01 23:26:30 +0200187static ssize_t show_client_name(struct device *dev, struct device_attribute *attr, char *buf)
188{
189 struct i2c_client *client = to_i2c_client(dev);
190 return sprintf(buf, "%s\n", client->name);
191}
192
193static ssize_t show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
194{
195 struct i2c_client *client = to_i2c_client(dev);
Jean Delvareeb8a7902008-05-18 20:49:41 +0200196 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
David Brownell7b4fbc52007-05-01 23:26:30 +0200197}
198
199static struct device_attribute i2c_dev_attrs[] = {
200 __ATTR(name, S_IRUGO, show_client_name, NULL),
201 /* modalias helps coldplug: modprobe $(cat .../modalias) */
202 __ATTR(modalias, S_IRUGO, show_modalias, NULL),
203 { },
204};
205
Jon Smirle9ca9eb2008-07-14 22:38:35 +0200206struct bus_type i2c_bus_type = {
David Brownellf37dd802007-02-13 22:09:00 +0100207 .name = "i2c",
David Brownell7b4fbc52007-05-01 23:26:30 +0200208 .dev_attrs = i2c_dev_attrs,
David Brownellf37dd802007-02-13 22:09:00 +0100209 .match = i2c_device_match,
David Brownell7b4fbc52007-05-01 23:26:30 +0200210 .uevent = i2c_device_uevent,
David Brownellf37dd802007-02-13 22:09:00 +0100211 .probe = i2c_device_probe,
212 .remove = i2c_device_remove,
213 .shutdown = i2c_device_shutdown,
214 .suspend = i2c_device_suspend,
215 .resume = i2c_device_resume,
Russell Kingb864c7d2006-01-05 14:37:50 +0000216};
Jon Smirle9ca9eb2008-07-14 22:38:35 +0200217EXPORT_SYMBOL_GPL(i2c_bus_type);
Russell Kingb864c7d2006-01-05 14:37:50 +0000218
David Brownell9b766b82008-01-27 18:14:51 +0100219
220/**
221 * i2c_verify_client - return parameter as i2c_client, or NULL
222 * @dev: device, probably from some driver model iterator
223 *
224 * When traversing the driver model tree, perhaps using driver model
225 * iterators like @device_for_each_child(), you can't assume very much
226 * about the nodes you find. Use this function to avoid oopses caused
227 * by wrongly treating some non-I2C device as an i2c_client.
228 */
229struct i2c_client *i2c_verify_client(struct device *dev)
230{
231 return (dev->bus == &i2c_bus_type)
232 ? to_i2c_client(dev)
233 : NULL;
234}
235EXPORT_SYMBOL(i2c_verify_client);
236
237
David Brownell9c1600e2007-05-01 23:26:31 +0200238/**
239 * i2c_new_device - instantiate an i2c device for use with a new style driver
240 * @adap: the adapter managing the device
241 * @info: describes one I2C device; bus_num is ignored
David Brownelld64f73b2007-07-12 14:12:28 +0200242 * Context: can sleep
David Brownell9c1600e2007-05-01 23:26:31 +0200243 *
244 * Create a device to work with a new style i2c driver, where binding is
245 * handled through driver model probe()/remove() methods. This call is not
246 * appropriate for use by mainboad initialization logic, which usually runs
247 * during an arch_initcall() long before any i2c_adapter could exist.
248 *
249 * This returns the new i2c client, which may be saved for later use with
250 * i2c_unregister_device(); or NULL to indicate an error.
251 */
252struct i2c_client *
253i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
254{
255 struct i2c_client *client;
256 int status;
257
258 client = kzalloc(sizeof *client, GFP_KERNEL);
259 if (!client)
260 return NULL;
261
262 client->adapter = adap;
263
264 client->dev.platform_data = info->platform_data;
David Brownell3bbb8352007-10-13 23:56:29 +0200265 device_init_wakeup(&client->dev, info->flags & I2C_CLIENT_WAKE);
266
267 client->flags = info->flags & ~I2C_CLIENT_WAKE;
David Brownell9c1600e2007-05-01 23:26:31 +0200268 client->addr = info->addr;
269 client->irq = info->irq;
270
David Brownell9c1600e2007-05-01 23:26:31 +0200271 strlcpy(client->name, info->type, sizeof(client->name));
272
273 /* a new style driver may be bound to this device when we
274 * return from this function, or any later moment (e.g. maybe
275 * hotplugging will load the driver module). and the device
276 * refcount model is the standard driver model one.
277 */
278 status = i2c_attach_client(client);
279 if (status < 0) {
280 kfree(client);
281 client = NULL;
282 }
283 return client;
284}
285EXPORT_SYMBOL_GPL(i2c_new_device);
286
287
288/**
289 * i2c_unregister_device - reverse effect of i2c_new_device()
290 * @client: value returned from i2c_new_device()
David Brownelld64f73b2007-07-12 14:12:28 +0200291 * Context: can sleep
David Brownell9c1600e2007-05-01 23:26:31 +0200292 */
293void i2c_unregister_device(struct i2c_client *client)
David Brownella1d9e6e2007-05-01 23:26:30 +0200294{
295 struct i2c_adapter *adapter = client->adapter;
296 struct i2c_driver *driver = client->driver;
297
298 if (driver && !is_newstyle_driver(driver)) {
299 dev_err(&client->dev, "can't unregister devices "
300 "with legacy drivers\n");
301 WARN_ON(1);
302 return;
303 }
304
Jean Delvare85081592008-07-14 22:38:36 +0200305 if (adapter->client_unregister) {
306 if (adapter->client_unregister(client)) {
307 dev_warn(&client->dev,
308 "client_unregister [%s] failed\n",
309 client->name);
310 }
311 }
312
David Brownella1d9e6e2007-05-01 23:26:30 +0200313 mutex_lock(&adapter->clist_lock);
314 list_del(&client->list);
315 mutex_unlock(&adapter->clist_lock);
316
317 device_unregister(&client->dev);
318}
David Brownell9c1600e2007-05-01 23:26:31 +0200319EXPORT_SYMBOL_GPL(i2c_unregister_device);
David Brownella1d9e6e2007-05-01 23:26:30 +0200320
321
Jean Delvare60b129d2008-05-11 20:37:06 +0200322static const struct i2c_device_id dummy_id[] = {
323 { "dummy", 0 },
324 { },
325};
326
Jean Delvared2653e92008-04-29 23:11:39 +0200327static int dummy_probe(struct i2c_client *client,
328 const struct i2c_device_id *id)
329{
330 return 0;
331}
332
333static int dummy_remove(struct i2c_client *client)
David Brownelle9f13732008-01-27 18:14:52 +0100334{
335 return 0;
336}
337
338static struct i2c_driver dummy_driver = {
339 .driver.name = "dummy",
Jean Delvared2653e92008-04-29 23:11:39 +0200340 .probe = dummy_probe,
341 .remove = dummy_remove,
Jean Delvare60b129d2008-05-11 20:37:06 +0200342 .id_table = dummy_id,
David Brownelle9f13732008-01-27 18:14:52 +0100343};
344
345/**
346 * i2c_new_dummy - return a new i2c device bound to a dummy driver
347 * @adapter: the adapter managing the device
348 * @address: seven bit address to be used
David Brownelle9f13732008-01-27 18:14:52 +0100349 * Context: can sleep
350 *
351 * This returns an I2C client bound to the "dummy" driver, intended for use
352 * with devices that consume multiple addresses. Examples of such chips
353 * include various EEPROMS (like 24c04 and 24c08 models).
354 *
355 * These dummy devices have two main uses. First, most I2C and SMBus calls
356 * except i2c_transfer() need a client handle; the dummy will be that handle.
357 * And second, this prevents the specified address from being bound to a
358 * different driver.
359 *
360 * This returns the new i2c client, which should be saved for later use with
361 * i2c_unregister_device(); or NULL to indicate an error.
362 */
363struct i2c_client *
Jean Delvare60b129d2008-05-11 20:37:06 +0200364i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
David Brownelle9f13732008-01-27 18:14:52 +0100365{
366 struct i2c_board_info info = {
Jean Delvare60b129d2008-05-11 20:37:06 +0200367 I2C_BOARD_INFO("dummy", address),
David Brownelle9f13732008-01-27 18:14:52 +0100368 };
369
David Brownelle9f13732008-01-27 18:14:52 +0100370 return i2c_new_device(adapter, &info);
371}
372EXPORT_SYMBOL_GPL(i2c_new_dummy);
373
David Brownellf37dd802007-02-13 22:09:00 +0100374/* ------------------------------------------------------------------------- */
375
David Brownell16ffadf2007-05-01 23:26:28 +0200376/* I2C bus adapters -- one roots each I2C or SMBUS segment */
377
Adrian Bunk83eaaed2007-10-13 23:56:30 +0200378static void i2c_adapter_dev_release(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379{
David Brownellef2c8322007-05-01 23:26:28 +0200380 struct i2c_adapter *adap = to_i2c_adapter(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 complete(&adap->dev_released);
382}
383
David Brownell16ffadf2007-05-01 23:26:28 +0200384static ssize_t
385show_adapter_name(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386{
David Brownellef2c8322007-05-01 23:26:28 +0200387 struct i2c_adapter *adap = to_i2c_adapter(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 return sprintf(buf, "%s\n", adap->name);
389}
David Brownell16ffadf2007-05-01 23:26:28 +0200390
391static struct device_attribute i2c_adapter_attrs[] = {
392 __ATTR(name, S_IRUGO, show_adapter_name, NULL),
393 { },
394};
395
Adrian Bunk83eaaed2007-10-13 23:56:30 +0200396static struct class i2c_adapter_class = {
David Brownell16ffadf2007-05-01 23:26:28 +0200397 .owner = THIS_MODULE,
398 .name = "i2c-adapter",
399 .dev_attrs = i2c_adapter_attrs,
400};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401
David Brownell9c1600e2007-05-01 23:26:31 +0200402static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
403{
404 struct i2c_devinfo *devinfo;
405
406 mutex_lock(&__i2c_board_lock);
407 list_for_each_entry(devinfo, &__i2c_board_list, list) {
408 if (devinfo->busnum == adapter->nr
409 && !i2c_new_device(adapter,
410 &devinfo->board_info))
411 printk(KERN_ERR "i2c-core: can't create i2c%d-%04x\n",
412 i2c_adapter_id(adapter),
413 devinfo->board_info.addr);
414 }
415 mutex_unlock(&__i2c_board_lock);
416}
417
Jean Delvare026526f2008-01-27 18:14:49 +0100418static int i2c_do_add_adapter(struct device_driver *d, void *data)
419{
420 struct i2c_driver *driver = to_i2c_driver(d);
421 struct i2c_adapter *adap = data;
422
Jean Delvare4735c982008-07-14 22:38:36 +0200423 /* Detect supported devices on that bus, and instantiate them */
424 i2c_detect(adap, driver);
425
426 /* Let legacy drivers scan this bus for matching devices */
Jean Delvare026526f2008-01-27 18:14:49 +0100427 if (driver->attach_adapter) {
428 /* We ignore the return code; if it fails, too bad */
429 driver->attach_adapter(adap);
430 }
431 return 0;
432}
433
David Brownell6e13e642007-05-01 23:26:31 +0200434static int i2c_register_adapter(struct i2c_adapter *adap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435{
Jean Delvare026526f2008-01-27 18:14:49 +0100436 int res = 0, dummy;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437
Ingo Molnar5c085d32006-01-18 23:16:04 +0100438 mutex_init(&adap->bus_lock);
439 mutex_init(&adap->clist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 INIT_LIST_HEAD(&adap->clients);
441
Jean Delvarecaada322008-01-27 18:14:49 +0100442 mutex_lock(&core_lock);
David Brownell6e13e642007-05-01 23:26:31 +0200443
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 /* Add the adapter to the driver core.
445 * If the parent pointer is not set up,
446 * we add this adapter to the host bus.
447 */
David Brownellb119dc32007-01-04 13:07:04 +0100448 if (adap->dev.parent == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 adap->dev.parent = &platform_bus;
Jean Delvarefe2c8d52007-02-13 22:09:04 +0100450 pr_debug("I2C adapter driver [%s] forgot to specify "
451 "physical device\n", adap->name);
David Brownellb119dc32007-01-04 13:07:04 +0100452 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 sprintf(adap->dev.bus_id, "i2c-%d", adap->nr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 adap->dev.release = &i2c_adapter_dev_release;
Jean Delvarefccb56e2007-05-01 23:26:27 +0200455 adap->dev.class = &i2c_adapter_class;
Jean Delvareb119c6c2006-08-15 18:26:30 +0200456 res = device_register(&adap->dev);
457 if (res)
458 goto out_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459
Jean Delvareb6d7b3d2005-07-31 19:02:53 +0200460 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
461
David Brownell6e13e642007-05-01 23:26:31 +0200462 /* create pre-declared device nodes for new-style drivers */
463 if (adap->nr < __i2c_first_dynamic_bus_num)
464 i2c_scan_static_board_info(adap);
465
Jean Delvare4735c982008-07-14 22:38:36 +0200466 /* Notify drivers */
Jean Delvare026526f2008-01-27 18:14:49 +0100467 dummy = bus_for_each_drv(&i2c_bus_type, NULL, adap,
468 i2c_do_add_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470out_unlock:
Jean Delvarecaada322008-01-27 18:14:49 +0100471 mutex_unlock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 return res;
Jean Delvareb119c6c2006-08-15 18:26:30 +0200473
Jean Delvareb119c6c2006-08-15 18:26:30 +0200474out_list:
Jean Delvareb119c6c2006-08-15 18:26:30 +0200475 idr_remove(&i2c_adapter_idr, adap->nr);
476 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477}
478
David Brownell6e13e642007-05-01 23:26:31 +0200479/**
480 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
481 * @adapter: the adapter to add
David Brownelld64f73b2007-07-12 14:12:28 +0200482 * Context: can sleep
David Brownell6e13e642007-05-01 23:26:31 +0200483 *
484 * This routine is used to declare an I2C adapter when its bus number
485 * doesn't matter. Examples: for I2C adapters dynamically added by
486 * USB links or PCI plugin cards.
487 *
488 * When this returns zero, a new bus number was allocated and stored
489 * in adap->nr, and the specified adapter became available for clients.
490 * Otherwise, a negative errno value is returned.
491 */
492int i2c_add_adapter(struct i2c_adapter *adapter)
493{
494 int id, res = 0;
495
496retry:
497 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
498 return -ENOMEM;
499
Jean Delvarecaada322008-01-27 18:14:49 +0100500 mutex_lock(&core_lock);
David Brownell6e13e642007-05-01 23:26:31 +0200501 /* "above" here means "above or equal to", sigh */
502 res = idr_get_new_above(&i2c_adapter_idr, adapter,
503 __i2c_first_dynamic_bus_num, &id);
Jean Delvarecaada322008-01-27 18:14:49 +0100504 mutex_unlock(&core_lock);
David Brownell6e13e642007-05-01 23:26:31 +0200505
506 if (res < 0) {
507 if (res == -EAGAIN)
508 goto retry;
509 return res;
510 }
511
512 adapter->nr = id;
513 return i2c_register_adapter(adapter);
514}
515EXPORT_SYMBOL(i2c_add_adapter);
516
517/**
518 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
519 * @adap: the adapter to register (with adap->nr initialized)
David Brownelld64f73b2007-07-12 14:12:28 +0200520 * Context: can sleep
David Brownell6e13e642007-05-01 23:26:31 +0200521 *
522 * This routine is used to declare an I2C adapter when its bus number
Randy Dunlap8c07e462008-03-23 20:28:20 +0100523 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
524 * or otherwise built in to the system's mainboard, and where i2c_board_info
David Brownell6e13e642007-05-01 23:26:31 +0200525 * is used to properly configure I2C devices.
526 *
527 * If no devices have pre-been declared for this bus, then be sure to
528 * register the adapter before any dynamically allocated ones. Otherwise
529 * the required bus ID may not be available.
530 *
531 * When this returns zero, the specified adapter became available for
532 * clients using the bus number provided in adap->nr. Also, the table
533 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
534 * and the appropriate driver model device nodes are created. Otherwise, a
535 * negative errno value is returned.
536 */
537int i2c_add_numbered_adapter(struct i2c_adapter *adap)
538{
539 int id;
540 int status;
541
542 if (adap->nr & ~MAX_ID_MASK)
543 return -EINVAL;
544
545retry:
546 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
547 return -ENOMEM;
548
Jean Delvarecaada322008-01-27 18:14:49 +0100549 mutex_lock(&core_lock);
David Brownell6e13e642007-05-01 23:26:31 +0200550 /* "above" here means "above or equal to", sigh;
551 * we need the "equal to" result to force the result
552 */
553 status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
554 if (status == 0 && id != adap->nr) {
555 status = -EBUSY;
556 idr_remove(&i2c_adapter_idr, id);
557 }
Jean Delvarecaada322008-01-27 18:14:49 +0100558 mutex_unlock(&core_lock);
David Brownell6e13e642007-05-01 23:26:31 +0200559 if (status == -EAGAIN)
560 goto retry;
561
562 if (status == 0)
563 status = i2c_register_adapter(adap);
564 return status;
565}
566EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
567
Jean Delvare026526f2008-01-27 18:14:49 +0100568static int i2c_do_del_adapter(struct device_driver *d, void *data)
569{
570 struct i2c_driver *driver = to_i2c_driver(d);
571 struct i2c_adapter *adapter = data;
Jean Delvare4735c982008-07-14 22:38:36 +0200572 struct i2c_client *client, *_n;
Jean Delvare026526f2008-01-27 18:14:49 +0100573 int res;
574
Jean Delvare4735c982008-07-14 22:38:36 +0200575 /* Remove the devices we created ourselves */
576 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
577 if (client->adapter == adapter) {
578 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
579 client->name, client->addr);
580 list_del(&client->detected);
581 i2c_unregister_device(client);
582 }
583 }
584
Jean Delvare026526f2008-01-27 18:14:49 +0100585 if (!driver->detach_adapter)
586 return 0;
587 res = driver->detach_adapter(adapter);
588 if (res)
589 dev_err(&adapter->dev, "detach_adapter failed (%d) "
590 "for driver [%s]\n", res, driver->driver.name);
591 return res;
592}
593
David Brownelld64f73b2007-07-12 14:12:28 +0200594/**
595 * i2c_del_adapter - unregister I2C adapter
596 * @adap: the adapter being unregistered
597 * Context: can sleep
598 *
599 * This unregisters an I2C adapter which was previously registered
600 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
601 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602int i2c_del_adapter(struct i2c_adapter *adap)
603{
Matthias Kaehlcke6a03cd92008-07-14 22:38:26 +0200604 struct i2c_client *client, *_n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 int res = 0;
606
Jean Delvarecaada322008-01-27 18:14:49 +0100607 mutex_lock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608
609 /* First make sure that this adapter was ever added */
Jean Delvare87c6c222008-01-27 18:14:48 +0100610 if (idr_find(&i2c_adapter_idr, adap->nr) != adap) {
Jean Delvareb6d7b3d2005-07-31 19:02:53 +0200611 pr_debug("i2c-core: attempting to delete unregistered "
612 "adapter [%s]\n", adap->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 res = -EINVAL;
614 goto out_unlock;
615 }
616
Jean Delvare026526f2008-01-27 18:14:49 +0100617 /* Tell drivers about this removal */
618 res = bus_for_each_drv(&i2c_bus_type, NULL, adap,
619 i2c_do_del_adapter);
620 if (res)
621 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622
623 /* detach any active clients. This must be done first, because
Tobias Klausera551acc2005-05-19 21:40:38 +0200624 * it can fail; in which case we give up. */
Matthias Kaehlcke6a03cd92008-07-14 22:38:26 +0200625 list_for_each_entry_safe(client, _n, &adap->clients, list) {
David Brownella1d9e6e2007-05-01 23:26:30 +0200626 struct i2c_driver *driver;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627
David Brownella1d9e6e2007-05-01 23:26:30 +0200628 driver = client->driver;
629
630 /* new style, follow standard driver model */
631 if (!driver || is_newstyle_driver(driver)) {
632 i2c_unregister_device(client);
633 continue;
634 }
635
636 /* legacy drivers create and remove clients themselves */
637 if ((res = driver->detach_client(client))) {
Jean Delvareb6d7b3d2005-07-31 19:02:53 +0200638 dev_err(&adap->dev, "detach_client failed for client "
639 "[%s] at address 0x%02x\n", client->name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 client->addr);
641 goto out_unlock;
642 }
643 }
644
645 /* clean up the sysfs representation */
646 init_completion(&adap->dev_released);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 device_unregister(&adap->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648
649 /* wait for sysfs to drop all references */
650 wait_for_completion(&adap->dev_released);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651
David Brownell6e13e642007-05-01 23:26:31 +0200652 /* free bus id */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 idr_remove(&i2c_adapter_idr, adap->nr);
654
Jean Delvareb6d7b3d2005-07-31 19:02:53 +0200655 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656
Jean Delvarebd4bc3d2008-07-16 19:30:05 +0200657 /* Clear the device structure in case this adapter is ever going to be
658 added again */
659 memset(&adap->dev, 0, sizeof(adap->dev));
660
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 out_unlock:
Jean Delvarecaada322008-01-27 18:14:49 +0100662 mutex_unlock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 return res;
664}
David Brownellc0564602007-05-01 23:26:31 +0200665EXPORT_SYMBOL(i2c_del_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666
667
David Brownell7b4fbc52007-05-01 23:26:30 +0200668/* ------------------------------------------------------------------------- */
669
Dave Young7f101a92008-07-14 22:38:19 +0200670static int __attach_adapter(struct device *dev, void *data)
671{
672 struct i2c_adapter *adapter = to_i2c_adapter(dev);
673 struct i2c_driver *driver = data;
674
Jean Delvare4735c982008-07-14 22:38:36 +0200675 i2c_detect(adapter, driver);
676
677 /* Legacy drivers scan i2c busses directly */
678 if (driver->attach_adapter)
679 driver->attach_adapter(adapter);
Dave Young7f101a92008-07-14 22:38:19 +0200680
681 return 0;
682}
683
David Brownell7b4fbc52007-05-01 23:26:30 +0200684/*
685 * An i2c_driver is used with one or more i2c_client (device) nodes to access
686 * i2c slave chips, on a bus instance associated with some i2c_adapter. There
687 * are two models for binding the driver to its device: "new style" drivers
688 * follow the standard Linux driver model and just respond to probe() calls
689 * issued if the driver core sees they match(); "legacy" drivers create device
690 * nodes themselves.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 */
692
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -0800693int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694{
Jean Delvare7eebcb72006-02-05 23:28:21 +0100695 int res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696
David Brownell7b4fbc52007-05-01 23:26:30 +0200697 /* new style driver methods can't mix with legacy ones */
David Brownella1d9e6e2007-05-01 23:26:30 +0200698 if (is_newstyle_driver(driver)) {
David Brownell7b4fbc52007-05-01 23:26:30 +0200699 if (driver->attach_adapter || driver->detach_adapter
700 || driver->detach_client) {
701 printk(KERN_WARNING
702 "i2c-core: driver [%s] is confused\n",
703 driver->driver.name);
704 return -EINVAL;
705 }
706 }
707
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 /* add the driver to the list of i2c drivers in the driver core */
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -0800709 driver->driver.owner = owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 driver->driver.bus = &i2c_bus_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711
David Brownell6e13e642007-05-01 23:26:31 +0200712 /* for new style drivers, when registration returns the driver core
713 * will have called probe() for all matching-but-unbound devices.
714 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 res = driver_register(&driver->driver);
716 if (res)
Jean Delvare7eebcb72006-02-05 23:28:21 +0100717 return res;
David Brownell438d6c22006-12-10 21:21:31 +0100718
Jean Delvarecaada322008-01-27 18:14:49 +0100719 mutex_lock(&core_lock);
Jean Delvare7eebcb72006-02-05 23:28:21 +0100720
Laurent Riffard35d8b2e2005-11-26 20:34:05 +0100721 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722
Jean Delvare4735c982008-07-14 22:38:36 +0200723 INIT_LIST_HEAD(&driver->clients);
724 /* Walk the adapters that are already present */
Greg Kroah-Hartman93562b52008-05-22 17:21:08 -0400725 class_for_each_device(&i2c_adapter_class, NULL, driver,
726 __attach_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727
Jean Delvarecaada322008-01-27 18:14:49 +0100728 mutex_unlock(&core_lock);
Jean Delvare7eebcb72006-02-05 23:28:21 +0100729 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730}
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -0800731EXPORT_SYMBOL(i2c_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732
Dave Young7f101a92008-07-14 22:38:19 +0200733static int __detach_adapter(struct device *dev, void *data)
734{
735 struct i2c_adapter *adapter = to_i2c_adapter(dev);
736 struct i2c_driver *driver = data;
Jean Delvare4735c982008-07-14 22:38:36 +0200737 struct i2c_client *client, *_n;
738
739 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
740 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
741 client->name, client->addr);
742 list_del(&client->detected);
743 i2c_unregister_device(client);
744 }
745
746 if (is_newstyle_driver(driver))
747 return 0;
Dave Young7f101a92008-07-14 22:38:19 +0200748
749 /* Have a look at each adapter, if clients of this driver are still
750 * attached. If so, detach them to be able to kill the driver
751 * afterwards.
752 */
753 if (driver->detach_adapter) {
754 if (driver->detach_adapter(adapter))
755 dev_err(&adapter->dev,
756 "detach_adapter failed for driver [%s]\n",
757 driver->driver.name);
758 } else {
Matthias Kaehlcke6a03cd92008-07-14 22:38:26 +0200759 struct i2c_client *client, *_n;
Dave Young7f101a92008-07-14 22:38:19 +0200760
Matthias Kaehlcke6a03cd92008-07-14 22:38:26 +0200761 list_for_each_entry_safe(client, _n, &adapter->clients, list) {
Dave Young7f101a92008-07-14 22:38:19 +0200762 if (client->driver != driver)
763 continue;
764 dev_dbg(&adapter->dev,
765 "detaching client [%s] at 0x%02x\n",
766 client->name, client->addr);
767 if (driver->detach_client(client))
768 dev_err(&adapter->dev, "detach_client "
769 "failed for client [%s] at 0x%02x\n",
770 client->name, client->addr);
771 }
772 }
773
774 return 0;
775}
776
David Brownella1d9e6e2007-05-01 23:26:30 +0200777/**
778 * i2c_del_driver - unregister I2C driver
779 * @driver: the driver being unregistered
David Brownelld64f73b2007-07-12 14:12:28 +0200780 * Context: can sleep
David Brownella1d9e6e2007-05-01 23:26:30 +0200781 */
Jean Delvareb3e82092007-05-01 23:26:32 +0200782void i2c_del_driver(struct i2c_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783{
Jean Delvarecaada322008-01-27 18:14:49 +0100784 mutex_lock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785
Greg Kroah-Hartman93562b52008-05-22 17:21:08 -0400786 class_for_each_device(&i2c_adapter_class, NULL, driver,
787 __detach_adapter);
David Brownella1d9e6e2007-05-01 23:26:30 +0200788
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 driver_unregister(&driver->driver);
Laurent Riffard35d8b2e2005-11-26 20:34:05 +0100790 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791
Jean Delvarecaada322008-01-27 18:14:49 +0100792 mutex_unlock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793}
David Brownellc0564602007-05-01 23:26:31 +0200794EXPORT_SYMBOL(i2c_del_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795
David Brownell7b4fbc52007-05-01 23:26:30 +0200796/* ------------------------------------------------------------------------- */
797
David Brownell9b766b82008-01-27 18:14:51 +0100798static int __i2c_check_addr(struct device *dev, void *addrp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799{
David Brownell9b766b82008-01-27 18:14:51 +0100800 struct i2c_client *client = i2c_verify_client(dev);
801 int addr = *(int *)addrp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802
David Brownell9b766b82008-01-27 18:14:51 +0100803 if (client && client->addr == addr)
804 return -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 return 0;
806}
807
Jean Delvare5e31c2b2007-11-15 19:24:02 +0100808static int i2c_check_addr(struct i2c_adapter *adapter, int addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809{
David Brownell9b766b82008-01-27 18:14:51 +0100810 return device_for_each_child(&adapter->dev, &addr, __i2c_check_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811}
812
813int i2c_attach_client(struct i2c_client *client)
814{
815 struct i2c_adapter *adapter = client->adapter;
Jean Delvareb119c6c2006-08-15 18:26:30 +0200816 int res = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 client->dev.parent = &client->adapter->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 client->dev.bus = &i2c_bus_type;
David Brownell9c1600e2007-05-01 23:26:31 +0200820
821 if (client->driver)
822 client->dev.driver = &client->driver->driver;
823
David Brownellde81d2a2007-05-22 19:49:16 +0200824 if (client->driver && !is_newstyle_driver(client->driver)) {
David Brownell9c1600e2007-05-01 23:26:31 +0200825 client->dev.release = i2c_client_release;
David Brownellde81d2a2007-05-22 19:49:16 +0200826 client->dev.uevent_suppress = 1;
827 } else
David Brownell9c1600e2007-05-01 23:26:31 +0200828 client->dev.release = i2c_client_dev_release;
David Brownell438d6c22006-12-10 21:21:31 +0100829
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 snprintf(&client->dev.bus_id[0], sizeof(client->dev.bus_id),
831 "%d-%04x", i2c_adapter_id(adapter), client->addr);
Jean Delvareb119c6c2006-08-15 18:26:30 +0200832 res = device_register(&client->dev);
833 if (res)
David Brownell86ec5ec2008-01-27 18:14:51 +0100834 goto out_err;
835
836 mutex_lock(&adapter->clist_lock);
837 list_add_tail(&client->list, &adapter->clients);
Jean Delvareb119c6c2006-08-15 18:26:30 +0200838 mutex_unlock(&adapter->clist_lock);
Jean Delvare77ed74d2006-09-30 17:18:59 +0200839
David Brownell86ec5ec2008-01-27 18:14:51 +0100840 dev_dbg(&adapter->dev, "client [%s] registered with bus id %s\n",
841 client->name, client->dev.bus_id);
842
Jean Delvare77ed74d2006-09-30 17:18:59 +0200843 if (adapter->client_register) {
844 if (adapter->client_register(client)) {
845 dev_dbg(&adapter->dev, "client_register "
846 "failed for client [%s] at 0x%02x\n",
847 client->name, client->addr);
848 }
849 }
850
851 return 0;
Jean Delvareb119c6c2006-08-15 18:26:30 +0200852
David Brownell86ec5ec2008-01-27 18:14:51 +0100853out_err:
Jean Delvareb119c6c2006-08-15 18:26:30 +0200854 dev_err(&adapter->dev, "Failed to attach i2c client %s at 0x%02x "
855 "(%d)\n", client->name, client->addr, res);
Jean Delvare77ed74d2006-09-30 17:18:59 +0200856 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857}
David Brownellc0564602007-05-01 23:26:31 +0200858EXPORT_SYMBOL(i2c_attach_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859
860int i2c_detach_client(struct i2c_client *client)
861{
862 struct i2c_adapter *adapter = client->adapter;
863 int res = 0;
David Brownell438d6c22006-12-10 21:21:31 +0100864
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 if (adapter->client_unregister) {
866 res = adapter->client_unregister(client);
867 if (res) {
868 dev_err(&client->dev,
Jean Delvare86749e82005-07-29 12:15:29 -0700869 "client_unregister [%s] failed, "
870 "client not detached\n", client->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 goto out;
872 }
873 }
874
Ingo Molnar5c085d32006-01-18 23:16:04 +0100875 mutex_lock(&adapter->clist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 list_del(&client->list);
Jean Delvare9ddced12008-01-27 18:14:51 +0100877 mutex_unlock(&adapter->clist_lock);
878
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 init_completion(&client->released);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 device_unregister(&client->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 wait_for_completion(&client->released);
882
883 out:
884 return res;
885}
David Brownellc0564602007-05-01 23:26:31 +0200886EXPORT_SYMBOL(i2c_detach_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887
Jean Delvaree48d3312008-01-27 18:14:48 +0100888/**
889 * i2c_use_client - increments the reference count of the i2c client structure
890 * @client: the client being referenced
891 *
892 * Each live reference to a client should be refcounted. The driver model does
893 * that automatically as part of driver binding, so that most drivers don't
894 * need to do this explicitly: they hold a reference until they're unbound
895 * from the device.
896 *
897 * A pointer to the client with the incremented reference counter is returned.
898 */
899struct i2c_client *i2c_use_client(struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900{
David Brownell6ea438e2008-07-14 22:38:24 +0200901 if (client && get_device(&client->dev))
902 return client;
903 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904}
David Brownellc0564602007-05-01 23:26:31 +0200905EXPORT_SYMBOL(i2c_use_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906
Jean Delvaree48d3312008-01-27 18:14:48 +0100907/**
908 * i2c_release_client - release a use of the i2c client structure
909 * @client: the client being no longer referenced
910 *
911 * Must be called when a user of a client is finished with it.
912 */
913void i2c_release_client(struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914{
David Brownell6ea438e2008-07-14 22:38:24 +0200915 if (client)
916 put_device(&client->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917}
David Brownellc0564602007-05-01 23:26:31 +0200918EXPORT_SYMBOL(i2c_release_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919
David Brownell9b766b82008-01-27 18:14:51 +0100920struct i2c_cmd_arg {
921 unsigned cmd;
922 void *arg;
923};
924
925static int i2c_cmd(struct device *dev, void *_arg)
926{
927 struct i2c_client *client = i2c_verify_client(dev);
928 struct i2c_cmd_arg *arg = _arg;
929
930 if (client && client->driver && client->driver->command)
931 client->driver->command(client, arg->cmd, arg->arg);
932 return 0;
933}
934
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
936{
David Brownell9b766b82008-01-27 18:14:51 +0100937 struct i2c_cmd_arg cmd_arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938
David Brownell9b766b82008-01-27 18:14:51 +0100939 cmd_arg.cmd = cmd;
940 cmd_arg.arg = arg;
941 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942}
David Brownellc0564602007-05-01 23:26:31 +0200943EXPORT_SYMBOL(i2c_clients_command);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944
945static int __init i2c_init(void)
946{
947 int retval;
948
949 retval = bus_register(&i2c_bus_type);
950 if (retval)
951 return retval;
David Brownelle9f13732008-01-27 18:14:52 +0100952 retval = class_register(&i2c_adapter_class);
953 if (retval)
954 goto bus_err;
955 retval = i2c_add_driver(&dummy_driver);
956 if (retval)
957 goto class_err;
958 return 0;
959
960class_err:
961 class_unregister(&i2c_adapter_class);
962bus_err:
963 bus_unregister(&i2c_bus_type);
964 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965}
966
967static void __exit i2c_exit(void)
968{
David Brownelle9f13732008-01-27 18:14:52 +0100969 i2c_del_driver(&dummy_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 class_unregister(&i2c_adapter_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 bus_unregister(&i2c_bus_type);
972}
973
974subsys_initcall(i2c_init);
975module_exit(i2c_exit);
976
977/* ----------------------------------------------------
978 * the functional interface to the i2c busses.
979 * ----------------------------------------------------
980 */
981
David Brownella1cdeda2008-07-14 22:38:24 +0200982/**
983 * i2c_transfer - execute a single or combined I2C message
984 * @adap: Handle to I2C bus
985 * @msgs: One or more messages to execute before STOP is issued to
986 * terminate the operation; each message begins with a START.
987 * @num: Number of messages to be executed.
988 *
989 * Returns negative errno, else the number of messages executed.
990 *
991 * Note that there is no requirement that each message be sent to
992 * the same slave address, although that is the most common model.
993 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num)
995{
996 int ret;
997
David Brownella1cdeda2008-07-14 22:38:24 +0200998 /* REVISIT the fault reporting model here is weak:
999 *
1000 * - When we get an error after receiving N bytes from a slave,
1001 * there is no way to report "N".
1002 *
1003 * - When we get a NAK after transmitting N bytes to a slave,
1004 * there is no way to report "N" ... or to let the master
1005 * continue executing the rest of this combined message, if
1006 * that's the appropriate response.
1007 *
1008 * - When for example "num" is two and we successfully complete
1009 * the first message but get an error part way through the
1010 * second, it's unclear whether that should be reported as
1011 * one (discarding status on the second message) or errno
1012 * (discarding status on the first one).
1013 */
1014
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 if (adap->algo->master_xfer) {
1016#ifdef DEBUG
1017 for (ret = 0; ret < num; ret++) {
1018 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
Jean Delvare209d27c2007-05-01 23:26:29 +02001019 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
1020 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
1021 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 }
1023#endif
1024
Mike Rapoportcea443a2008-01-27 18:14:50 +01001025 if (in_atomic() || irqs_disabled()) {
1026 ret = mutex_trylock(&adap->bus_lock);
1027 if (!ret)
1028 /* I2C activity is ongoing. */
1029 return -EAGAIN;
1030 } else {
1031 mutex_lock_nested(&adap->bus_lock, adap->level);
1032 }
1033
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 ret = adap->algo->master_xfer(adap,msgs,num);
Ingo Molnar5c085d32006-01-18 23:16:04 +01001035 mutex_unlock(&adap->bus_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036
1037 return ret;
1038 } else {
1039 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
David Brownell24a5bb72008-07-14 22:38:23 +02001040 return -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 }
1042}
David Brownellc0564602007-05-01 23:26:31 +02001043EXPORT_SYMBOL(i2c_transfer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044
David Brownella1cdeda2008-07-14 22:38:24 +02001045/**
1046 * i2c_master_send - issue a single I2C message in master transmit mode
1047 * @client: Handle to slave device
1048 * @buf: Data that will be written to the slave
1049 * @count: How many bytes to write
1050 *
1051 * Returns negative errno, or else the number of bytes written.
1052 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
1054{
1055 int ret;
1056 struct i2c_adapter *adap=client->adapter;
1057 struct i2c_msg msg;
1058
Jean Delvare815f55f2005-05-07 22:58:46 +02001059 msg.addr = client->addr;
1060 msg.flags = client->flags & I2C_M_TEN;
1061 msg.len = count;
1062 msg.buf = (char *)buf;
David Brownell438d6c22006-12-10 21:21:31 +01001063
Jean Delvare815f55f2005-05-07 22:58:46 +02001064 ret = i2c_transfer(adap, &msg, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065
Jean Delvare815f55f2005-05-07 22:58:46 +02001066 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1067 transmitted, else error code. */
1068 return (ret == 1) ? count : ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069}
David Brownellc0564602007-05-01 23:26:31 +02001070EXPORT_SYMBOL(i2c_master_send);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071
David Brownella1cdeda2008-07-14 22:38:24 +02001072/**
1073 * i2c_master_recv - issue a single I2C message in master receive mode
1074 * @client: Handle to slave device
1075 * @buf: Where to store data read from slave
1076 * @count: How many bytes to read
1077 *
1078 * Returns negative errno, or else the number of bytes read.
1079 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
1081{
1082 struct i2c_adapter *adap=client->adapter;
1083 struct i2c_msg msg;
1084 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085
Jean Delvare815f55f2005-05-07 22:58:46 +02001086 msg.addr = client->addr;
1087 msg.flags = client->flags & I2C_M_TEN;
1088 msg.flags |= I2C_M_RD;
1089 msg.len = count;
1090 msg.buf = buf;
1091
1092 ret = i2c_transfer(adap, &msg, 1);
1093
1094 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1095 transmitted, else error code. */
1096 return (ret == 1) ? count : ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097}
David Brownellc0564602007-05-01 23:26:31 +02001098EXPORT_SYMBOL(i2c_master_recv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100/* ----------------------------------------------------
1101 * the i2c address scanning function
1102 * Will not work for 10-bit addresses!
1103 * ----------------------------------------------------
1104 */
Jean Delvarea89ba0b2005-08-09 20:17:55 +02001105static int i2c_probe_address(struct i2c_adapter *adapter, int addr, int kind,
1106 int (*found_proc) (struct i2c_adapter *, int, int))
Jean Delvare9fc6adf2005-07-31 21:20:43 +02001107{
Jean Delvarea89ba0b2005-08-09 20:17:55 +02001108 int err;
Jean Delvare9fc6adf2005-07-31 21:20:43 +02001109
Jean Delvarea89ba0b2005-08-09 20:17:55 +02001110 /* Make sure the address is valid */
1111 if (addr < 0x03 || addr > 0x77) {
1112 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1113 addr);
1114 return -EINVAL;
Jean Delvare9fc6adf2005-07-31 21:20:43 +02001115 }
1116
Jean Delvarea89ba0b2005-08-09 20:17:55 +02001117 /* Skip if already in use */
1118 if (i2c_check_addr(adapter, addr))
1119 return 0;
1120
1121 /* Make sure there is something at this address, unless forced */
Jean Delvare4c9337d2005-08-09 20:28:10 +02001122 if (kind < 0) {
1123 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1124 I2C_SMBUS_QUICK, NULL) < 0)
1125 return 0;
1126
1127 /* prevent 24RF08 corruption */
1128 if ((addr & ~0x0f) == 0x50)
1129 i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1130 I2C_SMBUS_QUICK, NULL);
1131 }
Jean Delvarea89ba0b2005-08-09 20:17:55 +02001132
1133 /* Finally call the custom detection function */
1134 err = found_proc(adapter, addr, kind);
Jean Delvarea89ba0b2005-08-09 20:17:55 +02001135 /* -ENODEV can be returned if there is a chip at the given address
1136 but it isn't supported by this chip driver. We catch it here as
1137 this isn't an error. */
Jean Delvare114fd182006-09-03 22:25:04 +02001138 if (err == -ENODEV)
1139 err = 0;
1140
1141 if (err)
1142 dev_warn(&adapter->dev, "Client creation failed at 0x%x (%d)\n",
1143 addr, err);
1144 return err;
Jean Delvare9fc6adf2005-07-31 21:20:43 +02001145}
1146
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147int i2c_probe(struct i2c_adapter *adapter,
Mark M. Hoffmanbfb6df22008-01-27 18:14:46 +01001148 const struct i2c_client_address_data *address_data,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149 int (*found_proc) (struct i2c_adapter *, int, int))
1150{
Jean Delvarea89ba0b2005-08-09 20:17:55 +02001151 int i, err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 int adap_id = i2c_adapter_id(adapter);
1153
Jean Delvarea89ba0b2005-08-09 20:17:55 +02001154 /* Force entries are done first, and are not affected by ignore
1155 entries */
1156 if (address_data->forces) {
Mark M. Hoffmanbfb6df22008-01-27 18:14:46 +01001157 const unsigned short * const *forces = address_data->forces;
Jean Delvarea89ba0b2005-08-09 20:17:55 +02001158 int kind;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159
Jean Delvarea89ba0b2005-08-09 20:17:55 +02001160 for (kind = 0; forces[kind]; kind++) {
1161 for (i = 0; forces[kind][i] != I2C_CLIENT_END;
1162 i += 2) {
1163 if (forces[kind][i] == adap_id
1164 || forces[kind][i] == ANY_I2C_BUS) {
1165 dev_dbg(&adapter->dev, "found force "
1166 "parameter for adapter %d, "
1167 "addr 0x%02x, kind %d\n",
1168 adap_id, forces[kind][i + 1],
1169 kind);
1170 err = i2c_probe_address(adapter,
1171 forces[kind][i + 1],
1172 kind, found_proc);
1173 if (err)
1174 return err;
1175 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 }
1177 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178 }
Jean Delvarea89ba0b2005-08-09 20:17:55 +02001179
Jean Delvare4366dc92005-09-25 16:50:06 +02001180 /* Stop here if we can't use SMBUS_QUICK */
1181 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
1182 if (address_data->probe[0] == I2C_CLIENT_END
1183 && address_data->normal_i2c[0] == I2C_CLIENT_END)
David Brownell438d6c22006-12-10 21:21:31 +01001184 return 0;
Jean Delvare4366dc92005-09-25 16:50:06 +02001185
1186 dev_warn(&adapter->dev, "SMBus Quick command not supported, "
1187 "can't probe for chips\n");
David Brownell24a5bb72008-07-14 22:38:23 +02001188 return -EOPNOTSUPP;
Jean Delvare4366dc92005-09-25 16:50:06 +02001189 }
1190
Jean Delvarea89ba0b2005-08-09 20:17:55 +02001191 /* Probe entries are done second, and are not affected by ignore
1192 entries either */
1193 for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
1194 if (address_data->probe[i] == adap_id
1195 || address_data->probe[i] == ANY_I2C_BUS) {
1196 dev_dbg(&adapter->dev, "found probe parameter for "
1197 "adapter %d, addr 0x%02x\n", adap_id,
1198 address_data->probe[i + 1]);
1199 err = i2c_probe_address(adapter,
1200 address_data->probe[i + 1],
1201 -1, found_proc);
1202 if (err)
1203 return err;
1204 }
1205 }
1206
1207 /* Normal entries are done last, unless shadowed by an ignore entry */
1208 for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
1209 int j, ignore;
1210
1211 ignore = 0;
1212 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
1213 j += 2) {
1214 if ((address_data->ignore[j] == adap_id ||
1215 address_data->ignore[j] == ANY_I2C_BUS)
1216 && address_data->ignore[j + 1]
1217 == address_data->normal_i2c[i]) {
1218 dev_dbg(&adapter->dev, "found ignore "
1219 "parameter for adapter %d, "
1220 "addr 0x%02x\n", adap_id,
1221 address_data->ignore[j + 1]);
Mark M. Hoffman2369df92006-07-01 17:01:59 +02001222 ignore = 1;
1223 break;
Jean Delvarea89ba0b2005-08-09 20:17:55 +02001224 }
Jean Delvarea89ba0b2005-08-09 20:17:55 +02001225 }
1226 if (ignore)
1227 continue;
1228
1229 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1230 "addr 0x%02x\n", adap_id,
1231 address_data->normal_i2c[i]);
1232 err = i2c_probe_address(adapter, address_data->normal_i2c[i],
1233 -1, found_proc);
1234 if (err)
1235 return err;
1236 }
1237
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238 return 0;
1239}
David Brownellc0564602007-05-01 23:26:31 +02001240EXPORT_SYMBOL(i2c_probe);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241
Jean Delvare4735c982008-07-14 22:38:36 +02001242/* Separate detection function for new-style drivers */
1243static int i2c_detect_address(struct i2c_client *temp_client, int kind,
1244 struct i2c_driver *driver)
1245{
1246 struct i2c_board_info info;
1247 struct i2c_adapter *adapter = temp_client->adapter;
1248 int addr = temp_client->addr;
1249 int err;
1250
1251 /* Make sure the address is valid */
1252 if (addr < 0x03 || addr > 0x77) {
1253 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1254 addr);
1255 return -EINVAL;
1256 }
1257
1258 /* Skip if already in use */
1259 if (i2c_check_addr(adapter, addr))
1260 return 0;
1261
1262 /* Make sure there is something at this address, unless forced */
1263 if (kind < 0) {
1264 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1265 I2C_SMBUS_QUICK, NULL) < 0)
1266 return 0;
1267
1268 /* prevent 24RF08 corruption */
1269 if ((addr & ~0x0f) == 0x50)
1270 i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1271 I2C_SMBUS_QUICK, NULL);
1272 }
1273
1274 /* Finally call the custom detection function */
1275 memset(&info, 0, sizeof(struct i2c_board_info));
1276 info.addr = addr;
1277 err = driver->detect(temp_client, kind, &info);
1278 if (err) {
1279 /* -ENODEV is returned if the detection fails. We catch it
1280 here as this isn't an error. */
1281 return err == -ENODEV ? 0 : err;
1282 }
1283
1284 /* Consistency check */
1285 if (info.type[0] == '\0') {
1286 dev_err(&adapter->dev, "%s detection function provided "
1287 "no name for 0x%x\n", driver->driver.name,
1288 addr);
1289 } else {
1290 struct i2c_client *client;
1291
1292 /* Detection succeeded, instantiate the device */
1293 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
1294 info.type, info.addr);
1295 client = i2c_new_device(adapter, &info);
1296 if (client)
1297 list_add_tail(&client->detected, &driver->clients);
1298 else
1299 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
1300 info.type, info.addr);
1301 }
1302 return 0;
1303}
1304
1305static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
1306{
1307 const struct i2c_client_address_data *address_data;
1308 struct i2c_client *temp_client;
1309 int i, err = 0;
1310 int adap_id = i2c_adapter_id(adapter);
1311
1312 address_data = driver->address_data;
1313 if (!driver->detect || !address_data)
1314 return 0;
1315
1316 /* Set up a temporary client to help detect callback */
1317 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
1318 if (!temp_client)
1319 return -ENOMEM;
1320 temp_client->adapter = adapter;
1321
1322 /* Force entries are done first, and are not affected by ignore
1323 entries */
1324 if (address_data->forces) {
1325 const unsigned short * const *forces = address_data->forces;
1326 int kind;
1327
1328 for (kind = 0; forces[kind]; kind++) {
1329 for (i = 0; forces[kind][i] != I2C_CLIENT_END;
1330 i += 2) {
1331 if (forces[kind][i] == adap_id
1332 || forces[kind][i] == ANY_I2C_BUS) {
1333 dev_dbg(&adapter->dev, "found force "
1334 "parameter for adapter %d, "
1335 "addr 0x%02x, kind %d\n",
1336 adap_id, forces[kind][i + 1],
1337 kind);
1338 temp_client->addr = forces[kind][i + 1];
1339 err = i2c_detect_address(temp_client,
1340 kind, driver);
1341 if (err)
1342 goto exit_free;
1343 }
1344 }
1345 }
1346 }
1347
1348 /* Stop here if we can't use SMBUS_QUICK */
1349 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
1350 if (address_data->probe[0] == I2C_CLIENT_END
1351 && address_data->normal_i2c[0] == I2C_CLIENT_END)
1352 goto exit_free;
1353
1354 dev_warn(&adapter->dev, "SMBus Quick command not supported, "
1355 "can't probe for chips\n");
1356 err = -EOPNOTSUPP;
1357 goto exit_free;
1358 }
1359
1360 /* Stop here if the classes do not match */
1361 if (!(adapter->class & driver->class))
1362 goto exit_free;
1363
1364 /* Probe entries are done second, and are not affected by ignore
1365 entries either */
1366 for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
1367 if (address_data->probe[i] == adap_id
1368 || address_data->probe[i] == ANY_I2C_BUS) {
1369 dev_dbg(&adapter->dev, "found probe parameter for "
1370 "adapter %d, addr 0x%02x\n", adap_id,
1371 address_data->probe[i + 1]);
1372 temp_client->addr = address_data->probe[i + 1];
1373 err = i2c_detect_address(temp_client, -1, driver);
1374 if (err)
1375 goto exit_free;
1376 }
1377 }
1378
1379 /* Normal entries are done last, unless shadowed by an ignore entry */
1380 for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
1381 int j, ignore;
1382
1383 ignore = 0;
1384 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
1385 j += 2) {
1386 if ((address_data->ignore[j] == adap_id ||
1387 address_data->ignore[j] == ANY_I2C_BUS)
1388 && address_data->ignore[j + 1]
1389 == address_data->normal_i2c[i]) {
1390 dev_dbg(&adapter->dev, "found ignore "
1391 "parameter for adapter %d, "
1392 "addr 0x%02x\n", adap_id,
1393 address_data->ignore[j + 1]);
1394 ignore = 1;
1395 break;
1396 }
1397 }
1398 if (ignore)
1399 continue;
1400
1401 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1402 "addr 0x%02x\n", adap_id,
1403 address_data->normal_i2c[i]);
1404 temp_client->addr = address_data->normal_i2c[i];
1405 err = i2c_detect_address(temp_client, -1, driver);
1406 if (err)
1407 goto exit_free;
1408 }
1409
1410 exit_free:
1411 kfree(temp_client);
1412 return err;
1413}
1414
Jean Delvare12b50532007-05-01 23:26:31 +02001415struct i2c_client *
1416i2c_new_probed_device(struct i2c_adapter *adap,
1417 struct i2c_board_info *info,
1418 unsigned short const *addr_list)
1419{
1420 int i;
1421
1422 /* Stop here if the bus doesn't support probing */
1423 if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE)) {
1424 dev_err(&adap->dev, "Probing not supported\n");
1425 return NULL;
1426 }
1427
Jean Delvare12b50532007-05-01 23:26:31 +02001428 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1429 /* Check address validity */
1430 if (addr_list[i] < 0x03 || addr_list[i] > 0x77) {
1431 dev_warn(&adap->dev, "Invalid 7-bit address "
1432 "0x%02x\n", addr_list[i]);
1433 continue;
1434 }
1435
1436 /* Check address availability */
David Brownell9b766b82008-01-27 18:14:51 +01001437 if (i2c_check_addr(adap, addr_list[i])) {
Jean Delvare12b50532007-05-01 23:26:31 +02001438 dev_dbg(&adap->dev, "Address 0x%02x already in "
1439 "use, not probing\n", addr_list[i]);
1440 continue;
1441 }
1442
1443 /* Test address responsiveness
1444 The default probe method is a quick write, but it is known
1445 to corrupt the 24RF08 EEPROMs due to a state machine bug,
1446 and could also irreversibly write-protect some EEPROMs, so
1447 for address ranges 0x30-0x37 and 0x50-0x5f, we use a byte
1448 read instead. Also, some bus drivers don't implement
1449 quick write, so we fallback to a byte read it that case
1450 too. */
1451 if ((addr_list[i] & ~0x07) == 0x30
1452 || (addr_list[i] & ~0x0f) == 0x50
1453 || !i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK)) {
1454 if (i2c_smbus_xfer(adap, addr_list[i], 0,
1455 I2C_SMBUS_READ, 0,
1456 I2C_SMBUS_BYTE, NULL) >= 0)
1457 break;
1458 } else {
1459 if (i2c_smbus_xfer(adap, addr_list[i], 0,
1460 I2C_SMBUS_WRITE, 0,
1461 I2C_SMBUS_QUICK, NULL) >= 0)
1462 break;
1463 }
1464 }
Jean Delvare12b50532007-05-01 23:26:31 +02001465
1466 if (addr_list[i] == I2C_CLIENT_END) {
1467 dev_dbg(&adap->dev, "Probing failed, no device found\n");
1468 return NULL;
1469 }
1470
1471 info->addr = addr_list[i];
1472 return i2c_new_device(adap, info);
1473}
1474EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1475
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476struct i2c_adapter* i2c_get_adapter(int id)
1477{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478 struct i2c_adapter *adapter;
David Brownell438d6c22006-12-10 21:21:31 +01001479
Jean Delvarecaada322008-01-27 18:14:49 +01001480 mutex_lock(&core_lock);
Mark M. Hoffmana0920e12005-06-28 00:21:30 -04001481 adapter = (struct i2c_adapter *)idr_find(&i2c_adapter_idr, id);
1482 if (adapter && !try_module_get(adapter->owner))
1483 adapter = NULL;
1484
Jean Delvarecaada322008-01-27 18:14:49 +01001485 mutex_unlock(&core_lock);
Mark M. Hoffmana0920e12005-06-28 00:21:30 -04001486 return adapter;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487}
David Brownellc0564602007-05-01 23:26:31 +02001488EXPORT_SYMBOL(i2c_get_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489
1490void i2c_put_adapter(struct i2c_adapter *adap)
1491{
1492 module_put(adap->owner);
1493}
David Brownellc0564602007-05-01 23:26:31 +02001494EXPORT_SYMBOL(i2c_put_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495
1496/* The SMBus parts */
1497
David Brownell438d6c22006-12-10 21:21:31 +01001498#define POLY (0x1070U << 3)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499static u8
1500crc8(u16 data)
1501{
1502 int i;
David Brownell438d6c22006-12-10 21:21:31 +01001503
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504 for(i = 0; i < 8; i++) {
David Brownell438d6c22006-12-10 21:21:31 +01001505 if (data & 0x8000)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506 data = data ^ POLY;
1507 data = data << 1;
1508 }
1509 return (u8)(data >> 8);
1510}
1511
Jean Delvare421ef472005-10-26 21:28:55 +02001512/* Incremental CRC8 over count bytes in the array pointed to by p */
1513static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514{
1515 int i;
1516
1517 for(i = 0; i < count; i++)
Jean Delvare421ef472005-10-26 21:28:55 +02001518 crc = crc8((crc ^ p[i]) << 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519 return crc;
1520}
1521
Jean Delvare421ef472005-10-26 21:28:55 +02001522/* Assume a 7-bit address, which is reasonable for SMBus */
1523static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524{
Jean Delvare421ef472005-10-26 21:28:55 +02001525 /* The address will be sent first */
1526 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1527 pec = i2c_smbus_pec(pec, &addr, 1);
1528
1529 /* The data buffer follows */
1530 return i2c_smbus_pec(pec, msg->buf, msg->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531}
1532
Jean Delvare421ef472005-10-26 21:28:55 +02001533/* Used for write only transactions */
1534static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535{
Jean Delvare421ef472005-10-26 21:28:55 +02001536 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1537 msg->len++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538}
1539
Jean Delvare421ef472005-10-26 21:28:55 +02001540/* Return <0 on CRC error
1541 If there was a write before this read (most cases) we need to take the
1542 partial CRC from the write part into account.
1543 Note that this function does modify the message (we need to decrease the
1544 message length to hide the CRC byte from the caller). */
1545static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546{
Jean Delvare421ef472005-10-26 21:28:55 +02001547 u8 rpec = msg->buf[--msg->len];
1548 cpec = i2c_smbus_msg_pec(cpec, msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001549
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550 if (rpec != cpec) {
1551 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1552 rpec, cpec);
David Brownell24a5bb72008-07-14 22:38:23 +02001553 return -EBADMSG;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554 }
David Brownell438d6c22006-12-10 21:21:31 +01001555 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556}
1557
David Brownella1cdeda2008-07-14 22:38:24 +02001558/**
1559 * i2c_smbus_read_byte - SMBus "receive byte" protocol
1560 * @client: Handle to slave device
1561 *
1562 * This executes the SMBus "receive byte" protocol, returning negative errno
1563 * else the byte received from the device.
1564 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565s32 i2c_smbus_read_byte(struct i2c_client *client)
1566{
1567 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02001568 int status;
1569
1570 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1571 I2C_SMBUS_READ, 0,
1572 I2C_SMBUS_BYTE, &data);
1573 return (status < 0) ? status : data.byte;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574}
David Brownellc0564602007-05-01 23:26:31 +02001575EXPORT_SYMBOL(i2c_smbus_read_byte);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576
David Brownella1cdeda2008-07-14 22:38:24 +02001577/**
1578 * i2c_smbus_write_byte - SMBus "send byte" protocol
1579 * @client: Handle to slave device
1580 * @value: Byte to be sent
1581 *
1582 * This executes the SMBus "send byte" protocol, returning negative errno
1583 * else zero on success.
1584 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
1586{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
Jean Delvare421ef472005-10-26 21:28:55 +02001588 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589}
David Brownellc0564602007-05-01 23:26:31 +02001590EXPORT_SYMBOL(i2c_smbus_write_byte);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591
David Brownella1cdeda2008-07-14 22:38:24 +02001592/**
1593 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
1594 * @client: Handle to slave device
1595 * @command: Byte interpreted by slave
1596 *
1597 * This executes the SMBus "read byte" protocol, returning negative errno
1598 * else a data byte received from the device.
1599 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
1601{
1602 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02001603 int status;
1604
1605 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1606 I2C_SMBUS_READ, command,
1607 I2C_SMBUS_BYTE_DATA, &data);
1608 return (status < 0) ? status : data.byte;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609}
David Brownellc0564602007-05-01 23:26:31 +02001610EXPORT_SYMBOL(i2c_smbus_read_byte_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611
David Brownella1cdeda2008-07-14 22:38:24 +02001612/**
1613 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
1614 * @client: Handle to slave device
1615 * @command: Byte interpreted by slave
1616 * @value: Byte being written
1617 *
1618 * This executes the SMBus "write byte" protocol, returning negative errno
1619 * else zero on success.
1620 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001621s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
1622{
1623 union i2c_smbus_data data;
1624 data.byte = value;
1625 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1626 I2C_SMBUS_WRITE,command,
1627 I2C_SMBUS_BYTE_DATA,&data);
1628}
David Brownellc0564602007-05-01 23:26:31 +02001629EXPORT_SYMBOL(i2c_smbus_write_byte_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630
David Brownella1cdeda2008-07-14 22:38:24 +02001631/**
1632 * i2c_smbus_read_word_data - SMBus "read word" protocol
1633 * @client: Handle to slave device
1634 * @command: Byte interpreted by slave
1635 *
1636 * This executes the SMBus "read word" protocol, returning negative errno
1637 * else a 16-bit unsigned "word" received from the device.
1638 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
1640{
1641 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02001642 int status;
1643
1644 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1645 I2C_SMBUS_READ, command,
1646 I2C_SMBUS_WORD_DATA, &data);
1647 return (status < 0) ? status : data.word;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648}
David Brownellc0564602007-05-01 23:26:31 +02001649EXPORT_SYMBOL(i2c_smbus_read_word_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650
David Brownella1cdeda2008-07-14 22:38:24 +02001651/**
1652 * i2c_smbus_write_word_data - SMBus "write word" protocol
1653 * @client: Handle to slave device
1654 * @command: Byte interpreted by slave
1655 * @value: 16-bit "word" being written
1656 *
1657 * This executes the SMBus "write word" protocol, returning negative errno
1658 * else zero on success.
1659 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
1661{
1662 union i2c_smbus_data data;
1663 data.word = value;
1664 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1665 I2C_SMBUS_WRITE,command,
1666 I2C_SMBUS_WORD_DATA,&data);
1667}
David Brownellc0564602007-05-01 23:26:31 +02001668EXPORT_SYMBOL(i2c_smbus_write_word_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669
David Brownella64ec072007-10-13 23:56:31 +02001670/**
David Brownella1cdeda2008-07-14 22:38:24 +02001671 * i2c_smbus_read_block_data - SMBus "block read" protocol
David Brownella64ec072007-10-13 23:56:31 +02001672 * @client: Handle to slave device
David Brownella1cdeda2008-07-14 22:38:24 +02001673 * @command: Byte interpreted by slave
David Brownella64ec072007-10-13 23:56:31 +02001674 * @values: Byte array into which data will be read; big enough to hold
1675 * the data returned by the slave. SMBus allows at most 32 bytes.
1676 *
David Brownella1cdeda2008-07-14 22:38:24 +02001677 * This executes the SMBus "block read" protocol, returning negative errno
1678 * else the number of data bytes in the slave's response.
David Brownella64ec072007-10-13 23:56:31 +02001679 *
1680 * Note that using this function requires that the client's adapter support
1681 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
1682 * support this; its emulation through I2C messaging relies on a specific
1683 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
1684 */
Jean Delvareb86a1bc2007-05-01 23:26:34 +02001685s32 i2c_smbus_read_block_data(struct i2c_client *client, u8 command,
1686 u8 *values)
1687{
1688 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02001689 int status;
Jean Delvareb86a1bc2007-05-01 23:26:34 +02001690
David Brownell24a5bb72008-07-14 22:38:23 +02001691 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1692 I2C_SMBUS_READ, command,
1693 I2C_SMBUS_BLOCK_DATA, &data);
1694 if (status)
1695 return status;
Jean Delvareb86a1bc2007-05-01 23:26:34 +02001696
1697 memcpy(values, &data.block[1], data.block[0]);
1698 return data.block[0];
1699}
1700EXPORT_SYMBOL(i2c_smbus_read_block_data);
1701
David Brownella1cdeda2008-07-14 22:38:24 +02001702/**
1703 * i2c_smbus_write_block_data - SMBus "block write" protocol
1704 * @client: Handle to slave device
1705 * @command: Byte interpreted by slave
1706 * @length: Size of data block; SMBus allows at most 32 bytes
1707 * @values: Byte array which will be written.
1708 *
1709 * This executes the SMBus "block write" protocol, returning negative errno
1710 * else zero on success.
1711 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
Krzysztof Halasa46f5ed72006-06-12 21:42:20 +02001713 u8 length, const u8 *values)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714{
1715 union i2c_smbus_data data;
Jean Delvare76560322006-01-18 23:14:55 +01001716
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717 if (length > I2C_SMBUS_BLOCK_MAX)
1718 length = I2C_SMBUS_BLOCK_MAX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719 data.block[0] = length;
Jean Delvare76560322006-01-18 23:14:55 +01001720 memcpy(&data.block[1], values, length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1722 I2C_SMBUS_WRITE,command,
1723 I2C_SMBUS_BLOCK_DATA,&data);
1724}
David Brownellc0564602007-05-01 23:26:31 +02001725EXPORT_SYMBOL(i2c_smbus_write_block_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001726
1727/* Returns the number of read bytes */
Jean Delvare4b2643d2007-07-12 14:12:29 +02001728s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command,
1729 u8 length, u8 *values)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730{
1731 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02001732 int status;
Jean Delvare76560322006-01-18 23:14:55 +01001733
Jean Delvare4b2643d2007-07-12 14:12:29 +02001734 if (length > I2C_SMBUS_BLOCK_MAX)
1735 length = I2C_SMBUS_BLOCK_MAX;
1736 data.block[0] = length;
David Brownell24a5bb72008-07-14 22:38:23 +02001737 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1738 I2C_SMBUS_READ, command,
1739 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1740 if (status < 0)
1741 return status;
Jean Delvare76560322006-01-18 23:14:55 +01001742
1743 memcpy(values, &data.block[1], data.block[0]);
1744 return data.block[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745}
David Brownellc0564602007-05-01 23:26:31 +02001746EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747
Jean Delvare21bbd692006-01-09 15:19:18 +11001748s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, u8 command,
Krzysztof Halasa46f5ed72006-06-12 21:42:20 +02001749 u8 length, const u8 *values)
Jean Delvare21bbd692006-01-09 15:19:18 +11001750{
1751 union i2c_smbus_data data;
1752
1753 if (length > I2C_SMBUS_BLOCK_MAX)
1754 length = I2C_SMBUS_BLOCK_MAX;
1755 data.block[0] = length;
1756 memcpy(data.block + 1, values, length);
1757 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1758 I2C_SMBUS_WRITE, command,
1759 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1760}
David Brownellc0564602007-05-01 23:26:31 +02001761EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
Jean Delvare21bbd692006-01-09 15:19:18 +11001762
David Brownell438d6c22006-12-10 21:21:31 +01001763/* Simulate a SMBus command using the i2c protocol
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764 No checking of parameters is done! */
David Brownell438d6c22006-12-10 21:21:31 +01001765static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766 unsigned short flags,
David Brownell438d6c22006-12-10 21:21:31 +01001767 char read_write, u8 command, int size,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768 union i2c_smbus_data * data)
1769{
1770 /* So we need to generate a series of msgs. In the case of writing, we
1771 need to use only one message; when reading, we need two. We initialize
1772 most things with sane defaults, to keep the code below somewhat
1773 simpler. */
Hideki Iwamoto5c50d182005-09-25 17:01:11 +02001774 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1775 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776 int num = read_write == I2C_SMBUS_READ?2:1;
David Brownell438d6c22006-12-10 21:21:31 +01001777 struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 { addr, flags | I2C_M_RD, 0, msgbuf1 }
1779 };
1780 int i;
Jean Delvare421ef472005-10-26 21:28:55 +02001781 u8 partial_pec = 0;
David Brownell24a5bb72008-07-14 22:38:23 +02001782 int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783
1784 msgbuf0[0] = command;
1785 switch(size) {
1786 case I2C_SMBUS_QUICK:
1787 msg[0].len = 0;
1788 /* Special case: The read/write field is used as data */
1789 msg[0].flags = flags | (read_write==I2C_SMBUS_READ)?I2C_M_RD:0;
1790 num = 1;
1791 break;
1792 case I2C_SMBUS_BYTE:
1793 if (read_write == I2C_SMBUS_READ) {
1794 /* Special case: only a read! */
1795 msg[0].flags = I2C_M_RD | flags;
1796 num = 1;
1797 }
1798 break;
1799 case I2C_SMBUS_BYTE_DATA:
1800 if (read_write == I2C_SMBUS_READ)
1801 msg[1].len = 1;
1802 else {
1803 msg[0].len = 2;
1804 msgbuf0[1] = data->byte;
1805 }
1806 break;
1807 case I2C_SMBUS_WORD_DATA:
1808 if (read_write == I2C_SMBUS_READ)
1809 msg[1].len = 2;
1810 else {
1811 msg[0].len=3;
1812 msgbuf0[1] = data->word & 0xff;
Jean Delvare7eff82c2006-09-03 22:24:00 +02001813 msgbuf0[2] = data->word >> 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814 }
1815 break;
1816 case I2C_SMBUS_PROC_CALL:
1817 num = 2; /* Special case */
1818 read_write = I2C_SMBUS_READ;
1819 msg[0].len = 3;
1820 msg[1].len = 2;
1821 msgbuf0[1] = data->word & 0xff;
Jean Delvare7eff82c2006-09-03 22:24:00 +02001822 msgbuf0[2] = data->word >> 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823 break;
1824 case I2C_SMBUS_BLOCK_DATA:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825 if (read_write == I2C_SMBUS_READ) {
Jean Delvare209d27c2007-05-01 23:26:29 +02001826 msg[1].flags |= I2C_M_RECV_LEN;
1827 msg[1].len = 1; /* block length will be added by
1828 the underlying bus driver */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829 } else {
1830 msg[0].len = data->block[0] + 2;
1831 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
David Brownell24a5bb72008-07-14 22:38:23 +02001832 dev_err(&adapter->dev,
1833 "Invalid block write size %d\n",
1834 data->block[0]);
1835 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836 }
Hideki Iwamoto5c50d182005-09-25 17:01:11 +02001837 for (i = 1; i < msg[0].len; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838 msgbuf0[i] = data->block[i-1];
1839 }
1840 break;
1841 case I2C_SMBUS_BLOCK_PROC_CALL:
Jean Delvare209d27c2007-05-01 23:26:29 +02001842 num = 2; /* Another special case */
1843 read_write = I2C_SMBUS_READ;
1844 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
David Brownell24a5bb72008-07-14 22:38:23 +02001845 dev_err(&adapter->dev,
1846 "Invalid block write size %d\n",
Jean Delvare209d27c2007-05-01 23:26:29 +02001847 data->block[0]);
David Brownell24a5bb72008-07-14 22:38:23 +02001848 return -EINVAL;
Jean Delvare209d27c2007-05-01 23:26:29 +02001849 }
1850 msg[0].len = data->block[0] + 2;
1851 for (i = 1; i < msg[0].len; i++)
1852 msgbuf0[i] = data->block[i-1];
1853 msg[1].flags |= I2C_M_RECV_LEN;
1854 msg[1].len = 1; /* block length will be added by
1855 the underlying bus driver */
1856 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857 case I2C_SMBUS_I2C_BLOCK_DATA:
1858 if (read_write == I2C_SMBUS_READ) {
Jean Delvare4b2643d2007-07-12 14:12:29 +02001859 msg[1].len = data->block[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860 } else {
1861 msg[0].len = data->block[0] + 1;
Jean Delvare30dac742005-10-08 00:15:59 +02001862 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
David Brownell24a5bb72008-07-14 22:38:23 +02001863 dev_err(&adapter->dev,
1864 "Invalid block write size %d\n",
1865 data->block[0]);
1866 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867 }
1868 for (i = 1; i <= data->block[0]; i++)
1869 msgbuf0[i] = data->block[i];
1870 }
1871 break;
1872 default:
David Brownell24a5bb72008-07-14 22:38:23 +02001873 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
1874 return -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875 }
1876
Jean Delvare421ef472005-10-26 21:28:55 +02001877 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
1878 && size != I2C_SMBUS_I2C_BLOCK_DATA);
1879 if (i) {
1880 /* Compute PEC if first message is a write */
1881 if (!(msg[0].flags & I2C_M_RD)) {
David Brownell438d6c22006-12-10 21:21:31 +01001882 if (num == 1) /* Write only */
Jean Delvare421ef472005-10-26 21:28:55 +02001883 i2c_smbus_add_pec(&msg[0]);
1884 else /* Write followed by read */
1885 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
1886 }
1887 /* Ask for PEC if last message is a read */
1888 if (msg[num-1].flags & I2C_M_RD)
David Brownell438d6c22006-12-10 21:21:31 +01001889 msg[num-1].len++;
Jean Delvare421ef472005-10-26 21:28:55 +02001890 }
1891
David Brownell24a5bb72008-07-14 22:38:23 +02001892 status = i2c_transfer(adapter, msg, num);
1893 if (status < 0)
1894 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895
Jean Delvare421ef472005-10-26 21:28:55 +02001896 /* Check PEC if last message is a read */
1897 if (i && (msg[num-1].flags & I2C_M_RD)) {
David Brownell24a5bb72008-07-14 22:38:23 +02001898 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
1899 if (status < 0)
1900 return status;
Jean Delvare421ef472005-10-26 21:28:55 +02001901 }
1902
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903 if (read_write == I2C_SMBUS_READ)
1904 switch(size) {
1905 case I2C_SMBUS_BYTE:
1906 data->byte = msgbuf0[0];
1907 break;
1908 case I2C_SMBUS_BYTE_DATA:
1909 data->byte = msgbuf1[0];
1910 break;
David Brownell438d6c22006-12-10 21:21:31 +01001911 case I2C_SMBUS_WORD_DATA:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912 case I2C_SMBUS_PROC_CALL:
1913 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
1914 break;
1915 case I2C_SMBUS_I2C_BLOCK_DATA:
Jean Delvare4b2643d2007-07-12 14:12:29 +02001916 for (i = 0; i < data->block[0]; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917 data->block[i+1] = msgbuf1[i];
1918 break;
Jean Delvare209d27c2007-05-01 23:26:29 +02001919 case I2C_SMBUS_BLOCK_DATA:
1920 case I2C_SMBUS_BLOCK_PROC_CALL:
1921 for (i = 0; i < msgbuf1[0] + 1; i++)
1922 data->block[i] = msgbuf1[i];
1923 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001924 }
1925 return 0;
1926}
1927
David Brownella1cdeda2008-07-14 22:38:24 +02001928/**
1929 * i2c_smbus_xfer - execute SMBus protocol operations
1930 * @adapter: Handle to I2C bus
1931 * @addr: Address of SMBus slave on that bus
1932 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
1933 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
1934 * @command: Byte interpreted by slave, for protocols which use such bytes
1935 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
1936 * @data: Data to be read or written
1937 *
1938 * This executes an SMBus protocol operation, and returns a negative
1939 * errno code else zero on success.
1940 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001941s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u16 addr, unsigned short flags,
David Brownella1cdeda2008-07-14 22:38:24 +02001942 char read_write, u8 command, int protocol,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943 union i2c_smbus_data * data)
1944{
1945 s32 res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946
1947 flags &= I2C_M_TEN | I2C_CLIENT_PEC;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948
1949 if (adapter->algo->smbus_xfer) {
Ingo Molnar5c085d32006-01-18 23:16:04 +01001950 mutex_lock(&adapter->bus_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951 res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write,
David Brownella1cdeda2008-07-14 22:38:24 +02001952 command, protocol, data);
Ingo Molnar5c085d32006-01-18 23:16:04 +01001953 mutex_unlock(&adapter->bus_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954 } else
1955 res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
David Brownella1cdeda2008-07-14 22:38:24 +02001956 command, protocol, data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958 return res;
1959}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001960EXPORT_SYMBOL(i2c_smbus_xfer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961
1962MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
1963MODULE_DESCRIPTION("I2C-Bus main module");
1964MODULE_LICENSE("GPL");