blob: 8d80fceca6a4aaf8ff9ff1a24851687e684f579e [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>
Rodolfo Giomettif18c41d2009-06-19 16:58:20 +020036#include <linux/rwsem.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 Delvare99cd8e22009-06-19 16:58:20 +020042/* core_lock protects i2c_adapter_idr, userspace_devices, and guarantees
Jean Delvare35fc37f2009-06-19 16:58:19 +020043 that device detection, deletion of detected devices, and attach_adapter
44 and detach_adapter calls are serialized */
Jean Delvarecaada322008-01-27 18:14:49 +010045static DEFINE_MUTEX(core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070046static DEFINE_IDR(i2c_adapter_idr);
Jean Delvare99cd8e22009-06-19 16:58:20 +020047static LIST_HEAD(userspace_devices);
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
Jean Delvare4f8cf822009-09-18 22:45:46 +020049static struct device_type i2c_client_type;
Jean Delvaref8a227e2009-06-19 16:58:18 +020050static int i2c_check_addr(struct i2c_adapter *adapter, int addr);
Jean Delvare4735c982008-07-14 22:38:36 +020051static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
David Brownellf37dd802007-02-13 22:09:00 +010052
53/* ------------------------------------------------------------------------- */
54
Jean Delvared2653e92008-04-29 23:11:39 +020055static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
56 const struct i2c_client *client)
57{
58 while (id->name[0]) {
59 if (strcmp(client->name, id->name) == 0)
60 return id;
61 id++;
62 }
63 return NULL;
64}
65
Linus Torvalds1da177e2005-04-16 15:20:36 -070066static int i2c_device_match(struct device *dev, struct device_driver *drv)
67{
Jean Delvare51298d12009-09-18 22:45:45 +020068 struct i2c_client *client = i2c_verify_client(dev);
69 struct i2c_driver *driver;
David Brownell7b4fbc52007-05-01 23:26:30 +020070
Jean Delvare51298d12009-09-18 22:45:45 +020071 if (!client)
72 return 0;
73
74 driver = to_i2c_driver(drv);
Jean Delvared2653e92008-04-29 23:11:39 +020075 /* match on an id table if there is one */
76 if (driver->id_table)
77 return i2c_match_id(driver->id_table, client) != NULL;
78
Jean Delvareeb8a7902008-05-18 20:49:41 +020079 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070080}
81
David Brownell7b4fbc52007-05-01 23:26:30 +020082#ifdef CONFIG_HOTPLUG
83
84/* uevent helps with hotplug: modprobe -q $(MODALIAS) */
Kay Sievers7eff2e72007-08-14 15:15:12 +020085static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
David Brownell7b4fbc52007-05-01 23:26:30 +020086{
87 struct i2c_client *client = to_i2c_client(dev);
David Brownell7b4fbc52007-05-01 23:26:30 +020088
Jean Delvareeb8a7902008-05-18 20:49:41 +020089 if (add_uevent_var(env, "MODALIAS=%s%s",
90 I2C_MODULE_PREFIX, client->name))
91 return -ENOMEM;
David Brownell7b4fbc52007-05-01 23:26:30 +020092 dev_dbg(dev, "uevent\n");
93 return 0;
94}
95
96#else
97#define i2c_device_uevent NULL
98#endif /* CONFIG_HOTPLUG */
99
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100static int i2c_device_probe(struct device *dev)
101{
Jean Delvare51298d12009-09-18 22:45:45 +0200102 struct i2c_client *client = i2c_verify_client(dev);
103 struct i2c_driver *driver;
Hans Verkuil50c33042008-03-12 14:15:00 +0100104 int status;
David Brownell7b4fbc52007-05-01 23:26:30 +0200105
Jean Delvare51298d12009-09-18 22:45:45 +0200106 if (!client)
107 return 0;
108
109 driver = to_i2c_driver(dev->driver);
Jean Delvaree0457442008-07-14 22:38:30 +0200110 if (!driver->probe || !driver->id_table)
David Brownell7b4fbc52007-05-01 23:26:30 +0200111 return -ENODEV;
112 client->driver = driver;
Marc Pignatee354252008-08-28 08:33:22 +0200113 if (!device_can_wakeup(&client->dev))
114 device_init_wakeup(&client->dev,
115 client->flags & I2C_CLIENT_WAKE);
David Brownell7b4fbc52007-05-01 23:26:30 +0200116 dev_dbg(dev, "probe\n");
Jean Delvared2653e92008-04-29 23:11:39 +0200117
Jean Delvaree0457442008-07-14 22:38:30 +0200118 status = driver->probe(client, i2c_match_id(driver->id_table, client));
Hans Verkuil50c33042008-03-12 14:15:00 +0100119 if (status)
120 client->driver = NULL;
121 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122}
123
124static int i2c_device_remove(struct device *dev)
125{
Jean Delvare51298d12009-09-18 22:45:45 +0200126 struct i2c_client *client = i2c_verify_client(dev);
David Brownella1d9e6e2007-05-01 23:26:30 +0200127 struct i2c_driver *driver;
128 int status;
129
Jean Delvare51298d12009-09-18 22:45:45 +0200130 if (!client || !dev->driver)
David Brownella1d9e6e2007-05-01 23:26:30 +0200131 return 0;
132
133 driver = to_i2c_driver(dev->driver);
134 if (driver->remove) {
135 dev_dbg(dev, "remove\n");
136 status = driver->remove(client);
137 } else {
138 dev->driver = NULL;
139 status = 0;
140 }
141 if (status == 0)
142 client->driver = NULL;
143 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144}
145
David Brownellf37dd802007-02-13 22:09:00 +0100146static void i2c_device_shutdown(struct device *dev)
147{
Jean Delvare51298d12009-09-18 22:45:45 +0200148 struct i2c_client *client = i2c_verify_client(dev);
David Brownellf37dd802007-02-13 22:09:00 +0100149 struct i2c_driver *driver;
150
Jean Delvare51298d12009-09-18 22:45:45 +0200151 if (!client || !dev->driver)
David Brownellf37dd802007-02-13 22:09:00 +0100152 return;
153 driver = to_i2c_driver(dev->driver);
154 if (driver->shutdown)
Jean Delvare51298d12009-09-18 22:45:45 +0200155 driver->shutdown(client);
David Brownellf37dd802007-02-13 22:09:00 +0100156}
157
Zhenwen Xu09b8ce02009-03-28 21:34:46 +0100158static int i2c_device_suspend(struct device *dev, pm_message_t mesg)
David Brownellf37dd802007-02-13 22:09:00 +0100159{
Jean Delvare51298d12009-09-18 22:45:45 +0200160 struct i2c_client *client = i2c_verify_client(dev);
David Brownellf37dd802007-02-13 22:09:00 +0100161 struct i2c_driver *driver;
162
Jean Delvare51298d12009-09-18 22:45:45 +0200163 if (!client || !dev->driver)
David Brownellf37dd802007-02-13 22:09:00 +0100164 return 0;
165 driver = to_i2c_driver(dev->driver);
166 if (!driver->suspend)
167 return 0;
Jean Delvare51298d12009-09-18 22:45:45 +0200168 return driver->suspend(client, mesg);
David Brownellf37dd802007-02-13 22:09:00 +0100169}
170
Zhenwen Xu09b8ce02009-03-28 21:34:46 +0100171static int i2c_device_resume(struct device *dev)
David Brownellf37dd802007-02-13 22:09:00 +0100172{
Jean Delvare51298d12009-09-18 22:45:45 +0200173 struct i2c_client *client = i2c_verify_client(dev);
David Brownellf37dd802007-02-13 22:09:00 +0100174 struct i2c_driver *driver;
175
Jean Delvare51298d12009-09-18 22:45:45 +0200176 if (!client || !dev->driver)
David Brownellf37dd802007-02-13 22:09:00 +0100177 return 0;
178 driver = to_i2c_driver(dev->driver);
179 if (!driver->resume)
180 return 0;
Jean Delvare51298d12009-09-18 22:45:45 +0200181 return driver->resume(client);
David Brownellf37dd802007-02-13 22:09:00 +0100182}
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
Jean Delvare4f8cf822009-09-18 22:45:46 +0200190show_name(struct device *dev, struct device_attribute *attr, char *buf)
David Brownell7b4fbc52007-05-01 23:26:30 +0200191{
Jean Delvare4f8cf822009-09-18 22:45:46 +0200192 return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
193 to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
David Brownell7b4fbc52007-05-01 23:26:30 +0200194}
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
Jean Delvare4f8cf822009-09-18 22:45:46 +0200203static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
Jean Delvare51298d12009-09-18 22:45:45 +0200204static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
205
206static struct attribute *i2c_dev_attrs[] = {
207 &dev_attr_name.attr,
David Brownell7b4fbc52007-05-01 23:26:30 +0200208 /* modalias helps coldplug: modprobe $(cat .../modalias) */
Jean Delvare51298d12009-09-18 22:45:45 +0200209 &dev_attr_modalias.attr,
210 NULL
211};
212
213static struct attribute_group i2c_dev_attr_group = {
214 .attrs = i2c_dev_attrs,
215};
216
217static const struct attribute_group *i2c_dev_attr_groups[] = {
218 &i2c_dev_attr_group,
219 NULL
David Brownell7b4fbc52007-05-01 23:26:30 +0200220};
221
Jon Smirle9ca9eb2008-07-14 22:38:35 +0200222struct bus_type i2c_bus_type = {
David Brownellf37dd802007-02-13 22:09:00 +0100223 .name = "i2c",
224 .match = i2c_device_match,
225 .probe = i2c_device_probe,
226 .remove = i2c_device_remove,
227 .shutdown = i2c_device_shutdown,
228 .suspend = i2c_device_suspend,
229 .resume = i2c_device_resume,
Russell Kingb864c7d2006-01-05 14:37:50 +0000230};
Jon Smirle9ca9eb2008-07-14 22:38:35 +0200231EXPORT_SYMBOL_GPL(i2c_bus_type);
Russell Kingb864c7d2006-01-05 14:37:50 +0000232
Jean Delvare51298d12009-09-18 22:45:45 +0200233static struct device_type i2c_client_type = {
234 .groups = i2c_dev_attr_groups,
235 .uevent = i2c_device_uevent,
236 .release = i2c_client_dev_release,
237};
238
David Brownell9b766b82008-01-27 18:14:51 +0100239
240/**
241 * i2c_verify_client - return parameter as i2c_client, or NULL
242 * @dev: device, probably from some driver model iterator
243 *
244 * When traversing the driver model tree, perhaps using driver model
245 * iterators like @device_for_each_child(), you can't assume very much
246 * about the nodes you find. Use this function to avoid oopses caused
247 * by wrongly treating some non-I2C device as an i2c_client.
248 */
249struct i2c_client *i2c_verify_client(struct device *dev)
250{
Jean Delvare51298d12009-09-18 22:45:45 +0200251 return (dev->type == &i2c_client_type)
David Brownell9b766b82008-01-27 18:14:51 +0100252 ? to_i2c_client(dev)
253 : NULL;
254}
255EXPORT_SYMBOL(i2c_verify_client);
256
257
David Brownell9c1600e2007-05-01 23:26:31 +0200258/**
Jean Delvaref8a227e2009-06-19 16:58:18 +0200259 * i2c_new_device - instantiate an i2c device
David Brownell9c1600e2007-05-01 23:26:31 +0200260 * @adap: the adapter managing the device
261 * @info: describes one I2C device; bus_num is ignored
David Brownelld64f73b2007-07-12 14:12:28 +0200262 * Context: can sleep
David Brownell9c1600e2007-05-01 23:26:31 +0200263 *
Jean Delvaref8a227e2009-06-19 16:58:18 +0200264 * Create an i2c device. Binding is handled through driver model
265 * probe()/remove() methods. A driver may be bound to this device when we
266 * return from this function, or any later moment (e.g. maybe hotplugging will
267 * load the driver module). This call is not appropriate for use by mainboard
268 * initialization logic, which usually runs during an arch_initcall() long
269 * before any i2c_adapter could exist.
David Brownell9c1600e2007-05-01 23:26:31 +0200270 *
271 * This returns the new i2c client, which may be saved for later use with
272 * i2c_unregister_device(); or NULL to indicate an error.
273 */
274struct i2c_client *
275i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
276{
277 struct i2c_client *client;
278 int status;
279
280 client = kzalloc(sizeof *client, GFP_KERNEL);
281 if (!client)
282 return NULL;
283
284 client->adapter = adap;
285
286 client->dev.platform_data = info->platform_data;
David Brownell3bbb8352007-10-13 23:56:29 +0200287
Anton Vorontsov11f1f2a2008-10-22 20:21:33 +0200288 if (info->archdata)
289 client->dev.archdata = *info->archdata;
290
Marc Pignatee354252008-08-28 08:33:22 +0200291 client->flags = info->flags;
David Brownell9c1600e2007-05-01 23:26:31 +0200292 client->addr = info->addr;
293 client->irq = info->irq;
294
David Brownell9c1600e2007-05-01 23:26:31 +0200295 strlcpy(client->name, info->type, sizeof(client->name));
296
Jean Delvaref8a227e2009-06-19 16:58:18 +0200297 /* Check for address business */
298 status = i2c_check_addr(adap, client->addr);
299 if (status)
300 goto out_err;
301
302 client->dev.parent = &client->adapter->dev;
303 client->dev.bus = &i2c_bus_type;
Jean Delvare51298d12009-09-18 22:45:45 +0200304 client->dev.type = &i2c_client_type;
Jean Delvaref8a227e2009-06-19 16:58:18 +0200305
306 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
307 client->addr);
308 status = device_register(&client->dev);
309 if (status)
310 goto out_err;
311
Jean Delvaref8a227e2009-06-19 16:58:18 +0200312 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
313 client->name, dev_name(&client->dev));
314
David Brownell9c1600e2007-05-01 23:26:31 +0200315 return client;
Jean Delvaref8a227e2009-06-19 16:58:18 +0200316
317out_err:
318 dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
319 "(%d)\n", client->name, client->addr, status);
320 kfree(client);
321 return NULL;
David Brownell9c1600e2007-05-01 23:26:31 +0200322}
323EXPORT_SYMBOL_GPL(i2c_new_device);
324
325
326/**
327 * i2c_unregister_device - reverse effect of i2c_new_device()
328 * @client: value returned from i2c_new_device()
David Brownelld64f73b2007-07-12 14:12:28 +0200329 * Context: can sleep
David Brownell9c1600e2007-05-01 23:26:31 +0200330 */
331void i2c_unregister_device(struct i2c_client *client)
David Brownella1d9e6e2007-05-01 23:26:30 +0200332{
David Brownella1d9e6e2007-05-01 23:26:30 +0200333 device_unregister(&client->dev);
334}
David Brownell9c1600e2007-05-01 23:26:31 +0200335EXPORT_SYMBOL_GPL(i2c_unregister_device);
David Brownella1d9e6e2007-05-01 23:26:30 +0200336
337
Jean Delvare60b129d2008-05-11 20:37:06 +0200338static const struct i2c_device_id dummy_id[] = {
339 { "dummy", 0 },
340 { },
341};
342
Jean Delvared2653e92008-04-29 23:11:39 +0200343static int dummy_probe(struct i2c_client *client,
344 const struct i2c_device_id *id)
345{
346 return 0;
347}
348
349static int dummy_remove(struct i2c_client *client)
David Brownelle9f13732008-01-27 18:14:52 +0100350{
351 return 0;
352}
353
354static struct i2c_driver dummy_driver = {
355 .driver.name = "dummy",
Jean Delvared2653e92008-04-29 23:11:39 +0200356 .probe = dummy_probe,
357 .remove = dummy_remove,
Jean Delvare60b129d2008-05-11 20:37:06 +0200358 .id_table = dummy_id,
David Brownelle9f13732008-01-27 18:14:52 +0100359};
360
361/**
362 * i2c_new_dummy - return a new i2c device bound to a dummy driver
363 * @adapter: the adapter managing the device
364 * @address: seven bit address to be used
David Brownelle9f13732008-01-27 18:14:52 +0100365 * Context: can sleep
366 *
367 * This returns an I2C client bound to the "dummy" driver, intended for use
368 * with devices that consume multiple addresses. Examples of such chips
369 * include various EEPROMS (like 24c04 and 24c08 models).
370 *
371 * These dummy devices have two main uses. First, most I2C and SMBus calls
372 * except i2c_transfer() need a client handle; the dummy will be that handle.
373 * And second, this prevents the specified address from being bound to a
374 * different driver.
375 *
376 * This returns the new i2c client, which should be saved for later use with
377 * i2c_unregister_device(); or NULL to indicate an error.
378 */
Zhenwen Xu09b8ce02009-03-28 21:34:46 +0100379struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
David Brownelle9f13732008-01-27 18:14:52 +0100380{
381 struct i2c_board_info info = {
Jean Delvare60b129d2008-05-11 20:37:06 +0200382 I2C_BOARD_INFO("dummy", address),
David Brownelle9f13732008-01-27 18:14:52 +0100383 };
384
David Brownelle9f13732008-01-27 18:14:52 +0100385 return i2c_new_device(adapter, &info);
386}
387EXPORT_SYMBOL_GPL(i2c_new_dummy);
388
David Brownellf37dd802007-02-13 22:09:00 +0100389/* ------------------------------------------------------------------------- */
390
David Brownell16ffadf2007-05-01 23:26:28 +0200391/* I2C bus adapters -- one roots each I2C or SMBUS segment */
392
Adrian Bunk83eaaed2007-10-13 23:56:30 +0200393static void i2c_adapter_dev_release(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394{
David Brownellef2c83212007-05-01 23:26:28 +0200395 struct i2c_adapter *adap = to_i2c_adapter(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 complete(&adap->dev_released);
397}
398
Jean Delvare99cd8e22009-06-19 16:58:20 +0200399/*
400 * Let users instantiate I2C devices through sysfs. This can be used when
401 * platform initialization code doesn't contain the proper data for
402 * whatever reason. Also useful for drivers that do device detection and
403 * detection fails, either because the device uses an unexpected address,
404 * or this is a compatible device with different ID register values.
405 *
406 * Parameter checking may look overzealous, but we really don't want
407 * the user to provide incorrect parameters.
408 */
409static ssize_t
410i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
411 const char *buf, size_t count)
412{
413 struct i2c_adapter *adap = to_i2c_adapter(dev);
414 struct i2c_board_info info;
415 struct i2c_client *client;
416 char *blank, end;
417 int res;
418
419 dev_warn(dev, "The new_device interface is still experimental "
420 "and may change in a near future\n");
421 memset(&info, 0, sizeof(struct i2c_board_info));
422
423 blank = strchr(buf, ' ');
424 if (!blank) {
425 dev_err(dev, "%s: Missing parameters\n", "new_device");
426 return -EINVAL;
427 }
428 if (blank - buf > I2C_NAME_SIZE - 1) {
429 dev_err(dev, "%s: Invalid device name\n", "new_device");
430 return -EINVAL;
431 }
432 memcpy(info.type, buf, blank - buf);
433
434 /* Parse remaining parameters, reject extra parameters */
435 res = sscanf(++blank, "%hi%c", &info.addr, &end);
436 if (res < 1) {
437 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
438 return -EINVAL;
439 }
440 if (res > 1 && end != '\n') {
441 dev_err(dev, "%s: Extra parameters\n", "new_device");
442 return -EINVAL;
443 }
444
445 if (info.addr < 0x03 || info.addr > 0x77) {
446 dev_err(dev, "%s: Invalid I2C address 0x%hx\n", "new_device",
447 info.addr);
448 return -EINVAL;
449 }
450
451 client = i2c_new_device(adap, &info);
452 if (!client)
453 return -EEXIST;
454
455 /* Keep track of the added device */
456 mutex_lock(&core_lock);
457 list_add_tail(&client->detected, &userspace_devices);
458 mutex_unlock(&core_lock);
459 dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
460 info.type, info.addr);
461
462 return count;
463}
464
465/*
466 * And of course let the users delete the devices they instantiated, if
467 * they got it wrong. This interface can only be used to delete devices
468 * instantiated by i2c_sysfs_new_device above. This guarantees that we
469 * don't delete devices to which some kernel code still has references.
470 *
471 * Parameter checking may look overzealous, but we really don't want
472 * the user to delete the wrong device.
473 */
474static ssize_t
475i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
476 const char *buf, size_t count)
477{
478 struct i2c_adapter *adap = to_i2c_adapter(dev);
479 struct i2c_client *client, *next;
480 unsigned short addr;
481 char end;
482 int res;
483
484 /* Parse parameters, reject extra parameters */
485 res = sscanf(buf, "%hi%c", &addr, &end);
486 if (res < 1) {
487 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
488 return -EINVAL;
489 }
490 if (res > 1 && end != '\n') {
491 dev_err(dev, "%s: Extra parameters\n", "delete_device");
492 return -EINVAL;
493 }
494
495 /* Make sure the device was added through sysfs */
496 res = -ENOENT;
497 mutex_lock(&core_lock);
498 list_for_each_entry_safe(client, next, &userspace_devices, detected) {
499 if (client->addr == addr && client->adapter == adap) {
500 dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
501 "delete_device", client->name, client->addr);
502
503 list_del(&client->detected);
504 i2c_unregister_device(client);
505 res = count;
506 break;
507 }
508 }
509 mutex_unlock(&core_lock);
510
511 if (res < 0)
512 dev_err(dev, "%s: Can't find device in list\n",
513 "delete_device");
514 return res;
515}
516
Jean Delvare4f8cf822009-09-18 22:45:46 +0200517static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
518static DEVICE_ATTR(delete_device, S_IWUSR, NULL, i2c_sysfs_delete_device);
519
520static struct attribute *i2c_adapter_attrs[] = {
521 &dev_attr_name.attr,
522 &dev_attr_new_device.attr,
523 &dev_attr_delete_device.attr,
524 NULL
David Brownell16ffadf2007-05-01 23:26:28 +0200525};
526
Jean Delvare4f8cf822009-09-18 22:45:46 +0200527static struct attribute_group i2c_adapter_attr_group = {
528 .attrs = i2c_adapter_attrs,
529};
530
531static const struct attribute_group *i2c_adapter_attr_groups[] = {
532 &i2c_adapter_attr_group,
533 NULL
534};
535
536static struct device_type i2c_adapter_type = {
537 .groups = i2c_adapter_attr_groups,
538 .release = i2c_adapter_dev_release,
David Brownell16ffadf2007-05-01 23:26:28 +0200539};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540
Jean Delvare2bb50952009-09-18 22:45:46 +0200541#ifdef CONFIG_I2C_COMPAT
542static struct class_compat *i2c_adapter_compat_class;
543#endif
544
David Brownell9c1600e2007-05-01 23:26:31 +0200545static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
546{
547 struct i2c_devinfo *devinfo;
548
Rodolfo Giomettif18c41d2009-06-19 16:58:20 +0200549 down_read(&__i2c_board_lock);
David Brownell9c1600e2007-05-01 23:26:31 +0200550 list_for_each_entry(devinfo, &__i2c_board_list, list) {
551 if (devinfo->busnum == adapter->nr
552 && !i2c_new_device(adapter,
553 &devinfo->board_info))
Zhenwen Xu09b8ce02009-03-28 21:34:46 +0100554 dev_err(&adapter->dev,
555 "Can't create device at 0x%02x\n",
David Brownell9c1600e2007-05-01 23:26:31 +0200556 devinfo->board_info.addr);
557 }
Rodolfo Giomettif18c41d2009-06-19 16:58:20 +0200558 up_read(&__i2c_board_lock);
David Brownell9c1600e2007-05-01 23:26:31 +0200559}
560
Jean Delvare026526f2008-01-27 18:14:49 +0100561static int i2c_do_add_adapter(struct device_driver *d, void *data)
562{
563 struct i2c_driver *driver = to_i2c_driver(d);
564 struct i2c_adapter *adap = data;
565
Jean Delvare4735c982008-07-14 22:38:36 +0200566 /* Detect supported devices on that bus, and instantiate them */
567 i2c_detect(adap, driver);
568
569 /* Let legacy drivers scan this bus for matching devices */
Jean Delvare026526f2008-01-27 18:14:49 +0100570 if (driver->attach_adapter) {
571 /* We ignore the return code; if it fails, too bad */
572 driver->attach_adapter(adap);
573 }
574 return 0;
575}
576
David Brownell6e13e642007-05-01 23:26:31 +0200577static int i2c_register_adapter(struct i2c_adapter *adap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578{
Jean Delvare026526f2008-01-27 18:14:49 +0100579 int res = 0, dummy;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580
David Brownell1d0b19c2008-10-14 17:30:05 +0200581 /* Can't register until after driver model init */
Jean Delvare35fc37f2009-06-19 16:58:19 +0200582 if (unlikely(WARN_ON(!i2c_bus_type.p))) {
583 res = -EAGAIN;
584 goto out_list;
585 }
David Brownell1d0b19c2008-10-14 17:30:05 +0200586
Ingo Molnar5c085d32006-01-18 23:16:04 +0100587 mutex_init(&adap->bus_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588
Jean Delvare8fcfef62009-03-28 21:34:43 +0100589 /* Set default timeout to 1 second if not already set */
590 if (adap->timeout == 0)
591 adap->timeout = HZ;
592
Kay Sievers27d9c182009-01-07 14:29:16 +0100593 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
Jean Delvare4f8cf822009-09-18 22:45:46 +0200594 adap->dev.bus = &i2c_bus_type;
595 adap->dev.type = &i2c_adapter_type;
Jean Delvareb119c6c2006-08-15 18:26:30 +0200596 res = device_register(&adap->dev);
597 if (res)
598 goto out_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599
Jean Delvareb6d7b3d2005-07-31 19:02:53 +0200600 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
601
Jean Delvare2bb50952009-09-18 22:45:46 +0200602#ifdef CONFIG_I2C_COMPAT
603 res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
604 adap->dev.parent);
605 if (res)
606 dev_warn(&adap->dev,
607 "Failed to create compatibility class link\n");
608#endif
609
Jean Delvare729d6dd2009-06-19 16:58:18 +0200610 /* create pre-declared device nodes */
David Brownell6e13e642007-05-01 23:26:31 +0200611 if (adap->nr < __i2c_first_dynamic_bus_num)
612 i2c_scan_static_board_info(adap);
613
Jean Delvare4735c982008-07-14 22:38:36 +0200614 /* Notify drivers */
Jean Delvare35fc37f2009-06-19 16:58:19 +0200615 mutex_lock(&core_lock);
Jean Delvare026526f2008-01-27 18:14:49 +0100616 dummy = bus_for_each_drv(&i2c_bus_type, NULL, adap,
617 i2c_do_add_adapter);
Jean Delvarecaada322008-01-27 18:14:49 +0100618 mutex_unlock(&core_lock);
Jean Delvare35fc37f2009-06-19 16:58:19 +0200619
620 return 0;
Jean Delvareb119c6c2006-08-15 18:26:30 +0200621
Jean Delvareb119c6c2006-08-15 18:26:30 +0200622out_list:
Jean Delvare35fc37f2009-06-19 16:58:19 +0200623 mutex_lock(&core_lock);
Jean Delvareb119c6c2006-08-15 18:26:30 +0200624 idr_remove(&i2c_adapter_idr, adap->nr);
Jean Delvare35fc37f2009-06-19 16:58:19 +0200625 mutex_unlock(&core_lock);
626 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627}
628
David Brownell6e13e642007-05-01 23:26:31 +0200629/**
630 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
631 * @adapter: the adapter to add
David Brownelld64f73b2007-07-12 14:12:28 +0200632 * Context: can sleep
David Brownell6e13e642007-05-01 23:26:31 +0200633 *
634 * This routine is used to declare an I2C adapter when its bus number
635 * doesn't matter. Examples: for I2C adapters dynamically added by
636 * USB links or PCI plugin cards.
637 *
638 * When this returns zero, a new bus number was allocated and stored
639 * in adap->nr, and the specified adapter became available for clients.
640 * Otherwise, a negative errno value is returned.
641 */
642int i2c_add_adapter(struct i2c_adapter *adapter)
643{
644 int id, res = 0;
645
646retry:
647 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
648 return -ENOMEM;
649
Jean Delvarecaada322008-01-27 18:14:49 +0100650 mutex_lock(&core_lock);
David Brownell6e13e642007-05-01 23:26:31 +0200651 /* "above" here means "above or equal to", sigh */
652 res = idr_get_new_above(&i2c_adapter_idr, adapter,
653 __i2c_first_dynamic_bus_num, &id);
Jean Delvarecaada322008-01-27 18:14:49 +0100654 mutex_unlock(&core_lock);
David Brownell6e13e642007-05-01 23:26:31 +0200655
656 if (res < 0) {
657 if (res == -EAGAIN)
658 goto retry;
659 return res;
660 }
661
662 adapter->nr = id;
663 return i2c_register_adapter(adapter);
664}
665EXPORT_SYMBOL(i2c_add_adapter);
666
667/**
668 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
669 * @adap: the adapter to register (with adap->nr initialized)
David Brownelld64f73b2007-07-12 14:12:28 +0200670 * Context: can sleep
David Brownell6e13e642007-05-01 23:26:31 +0200671 *
672 * This routine is used to declare an I2C adapter when its bus number
Randy Dunlap8c07e462008-03-23 20:28:20 +0100673 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
674 * or otherwise built in to the system's mainboard, and where i2c_board_info
David Brownell6e13e642007-05-01 23:26:31 +0200675 * is used to properly configure I2C devices.
676 *
677 * If no devices have pre-been declared for this bus, then be sure to
678 * register the adapter before any dynamically allocated ones. Otherwise
679 * the required bus ID may not be available.
680 *
681 * When this returns zero, the specified adapter became available for
682 * clients using the bus number provided in adap->nr. Also, the table
683 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
684 * and the appropriate driver model device nodes are created. Otherwise, a
685 * negative errno value is returned.
686 */
687int i2c_add_numbered_adapter(struct i2c_adapter *adap)
688{
689 int id;
690 int status;
691
692 if (adap->nr & ~MAX_ID_MASK)
693 return -EINVAL;
694
695retry:
696 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
697 return -ENOMEM;
698
Jean Delvarecaada322008-01-27 18:14:49 +0100699 mutex_lock(&core_lock);
David Brownell6e13e642007-05-01 23:26:31 +0200700 /* "above" here means "above or equal to", sigh;
701 * we need the "equal to" result to force the result
702 */
703 status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
704 if (status == 0 && id != adap->nr) {
705 status = -EBUSY;
706 idr_remove(&i2c_adapter_idr, id);
707 }
Jean Delvarecaada322008-01-27 18:14:49 +0100708 mutex_unlock(&core_lock);
David Brownell6e13e642007-05-01 23:26:31 +0200709 if (status == -EAGAIN)
710 goto retry;
711
712 if (status == 0)
713 status = i2c_register_adapter(adap);
714 return status;
715}
716EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
717
Jean Delvare026526f2008-01-27 18:14:49 +0100718static int i2c_do_del_adapter(struct device_driver *d, void *data)
719{
720 struct i2c_driver *driver = to_i2c_driver(d);
721 struct i2c_adapter *adapter = data;
Jean Delvare4735c982008-07-14 22:38:36 +0200722 struct i2c_client *client, *_n;
Jean Delvare026526f2008-01-27 18:14:49 +0100723 int res;
724
Jean Delvareacec2112009-03-28 21:34:40 +0100725 /* Remove the devices we created ourselves as the result of hardware
726 * probing (using a driver's detect method) */
Jean Delvare4735c982008-07-14 22:38:36 +0200727 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
728 if (client->adapter == adapter) {
729 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
730 client->name, client->addr);
731 list_del(&client->detected);
732 i2c_unregister_device(client);
733 }
734 }
735
Jean Delvare026526f2008-01-27 18:14:49 +0100736 if (!driver->detach_adapter)
737 return 0;
738 res = driver->detach_adapter(adapter);
739 if (res)
740 dev_err(&adapter->dev, "detach_adapter failed (%d) "
741 "for driver [%s]\n", res, driver->driver.name);
742 return res;
743}
744
Jean Delvaree549c2b2009-06-19 16:58:19 +0200745static int __unregister_client(struct device *dev, void *dummy)
746{
747 struct i2c_client *client = i2c_verify_client(dev);
748 if (client)
749 i2c_unregister_device(client);
750 return 0;
751}
752
David Brownelld64f73b2007-07-12 14:12:28 +0200753/**
754 * i2c_del_adapter - unregister I2C adapter
755 * @adap: the adapter being unregistered
756 * Context: can sleep
757 *
758 * This unregisters an I2C adapter which was previously registered
759 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
760 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761int i2c_del_adapter(struct i2c_adapter *adap)
762{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 int res = 0;
Jean Delvare35fc37f2009-06-19 16:58:19 +0200764 struct i2c_adapter *found;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765
766 /* First make sure that this adapter was ever added */
Jean Delvare35fc37f2009-06-19 16:58:19 +0200767 mutex_lock(&core_lock);
768 found = idr_find(&i2c_adapter_idr, adap->nr);
769 mutex_unlock(&core_lock);
770 if (found != adap) {
Jean Delvareb6d7b3d2005-07-31 19:02:53 +0200771 pr_debug("i2c-core: attempting to delete unregistered "
772 "adapter [%s]\n", adap->name);
Jean Delvare35fc37f2009-06-19 16:58:19 +0200773 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 }
775
Jean Delvare026526f2008-01-27 18:14:49 +0100776 /* Tell drivers about this removal */
Jean Delvare35fc37f2009-06-19 16:58:19 +0200777 mutex_lock(&core_lock);
Jean Delvare026526f2008-01-27 18:14:49 +0100778 res = bus_for_each_drv(&i2c_bus_type, NULL, adap,
779 i2c_do_del_adapter);
Jean Delvare35fc37f2009-06-19 16:58:19 +0200780 mutex_unlock(&core_lock);
Jean Delvare026526f2008-01-27 18:14:49 +0100781 if (res)
Jean Delvare35fc37f2009-06-19 16:58:19 +0200782 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783
Jean Delvaree549c2b2009-06-19 16:58:19 +0200784 /* Detach any active clients. This can't fail, thus we do not
785 checking the returned value. */
786 res = device_for_each_child(&adap->dev, NULL, __unregister_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787
Jean Delvare2bb50952009-09-18 22:45:46 +0200788#ifdef CONFIG_I2C_COMPAT
789 class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
790 adap->dev.parent);
791#endif
792
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 /* clean up the sysfs representation */
794 init_completion(&adap->dev_released);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 device_unregister(&adap->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796
797 /* wait for sysfs to drop all references */
798 wait_for_completion(&adap->dev_released);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799
David Brownell6e13e642007-05-01 23:26:31 +0200800 /* free bus id */
Jean Delvare35fc37f2009-06-19 16:58:19 +0200801 mutex_lock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 idr_remove(&i2c_adapter_idr, adap->nr);
Jean Delvare35fc37f2009-06-19 16:58:19 +0200803 mutex_unlock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804
Jean Delvareb6d7b3d2005-07-31 19:02:53 +0200805 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806
Jean Delvarebd4bc3db2008-07-16 19:30:05 +0200807 /* Clear the device structure in case this adapter is ever going to be
808 added again */
809 memset(&adap->dev, 0, sizeof(adap->dev));
810
Jean Delvare35fc37f2009-06-19 16:58:19 +0200811 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812}
David Brownellc0564602007-05-01 23:26:31 +0200813EXPORT_SYMBOL(i2c_del_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814
815
David Brownell7b4fbc52007-05-01 23:26:30 +0200816/* ------------------------------------------------------------------------- */
817
Dave Young7f101a92008-07-14 22:38:19 +0200818static int __attach_adapter(struct device *dev, void *data)
819{
Jean Delvare4f8cf822009-09-18 22:45:46 +0200820 struct i2c_adapter *adapter;
Dave Young7f101a92008-07-14 22:38:19 +0200821 struct i2c_driver *driver = data;
822
Jean Delvare4f8cf822009-09-18 22:45:46 +0200823 if (dev->type != &i2c_adapter_type)
824 return 0;
825 adapter = to_i2c_adapter(dev);
826
Jean Delvare4735c982008-07-14 22:38:36 +0200827 i2c_detect(adapter, driver);
828
829 /* Legacy drivers scan i2c busses directly */
830 if (driver->attach_adapter)
831 driver->attach_adapter(adapter);
Dave Young7f101a92008-07-14 22:38:19 +0200832
833 return 0;
834}
835
David Brownell7b4fbc52007-05-01 23:26:30 +0200836/*
837 * An i2c_driver is used with one or more i2c_client (device) nodes to access
Jean Delvare729d6dd2009-06-19 16:58:18 +0200838 * i2c slave chips, on a bus instance associated with some i2c_adapter.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 */
840
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -0800841int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842{
Jean Delvare7eebcb72006-02-05 23:28:21 +0100843 int res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844
David Brownell1d0b19c2008-10-14 17:30:05 +0200845 /* Can't register until after driver model init */
846 if (unlikely(WARN_ON(!i2c_bus_type.p)))
847 return -EAGAIN;
848
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849 /* add the driver to the list of i2c drivers in the driver core */
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -0800850 driver->driver.owner = owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 driver->driver.bus = &i2c_bus_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852
Jean Delvare729d6dd2009-06-19 16:58:18 +0200853 /* When registration returns, the driver core
David Brownell6e13e642007-05-01 23:26:31 +0200854 * will have called probe() for all matching-but-unbound devices.
855 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 res = driver_register(&driver->driver);
857 if (res)
Jean Delvare7eebcb72006-02-05 23:28:21 +0100858 return res;
David Brownell438d6c22006-12-10 21:21:31 +0100859
Laurent Riffard35d8b2e2005-11-26 20:34:05 +0100860 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861
Jean Delvare4735c982008-07-14 22:38:36 +0200862 INIT_LIST_HEAD(&driver->clients);
863 /* Walk the adapters that are already present */
Jean Delvare35fc37f2009-06-19 16:58:19 +0200864 mutex_lock(&core_lock);
Jean Delvare4f8cf822009-09-18 22:45:46 +0200865 bus_for_each_dev(&i2c_bus_type, NULL, driver, __attach_adapter);
Jean Delvarecaada322008-01-27 18:14:49 +0100866 mutex_unlock(&core_lock);
Jean Delvare35fc37f2009-06-19 16:58:19 +0200867
Jean Delvare7eebcb72006-02-05 23:28:21 +0100868 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869}
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -0800870EXPORT_SYMBOL(i2c_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871
Dave Young7f101a92008-07-14 22:38:19 +0200872static int __detach_adapter(struct device *dev, void *data)
873{
Jean Delvare4f8cf822009-09-18 22:45:46 +0200874 struct i2c_adapter *adapter;
Dave Young7f101a92008-07-14 22:38:19 +0200875 struct i2c_driver *driver = data;
Jean Delvare4735c982008-07-14 22:38:36 +0200876 struct i2c_client *client, *_n;
877
Jean Delvare4f8cf822009-09-18 22:45:46 +0200878 if (dev->type != &i2c_adapter_type)
879 return 0;
880 adapter = to_i2c_adapter(dev);
881
Jean Delvareacec2112009-03-28 21:34:40 +0100882 /* Remove the devices we created ourselves as the result of hardware
883 * probing (using a driver's detect method) */
Jean Delvare4735c982008-07-14 22:38:36 +0200884 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
885 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
886 client->name, client->addr);
887 list_del(&client->detected);
888 i2c_unregister_device(client);
889 }
890
Dave Young7f101a92008-07-14 22:38:19 +0200891 if (driver->detach_adapter) {
892 if (driver->detach_adapter(adapter))
893 dev_err(&adapter->dev,
894 "detach_adapter failed for driver [%s]\n",
895 driver->driver.name);
Dave Young7f101a92008-07-14 22:38:19 +0200896 }
897
898 return 0;
899}
900
David Brownella1d9e6e2007-05-01 23:26:30 +0200901/**
902 * i2c_del_driver - unregister I2C driver
903 * @driver: the driver being unregistered
David Brownelld64f73b2007-07-12 14:12:28 +0200904 * Context: can sleep
David Brownella1d9e6e2007-05-01 23:26:30 +0200905 */
Jean Delvareb3e82092007-05-01 23:26:32 +0200906void i2c_del_driver(struct i2c_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907{
Jean Delvarecaada322008-01-27 18:14:49 +0100908 mutex_lock(&core_lock);
Jean Delvare4f8cf822009-09-18 22:45:46 +0200909 bus_for_each_dev(&i2c_bus_type, NULL, driver, __detach_adapter);
Jean Delvare35fc37f2009-06-19 16:58:19 +0200910 mutex_unlock(&core_lock);
David Brownella1d9e6e2007-05-01 23:26:30 +0200911
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 driver_unregister(&driver->driver);
Laurent Riffard35d8b2e2005-11-26 20:34:05 +0100913 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914}
David Brownellc0564602007-05-01 23:26:31 +0200915EXPORT_SYMBOL(i2c_del_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916
David Brownell7b4fbc52007-05-01 23:26:30 +0200917/* ------------------------------------------------------------------------- */
918
David Brownell9b766b82008-01-27 18:14:51 +0100919static int __i2c_check_addr(struct device *dev, void *addrp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920{
David Brownell9b766b82008-01-27 18:14:51 +0100921 struct i2c_client *client = i2c_verify_client(dev);
922 int addr = *(int *)addrp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923
David Brownell9b766b82008-01-27 18:14:51 +0100924 if (client && client->addr == addr)
925 return -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 return 0;
927}
928
Jean Delvare5e31c2b2007-11-15 19:24:02 +0100929static int i2c_check_addr(struct i2c_adapter *adapter, int addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930{
David Brownell9b766b82008-01-27 18:14:51 +0100931 return device_for_each_child(&adapter->dev, &addr, __i2c_check_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932}
933
Jean Delvaree48d3312008-01-27 18:14:48 +0100934/**
935 * i2c_use_client - increments the reference count of the i2c client structure
936 * @client: the client being referenced
937 *
938 * Each live reference to a client should be refcounted. The driver model does
939 * that automatically as part of driver binding, so that most drivers don't
940 * need to do this explicitly: they hold a reference until they're unbound
941 * from the device.
942 *
943 * A pointer to the client with the incremented reference counter is returned.
944 */
945struct i2c_client *i2c_use_client(struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946{
David Brownell6ea438e2008-07-14 22:38:24 +0200947 if (client && get_device(&client->dev))
948 return client;
949 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950}
David Brownellc0564602007-05-01 23:26:31 +0200951EXPORT_SYMBOL(i2c_use_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952
Jean Delvaree48d3312008-01-27 18:14:48 +0100953/**
954 * i2c_release_client - release a use of the i2c client structure
955 * @client: the client being no longer referenced
956 *
957 * Must be called when a user of a client is finished with it.
958 */
959void i2c_release_client(struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960{
David Brownell6ea438e2008-07-14 22:38:24 +0200961 if (client)
962 put_device(&client->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963}
David Brownellc0564602007-05-01 23:26:31 +0200964EXPORT_SYMBOL(i2c_release_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965
David Brownell9b766b82008-01-27 18:14:51 +0100966struct i2c_cmd_arg {
967 unsigned cmd;
968 void *arg;
969};
970
971static int i2c_cmd(struct device *dev, void *_arg)
972{
973 struct i2c_client *client = i2c_verify_client(dev);
974 struct i2c_cmd_arg *arg = _arg;
975
976 if (client && client->driver && client->driver->command)
977 client->driver->command(client, arg->cmd, arg->arg);
978 return 0;
979}
980
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
982{
David Brownell9b766b82008-01-27 18:14:51 +0100983 struct i2c_cmd_arg cmd_arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984
David Brownell9b766b82008-01-27 18:14:51 +0100985 cmd_arg.cmd = cmd;
986 cmd_arg.arg = arg;
987 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988}
David Brownellc0564602007-05-01 23:26:31 +0200989EXPORT_SYMBOL(i2c_clients_command);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990
991static int __init i2c_init(void)
992{
993 int retval;
994
995 retval = bus_register(&i2c_bus_type);
996 if (retval)
997 return retval;
Jean Delvare2bb50952009-09-18 22:45:46 +0200998#ifdef CONFIG_I2C_COMPAT
999 i2c_adapter_compat_class = class_compat_register("i2c-adapter");
1000 if (!i2c_adapter_compat_class) {
1001 retval = -ENOMEM;
1002 goto bus_err;
1003 }
1004#endif
David Brownelle9f13732008-01-27 18:14:52 +01001005 retval = i2c_add_driver(&dummy_driver);
1006 if (retval)
Jean Delvare2bb50952009-09-18 22:45:46 +02001007 goto class_err;
David Brownelle9f13732008-01-27 18:14:52 +01001008 return 0;
1009
Jean Delvare2bb50952009-09-18 22:45:46 +02001010class_err:
1011#ifdef CONFIG_I2C_COMPAT
1012 class_compat_unregister(i2c_adapter_compat_class);
David Brownelle9f13732008-01-27 18:14:52 +01001013bus_err:
Jean Delvare2bb50952009-09-18 22:45:46 +02001014#endif
David Brownelle9f13732008-01-27 18:14:52 +01001015 bus_unregister(&i2c_bus_type);
1016 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017}
1018
1019static void __exit i2c_exit(void)
1020{
David Brownelle9f13732008-01-27 18:14:52 +01001021 i2c_del_driver(&dummy_driver);
Jean Delvare2bb50952009-09-18 22:45:46 +02001022#ifdef CONFIG_I2C_COMPAT
1023 class_compat_unregister(i2c_adapter_compat_class);
1024#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 bus_unregister(&i2c_bus_type);
1026}
1027
David Brownella10f9e72008-10-14 17:30:06 +02001028/* We must initialize early, because some subsystems register i2c drivers
1029 * in subsys_initcall() code, but are linked (and initialized) before i2c.
1030 */
1031postcore_initcall(i2c_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032module_exit(i2c_exit);
1033
1034/* ----------------------------------------------------
1035 * the functional interface to the i2c busses.
1036 * ----------------------------------------------------
1037 */
1038
David Brownella1cdeda2008-07-14 22:38:24 +02001039/**
1040 * i2c_transfer - execute a single or combined I2C message
1041 * @adap: Handle to I2C bus
1042 * @msgs: One or more messages to execute before STOP is issued to
1043 * terminate the operation; each message begins with a START.
1044 * @num: Number of messages to be executed.
1045 *
1046 * Returns negative errno, else the number of messages executed.
1047 *
1048 * Note that there is no requirement that each message be sent to
1049 * the same slave address, although that is the most common model.
1050 */
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01001051int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052{
Clifford Wolf66b650f2009-06-15 18:01:46 +02001053 unsigned long orig_jiffies;
1054 int ret, try;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055
David Brownella1cdeda2008-07-14 22:38:24 +02001056 /* REVISIT the fault reporting model here is weak:
1057 *
1058 * - When we get an error after receiving N bytes from a slave,
1059 * there is no way to report "N".
1060 *
1061 * - When we get a NAK after transmitting N bytes to a slave,
1062 * there is no way to report "N" ... or to let the master
1063 * continue executing the rest of this combined message, if
1064 * that's the appropriate response.
1065 *
1066 * - When for example "num" is two and we successfully complete
1067 * the first message but get an error part way through the
1068 * second, it's unclear whether that should be reported as
1069 * one (discarding status on the second message) or errno
1070 * (discarding status on the first one).
1071 */
1072
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 if (adap->algo->master_xfer) {
1074#ifdef DEBUG
1075 for (ret = 0; ret < num; ret++) {
1076 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
Jean Delvare209d27c2007-05-01 23:26:29 +02001077 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
1078 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
1079 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080 }
1081#endif
1082
Mike Rapoportcea443a2008-01-27 18:14:50 +01001083 if (in_atomic() || irqs_disabled()) {
1084 ret = mutex_trylock(&adap->bus_lock);
1085 if (!ret)
1086 /* I2C activity is ongoing. */
1087 return -EAGAIN;
1088 } else {
1089 mutex_lock_nested(&adap->bus_lock, adap->level);
1090 }
1091
Clifford Wolf66b650f2009-06-15 18:01:46 +02001092 /* Retry automatically on arbitration loss */
1093 orig_jiffies = jiffies;
1094 for (ret = 0, try = 0; try <= adap->retries; try++) {
1095 ret = adap->algo->master_xfer(adap, msgs, num);
1096 if (ret != -EAGAIN)
1097 break;
1098 if (time_after(jiffies, orig_jiffies + adap->timeout))
1099 break;
1100 }
Ingo Molnar5c085d32006-01-18 23:16:04 +01001101 mutex_unlock(&adap->bus_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102
1103 return ret;
1104 } else {
1105 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
David Brownell24a5bb72008-07-14 22:38:23 +02001106 return -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107 }
1108}
David Brownellc0564602007-05-01 23:26:31 +02001109EXPORT_SYMBOL(i2c_transfer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110
David Brownella1cdeda2008-07-14 22:38:24 +02001111/**
1112 * i2c_master_send - issue a single I2C message in master transmit mode
1113 * @client: Handle to slave device
1114 * @buf: Data that will be written to the slave
1115 * @count: How many bytes to write
1116 *
1117 * Returns negative errno, or else the number of bytes written.
1118 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
1120{
1121 int ret;
1122 struct i2c_adapter *adap=client->adapter;
1123 struct i2c_msg msg;
1124
Jean Delvare815f55f2005-05-07 22:58:46 +02001125 msg.addr = client->addr;
1126 msg.flags = client->flags & I2C_M_TEN;
1127 msg.len = count;
1128 msg.buf = (char *)buf;
David Brownell438d6c22006-12-10 21:21:31 +01001129
Jean Delvare815f55f2005-05-07 22:58:46 +02001130 ret = i2c_transfer(adap, &msg, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131
Jean Delvare815f55f2005-05-07 22:58:46 +02001132 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1133 transmitted, else error code. */
1134 return (ret == 1) ? count : ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135}
David Brownellc0564602007-05-01 23:26:31 +02001136EXPORT_SYMBOL(i2c_master_send);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137
David Brownella1cdeda2008-07-14 22:38:24 +02001138/**
1139 * i2c_master_recv - issue a single I2C message in master receive mode
1140 * @client: Handle to slave device
1141 * @buf: Where to store data read from slave
1142 * @count: How many bytes to read
1143 *
1144 * Returns negative errno, or else the number of bytes read.
1145 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
1147{
1148 struct i2c_adapter *adap=client->adapter;
1149 struct i2c_msg msg;
1150 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151
Jean Delvare815f55f2005-05-07 22:58:46 +02001152 msg.addr = client->addr;
1153 msg.flags = client->flags & I2C_M_TEN;
1154 msg.flags |= I2C_M_RD;
1155 msg.len = count;
1156 msg.buf = buf;
1157
1158 ret = i2c_transfer(adap, &msg, 1);
1159
1160 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1161 transmitted, else error code. */
1162 return (ret == 1) ? count : ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163}
David Brownellc0564602007-05-01 23:26:31 +02001164EXPORT_SYMBOL(i2c_master_recv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166/* ----------------------------------------------------
1167 * the i2c address scanning function
1168 * Will not work for 10-bit addresses!
1169 * ----------------------------------------------------
1170 */
Jean Delvare9fc6adf2005-07-31 21:20:43 +02001171
Jean Delvare4735c982008-07-14 22:38:36 +02001172static int i2c_detect_address(struct i2c_client *temp_client, int kind,
1173 struct i2c_driver *driver)
1174{
1175 struct i2c_board_info info;
1176 struct i2c_adapter *adapter = temp_client->adapter;
1177 int addr = temp_client->addr;
1178 int err;
1179
1180 /* Make sure the address is valid */
1181 if (addr < 0x03 || addr > 0x77) {
1182 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1183 addr);
1184 return -EINVAL;
1185 }
1186
1187 /* Skip if already in use */
1188 if (i2c_check_addr(adapter, addr))
1189 return 0;
1190
1191 /* Make sure there is something at this address, unless forced */
1192 if (kind < 0) {
1193 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1194 I2C_SMBUS_QUICK, NULL) < 0)
1195 return 0;
1196
1197 /* prevent 24RF08 corruption */
1198 if ((addr & ~0x0f) == 0x50)
1199 i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1200 I2C_SMBUS_QUICK, NULL);
1201 }
1202
1203 /* Finally call the custom detection function */
1204 memset(&info, 0, sizeof(struct i2c_board_info));
1205 info.addr = addr;
1206 err = driver->detect(temp_client, kind, &info);
1207 if (err) {
1208 /* -ENODEV is returned if the detection fails. We catch it
1209 here as this isn't an error. */
1210 return err == -ENODEV ? 0 : err;
1211 }
1212
1213 /* Consistency check */
1214 if (info.type[0] == '\0') {
1215 dev_err(&adapter->dev, "%s detection function provided "
1216 "no name for 0x%x\n", driver->driver.name,
1217 addr);
1218 } else {
1219 struct i2c_client *client;
1220
1221 /* Detection succeeded, instantiate the device */
1222 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
1223 info.type, info.addr);
1224 client = i2c_new_device(adapter, &info);
1225 if (client)
1226 list_add_tail(&client->detected, &driver->clients);
1227 else
1228 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
1229 info.type, info.addr);
1230 }
1231 return 0;
1232}
1233
1234static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
1235{
1236 const struct i2c_client_address_data *address_data;
1237 struct i2c_client *temp_client;
1238 int i, err = 0;
1239 int adap_id = i2c_adapter_id(adapter);
1240
1241 address_data = driver->address_data;
1242 if (!driver->detect || !address_data)
1243 return 0;
1244
1245 /* Set up a temporary client to help detect callback */
1246 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
1247 if (!temp_client)
1248 return -ENOMEM;
1249 temp_client->adapter = adapter;
1250
1251 /* Force entries are done first, and are not affected by ignore
1252 entries */
1253 if (address_data->forces) {
1254 const unsigned short * const *forces = address_data->forces;
1255 int kind;
1256
1257 for (kind = 0; forces[kind]; kind++) {
1258 for (i = 0; forces[kind][i] != I2C_CLIENT_END;
1259 i += 2) {
1260 if (forces[kind][i] == adap_id
1261 || forces[kind][i] == ANY_I2C_BUS) {
1262 dev_dbg(&adapter->dev, "found force "
1263 "parameter for adapter %d, "
1264 "addr 0x%02x, kind %d\n",
1265 adap_id, forces[kind][i + 1],
1266 kind);
1267 temp_client->addr = forces[kind][i + 1];
1268 err = i2c_detect_address(temp_client,
1269 kind, driver);
1270 if (err)
1271 goto exit_free;
1272 }
1273 }
1274 }
1275 }
1276
Jean Delvare4329cf82008-08-28 08:33:23 +02001277 /* Stop here if the classes do not match */
1278 if (!(adapter->class & driver->class))
1279 goto exit_free;
1280
Jean Delvare4735c982008-07-14 22:38:36 +02001281 /* Stop here if we can't use SMBUS_QUICK */
1282 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
1283 if (address_data->probe[0] == I2C_CLIENT_END
1284 && address_data->normal_i2c[0] == I2C_CLIENT_END)
1285 goto exit_free;
1286
1287 dev_warn(&adapter->dev, "SMBus Quick command not supported, "
1288 "can't probe for chips\n");
1289 err = -EOPNOTSUPP;
1290 goto exit_free;
1291 }
1292
Jean Delvare4735c982008-07-14 22:38:36 +02001293 /* Probe entries are done second, and are not affected by ignore
1294 entries either */
1295 for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
1296 if (address_data->probe[i] == adap_id
1297 || address_data->probe[i] == ANY_I2C_BUS) {
1298 dev_dbg(&adapter->dev, "found probe parameter for "
1299 "adapter %d, addr 0x%02x\n", adap_id,
1300 address_data->probe[i + 1]);
1301 temp_client->addr = address_data->probe[i + 1];
1302 err = i2c_detect_address(temp_client, -1, driver);
1303 if (err)
1304 goto exit_free;
1305 }
1306 }
1307
1308 /* Normal entries are done last, unless shadowed by an ignore entry */
1309 for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
1310 int j, ignore;
1311
1312 ignore = 0;
1313 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
1314 j += 2) {
1315 if ((address_data->ignore[j] == adap_id ||
1316 address_data->ignore[j] == ANY_I2C_BUS)
1317 && address_data->ignore[j + 1]
1318 == address_data->normal_i2c[i]) {
1319 dev_dbg(&adapter->dev, "found ignore "
1320 "parameter for adapter %d, "
1321 "addr 0x%02x\n", adap_id,
1322 address_data->ignore[j + 1]);
1323 ignore = 1;
1324 break;
1325 }
1326 }
1327 if (ignore)
1328 continue;
1329
1330 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1331 "addr 0x%02x\n", adap_id,
1332 address_data->normal_i2c[i]);
1333 temp_client->addr = address_data->normal_i2c[i];
1334 err = i2c_detect_address(temp_client, -1, driver);
1335 if (err)
1336 goto exit_free;
1337 }
1338
1339 exit_free:
1340 kfree(temp_client);
1341 return err;
1342}
1343
Jean Delvare12b5053a2007-05-01 23:26:31 +02001344struct i2c_client *
1345i2c_new_probed_device(struct i2c_adapter *adap,
1346 struct i2c_board_info *info,
1347 unsigned short const *addr_list)
1348{
1349 int i;
1350
1351 /* Stop here if the bus doesn't support probing */
1352 if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE)) {
1353 dev_err(&adap->dev, "Probing not supported\n");
1354 return NULL;
1355 }
1356
Jean Delvare12b5053a2007-05-01 23:26:31 +02001357 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1358 /* Check address validity */
1359 if (addr_list[i] < 0x03 || addr_list[i] > 0x77) {
1360 dev_warn(&adap->dev, "Invalid 7-bit address "
1361 "0x%02x\n", addr_list[i]);
1362 continue;
1363 }
1364
1365 /* Check address availability */
David Brownell9b766b82008-01-27 18:14:51 +01001366 if (i2c_check_addr(adap, addr_list[i])) {
Jean Delvare12b5053a2007-05-01 23:26:31 +02001367 dev_dbg(&adap->dev, "Address 0x%02x already in "
1368 "use, not probing\n", addr_list[i]);
1369 continue;
1370 }
1371
1372 /* Test address responsiveness
1373 The default probe method is a quick write, but it is known
1374 to corrupt the 24RF08 EEPROMs due to a state machine bug,
1375 and could also irreversibly write-protect some EEPROMs, so
1376 for address ranges 0x30-0x37 and 0x50-0x5f, we use a byte
1377 read instead. Also, some bus drivers don't implement
1378 quick write, so we fallback to a byte read it that case
1379 too. */
1380 if ((addr_list[i] & ~0x07) == 0x30
1381 || (addr_list[i] & ~0x0f) == 0x50
1382 || !i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK)) {
Hans Verkuilb25b7912008-08-10 22:56:15 +02001383 union i2c_smbus_data data;
1384
Jean Delvare12b5053a2007-05-01 23:26:31 +02001385 if (i2c_smbus_xfer(adap, addr_list[i], 0,
1386 I2C_SMBUS_READ, 0,
Hans Verkuilb25b7912008-08-10 22:56:15 +02001387 I2C_SMBUS_BYTE, &data) >= 0)
Jean Delvare12b5053a2007-05-01 23:26:31 +02001388 break;
1389 } else {
1390 if (i2c_smbus_xfer(adap, addr_list[i], 0,
1391 I2C_SMBUS_WRITE, 0,
1392 I2C_SMBUS_QUICK, NULL) >= 0)
1393 break;
1394 }
1395 }
Jean Delvare12b5053a2007-05-01 23:26:31 +02001396
1397 if (addr_list[i] == I2C_CLIENT_END) {
1398 dev_dbg(&adap->dev, "Probing failed, no device found\n");
1399 return NULL;
1400 }
1401
1402 info->addr = addr_list[i];
1403 return i2c_new_device(adap, info);
1404}
1405EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1406
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407struct i2c_adapter* i2c_get_adapter(int id)
1408{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409 struct i2c_adapter *adapter;
David Brownell438d6c22006-12-10 21:21:31 +01001410
Jean Delvarecaada322008-01-27 18:14:49 +01001411 mutex_lock(&core_lock);
Jack Stone1cf92b42009-06-15 18:01:46 +02001412 adapter = idr_find(&i2c_adapter_idr, id);
Mark M. Hoffmana0920e12005-06-28 00:21:30 -04001413 if (adapter && !try_module_get(adapter->owner))
1414 adapter = NULL;
1415
Jean Delvarecaada322008-01-27 18:14:49 +01001416 mutex_unlock(&core_lock);
Mark M. Hoffmana0920e12005-06-28 00:21:30 -04001417 return adapter;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418}
David Brownellc0564602007-05-01 23:26:31 +02001419EXPORT_SYMBOL(i2c_get_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420
1421void i2c_put_adapter(struct i2c_adapter *adap)
1422{
1423 module_put(adap->owner);
1424}
David Brownellc0564602007-05-01 23:26:31 +02001425EXPORT_SYMBOL(i2c_put_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426
1427/* The SMBus parts */
1428
David Brownell438d6c22006-12-10 21:21:31 +01001429#define POLY (0x1070U << 3)
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01001430static u8 crc8(u16 data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431{
1432 int i;
David Brownell438d6c22006-12-10 21:21:31 +01001433
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434 for(i = 0; i < 8; i++) {
David Brownell438d6c22006-12-10 21:21:31 +01001435 if (data & 0x8000)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436 data = data ^ POLY;
1437 data = data << 1;
1438 }
1439 return (u8)(data >> 8);
1440}
1441
Jean Delvare421ef472005-10-26 21:28:55 +02001442/* Incremental CRC8 over count bytes in the array pointed to by p */
1443static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444{
1445 int i;
1446
1447 for(i = 0; i < count; i++)
Jean Delvare421ef472005-10-26 21:28:55 +02001448 crc = crc8((crc ^ p[i]) << 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449 return crc;
1450}
1451
Jean Delvare421ef472005-10-26 21:28:55 +02001452/* Assume a 7-bit address, which is reasonable for SMBus */
1453static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454{
Jean Delvare421ef472005-10-26 21:28:55 +02001455 /* The address will be sent first */
1456 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1457 pec = i2c_smbus_pec(pec, &addr, 1);
1458
1459 /* The data buffer follows */
1460 return i2c_smbus_pec(pec, msg->buf, msg->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461}
1462
Jean Delvare421ef472005-10-26 21:28:55 +02001463/* Used for write only transactions */
1464static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465{
Jean Delvare421ef472005-10-26 21:28:55 +02001466 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1467 msg->len++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468}
1469
Jean Delvare421ef472005-10-26 21:28:55 +02001470/* Return <0 on CRC error
1471 If there was a write before this read (most cases) we need to take the
1472 partial CRC from the write part into account.
1473 Note that this function does modify the message (we need to decrease the
1474 message length to hide the CRC byte from the caller). */
1475static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476{
Jean Delvare421ef472005-10-26 21:28:55 +02001477 u8 rpec = msg->buf[--msg->len];
1478 cpec = i2c_smbus_msg_pec(cpec, msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480 if (rpec != cpec) {
1481 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1482 rpec, cpec);
David Brownell24a5bb72008-07-14 22:38:23 +02001483 return -EBADMSG;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484 }
David Brownell438d6c22006-12-10 21:21:31 +01001485 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486}
1487
David Brownella1cdeda2008-07-14 22:38:24 +02001488/**
1489 * i2c_smbus_read_byte - SMBus "receive byte" protocol
1490 * @client: Handle to slave device
1491 *
1492 * This executes the SMBus "receive byte" protocol, returning negative errno
1493 * else the byte received from the device.
1494 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495s32 i2c_smbus_read_byte(struct i2c_client *client)
1496{
1497 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02001498 int status;
1499
1500 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1501 I2C_SMBUS_READ, 0,
1502 I2C_SMBUS_BYTE, &data);
1503 return (status < 0) ? status : data.byte;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504}
David Brownellc0564602007-05-01 23:26:31 +02001505EXPORT_SYMBOL(i2c_smbus_read_byte);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506
David Brownella1cdeda2008-07-14 22:38:24 +02001507/**
1508 * i2c_smbus_write_byte - SMBus "send byte" protocol
1509 * @client: Handle to slave device
1510 * @value: Byte to be sent
1511 *
1512 * This executes the SMBus "send byte" protocol, returning negative errno
1513 * else zero on success.
1514 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
1516{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
Jean Delvare421ef472005-10-26 21:28:55 +02001518 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519}
David Brownellc0564602007-05-01 23:26:31 +02001520EXPORT_SYMBOL(i2c_smbus_write_byte);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521
David Brownella1cdeda2008-07-14 22:38:24 +02001522/**
1523 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
1524 * @client: Handle to slave device
1525 * @command: Byte interpreted by slave
1526 *
1527 * This executes the SMBus "read byte" protocol, returning negative errno
1528 * else a data byte received from the device.
1529 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
1531{
1532 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02001533 int status;
1534
1535 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1536 I2C_SMBUS_READ, command,
1537 I2C_SMBUS_BYTE_DATA, &data);
1538 return (status < 0) ? status : data.byte;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539}
David Brownellc0564602007-05-01 23:26:31 +02001540EXPORT_SYMBOL(i2c_smbus_read_byte_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541
David Brownella1cdeda2008-07-14 22:38:24 +02001542/**
1543 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
1544 * @client: Handle to slave device
1545 * @command: Byte interpreted by slave
1546 * @value: Byte being written
1547 *
1548 * This executes the SMBus "write byte" protocol, returning negative errno
1549 * else zero on success.
1550 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
1552{
1553 union i2c_smbus_data data;
1554 data.byte = value;
1555 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1556 I2C_SMBUS_WRITE,command,
1557 I2C_SMBUS_BYTE_DATA,&data);
1558}
David Brownellc0564602007-05-01 23:26:31 +02001559EXPORT_SYMBOL(i2c_smbus_write_byte_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560
David Brownella1cdeda2008-07-14 22:38:24 +02001561/**
1562 * i2c_smbus_read_word_data - SMBus "read word" protocol
1563 * @client: Handle to slave device
1564 * @command: Byte interpreted by slave
1565 *
1566 * This executes the SMBus "read word" protocol, returning negative errno
1567 * else a 16-bit unsigned "word" received from the device.
1568 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
1570{
1571 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02001572 int status;
1573
1574 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1575 I2C_SMBUS_READ, command,
1576 I2C_SMBUS_WORD_DATA, &data);
1577 return (status < 0) ? status : data.word;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578}
David Brownellc0564602007-05-01 23:26:31 +02001579EXPORT_SYMBOL(i2c_smbus_read_word_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580
David Brownella1cdeda2008-07-14 22:38:24 +02001581/**
1582 * i2c_smbus_write_word_data - SMBus "write word" protocol
1583 * @client: Handle to slave device
1584 * @command: Byte interpreted by slave
1585 * @value: 16-bit "word" being written
1586 *
1587 * This executes the SMBus "write word" protocol, returning negative errno
1588 * else zero on success.
1589 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
1591{
1592 union i2c_smbus_data data;
1593 data.word = value;
1594 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1595 I2C_SMBUS_WRITE,command,
1596 I2C_SMBUS_WORD_DATA,&data);
1597}
David Brownellc0564602007-05-01 23:26:31 +02001598EXPORT_SYMBOL(i2c_smbus_write_word_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599
David Brownella64ec072007-10-13 23:56:31 +02001600/**
Prakash Mortha596c88f2008-10-14 17:30:06 +02001601 * i2c_smbus_process_call - SMBus "process call" protocol
1602 * @client: Handle to slave device
1603 * @command: Byte interpreted by slave
1604 * @value: 16-bit "word" being written
1605 *
1606 * This executes the SMBus "process call" protocol, returning negative errno
1607 * else a 16-bit unsigned "word" received from the device.
1608 */
1609s32 i2c_smbus_process_call(struct i2c_client *client, u8 command, u16 value)
1610{
1611 union i2c_smbus_data data;
1612 int status;
1613 data.word = value;
1614
1615 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1616 I2C_SMBUS_WRITE, command,
1617 I2C_SMBUS_PROC_CALL, &data);
1618 return (status < 0) ? status : data.word;
1619}
1620EXPORT_SYMBOL(i2c_smbus_process_call);
1621
1622/**
David Brownella1cdeda2008-07-14 22:38:24 +02001623 * i2c_smbus_read_block_data - SMBus "block read" protocol
David Brownella64ec072007-10-13 23:56:31 +02001624 * @client: Handle to slave device
David Brownella1cdeda2008-07-14 22:38:24 +02001625 * @command: Byte interpreted by slave
David Brownella64ec072007-10-13 23:56:31 +02001626 * @values: Byte array into which data will be read; big enough to hold
1627 * the data returned by the slave. SMBus allows at most 32 bytes.
1628 *
David Brownella1cdeda2008-07-14 22:38:24 +02001629 * This executes the SMBus "block read" protocol, returning negative errno
1630 * else the number of data bytes in the slave's response.
David Brownella64ec072007-10-13 23:56:31 +02001631 *
1632 * Note that using this function requires that the client's adapter support
1633 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
1634 * support this; its emulation through I2C messaging relies on a specific
1635 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
1636 */
Jean Delvareb86a1bc2007-05-01 23:26:34 +02001637s32 i2c_smbus_read_block_data(struct i2c_client *client, u8 command,
1638 u8 *values)
1639{
1640 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02001641 int status;
Jean Delvareb86a1bc2007-05-01 23:26:34 +02001642
David Brownell24a5bb72008-07-14 22:38:23 +02001643 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1644 I2C_SMBUS_READ, command,
1645 I2C_SMBUS_BLOCK_DATA, &data);
1646 if (status)
1647 return status;
Jean Delvareb86a1bc2007-05-01 23:26:34 +02001648
1649 memcpy(values, &data.block[1], data.block[0]);
1650 return data.block[0];
1651}
1652EXPORT_SYMBOL(i2c_smbus_read_block_data);
1653
David Brownella1cdeda2008-07-14 22:38:24 +02001654/**
1655 * i2c_smbus_write_block_data - SMBus "block write" protocol
1656 * @client: Handle to slave device
1657 * @command: Byte interpreted by slave
1658 * @length: Size of data block; SMBus allows at most 32 bytes
1659 * @values: Byte array which will be written.
1660 *
1661 * This executes the SMBus "block write" protocol, returning negative errno
1662 * else zero on success.
1663 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
Krzysztof Halasa46f5ed72006-06-12 21:42:20 +02001665 u8 length, const u8 *values)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666{
1667 union i2c_smbus_data data;
Jean Delvare76560322006-01-18 23:14:55 +01001668
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669 if (length > I2C_SMBUS_BLOCK_MAX)
1670 length = I2C_SMBUS_BLOCK_MAX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671 data.block[0] = length;
Jean Delvare76560322006-01-18 23:14:55 +01001672 memcpy(&data.block[1], values, length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1674 I2C_SMBUS_WRITE,command,
1675 I2C_SMBUS_BLOCK_DATA,&data);
1676}
David Brownellc0564602007-05-01 23:26:31 +02001677EXPORT_SYMBOL(i2c_smbus_write_block_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678
1679/* Returns the number of read bytes */
Jean Delvare4b2643d2007-07-12 14:12:29 +02001680s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command,
1681 u8 length, u8 *values)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682{
1683 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02001684 int status;
Jean Delvare76560322006-01-18 23:14:55 +01001685
Jean Delvare4b2643d2007-07-12 14:12:29 +02001686 if (length > I2C_SMBUS_BLOCK_MAX)
1687 length = I2C_SMBUS_BLOCK_MAX;
1688 data.block[0] = length;
David Brownell24a5bb72008-07-14 22:38:23 +02001689 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1690 I2C_SMBUS_READ, command,
1691 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1692 if (status < 0)
1693 return status;
Jean Delvare76560322006-01-18 23:14:55 +01001694
1695 memcpy(values, &data.block[1], data.block[0]);
1696 return data.block[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697}
David Brownellc0564602007-05-01 23:26:31 +02001698EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699
Jean Delvare21bbd692006-01-09 15:19:18 +11001700s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, u8 command,
Krzysztof Halasa46f5ed72006-06-12 21:42:20 +02001701 u8 length, const u8 *values)
Jean Delvare21bbd692006-01-09 15:19:18 +11001702{
1703 union i2c_smbus_data data;
1704
1705 if (length > I2C_SMBUS_BLOCK_MAX)
1706 length = I2C_SMBUS_BLOCK_MAX;
1707 data.block[0] = length;
1708 memcpy(data.block + 1, values, length);
1709 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1710 I2C_SMBUS_WRITE, command,
1711 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1712}
David Brownellc0564602007-05-01 23:26:31 +02001713EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
Jean Delvare21bbd692006-01-09 15:19:18 +11001714
David Brownell438d6c22006-12-10 21:21:31 +01001715/* Simulate a SMBus command using the i2c protocol
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716 No checking of parameters is done! */
David Brownell438d6c22006-12-10 21:21:31 +01001717static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718 unsigned short flags,
David Brownell438d6c22006-12-10 21:21:31 +01001719 char read_write, u8 command, int size,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720 union i2c_smbus_data * data)
1721{
1722 /* So we need to generate a series of msgs. In the case of writing, we
1723 need to use only one message; when reading, we need two. We initialize
1724 most things with sane defaults, to keep the code below somewhat
1725 simpler. */
Hideki Iwamoto5c50d182005-09-25 17:01:11 +02001726 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1727 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728 int num = read_write == I2C_SMBUS_READ?2:1;
David Brownell438d6c22006-12-10 21:21:31 +01001729 struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730 { addr, flags | I2C_M_RD, 0, msgbuf1 }
1731 };
1732 int i;
Jean Delvare421ef472005-10-26 21:28:55 +02001733 u8 partial_pec = 0;
David Brownell24a5bb72008-07-14 22:38:23 +02001734 int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001735
1736 msgbuf0[0] = command;
1737 switch(size) {
1738 case I2C_SMBUS_QUICK:
1739 msg[0].len = 0;
1740 /* Special case: The read/write field is used as data */
Roel Kluinf29d2e02009-02-24 19:19:48 +01001741 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
1742 I2C_M_RD : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743 num = 1;
1744 break;
1745 case I2C_SMBUS_BYTE:
1746 if (read_write == I2C_SMBUS_READ) {
1747 /* Special case: only a read! */
1748 msg[0].flags = I2C_M_RD | flags;
1749 num = 1;
1750 }
1751 break;
1752 case I2C_SMBUS_BYTE_DATA:
1753 if (read_write == I2C_SMBUS_READ)
1754 msg[1].len = 1;
1755 else {
1756 msg[0].len = 2;
1757 msgbuf0[1] = data->byte;
1758 }
1759 break;
1760 case I2C_SMBUS_WORD_DATA:
1761 if (read_write == I2C_SMBUS_READ)
1762 msg[1].len = 2;
1763 else {
1764 msg[0].len=3;
1765 msgbuf0[1] = data->word & 0xff;
Jean Delvare7eff82c2006-09-03 22:24:00 +02001766 msgbuf0[2] = data->word >> 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001767 }
1768 break;
1769 case I2C_SMBUS_PROC_CALL:
1770 num = 2; /* Special case */
1771 read_write = I2C_SMBUS_READ;
1772 msg[0].len = 3;
1773 msg[1].len = 2;
1774 msgbuf0[1] = data->word & 0xff;
Jean Delvare7eff82c2006-09-03 22:24:00 +02001775 msgbuf0[2] = data->word >> 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776 break;
1777 case I2C_SMBUS_BLOCK_DATA:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 if (read_write == I2C_SMBUS_READ) {
Jean Delvare209d27c2007-05-01 23:26:29 +02001779 msg[1].flags |= I2C_M_RECV_LEN;
1780 msg[1].len = 1; /* block length will be added by
1781 the underlying bus driver */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782 } else {
1783 msg[0].len = data->block[0] + 2;
1784 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
David Brownell24a5bb72008-07-14 22:38:23 +02001785 dev_err(&adapter->dev,
1786 "Invalid block write size %d\n",
1787 data->block[0]);
1788 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789 }
Hideki Iwamoto5c50d182005-09-25 17:01:11 +02001790 for (i = 1; i < msg[0].len; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791 msgbuf0[i] = data->block[i-1];
1792 }
1793 break;
1794 case I2C_SMBUS_BLOCK_PROC_CALL:
Jean Delvare209d27c2007-05-01 23:26:29 +02001795 num = 2; /* Another special case */
1796 read_write = I2C_SMBUS_READ;
1797 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
David Brownell24a5bb72008-07-14 22:38:23 +02001798 dev_err(&adapter->dev,
1799 "Invalid block write size %d\n",
Jean Delvare209d27c2007-05-01 23:26:29 +02001800 data->block[0]);
David Brownell24a5bb72008-07-14 22:38:23 +02001801 return -EINVAL;
Jean Delvare209d27c2007-05-01 23:26:29 +02001802 }
1803 msg[0].len = data->block[0] + 2;
1804 for (i = 1; i < msg[0].len; i++)
1805 msgbuf0[i] = data->block[i-1];
1806 msg[1].flags |= I2C_M_RECV_LEN;
1807 msg[1].len = 1; /* block length will be added by
1808 the underlying bus driver */
1809 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810 case I2C_SMBUS_I2C_BLOCK_DATA:
1811 if (read_write == I2C_SMBUS_READ) {
Jean Delvare4b2643d2007-07-12 14:12:29 +02001812 msg[1].len = data->block[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 } else {
1814 msg[0].len = data->block[0] + 1;
Jean Delvare30dac742005-10-08 00:15:59 +02001815 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
David Brownell24a5bb72008-07-14 22:38:23 +02001816 dev_err(&adapter->dev,
1817 "Invalid block write size %d\n",
1818 data->block[0]);
1819 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820 }
1821 for (i = 1; i <= data->block[0]; i++)
1822 msgbuf0[i] = data->block[i];
1823 }
1824 break;
1825 default:
David Brownell24a5bb72008-07-14 22:38:23 +02001826 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
1827 return -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828 }
1829
Jean Delvare421ef472005-10-26 21:28:55 +02001830 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
1831 && size != I2C_SMBUS_I2C_BLOCK_DATA);
1832 if (i) {
1833 /* Compute PEC if first message is a write */
1834 if (!(msg[0].flags & I2C_M_RD)) {
David Brownell438d6c22006-12-10 21:21:31 +01001835 if (num == 1) /* Write only */
Jean Delvare421ef472005-10-26 21:28:55 +02001836 i2c_smbus_add_pec(&msg[0]);
1837 else /* Write followed by read */
1838 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
1839 }
1840 /* Ask for PEC if last message is a read */
1841 if (msg[num-1].flags & I2C_M_RD)
David Brownell438d6c22006-12-10 21:21:31 +01001842 msg[num-1].len++;
Jean Delvare421ef472005-10-26 21:28:55 +02001843 }
1844
David Brownell24a5bb72008-07-14 22:38:23 +02001845 status = i2c_transfer(adapter, msg, num);
1846 if (status < 0)
1847 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001848
Jean Delvare421ef472005-10-26 21:28:55 +02001849 /* Check PEC if last message is a read */
1850 if (i && (msg[num-1].flags & I2C_M_RD)) {
David Brownell24a5bb72008-07-14 22:38:23 +02001851 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
1852 if (status < 0)
1853 return status;
Jean Delvare421ef472005-10-26 21:28:55 +02001854 }
1855
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856 if (read_write == I2C_SMBUS_READ)
1857 switch(size) {
1858 case I2C_SMBUS_BYTE:
1859 data->byte = msgbuf0[0];
1860 break;
1861 case I2C_SMBUS_BYTE_DATA:
1862 data->byte = msgbuf1[0];
1863 break;
David Brownell438d6c22006-12-10 21:21:31 +01001864 case I2C_SMBUS_WORD_DATA:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865 case I2C_SMBUS_PROC_CALL:
1866 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
1867 break;
1868 case I2C_SMBUS_I2C_BLOCK_DATA:
Jean Delvare4b2643d2007-07-12 14:12:29 +02001869 for (i = 0; i < data->block[0]; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 data->block[i+1] = msgbuf1[i];
1871 break;
Jean Delvare209d27c2007-05-01 23:26:29 +02001872 case I2C_SMBUS_BLOCK_DATA:
1873 case I2C_SMBUS_BLOCK_PROC_CALL:
1874 for (i = 0; i < msgbuf1[0] + 1; i++)
1875 data->block[i] = msgbuf1[i];
1876 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877 }
1878 return 0;
1879}
1880
David Brownella1cdeda2008-07-14 22:38:24 +02001881/**
1882 * i2c_smbus_xfer - execute SMBus protocol operations
1883 * @adapter: Handle to I2C bus
1884 * @addr: Address of SMBus slave on that bus
1885 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
1886 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
1887 * @command: Byte interpreted by slave, for protocols which use such bytes
1888 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
1889 * @data: Data to be read or written
1890 *
1891 * This executes an SMBus protocol operation, and returns a negative
1892 * errno code else zero on success.
1893 */
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01001894s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
David Brownella1cdeda2008-07-14 22:38:24 +02001895 char read_write, u8 command, int protocol,
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01001896 union i2c_smbus_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897{
Clifford Wolf66b650f2009-06-15 18:01:46 +02001898 unsigned long orig_jiffies;
1899 int try;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900 s32 res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001901
1902 flags &= I2C_M_TEN | I2C_CLIENT_PEC;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903
1904 if (adapter->algo->smbus_xfer) {
Ingo Molnar5c085d32006-01-18 23:16:04 +01001905 mutex_lock(&adapter->bus_lock);
Clifford Wolf66b650f2009-06-15 18:01:46 +02001906
1907 /* Retry automatically on arbitration loss */
1908 orig_jiffies = jiffies;
1909 for (res = 0, try = 0; try <= adapter->retries; try++) {
1910 res = adapter->algo->smbus_xfer(adapter, addr, flags,
1911 read_write, command,
1912 protocol, data);
1913 if (res != -EAGAIN)
1914 break;
1915 if (time_after(jiffies,
1916 orig_jiffies + adapter->timeout))
1917 break;
1918 }
Ingo Molnar5c085d32006-01-18 23:16:04 +01001919 mutex_unlock(&adapter->bus_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920 } else
1921 res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
David Brownella1cdeda2008-07-14 22:38:24 +02001922 command, protocol, data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923
Linus Torvalds1da177e2005-04-16 15:20:36 -07001924 return res;
1925}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926EXPORT_SYMBOL(i2c_smbus_xfer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001927
1928MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
1929MODULE_DESCRIPTION("I2C-Bus main module");
1930MODULE_LICENSE("GPL");