blob: 7c469a62c3c145b547d7c8948252b7ca9a51bde2 [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 Rapoportcea443a82008-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>
Mark Brown6de468a2010-03-02 12:23:46 +010037#include <linux/pm_runtime.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include <asm/uaccess.h>
39
David Brownell9c1600e2007-05-01 23:26:31 +020040#include "i2c-core.h"
41
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
Jean Delvare6629dcf2010-05-04 11:09:28 +020043/* core_lock protects i2c_adapter_idr, and guarantees
Jean Delvare35fc37f2009-06-19 16:58:19 +020044 that device detection, deletion of detected devices, and attach_adapter
45 and detach_adapter calls are serialized */
Jean Delvarecaada322008-01-27 18:14:49 +010046static DEFINE_MUTEX(core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070047static DEFINE_IDR(i2c_adapter_idr);
48
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));
Wolfram Sange4a7b9b2010-05-04 11:09:27 +0200119 if (status) {
Hans Verkuil50c33042008-03-12 14:15:00 +0100120 client->driver = NULL;
Wolfram Sange4a7b9b2010-05-04 11:09:27 +0200121 i2c_set_clientdata(client, NULL);
122 }
Hans Verkuil50c33042008-03-12 14:15:00 +0100123 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124}
125
126static int i2c_device_remove(struct device *dev)
127{
Jean Delvare51298d12009-09-18 22:45:45 +0200128 struct i2c_client *client = i2c_verify_client(dev);
David Brownella1d9e6e2007-05-01 23:26:30 +0200129 struct i2c_driver *driver;
130 int status;
131
Jean Delvare51298d12009-09-18 22:45:45 +0200132 if (!client || !dev->driver)
David Brownella1d9e6e2007-05-01 23:26:30 +0200133 return 0;
134
135 driver = to_i2c_driver(dev->driver);
136 if (driver->remove) {
137 dev_dbg(dev, "remove\n");
138 status = driver->remove(client);
139 } else {
140 dev->driver = NULL;
141 status = 0;
142 }
Wolfram Sange4a7b9b2010-05-04 11:09:27 +0200143 if (status == 0) {
David Brownella1d9e6e2007-05-01 23:26:30 +0200144 client->driver = NULL;
Wolfram Sange4a7b9b2010-05-04 11:09:27 +0200145 i2c_set_clientdata(client, NULL);
146 }
David Brownella1d9e6e2007-05-01 23:26:30 +0200147 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148}
149
David Brownellf37dd802007-02-13 22:09:00 +0100150static void i2c_device_shutdown(struct device *dev)
151{
Jean Delvare51298d12009-09-18 22:45:45 +0200152 struct i2c_client *client = i2c_verify_client(dev);
David Brownellf37dd802007-02-13 22:09:00 +0100153 struct i2c_driver *driver;
154
Jean Delvare51298d12009-09-18 22:45:45 +0200155 if (!client || !dev->driver)
David Brownellf37dd802007-02-13 22:09:00 +0100156 return;
157 driver = to_i2c_driver(dev->driver);
158 if (driver->shutdown)
Jean Delvare51298d12009-09-18 22:45:45 +0200159 driver->shutdown(client);
David Brownellf37dd802007-02-13 22:09:00 +0100160}
161
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200162#ifdef CONFIG_PM_SLEEP
163static int i2c_legacy_suspend(struct device *dev, pm_message_t mesg)
David Brownellf37dd802007-02-13 22:09:00 +0100164{
Jean Delvare51298d12009-09-18 22:45:45 +0200165 struct i2c_client *client = i2c_verify_client(dev);
David Brownellf37dd802007-02-13 22:09:00 +0100166 struct i2c_driver *driver;
167
Jean Delvare51298d12009-09-18 22:45:45 +0200168 if (!client || !dev->driver)
David Brownellf37dd802007-02-13 22:09:00 +0100169 return 0;
170 driver = to_i2c_driver(dev->driver);
171 if (!driver->suspend)
172 return 0;
Jean Delvare51298d12009-09-18 22:45:45 +0200173 return driver->suspend(client, mesg);
David Brownellf37dd802007-02-13 22:09:00 +0100174}
175
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200176static int i2c_legacy_resume(struct device *dev)
David Brownellf37dd802007-02-13 22:09:00 +0100177{
Jean Delvare51298d12009-09-18 22:45:45 +0200178 struct i2c_client *client = i2c_verify_client(dev);
David Brownellf37dd802007-02-13 22:09:00 +0100179 struct i2c_driver *driver;
180
Jean Delvare51298d12009-09-18 22:45:45 +0200181 if (!client || !dev->driver)
David Brownellf37dd802007-02-13 22:09:00 +0100182 return 0;
183 driver = to_i2c_driver(dev->driver);
184 if (!driver->resume)
185 return 0;
Jean Delvare51298d12009-09-18 22:45:45 +0200186 return driver->resume(client);
David Brownellf37dd802007-02-13 22:09:00 +0100187}
188
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200189static int i2c_device_pm_suspend(struct device *dev)
190{
191 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
192
193 if (pm_runtime_suspended(dev))
194 return 0;
195
196 if (pm)
197 return pm->suspend ? pm->suspend(dev) : 0;
198
199 return i2c_legacy_suspend(dev, PMSG_SUSPEND);
200}
201
202static int i2c_device_pm_resume(struct device *dev)
203{
204 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
205 int ret;
206
207 if (pm)
208 ret = pm->resume ? pm->resume(dev) : 0;
209 else
210 ret = i2c_legacy_resume(dev);
211
212 if (!ret) {
213 pm_runtime_disable(dev);
214 pm_runtime_set_active(dev);
215 pm_runtime_enable(dev);
216 }
217
218 return ret;
219}
220
221static int i2c_device_pm_freeze(struct device *dev)
222{
223 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
224
225 if (pm_runtime_suspended(dev))
226 return 0;
227
228 if (pm)
229 return pm->freeze ? pm->freeze(dev) : 0;
230
231 return i2c_legacy_suspend(dev, PMSG_FREEZE);
232}
233
234static int i2c_device_pm_thaw(struct device *dev)
235{
236 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
237
238 if (pm_runtime_suspended(dev))
239 return 0;
240
241 if (pm)
242 return pm->thaw ? pm->thaw(dev) : 0;
243
244 return i2c_legacy_resume(dev);
245}
246
247static int i2c_device_pm_poweroff(struct device *dev)
248{
249 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
250
251 if (pm_runtime_suspended(dev))
252 return 0;
253
254 if (pm)
255 return pm->poweroff ? pm->poweroff(dev) : 0;
256
257 return i2c_legacy_suspend(dev, PMSG_HIBERNATE);
258}
259
260static int i2c_device_pm_restore(struct device *dev)
261{
262 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
263 int ret;
264
265 if (pm)
266 ret = pm->restore ? pm->restore(dev) : 0;
267 else
268 ret = i2c_legacy_resume(dev);
269
270 if (!ret) {
271 pm_runtime_disable(dev);
272 pm_runtime_set_active(dev);
273 pm_runtime_enable(dev);
274 }
275
276 return ret;
277}
278#else /* !CONFIG_PM_SLEEP */
279#define i2c_device_pm_suspend NULL
280#define i2c_device_pm_resume NULL
281#define i2c_device_pm_freeze NULL
282#define i2c_device_pm_thaw NULL
283#define i2c_device_pm_poweroff NULL
284#define i2c_device_pm_restore NULL
285#endif /* !CONFIG_PM_SLEEP */
286
David Brownell9c1600e2007-05-01 23:26:31 +0200287static void i2c_client_dev_release(struct device *dev)
288{
289 kfree(to_i2c_client(dev));
290}
291
Zhenwen Xu09b8ce02009-03-28 21:34:46 +0100292static ssize_t
Jean Delvare4f8cf822009-09-18 22:45:46 +0200293show_name(struct device *dev, struct device_attribute *attr, char *buf)
David Brownell7b4fbc52007-05-01 23:26:30 +0200294{
Jean Delvare4f8cf822009-09-18 22:45:46 +0200295 return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
296 to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
David Brownell7b4fbc52007-05-01 23:26:30 +0200297}
298
Zhenwen Xu09b8ce02009-03-28 21:34:46 +0100299static ssize_t
300show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
David Brownell7b4fbc52007-05-01 23:26:30 +0200301{
302 struct i2c_client *client = to_i2c_client(dev);
Jean Delvareeb8a7902008-05-18 20:49:41 +0200303 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
David Brownell7b4fbc52007-05-01 23:26:30 +0200304}
305
Jean Delvare4f8cf822009-09-18 22:45:46 +0200306static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
Jean Delvare51298d12009-09-18 22:45:45 +0200307static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
308
309static struct attribute *i2c_dev_attrs[] = {
310 &dev_attr_name.attr,
David Brownell7b4fbc52007-05-01 23:26:30 +0200311 /* modalias helps coldplug: modprobe $(cat .../modalias) */
Jean Delvare51298d12009-09-18 22:45:45 +0200312 &dev_attr_modalias.attr,
313 NULL
314};
315
316static struct attribute_group i2c_dev_attr_group = {
317 .attrs = i2c_dev_attrs,
318};
319
320static const struct attribute_group *i2c_dev_attr_groups[] = {
321 &i2c_dev_attr_group,
322 NULL
David Brownell7b4fbc52007-05-01 23:26:30 +0200323};
324
Tobias Klauser0b2c3682010-01-16 20:43:12 +0100325static const struct dev_pm_ops i2c_device_pm_ops = {
sonic zhang54067ee2009-12-14 21:17:30 +0100326 .suspend = i2c_device_pm_suspend,
327 .resume = i2c_device_pm_resume,
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200328 .freeze = i2c_device_pm_freeze,
329 .thaw = i2c_device_pm_thaw,
330 .poweroff = i2c_device_pm_poweroff,
331 .restore = i2c_device_pm_restore,
332 SET_RUNTIME_PM_OPS(
333 pm_generic_runtime_suspend,
334 pm_generic_runtime_resume,
335 pm_generic_runtime_idle
336 )
sonic zhang54067ee2009-12-14 21:17:30 +0100337};
338
Jon Smirle9ca9eb2008-07-14 22:38:35 +0200339struct bus_type i2c_bus_type = {
David Brownellf37dd802007-02-13 22:09:00 +0100340 .name = "i2c",
341 .match = i2c_device_match,
342 .probe = i2c_device_probe,
343 .remove = i2c_device_remove,
344 .shutdown = i2c_device_shutdown,
sonic zhang54067ee2009-12-14 21:17:30 +0100345 .pm = &i2c_device_pm_ops,
Russell Kingb864c7d2006-01-05 14:37:50 +0000346};
Jon Smirle9ca9eb2008-07-14 22:38:35 +0200347EXPORT_SYMBOL_GPL(i2c_bus_type);
Russell Kingb864c7d2006-01-05 14:37:50 +0000348
Jean Delvare51298d12009-09-18 22:45:45 +0200349static struct device_type i2c_client_type = {
350 .groups = i2c_dev_attr_groups,
351 .uevent = i2c_device_uevent,
352 .release = i2c_client_dev_release,
353};
354
David Brownell9b766b82008-01-27 18:14:51 +0100355
356/**
357 * i2c_verify_client - return parameter as i2c_client, or NULL
358 * @dev: device, probably from some driver model iterator
359 *
360 * When traversing the driver model tree, perhaps using driver model
361 * iterators like @device_for_each_child(), you can't assume very much
362 * about the nodes you find. Use this function to avoid oopses caused
363 * by wrongly treating some non-I2C device as an i2c_client.
364 */
365struct i2c_client *i2c_verify_client(struct device *dev)
366{
Jean Delvare51298d12009-09-18 22:45:45 +0200367 return (dev->type == &i2c_client_type)
David Brownell9b766b82008-01-27 18:14:51 +0100368 ? to_i2c_client(dev)
369 : NULL;
370}
371EXPORT_SYMBOL(i2c_verify_client);
372
373
David Brownell9c1600e2007-05-01 23:26:31 +0200374/**
Jean Delvaref8a227e2009-06-19 16:58:18 +0200375 * i2c_new_device - instantiate an i2c device
David Brownell9c1600e2007-05-01 23:26:31 +0200376 * @adap: the adapter managing the device
377 * @info: describes one I2C device; bus_num is ignored
David Brownelld64f73b2007-07-12 14:12:28 +0200378 * Context: can sleep
David Brownell9c1600e2007-05-01 23:26:31 +0200379 *
Jean Delvaref8a227e2009-06-19 16:58:18 +0200380 * Create an i2c device. Binding is handled through driver model
381 * probe()/remove() methods. A driver may be bound to this device when we
382 * return from this function, or any later moment (e.g. maybe hotplugging will
383 * load the driver module). This call is not appropriate for use by mainboard
384 * initialization logic, which usually runs during an arch_initcall() long
385 * before any i2c_adapter could exist.
David Brownell9c1600e2007-05-01 23:26:31 +0200386 *
387 * This returns the new i2c client, which may be saved for later use with
388 * i2c_unregister_device(); or NULL to indicate an error.
389 */
390struct i2c_client *
391i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
392{
393 struct i2c_client *client;
394 int status;
395
396 client = kzalloc(sizeof *client, GFP_KERNEL);
397 if (!client)
398 return NULL;
399
400 client->adapter = adap;
401
402 client->dev.platform_data = info->platform_data;
David Brownell3bbb8352007-10-13 23:56:29 +0200403
Anton Vorontsov11f1f2a2008-10-22 20:21:33 +0200404 if (info->archdata)
405 client->dev.archdata = *info->archdata;
406
Marc Pignatee354252008-08-28 08:33:22 +0200407 client->flags = info->flags;
David Brownell9c1600e2007-05-01 23:26:31 +0200408 client->addr = info->addr;
409 client->irq = info->irq;
410
David Brownell9c1600e2007-05-01 23:26:31 +0200411 strlcpy(client->name, info->type, sizeof(client->name));
412
Jean Delvaref8a227e2009-06-19 16:58:18 +0200413 /* Check for address business */
414 status = i2c_check_addr(adap, client->addr);
415 if (status)
416 goto out_err;
417
418 client->dev.parent = &client->adapter->dev;
419 client->dev.bus = &i2c_bus_type;
Jean Delvare51298d12009-09-18 22:45:45 +0200420 client->dev.type = &i2c_client_type;
Jean Delvaref8a227e2009-06-19 16:58:18 +0200421
422 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
423 client->addr);
424 status = device_register(&client->dev);
425 if (status)
426 goto out_err;
427
Jean Delvaref8a227e2009-06-19 16:58:18 +0200428 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
429 client->name, dev_name(&client->dev));
430
David Brownell9c1600e2007-05-01 23:26:31 +0200431 return client;
Jean Delvaref8a227e2009-06-19 16:58:18 +0200432
433out_err:
434 dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
435 "(%d)\n", client->name, client->addr, status);
436 kfree(client);
437 return NULL;
David Brownell9c1600e2007-05-01 23:26:31 +0200438}
439EXPORT_SYMBOL_GPL(i2c_new_device);
440
441
442/**
443 * i2c_unregister_device - reverse effect of i2c_new_device()
444 * @client: value returned from i2c_new_device()
David Brownelld64f73b2007-07-12 14:12:28 +0200445 * Context: can sleep
David Brownell9c1600e2007-05-01 23:26:31 +0200446 */
447void i2c_unregister_device(struct i2c_client *client)
David Brownella1d9e6e2007-05-01 23:26:30 +0200448{
David Brownella1d9e6e2007-05-01 23:26:30 +0200449 device_unregister(&client->dev);
450}
David Brownell9c1600e2007-05-01 23:26:31 +0200451EXPORT_SYMBOL_GPL(i2c_unregister_device);
David Brownella1d9e6e2007-05-01 23:26:30 +0200452
453
Jean Delvare60b129d2008-05-11 20:37:06 +0200454static const struct i2c_device_id dummy_id[] = {
455 { "dummy", 0 },
456 { },
457};
458
Jean Delvared2653e92008-04-29 23:11:39 +0200459static int dummy_probe(struct i2c_client *client,
460 const struct i2c_device_id *id)
461{
462 return 0;
463}
464
465static int dummy_remove(struct i2c_client *client)
David Brownelle9f13732008-01-27 18:14:52 +0100466{
467 return 0;
468}
469
470static struct i2c_driver dummy_driver = {
471 .driver.name = "dummy",
Jean Delvared2653e92008-04-29 23:11:39 +0200472 .probe = dummy_probe,
473 .remove = dummy_remove,
Jean Delvare60b129d2008-05-11 20:37:06 +0200474 .id_table = dummy_id,
David Brownelle9f13732008-01-27 18:14:52 +0100475};
476
477/**
478 * i2c_new_dummy - return a new i2c device bound to a dummy driver
479 * @adapter: the adapter managing the device
480 * @address: seven bit address to be used
David Brownelle9f13732008-01-27 18:14:52 +0100481 * Context: can sleep
482 *
483 * This returns an I2C client bound to the "dummy" driver, intended for use
484 * with devices that consume multiple addresses. Examples of such chips
485 * include various EEPROMS (like 24c04 and 24c08 models).
486 *
487 * These dummy devices have two main uses. First, most I2C and SMBus calls
488 * except i2c_transfer() need a client handle; the dummy will be that handle.
489 * And second, this prevents the specified address from being bound to a
490 * different driver.
491 *
492 * This returns the new i2c client, which should be saved for later use with
493 * i2c_unregister_device(); or NULL to indicate an error.
494 */
Zhenwen Xu09b8ce02009-03-28 21:34:46 +0100495struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
David Brownelle9f13732008-01-27 18:14:52 +0100496{
497 struct i2c_board_info info = {
Jean Delvare60b129d2008-05-11 20:37:06 +0200498 I2C_BOARD_INFO("dummy", address),
David Brownelle9f13732008-01-27 18:14:52 +0100499 };
500
David Brownelle9f13732008-01-27 18:14:52 +0100501 return i2c_new_device(adapter, &info);
502}
503EXPORT_SYMBOL_GPL(i2c_new_dummy);
504
David Brownellf37dd802007-02-13 22:09:00 +0100505/* ------------------------------------------------------------------------- */
506
David Brownell16ffadf2007-05-01 23:26:28 +0200507/* I2C bus adapters -- one roots each I2C or SMBUS segment */
508
Adrian Bunk83eaaed2007-10-13 23:56:30 +0200509static void i2c_adapter_dev_release(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510{
David Brownellef2c83212007-05-01 23:26:28 +0200511 struct i2c_adapter *adap = to_i2c_adapter(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 complete(&adap->dev_released);
513}
514
Jean Delvare99cd8e22009-06-19 16:58:20 +0200515/*
516 * Let users instantiate I2C devices through sysfs. This can be used when
517 * platform initialization code doesn't contain the proper data for
518 * whatever reason. Also useful for drivers that do device detection and
519 * detection fails, either because the device uses an unexpected address,
520 * or this is a compatible device with different ID register values.
521 *
522 * Parameter checking may look overzealous, but we really don't want
523 * the user to provide incorrect parameters.
524 */
525static ssize_t
526i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
527 const char *buf, size_t count)
528{
529 struct i2c_adapter *adap = to_i2c_adapter(dev);
530 struct i2c_board_info info;
531 struct i2c_client *client;
532 char *blank, end;
533 int res;
534
535 dev_warn(dev, "The new_device interface is still experimental "
536 "and may change in a near future\n");
537 memset(&info, 0, sizeof(struct i2c_board_info));
538
539 blank = strchr(buf, ' ');
540 if (!blank) {
541 dev_err(dev, "%s: Missing parameters\n", "new_device");
542 return -EINVAL;
543 }
544 if (blank - buf > I2C_NAME_SIZE - 1) {
545 dev_err(dev, "%s: Invalid device name\n", "new_device");
546 return -EINVAL;
547 }
548 memcpy(info.type, buf, blank - buf);
549
550 /* Parse remaining parameters, reject extra parameters */
551 res = sscanf(++blank, "%hi%c", &info.addr, &end);
552 if (res < 1) {
553 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
554 return -EINVAL;
555 }
556 if (res > 1 && end != '\n') {
557 dev_err(dev, "%s: Extra parameters\n", "new_device");
558 return -EINVAL;
559 }
560
561 if (info.addr < 0x03 || info.addr > 0x77) {
562 dev_err(dev, "%s: Invalid I2C address 0x%hx\n", "new_device",
563 info.addr);
564 return -EINVAL;
565 }
566
567 client = i2c_new_device(adap, &info);
568 if (!client)
569 return -EEXIST;
570
571 /* Keep track of the added device */
Jean Delvare6629dcf2010-05-04 11:09:28 +0200572 i2c_lock_adapter(adap);
573 list_add_tail(&client->detected, &adap->userspace_clients);
574 i2c_unlock_adapter(adap);
Jean Delvare99cd8e22009-06-19 16:58:20 +0200575 dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
576 info.type, info.addr);
577
578 return count;
579}
580
581/*
582 * And of course let the users delete the devices they instantiated, if
583 * they got it wrong. This interface can only be used to delete devices
584 * instantiated by i2c_sysfs_new_device above. This guarantees that we
585 * don't delete devices to which some kernel code still has references.
586 *
587 * Parameter checking may look overzealous, but we really don't want
588 * the user to delete the wrong device.
589 */
590static ssize_t
591i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
592 const char *buf, size_t count)
593{
594 struct i2c_adapter *adap = to_i2c_adapter(dev);
595 struct i2c_client *client, *next;
596 unsigned short addr;
597 char end;
598 int res;
599
600 /* Parse parameters, reject extra parameters */
601 res = sscanf(buf, "%hi%c", &addr, &end);
602 if (res < 1) {
603 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
604 return -EINVAL;
605 }
606 if (res > 1 && end != '\n') {
607 dev_err(dev, "%s: Extra parameters\n", "delete_device");
608 return -EINVAL;
609 }
610
611 /* Make sure the device was added through sysfs */
612 res = -ENOENT;
Jean Delvare6629dcf2010-05-04 11:09:28 +0200613 i2c_lock_adapter(adap);
614 list_for_each_entry_safe(client, next, &adap->userspace_clients,
615 detected) {
616 if (client->addr == addr) {
Jean Delvare99cd8e22009-06-19 16:58:20 +0200617 dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
618 "delete_device", client->name, client->addr);
619
620 list_del(&client->detected);
621 i2c_unregister_device(client);
622 res = count;
623 break;
624 }
625 }
Jean Delvare6629dcf2010-05-04 11:09:28 +0200626 i2c_unlock_adapter(adap);
Jean Delvare99cd8e22009-06-19 16:58:20 +0200627
628 if (res < 0)
629 dev_err(dev, "%s: Can't find device in list\n",
630 "delete_device");
631 return res;
632}
633
Jean Delvare4f8cf822009-09-18 22:45:46 +0200634static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
635static DEVICE_ATTR(delete_device, S_IWUSR, NULL, i2c_sysfs_delete_device);
636
637static struct attribute *i2c_adapter_attrs[] = {
638 &dev_attr_name.attr,
639 &dev_attr_new_device.attr,
640 &dev_attr_delete_device.attr,
641 NULL
David Brownell16ffadf2007-05-01 23:26:28 +0200642};
643
Jean Delvare4f8cf822009-09-18 22:45:46 +0200644static struct attribute_group i2c_adapter_attr_group = {
645 .attrs = i2c_adapter_attrs,
646};
647
648static const struct attribute_group *i2c_adapter_attr_groups[] = {
649 &i2c_adapter_attr_group,
650 NULL
651};
652
653static struct device_type i2c_adapter_type = {
654 .groups = i2c_adapter_attr_groups,
655 .release = i2c_adapter_dev_release,
David Brownell16ffadf2007-05-01 23:26:28 +0200656};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657
Jean Delvare2bb50952009-09-18 22:45:46 +0200658#ifdef CONFIG_I2C_COMPAT
659static struct class_compat *i2c_adapter_compat_class;
660#endif
661
David Brownell9c1600e2007-05-01 23:26:31 +0200662static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
663{
664 struct i2c_devinfo *devinfo;
665
Rodolfo Giomettif18c41d2009-06-19 16:58:20 +0200666 down_read(&__i2c_board_lock);
David Brownell9c1600e2007-05-01 23:26:31 +0200667 list_for_each_entry(devinfo, &__i2c_board_list, list) {
668 if (devinfo->busnum == adapter->nr
669 && !i2c_new_device(adapter,
670 &devinfo->board_info))
Zhenwen Xu09b8ce02009-03-28 21:34:46 +0100671 dev_err(&adapter->dev,
672 "Can't create device at 0x%02x\n",
David Brownell9c1600e2007-05-01 23:26:31 +0200673 devinfo->board_info.addr);
674 }
Rodolfo Giomettif18c41d2009-06-19 16:58:20 +0200675 up_read(&__i2c_board_lock);
David Brownell9c1600e2007-05-01 23:26:31 +0200676}
677
Jean Delvare69b00892009-12-06 17:06:27 +0100678static int i2c_do_add_adapter(struct i2c_driver *driver,
679 struct i2c_adapter *adap)
Jean Delvare026526f2008-01-27 18:14:49 +0100680{
Jean Delvare4735c982008-07-14 22:38:36 +0200681 /* Detect supported devices on that bus, and instantiate them */
682 i2c_detect(adap, driver);
683
684 /* Let legacy drivers scan this bus for matching devices */
Jean Delvare026526f2008-01-27 18:14:49 +0100685 if (driver->attach_adapter) {
686 /* We ignore the return code; if it fails, too bad */
687 driver->attach_adapter(adap);
688 }
689 return 0;
690}
691
Jean Delvare69b00892009-12-06 17:06:27 +0100692static int __process_new_adapter(struct device_driver *d, void *data)
693{
694 return i2c_do_add_adapter(to_i2c_driver(d), data);
695}
696
David Brownell6e13e642007-05-01 23:26:31 +0200697static int i2c_register_adapter(struct i2c_adapter *adap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698{
Jean Delvare026526f2008-01-27 18:14:49 +0100699 int res = 0, dummy;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700
David Brownell1d0b19c2008-10-14 17:30:05 +0200701 /* Can't register until after driver model init */
Jean Delvare35fc37f2009-06-19 16:58:19 +0200702 if (unlikely(WARN_ON(!i2c_bus_type.p))) {
703 res = -EAGAIN;
704 goto out_list;
705 }
David Brownell1d0b19c2008-10-14 17:30:05 +0200706
Mika Kuoppala194684e2009-12-06 17:06:22 +0100707 rt_mutex_init(&adap->bus_lock);
Jean Delvare6629dcf2010-05-04 11:09:28 +0200708 INIT_LIST_HEAD(&adap->userspace_clients);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709
Jean Delvare8fcfef62009-03-28 21:34:43 +0100710 /* Set default timeout to 1 second if not already set */
711 if (adap->timeout == 0)
712 adap->timeout = HZ;
713
Kay Sievers27d9c182009-01-07 14:29:16 +0100714 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
Jean Delvare4f8cf822009-09-18 22:45:46 +0200715 adap->dev.bus = &i2c_bus_type;
716 adap->dev.type = &i2c_adapter_type;
Jean Delvareb119c6c2006-08-15 18:26:30 +0200717 res = device_register(&adap->dev);
718 if (res)
719 goto out_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720
Jean Delvareb6d7b3d2005-07-31 19:02:53 +0200721 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
722
Jean Delvare2bb50952009-09-18 22:45:46 +0200723#ifdef CONFIG_I2C_COMPAT
724 res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
725 adap->dev.parent);
726 if (res)
727 dev_warn(&adap->dev,
728 "Failed to create compatibility class link\n");
729#endif
730
Jean Delvare729d6dd2009-06-19 16:58:18 +0200731 /* create pre-declared device nodes */
David Brownell6e13e642007-05-01 23:26:31 +0200732 if (adap->nr < __i2c_first_dynamic_bus_num)
733 i2c_scan_static_board_info(adap);
734
Jean Delvare4735c982008-07-14 22:38:36 +0200735 /* Notify drivers */
Jean Delvare35fc37f2009-06-19 16:58:19 +0200736 mutex_lock(&core_lock);
Jean Delvare026526f2008-01-27 18:14:49 +0100737 dummy = bus_for_each_drv(&i2c_bus_type, NULL, adap,
Jean Delvare69b00892009-12-06 17:06:27 +0100738 __process_new_adapter);
Jean Delvarecaada322008-01-27 18:14:49 +0100739 mutex_unlock(&core_lock);
Jean Delvare35fc37f2009-06-19 16:58:19 +0200740
741 return 0;
Jean Delvareb119c6c2006-08-15 18:26:30 +0200742
Jean Delvareb119c6c2006-08-15 18:26:30 +0200743out_list:
Jean Delvare35fc37f2009-06-19 16:58:19 +0200744 mutex_lock(&core_lock);
Jean Delvareb119c6c2006-08-15 18:26:30 +0200745 idr_remove(&i2c_adapter_idr, adap->nr);
Jean Delvare35fc37f2009-06-19 16:58:19 +0200746 mutex_unlock(&core_lock);
747 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748}
749
David Brownell6e13e642007-05-01 23:26:31 +0200750/**
751 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
752 * @adapter: the adapter to add
David Brownelld64f73b2007-07-12 14:12:28 +0200753 * Context: can sleep
David Brownell6e13e642007-05-01 23:26:31 +0200754 *
755 * This routine is used to declare an I2C adapter when its bus number
756 * doesn't matter. Examples: for I2C adapters dynamically added by
757 * USB links or PCI plugin cards.
758 *
759 * When this returns zero, a new bus number was allocated and stored
760 * in adap->nr, and the specified adapter became available for clients.
761 * Otherwise, a negative errno value is returned.
762 */
763int i2c_add_adapter(struct i2c_adapter *adapter)
764{
765 int id, res = 0;
766
767retry:
768 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
769 return -ENOMEM;
770
Jean Delvarecaada322008-01-27 18:14:49 +0100771 mutex_lock(&core_lock);
David Brownell6e13e642007-05-01 23:26:31 +0200772 /* "above" here means "above or equal to", sigh */
773 res = idr_get_new_above(&i2c_adapter_idr, adapter,
774 __i2c_first_dynamic_bus_num, &id);
Jean Delvarecaada322008-01-27 18:14:49 +0100775 mutex_unlock(&core_lock);
David Brownell6e13e642007-05-01 23:26:31 +0200776
777 if (res < 0) {
778 if (res == -EAGAIN)
779 goto retry;
780 return res;
781 }
782
783 adapter->nr = id;
784 return i2c_register_adapter(adapter);
785}
786EXPORT_SYMBOL(i2c_add_adapter);
787
788/**
789 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
790 * @adap: the adapter to register (with adap->nr initialized)
David Brownelld64f73b2007-07-12 14:12:28 +0200791 * Context: can sleep
David Brownell6e13e642007-05-01 23:26:31 +0200792 *
793 * This routine is used to declare an I2C adapter when its bus number
Randy Dunlap8c07e462008-03-23 20:28:20 +0100794 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
795 * or otherwise built in to the system's mainboard, and where i2c_board_info
David Brownell6e13e642007-05-01 23:26:31 +0200796 * is used to properly configure I2C devices.
797 *
798 * If no devices have pre-been declared for this bus, then be sure to
799 * register the adapter before any dynamically allocated ones. Otherwise
800 * the required bus ID may not be available.
801 *
802 * When this returns zero, the specified adapter became available for
803 * clients using the bus number provided in adap->nr. Also, the table
804 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
805 * and the appropriate driver model device nodes are created. Otherwise, a
806 * negative errno value is returned.
807 */
808int i2c_add_numbered_adapter(struct i2c_adapter *adap)
809{
810 int id;
811 int status;
812
813 if (adap->nr & ~MAX_ID_MASK)
814 return -EINVAL;
815
816retry:
817 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
818 return -ENOMEM;
819
Jean Delvarecaada322008-01-27 18:14:49 +0100820 mutex_lock(&core_lock);
David Brownell6e13e642007-05-01 23:26:31 +0200821 /* "above" here means "above or equal to", sigh;
822 * we need the "equal to" result to force the result
823 */
824 status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
825 if (status == 0 && id != adap->nr) {
826 status = -EBUSY;
827 idr_remove(&i2c_adapter_idr, id);
828 }
Jean Delvarecaada322008-01-27 18:14:49 +0100829 mutex_unlock(&core_lock);
David Brownell6e13e642007-05-01 23:26:31 +0200830 if (status == -EAGAIN)
831 goto retry;
832
833 if (status == 0)
834 status = i2c_register_adapter(adap);
835 return status;
836}
837EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
838
Jean Delvare69b00892009-12-06 17:06:27 +0100839static int i2c_do_del_adapter(struct i2c_driver *driver,
840 struct i2c_adapter *adapter)
Jean Delvare026526f2008-01-27 18:14:49 +0100841{
Jean Delvare4735c982008-07-14 22:38:36 +0200842 struct i2c_client *client, *_n;
Jean Delvare026526f2008-01-27 18:14:49 +0100843 int res;
844
Jean Delvareacec2112009-03-28 21:34:40 +0100845 /* Remove the devices we created ourselves as the result of hardware
846 * probing (using a driver's detect method) */
Jean Delvare4735c982008-07-14 22:38:36 +0200847 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
848 if (client->adapter == adapter) {
849 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
850 client->name, client->addr);
851 list_del(&client->detected);
852 i2c_unregister_device(client);
853 }
854 }
855
Jean Delvare026526f2008-01-27 18:14:49 +0100856 if (!driver->detach_adapter)
857 return 0;
858 res = driver->detach_adapter(adapter);
859 if (res)
860 dev_err(&adapter->dev, "detach_adapter failed (%d) "
861 "for driver [%s]\n", res, driver->driver.name);
862 return res;
863}
864
Jean Delvaree549c2b2009-06-19 16:58:19 +0200865static int __unregister_client(struct device *dev, void *dummy)
866{
867 struct i2c_client *client = i2c_verify_client(dev);
868 if (client)
869 i2c_unregister_device(client);
870 return 0;
871}
872
Jean Delvare69b00892009-12-06 17:06:27 +0100873static int __process_removed_adapter(struct device_driver *d, void *data)
874{
875 return i2c_do_del_adapter(to_i2c_driver(d), data);
876}
877
David Brownelld64f73b2007-07-12 14:12:28 +0200878/**
879 * i2c_del_adapter - unregister I2C adapter
880 * @adap: the adapter being unregistered
881 * Context: can sleep
882 *
883 * This unregisters an I2C adapter which was previously registered
884 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
885 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886int i2c_del_adapter(struct i2c_adapter *adap)
887{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 int res = 0;
Jean Delvare35fc37f2009-06-19 16:58:19 +0200889 struct i2c_adapter *found;
Jean Delvarebbd2d9c2009-11-26 09:22:33 +0100890 struct i2c_client *client, *next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891
892 /* First make sure that this adapter was ever added */
Jean Delvare35fc37f2009-06-19 16:58:19 +0200893 mutex_lock(&core_lock);
894 found = idr_find(&i2c_adapter_idr, adap->nr);
895 mutex_unlock(&core_lock);
896 if (found != adap) {
Jean Delvareb6d7b3d2005-07-31 19:02:53 +0200897 pr_debug("i2c-core: attempting to delete unregistered "
898 "adapter [%s]\n", adap->name);
Jean Delvare35fc37f2009-06-19 16:58:19 +0200899 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 }
901
Jean Delvare026526f2008-01-27 18:14:49 +0100902 /* Tell drivers about this removal */
Jean Delvare35fc37f2009-06-19 16:58:19 +0200903 mutex_lock(&core_lock);
Jean Delvare026526f2008-01-27 18:14:49 +0100904 res = bus_for_each_drv(&i2c_bus_type, NULL, adap,
Jean Delvare69b00892009-12-06 17:06:27 +0100905 __process_removed_adapter);
Jean Delvare35fc37f2009-06-19 16:58:19 +0200906 mutex_unlock(&core_lock);
Jean Delvare026526f2008-01-27 18:14:49 +0100907 if (res)
Jean Delvare35fc37f2009-06-19 16:58:19 +0200908 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909
Jean Delvarebbd2d9c2009-11-26 09:22:33 +0100910 /* Remove devices instantiated from sysfs */
Jean Delvare6629dcf2010-05-04 11:09:28 +0200911 i2c_lock_adapter(adap);
912 list_for_each_entry_safe(client, next, &adap->userspace_clients,
913 detected) {
914 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
915 client->addr);
916 list_del(&client->detected);
917 i2c_unregister_device(client);
Jean Delvarebbd2d9c2009-11-26 09:22:33 +0100918 }
Jean Delvare6629dcf2010-05-04 11:09:28 +0200919 i2c_unlock_adapter(adap);
Jean Delvarebbd2d9c2009-11-26 09:22:33 +0100920
Jean Delvaree549c2b2009-06-19 16:58:19 +0200921 /* Detach any active clients. This can't fail, thus we do not
922 checking the returned value. */
923 res = device_for_each_child(&adap->dev, NULL, __unregister_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924
Jean Delvare2bb50952009-09-18 22:45:46 +0200925#ifdef CONFIG_I2C_COMPAT
926 class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
927 adap->dev.parent);
928#endif
929
Thadeu Lima de Souza Cascardoc5567522010-01-16 20:43:13 +0100930 /* device name is gone after device_unregister */
931 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
932
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 /* clean up the sysfs representation */
934 init_completion(&adap->dev_released);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935 device_unregister(&adap->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936
937 /* wait for sysfs to drop all references */
938 wait_for_completion(&adap->dev_released);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939
David Brownell6e13e642007-05-01 23:26:31 +0200940 /* free bus id */
Jean Delvare35fc37f2009-06-19 16:58:19 +0200941 mutex_lock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 idr_remove(&i2c_adapter_idr, adap->nr);
Jean Delvare35fc37f2009-06-19 16:58:19 +0200943 mutex_unlock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944
Jean Delvarebd4bc3db2008-07-16 19:30:05 +0200945 /* Clear the device structure in case this adapter is ever going to be
946 added again */
947 memset(&adap->dev, 0, sizeof(adap->dev));
948
Jean Delvare35fc37f2009-06-19 16:58:19 +0200949 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950}
David Brownellc0564602007-05-01 23:26:31 +0200951EXPORT_SYMBOL(i2c_del_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952
953
David Brownell7b4fbc52007-05-01 23:26:30 +0200954/* ------------------------------------------------------------------------- */
955
Jean Delvare69b00892009-12-06 17:06:27 +0100956static int __process_new_driver(struct device *dev, void *data)
Dave Young7f101a92008-07-14 22:38:19 +0200957{
Jean Delvare4f8cf822009-09-18 22:45:46 +0200958 if (dev->type != &i2c_adapter_type)
959 return 0;
Jean Delvare69b00892009-12-06 17:06:27 +0100960 return i2c_do_add_adapter(data, to_i2c_adapter(dev));
Dave Young7f101a92008-07-14 22:38:19 +0200961}
962
David Brownell7b4fbc52007-05-01 23:26:30 +0200963/*
964 * An i2c_driver is used with one or more i2c_client (device) nodes to access
Jean Delvare729d6dd2009-06-19 16:58:18 +0200965 * i2c slave chips, on a bus instance associated with some i2c_adapter.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 */
967
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -0800968int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969{
Jean Delvare7eebcb72006-02-05 23:28:21 +0100970 int res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971
David Brownell1d0b19c2008-10-14 17:30:05 +0200972 /* Can't register until after driver model init */
973 if (unlikely(WARN_ON(!i2c_bus_type.p)))
974 return -EAGAIN;
975
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 /* add the driver to the list of i2c drivers in the driver core */
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -0800977 driver->driver.owner = owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 driver->driver.bus = &i2c_bus_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979
Jean Delvare729d6dd2009-06-19 16:58:18 +0200980 /* When registration returns, the driver core
David Brownell6e13e642007-05-01 23:26:31 +0200981 * will have called probe() for all matching-but-unbound devices.
982 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 res = driver_register(&driver->driver);
984 if (res)
Jean Delvare7eebcb72006-02-05 23:28:21 +0100985 return res;
David Brownell438d6c22006-12-10 21:21:31 +0100986
Laurent Riffard35d8b2e2005-11-26 20:34:05 +0100987 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988
Jean Delvare4735c982008-07-14 22:38:36 +0200989 INIT_LIST_HEAD(&driver->clients);
990 /* Walk the adapters that are already present */
Jean Delvare35fc37f2009-06-19 16:58:19 +0200991 mutex_lock(&core_lock);
Jean Delvare69b00892009-12-06 17:06:27 +0100992 bus_for_each_dev(&i2c_bus_type, NULL, driver, __process_new_driver);
Jean Delvarecaada322008-01-27 18:14:49 +0100993 mutex_unlock(&core_lock);
Jean Delvare35fc37f2009-06-19 16:58:19 +0200994
Jean Delvare7eebcb72006-02-05 23:28:21 +0100995 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996}
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -0800997EXPORT_SYMBOL(i2c_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998
Jean Delvare69b00892009-12-06 17:06:27 +0100999static int __process_removed_driver(struct device *dev, void *data)
Dave Young7f101a92008-07-14 22:38:19 +02001000{
Jean Delvare4f8cf822009-09-18 22:45:46 +02001001 if (dev->type != &i2c_adapter_type)
1002 return 0;
Jean Delvare69b00892009-12-06 17:06:27 +01001003 return i2c_do_del_adapter(data, to_i2c_adapter(dev));
Dave Young7f101a92008-07-14 22:38:19 +02001004}
1005
David Brownella1d9e6e2007-05-01 23:26:30 +02001006/**
1007 * i2c_del_driver - unregister I2C driver
1008 * @driver: the driver being unregistered
David Brownelld64f73b2007-07-12 14:12:28 +02001009 * Context: can sleep
David Brownella1d9e6e2007-05-01 23:26:30 +02001010 */
Jean Delvareb3e82092007-05-01 23:26:32 +02001011void i2c_del_driver(struct i2c_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012{
Jean Delvarecaada322008-01-27 18:14:49 +01001013 mutex_lock(&core_lock);
Jean Delvare69b00892009-12-06 17:06:27 +01001014 bus_for_each_dev(&i2c_bus_type, NULL, driver, __process_removed_driver);
Jean Delvare35fc37f2009-06-19 16:58:19 +02001015 mutex_unlock(&core_lock);
David Brownella1d9e6e2007-05-01 23:26:30 +02001016
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 driver_unregister(&driver->driver);
Laurent Riffard35d8b2e2005-11-26 20:34:05 +01001018 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019}
David Brownellc0564602007-05-01 23:26:31 +02001020EXPORT_SYMBOL(i2c_del_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021
David Brownell7b4fbc52007-05-01 23:26:30 +02001022/* ------------------------------------------------------------------------- */
1023
David Brownell9b766b82008-01-27 18:14:51 +01001024static int __i2c_check_addr(struct device *dev, void *addrp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025{
David Brownell9b766b82008-01-27 18:14:51 +01001026 struct i2c_client *client = i2c_verify_client(dev);
1027 int addr = *(int *)addrp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028
David Brownell9b766b82008-01-27 18:14:51 +01001029 if (client && client->addr == addr)
1030 return -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 return 0;
1032}
1033
Jean Delvare5e31c2b2007-11-15 19:24:02 +01001034static int i2c_check_addr(struct i2c_adapter *adapter, int addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035{
David Brownell9b766b82008-01-27 18:14:51 +01001036 return device_for_each_child(&adapter->dev, &addr, __i2c_check_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037}
1038
Jean Delvaree48d3312008-01-27 18:14:48 +01001039/**
1040 * i2c_use_client - increments the reference count of the i2c client structure
1041 * @client: the client being referenced
1042 *
1043 * Each live reference to a client should be refcounted. The driver model does
1044 * that automatically as part of driver binding, so that most drivers don't
1045 * need to do this explicitly: they hold a reference until they're unbound
1046 * from the device.
1047 *
1048 * A pointer to the client with the incremented reference counter is returned.
1049 */
1050struct i2c_client *i2c_use_client(struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051{
David Brownell6ea438e2008-07-14 22:38:24 +02001052 if (client && get_device(&client->dev))
1053 return client;
1054 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055}
David Brownellc0564602007-05-01 23:26:31 +02001056EXPORT_SYMBOL(i2c_use_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057
Jean Delvaree48d3312008-01-27 18:14:48 +01001058/**
1059 * i2c_release_client - release a use of the i2c client structure
1060 * @client: the client being no longer referenced
1061 *
1062 * Must be called when a user of a client is finished with it.
1063 */
1064void i2c_release_client(struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065{
David Brownell6ea438e2008-07-14 22:38:24 +02001066 if (client)
1067 put_device(&client->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068}
David Brownellc0564602007-05-01 23:26:31 +02001069EXPORT_SYMBOL(i2c_release_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070
David Brownell9b766b82008-01-27 18:14:51 +01001071struct i2c_cmd_arg {
1072 unsigned cmd;
1073 void *arg;
1074};
1075
1076static int i2c_cmd(struct device *dev, void *_arg)
1077{
1078 struct i2c_client *client = i2c_verify_client(dev);
1079 struct i2c_cmd_arg *arg = _arg;
1080
1081 if (client && client->driver && client->driver->command)
1082 client->driver->command(client, arg->cmd, arg->arg);
1083 return 0;
1084}
1085
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
1087{
David Brownell9b766b82008-01-27 18:14:51 +01001088 struct i2c_cmd_arg cmd_arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089
David Brownell9b766b82008-01-27 18:14:51 +01001090 cmd_arg.cmd = cmd;
1091 cmd_arg.arg = arg;
1092 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093}
David Brownellc0564602007-05-01 23:26:31 +02001094EXPORT_SYMBOL(i2c_clients_command);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095
1096static int __init i2c_init(void)
1097{
1098 int retval;
1099
1100 retval = bus_register(&i2c_bus_type);
1101 if (retval)
1102 return retval;
Jean Delvare2bb50952009-09-18 22:45:46 +02001103#ifdef CONFIG_I2C_COMPAT
1104 i2c_adapter_compat_class = class_compat_register("i2c-adapter");
1105 if (!i2c_adapter_compat_class) {
1106 retval = -ENOMEM;
1107 goto bus_err;
1108 }
1109#endif
David Brownelle9f13732008-01-27 18:14:52 +01001110 retval = i2c_add_driver(&dummy_driver);
1111 if (retval)
Jean Delvare2bb50952009-09-18 22:45:46 +02001112 goto class_err;
David Brownelle9f13732008-01-27 18:14:52 +01001113 return 0;
1114
Jean Delvare2bb50952009-09-18 22:45:46 +02001115class_err:
1116#ifdef CONFIG_I2C_COMPAT
1117 class_compat_unregister(i2c_adapter_compat_class);
David Brownelle9f13732008-01-27 18:14:52 +01001118bus_err:
Jean Delvare2bb50952009-09-18 22:45:46 +02001119#endif
David Brownelle9f13732008-01-27 18:14:52 +01001120 bus_unregister(&i2c_bus_type);
1121 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122}
1123
1124static void __exit i2c_exit(void)
1125{
David Brownelle9f13732008-01-27 18:14:52 +01001126 i2c_del_driver(&dummy_driver);
Jean Delvare2bb50952009-09-18 22:45:46 +02001127#ifdef CONFIG_I2C_COMPAT
1128 class_compat_unregister(i2c_adapter_compat_class);
1129#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 bus_unregister(&i2c_bus_type);
1131}
1132
David Brownella10f9e72008-10-14 17:30:06 +02001133/* We must initialize early, because some subsystems register i2c drivers
1134 * in subsys_initcall() code, but are linked (and initialized) before i2c.
1135 */
1136postcore_initcall(i2c_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137module_exit(i2c_exit);
1138
1139/* ----------------------------------------------------
1140 * the functional interface to the i2c busses.
1141 * ----------------------------------------------------
1142 */
1143
David Brownella1cdeda2008-07-14 22:38:24 +02001144/**
1145 * i2c_transfer - execute a single or combined I2C message
1146 * @adap: Handle to I2C bus
1147 * @msgs: One or more messages to execute before STOP is issued to
1148 * terminate the operation; each message begins with a START.
1149 * @num: Number of messages to be executed.
1150 *
1151 * Returns negative errno, else the number of messages executed.
1152 *
1153 * Note that there is no requirement that each message be sent to
1154 * the same slave address, although that is the most common model.
1155 */
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01001156int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157{
Clifford Wolf66b650f2009-06-15 18:01:46 +02001158 unsigned long orig_jiffies;
1159 int ret, try;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160
David Brownella1cdeda2008-07-14 22:38:24 +02001161 /* REVISIT the fault reporting model here is weak:
1162 *
1163 * - When we get an error after receiving N bytes from a slave,
1164 * there is no way to report "N".
1165 *
1166 * - When we get a NAK after transmitting N bytes to a slave,
1167 * there is no way to report "N" ... or to let the master
1168 * continue executing the rest of this combined message, if
1169 * that's the appropriate response.
1170 *
1171 * - When for example "num" is two and we successfully complete
1172 * the first message but get an error part way through the
1173 * second, it's unclear whether that should be reported as
1174 * one (discarding status on the second message) or errno
1175 * (discarding status on the first one).
1176 */
1177
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178 if (adap->algo->master_xfer) {
1179#ifdef DEBUG
1180 for (ret = 0; ret < num; ret++) {
1181 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
Jean Delvare209d27c2007-05-01 23:26:29 +02001182 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
1183 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
1184 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185 }
1186#endif
1187
Mike Rapoportcea443a82008-01-27 18:14:50 +01001188 if (in_atomic() || irqs_disabled()) {
Mika Kuoppala194684e2009-12-06 17:06:22 +01001189 ret = rt_mutex_trylock(&adap->bus_lock);
Mike Rapoportcea443a82008-01-27 18:14:50 +01001190 if (!ret)
1191 /* I2C activity is ongoing. */
1192 return -EAGAIN;
1193 } else {
Mika Kuoppala194684e2009-12-06 17:06:22 +01001194 rt_mutex_lock(&adap->bus_lock);
Mike Rapoportcea443a82008-01-27 18:14:50 +01001195 }
1196
Clifford Wolf66b650f2009-06-15 18:01:46 +02001197 /* Retry automatically on arbitration loss */
1198 orig_jiffies = jiffies;
1199 for (ret = 0, try = 0; try <= adap->retries; try++) {
1200 ret = adap->algo->master_xfer(adap, msgs, num);
1201 if (ret != -EAGAIN)
1202 break;
1203 if (time_after(jiffies, orig_jiffies + adap->timeout))
1204 break;
1205 }
Mika Kuoppala194684e2009-12-06 17:06:22 +01001206 rt_mutex_unlock(&adap->bus_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207
1208 return ret;
1209 } else {
1210 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
David Brownell24a5bb72008-07-14 22:38:23 +02001211 return -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212 }
1213}
David Brownellc0564602007-05-01 23:26:31 +02001214EXPORT_SYMBOL(i2c_transfer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215
David Brownella1cdeda2008-07-14 22:38:24 +02001216/**
1217 * i2c_master_send - issue a single I2C message in master transmit mode
1218 * @client: Handle to slave device
1219 * @buf: Data that will be written to the slave
Zhangfei Gao0c43ea52010-03-02 12:23:49 +01001220 * @count: How many bytes to write, must be less than 64k since msg.len is u16
David Brownella1cdeda2008-07-14 22:38:24 +02001221 *
1222 * Returns negative errno, or else the number of bytes written.
1223 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
1225{
1226 int ret;
1227 struct i2c_adapter *adap=client->adapter;
1228 struct i2c_msg msg;
1229
Jean Delvare815f55f2005-05-07 22:58:46 +02001230 msg.addr = client->addr;
1231 msg.flags = client->flags & I2C_M_TEN;
1232 msg.len = count;
1233 msg.buf = (char *)buf;
David Brownell438d6c22006-12-10 21:21:31 +01001234
Jean Delvare815f55f2005-05-07 22:58:46 +02001235 ret = i2c_transfer(adap, &msg, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236
Jean Delvare815f55f2005-05-07 22:58:46 +02001237 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1238 transmitted, else error code. */
1239 return (ret == 1) ? count : ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240}
David Brownellc0564602007-05-01 23:26:31 +02001241EXPORT_SYMBOL(i2c_master_send);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242
David Brownella1cdeda2008-07-14 22:38:24 +02001243/**
1244 * i2c_master_recv - issue a single I2C message in master receive mode
1245 * @client: Handle to slave device
1246 * @buf: Where to store data read from slave
Zhangfei Gao0c43ea52010-03-02 12:23:49 +01001247 * @count: How many bytes to read, must be less than 64k since msg.len is u16
David Brownella1cdeda2008-07-14 22:38:24 +02001248 *
1249 * Returns negative errno, or else the number of bytes read.
1250 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
1252{
1253 struct i2c_adapter *adap=client->adapter;
1254 struct i2c_msg msg;
1255 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256
Jean Delvare815f55f2005-05-07 22:58:46 +02001257 msg.addr = client->addr;
1258 msg.flags = client->flags & I2C_M_TEN;
1259 msg.flags |= I2C_M_RD;
1260 msg.len = count;
1261 msg.buf = buf;
1262
1263 ret = i2c_transfer(adap, &msg, 1);
1264
1265 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1266 transmitted, else error code. */
1267 return (ret == 1) ? count : ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268}
David Brownellc0564602007-05-01 23:26:31 +02001269EXPORT_SYMBOL(i2c_master_recv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271/* ----------------------------------------------------
1272 * the i2c address scanning function
1273 * Will not work for 10-bit addresses!
1274 * ----------------------------------------------------
1275 */
Jean Delvare9fc6adf2005-07-31 21:20:43 +02001276
Jean Delvareccfbbd02009-12-06 17:06:25 +01001277static int i2c_detect_address(struct i2c_client *temp_client,
Jean Delvare4735c982008-07-14 22:38:36 +02001278 struct i2c_driver *driver)
1279{
1280 struct i2c_board_info info;
1281 struct i2c_adapter *adapter = temp_client->adapter;
1282 int addr = temp_client->addr;
1283 int err;
1284
1285 /* Make sure the address is valid */
1286 if (addr < 0x03 || addr > 0x77) {
1287 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1288 addr);
1289 return -EINVAL;
1290 }
1291
1292 /* Skip if already in use */
1293 if (i2c_check_addr(adapter, addr))
1294 return 0;
1295
Jean Delvareccfbbd02009-12-06 17:06:25 +01001296 /* Make sure there is something at this address */
Jean Delvareb1d4b392010-05-04 11:09:28 +02001297 if (addr == 0x73 && (adapter->class & I2C_CLASS_HWMON)) {
1298 /* Special probe for FSC hwmon chips */
1299 union i2c_smbus_data dummy;
Jean Delvare4735c982008-07-14 22:38:36 +02001300
Jean Delvareb1d4b392010-05-04 11:09:28 +02001301 if (i2c_smbus_xfer(adapter, addr, 0, I2C_SMBUS_READ, 0,
1302 I2C_SMBUS_BYTE_DATA, &dummy) < 0)
1303 return 0;
1304 } else {
1305 if (i2c_smbus_xfer(adapter, addr, 0, I2C_SMBUS_WRITE, 0,
1306 I2C_SMBUS_QUICK, NULL) < 0)
1307 return 0;
1308
1309 /* Prevent 24RF08 corruption */
1310 if ((addr & ~0x0f) == 0x50)
1311 i2c_smbus_xfer(adapter, addr, 0, I2C_SMBUS_WRITE, 0,
1312 I2C_SMBUS_QUICK, NULL);
1313 }
Jean Delvare4735c982008-07-14 22:38:36 +02001314
1315 /* Finally call the custom detection function */
1316 memset(&info, 0, sizeof(struct i2c_board_info));
1317 info.addr = addr;
Jean Delvare310ec792009-12-14 21:17:23 +01001318 err = driver->detect(temp_client, &info);
Jean Delvare4735c982008-07-14 22:38:36 +02001319 if (err) {
1320 /* -ENODEV is returned if the detection fails. We catch it
1321 here as this isn't an error. */
1322 return err == -ENODEV ? 0 : err;
1323 }
1324
1325 /* Consistency check */
1326 if (info.type[0] == '\0') {
1327 dev_err(&adapter->dev, "%s detection function provided "
1328 "no name for 0x%x\n", driver->driver.name,
1329 addr);
1330 } else {
1331 struct i2c_client *client;
1332
1333 /* Detection succeeded, instantiate the device */
1334 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
1335 info.type, info.addr);
1336 client = i2c_new_device(adapter, &info);
1337 if (client)
1338 list_add_tail(&client->detected, &driver->clients);
1339 else
1340 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
1341 info.type, info.addr);
1342 }
1343 return 0;
1344}
1345
1346static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
1347{
Jean Delvarec3813d62009-12-14 21:17:25 +01001348 const unsigned short *address_list;
Jean Delvare4735c982008-07-14 22:38:36 +02001349 struct i2c_client *temp_client;
1350 int i, err = 0;
1351 int adap_id = i2c_adapter_id(adapter);
1352
Jean Delvarec3813d62009-12-14 21:17:25 +01001353 address_list = driver->address_list;
1354 if (!driver->detect || !address_list)
Jean Delvare4735c982008-07-14 22:38:36 +02001355 return 0;
1356
1357 /* Set up a temporary client to help detect callback */
1358 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
1359 if (!temp_client)
1360 return -ENOMEM;
1361 temp_client->adapter = adapter;
1362
Jean Delvare4329cf82008-08-28 08:33:23 +02001363 /* Stop here if the classes do not match */
1364 if (!(adapter->class & driver->class))
1365 goto exit_free;
1366
Jean Delvare4735c982008-07-14 22:38:36 +02001367 /* Stop here if we can't use SMBUS_QUICK */
1368 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
Jean Delvarec3813d62009-12-14 21:17:25 +01001369 if (address_list[0] == I2C_CLIENT_END)
Jean Delvare4735c982008-07-14 22:38:36 +02001370 goto exit_free;
1371
1372 dev_warn(&adapter->dev, "SMBus Quick command not supported, "
1373 "can't probe for chips\n");
1374 err = -EOPNOTSUPP;
1375 goto exit_free;
1376 }
1377
Jean Delvarec3813d62009-12-14 21:17:25 +01001378 for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
Jean Delvare4735c982008-07-14 22:38:36 +02001379 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
Jean Delvarec3813d62009-12-14 21:17:25 +01001380 "addr 0x%02x\n", adap_id, address_list[i]);
1381 temp_client->addr = address_list[i];
Jean Delvareccfbbd02009-12-06 17:06:25 +01001382 err = i2c_detect_address(temp_client, driver);
Jean Delvare4735c982008-07-14 22:38:36 +02001383 if (err)
1384 goto exit_free;
1385 }
1386
1387 exit_free:
1388 kfree(temp_client);
1389 return err;
1390}
1391
Jean Delvare12b5053a2007-05-01 23:26:31 +02001392struct i2c_client *
1393i2c_new_probed_device(struct i2c_adapter *adap,
1394 struct i2c_board_info *info,
1395 unsigned short const *addr_list)
1396{
1397 int i;
1398
1399 /* Stop here if the bus doesn't support probing */
1400 if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE)) {
1401 dev_err(&adap->dev, "Probing not supported\n");
1402 return NULL;
1403 }
1404
Jean Delvare12b5053a2007-05-01 23:26:31 +02001405 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1406 /* Check address validity */
1407 if (addr_list[i] < 0x03 || addr_list[i] > 0x77) {
1408 dev_warn(&adap->dev, "Invalid 7-bit address "
1409 "0x%02x\n", addr_list[i]);
1410 continue;
1411 }
1412
1413 /* Check address availability */
David Brownell9b766b82008-01-27 18:14:51 +01001414 if (i2c_check_addr(adap, addr_list[i])) {
Jean Delvare12b5053a2007-05-01 23:26:31 +02001415 dev_dbg(&adap->dev, "Address 0x%02x already in "
1416 "use, not probing\n", addr_list[i]);
1417 continue;
1418 }
1419
1420 /* Test address responsiveness
1421 The default probe method is a quick write, but it is known
1422 to corrupt the 24RF08 EEPROMs due to a state machine bug,
1423 and could also irreversibly write-protect some EEPROMs, so
1424 for address ranges 0x30-0x37 and 0x50-0x5f, we use a byte
1425 read instead. Also, some bus drivers don't implement
1426 quick write, so we fallback to a byte read it that case
1427 too. */
1428 if ((addr_list[i] & ~0x07) == 0x30
1429 || (addr_list[i] & ~0x0f) == 0x50
1430 || !i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK)) {
Hans Verkuilb25b7912008-08-10 22:56:15 +02001431 union i2c_smbus_data data;
1432
Jean Delvare12b5053a2007-05-01 23:26:31 +02001433 if (i2c_smbus_xfer(adap, addr_list[i], 0,
1434 I2C_SMBUS_READ, 0,
Hans Verkuilb25b7912008-08-10 22:56:15 +02001435 I2C_SMBUS_BYTE, &data) >= 0)
Jean Delvare12b5053a2007-05-01 23:26:31 +02001436 break;
1437 } else {
1438 if (i2c_smbus_xfer(adap, addr_list[i], 0,
1439 I2C_SMBUS_WRITE, 0,
1440 I2C_SMBUS_QUICK, NULL) >= 0)
1441 break;
1442 }
1443 }
Jean Delvare12b5053a2007-05-01 23:26:31 +02001444
1445 if (addr_list[i] == I2C_CLIENT_END) {
1446 dev_dbg(&adap->dev, "Probing failed, no device found\n");
1447 return NULL;
1448 }
1449
1450 info->addr = addr_list[i];
1451 return i2c_new_device(adap, info);
1452}
1453EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1454
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455struct i2c_adapter* i2c_get_adapter(int id)
1456{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 struct i2c_adapter *adapter;
David Brownell438d6c22006-12-10 21:21:31 +01001458
Jean Delvarecaada322008-01-27 18:14:49 +01001459 mutex_lock(&core_lock);
Jack Stone1cf92b42009-06-15 18:01:46 +02001460 adapter = idr_find(&i2c_adapter_idr, id);
Mark M. Hoffmana0920e12005-06-28 00:21:30 -04001461 if (adapter && !try_module_get(adapter->owner))
1462 adapter = NULL;
1463
Jean Delvarecaada322008-01-27 18:14:49 +01001464 mutex_unlock(&core_lock);
Mark M. Hoffmana0920e12005-06-28 00:21:30 -04001465 return adapter;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466}
David Brownellc0564602007-05-01 23:26:31 +02001467EXPORT_SYMBOL(i2c_get_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468
1469void i2c_put_adapter(struct i2c_adapter *adap)
1470{
1471 module_put(adap->owner);
1472}
David Brownellc0564602007-05-01 23:26:31 +02001473EXPORT_SYMBOL(i2c_put_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474
1475/* The SMBus parts */
1476
David Brownell438d6c22006-12-10 21:21:31 +01001477#define POLY (0x1070U << 3)
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01001478static u8 crc8(u16 data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479{
1480 int i;
David Brownell438d6c22006-12-10 21:21:31 +01001481
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482 for(i = 0; i < 8; i++) {
David Brownell438d6c22006-12-10 21:21:31 +01001483 if (data & 0x8000)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484 data = data ^ POLY;
1485 data = data << 1;
1486 }
1487 return (u8)(data >> 8);
1488}
1489
Jean Delvare421ef472005-10-26 21:28:55 +02001490/* Incremental CRC8 over count bytes in the array pointed to by p */
1491static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492{
1493 int i;
1494
1495 for(i = 0; i < count; i++)
Jean Delvare421ef472005-10-26 21:28:55 +02001496 crc = crc8((crc ^ p[i]) << 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 return crc;
1498}
1499
Jean Delvare421ef472005-10-26 21:28:55 +02001500/* Assume a 7-bit address, which is reasonable for SMBus */
1501static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502{
Jean Delvare421ef472005-10-26 21:28:55 +02001503 /* The address will be sent first */
1504 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1505 pec = i2c_smbus_pec(pec, &addr, 1);
1506
1507 /* The data buffer follows */
1508 return i2c_smbus_pec(pec, msg->buf, msg->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509}
1510
Jean Delvare421ef472005-10-26 21:28:55 +02001511/* Used for write only transactions */
1512static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513{
Jean Delvare421ef472005-10-26 21:28:55 +02001514 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1515 msg->len++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516}
1517
Jean Delvare421ef472005-10-26 21:28:55 +02001518/* Return <0 on CRC error
1519 If there was a write before this read (most cases) we need to take the
1520 partial CRC from the write part into account.
1521 Note that this function does modify the message (we need to decrease the
1522 message length to hide the CRC byte from the caller). */
1523static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524{
Jean Delvare421ef472005-10-26 21:28:55 +02001525 u8 rpec = msg->buf[--msg->len];
1526 cpec = i2c_smbus_msg_pec(cpec, msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528 if (rpec != cpec) {
1529 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1530 rpec, cpec);
David Brownell24a5bb72008-07-14 22:38:23 +02001531 return -EBADMSG;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532 }
David Brownell438d6c22006-12-10 21:21:31 +01001533 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534}
1535
David Brownella1cdeda2008-07-14 22:38:24 +02001536/**
1537 * i2c_smbus_read_byte - SMBus "receive byte" protocol
1538 * @client: Handle to slave device
1539 *
1540 * This executes the SMBus "receive byte" protocol, returning negative errno
1541 * else the byte received from the device.
1542 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001543s32 i2c_smbus_read_byte(struct i2c_client *client)
1544{
1545 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02001546 int status;
1547
1548 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1549 I2C_SMBUS_READ, 0,
1550 I2C_SMBUS_BYTE, &data);
1551 return (status < 0) ? status : data.byte;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552}
David Brownellc0564602007-05-01 23:26:31 +02001553EXPORT_SYMBOL(i2c_smbus_read_byte);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554
David Brownella1cdeda2008-07-14 22:38:24 +02001555/**
1556 * i2c_smbus_write_byte - SMBus "send byte" protocol
1557 * @client: Handle to slave device
1558 * @value: Byte to be sent
1559 *
1560 * This executes the SMBus "send byte" protocol, returning negative errno
1561 * else zero on success.
1562 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
1564{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
Jean Delvare421ef472005-10-26 21:28:55 +02001566 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567}
David Brownellc0564602007-05-01 23:26:31 +02001568EXPORT_SYMBOL(i2c_smbus_write_byte);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569
David Brownella1cdeda2008-07-14 22:38:24 +02001570/**
1571 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
1572 * @client: Handle to slave device
1573 * @command: Byte interpreted by slave
1574 *
1575 * This executes the SMBus "read byte" protocol, returning negative errno
1576 * else a data byte received from the device.
1577 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
1579{
1580 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02001581 int status;
1582
1583 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1584 I2C_SMBUS_READ, command,
1585 I2C_SMBUS_BYTE_DATA, &data);
1586 return (status < 0) ? status : data.byte;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587}
David Brownellc0564602007-05-01 23:26:31 +02001588EXPORT_SYMBOL(i2c_smbus_read_byte_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589
David Brownella1cdeda2008-07-14 22:38:24 +02001590/**
1591 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
1592 * @client: Handle to slave device
1593 * @command: Byte interpreted by slave
1594 * @value: Byte being written
1595 *
1596 * This executes the SMBus "write byte" protocol, returning negative errno
1597 * else zero on success.
1598 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
1600{
1601 union i2c_smbus_data data;
1602 data.byte = value;
1603 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1604 I2C_SMBUS_WRITE,command,
1605 I2C_SMBUS_BYTE_DATA,&data);
1606}
David Brownellc0564602007-05-01 23:26:31 +02001607EXPORT_SYMBOL(i2c_smbus_write_byte_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608
David Brownella1cdeda2008-07-14 22:38:24 +02001609/**
1610 * i2c_smbus_read_word_data - SMBus "read word" protocol
1611 * @client: Handle to slave device
1612 * @command: Byte interpreted by slave
1613 *
1614 * This executes the SMBus "read word" protocol, returning negative errno
1615 * else a 16-bit unsigned "word" received from the device.
1616 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
1618{
1619 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02001620 int status;
1621
1622 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1623 I2C_SMBUS_READ, command,
1624 I2C_SMBUS_WORD_DATA, &data);
1625 return (status < 0) ? status : data.word;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626}
David Brownellc0564602007-05-01 23:26:31 +02001627EXPORT_SYMBOL(i2c_smbus_read_word_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628
David Brownella1cdeda2008-07-14 22:38:24 +02001629/**
1630 * i2c_smbus_write_word_data - SMBus "write word" protocol
1631 * @client: Handle to slave device
1632 * @command: Byte interpreted by slave
1633 * @value: 16-bit "word" being written
1634 *
1635 * This executes the SMBus "write word" protocol, returning negative errno
1636 * else zero on success.
1637 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
1639{
1640 union i2c_smbus_data data;
1641 data.word = value;
1642 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1643 I2C_SMBUS_WRITE,command,
1644 I2C_SMBUS_WORD_DATA,&data);
1645}
David Brownellc0564602007-05-01 23:26:31 +02001646EXPORT_SYMBOL(i2c_smbus_write_word_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647
David Brownella64ec072007-10-13 23:56:31 +02001648/**
Prakash Mortha596c88f2008-10-14 17:30:06 +02001649 * i2c_smbus_process_call - SMBus "process call" protocol
1650 * @client: Handle to slave device
1651 * @command: Byte interpreted by slave
1652 * @value: 16-bit "word" being written
1653 *
1654 * This executes the SMBus "process call" protocol, returning negative errno
1655 * else a 16-bit unsigned "word" received from the device.
1656 */
1657s32 i2c_smbus_process_call(struct i2c_client *client, u8 command, u16 value)
1658{
1659 union i2c_smbus_data data;
1660 int status;
1661 data.word = value;
1662
1663 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1664 I2C_SMBUS_WRITE, command,
1665 I2C_SMBUS_PROC_CALL, &data);
1666 return (status < 0) ? status : data.word;
1667}
1668EXPORT_SYMBOL(i2c_smbus_process_call);
1669
1670/**
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 */
Roel Kluinf29d2e02009-02-24 19:19:48 +01001789 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
1790 I2C_M_RD : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791 num = 1;
1792 break;
1793 case I2C_SMBUS_BYTE:
1794 if (read_write == I2C_SMBUS_READ) {
1795 /* Special case: only a read! */
1796 msg[0].flags = I2C_M_RD | flags;
1797 num = 1;
1798 }
1799 break;
1800 case I2C_SMBUS_BYTE_DATA:
1801 if (read_write == I2C_SMBUS_READ)
1802 msg[1].len = 1;
1803 else {
1804 msg[0].len = 2;
1805 msgbuf0[1] = data->byte;
1806 }
1807 break;
1808 case I2C_SMBUS_WORD_DATA:
1809 if (read_write == I2C_SMBUS_READ)
1810 msg[1].len = 2;
1811 else {
1812 msg[0].len=3;
1813 msgbuf0[1] = data->word & 0xff;
Jean Delvare7eff82c2006-09-03 22:24:00 +02001814 msgbuf0[2] = data->word >> 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001815 }
1816 break;
1817 case I2C_SMBUS_PROC_CALL:
1818 num = 2; /* Special case */
1819 read_write = I2C_SMBUS_READ;
1820 msg[0].len = 3;
1821 msg[1].len = 2;
1822 msgbuf0[1] = data->word & 0xff;
Jean Delvare7eff82c2006-09-03 22:24:00 +02001823 msgbuf0[2] = data->word >> 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824 break;
1825 case I2C_SMBUS_BLOCK_DATA:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 if (read_write == I2C_SMBUS_READ) {
Jean Delvare209d27c2007-05-01 23:26:29 +02001827 msg[1].flags |= I2C_M_RECV_LEN;
1828 msg[1].len = 1; /* block length will be added by
1829 the underlying bus driver */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830 } else {
1831 msg[0].len = data->block[0] + 2;
1832 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
David Brownell24a5bb72008-07-14 22:38:23 +02001833 dev_err(&adapter->dev,
1834 "Invalid block write size %d\n",
1835 data->block[0]);
1836 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837 }
Hideki Iwamoto5c50d182005-09-25 17:01:11 +02001838 for (i = 1; i < msg[0].len; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839 msgbuf0[i] = data->block[i-1];
1840 }
1841 break;
1842 case I2C_SMBUS_BLOCK_PROC_CALL:
Jean Delvare209d27c2007-05-01 23:26:29 +02001843 num = 2; /* Another special case */
1844 read_write = I2C_SMBUS_READ;
1845 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
David Brownell24a5bb72008-07-14 22:38:23 +02001846 dev_err(&adapter->dev,
1847 "Invalid block write size %d\n",
Jean Delvare209d27c2007-05-01 23:26:29 +02001848 data->block[0]);
David Brownell24a5bb72008-07-14 22:38:23 +02001849 return -EINVAL;
Jean Delvare209d27c2007-05-01 23:26:29 +02001850 }
1851 msg[0].len = data->block[0] + 2;
1852 for (i = 1; i < msg[0].len; i++)
1853 msgbuf0[i] = data->block[i-1];
1854 msg[1].flags |= I2C_M_RECV_LEN;
1855 msg[1].len = 1; /* block length will be added by
1856 the underlying bus driver */
1857 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001858 case I2C_SMBUS_I2C_BLOCK_DATA:
1859 if (read_write == I2C_SMBUS_READ) {
Jean Delvare4b2643d2007-07-12 14:12:29 +02001860 msg[1].len = data->block[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861 } else {
1862 msg[0].len = data->block[0] + 1;
Jean Delvare30dac742005-10-08 00:15:59 +02001863 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
David Brownell24a5bb72008-07-14 22:38:23 +02001864 dev_err(&adapter->dev,
1865 "Invalid block write size %d\n",
1866 data->block[0]);
1867 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001868 }
1869 for (i = 1; i <= data->block[0]; i++)
1870 msgbuf0[i] = data->block[i];
1871 }
1872 break;
1873 default:
David Brownell24a5bb72008-07-14 22:38:23 +02001874 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
1875 return -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001876 }
1877
Jean Delvare421ef472005-10-26 21:28:55 +02001878 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
1879 && size != I2C_SMBUS_I2C_BLOCK_DATA);
1880 if (i) {
1881 /* Compute PEC if first message is a write */
1882 if (!(msg[0].flags & I2C_M_RD)) {
David Brownell438d6c22006-12-10 21:21:31 +01001883 if (num == 1) /* Write only */
Jean Delvare421ef472005-10-26 21:28:55 +02001884 i2c_smbus_add_pec(&msg[0]);
1885 else /* Write followed by read */
1886 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
1887 }
1888 /* Ask for PEC if last message is a read */
1889 if (msg[num-1].flags & I2C_M_RD)
David Brownell438d6c22006-12-10 21:21:31 +01001890 msg[num-1].len++;
Jean Delvare421ef472005-10-26 21:28:55 +02001891 }
1892
David Brownell24a5bb72008-07-14 22:38:23 +02001893 status = i2c_transfer(adapter, msg, num);
1894 if (status < 0)
1895 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896
Jean Delvare421ef472005-10-26 21:28:55 +02001897 /* Check PEC if last message is a read */
1898 if (i && (msg[num-1].flags & I2C_M_RD)) {
David Brownell24a5bb72008-07-14 22:38:23 +02001899 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
1900 if (status < 0)
1901 return status;
Jean Delvare421ef472005-10-26 21:28:55 +02001902 }
1903
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904 if (read_write == I2C_SMBUS_READ)
1905 switch(size) {
1906 case I2C_SMBUS_BYTE:
1907 data->byte = msgbuf0[0];
1908 break;
1909 case I2C_SMBUS_BYTE_DATA:
1910 data->byte = msgbuf1[0];
1911 break;
David Brownell438d6c22006-12-10 21:21:31 +01001912 case I2C_SMBUS_WORD_DATA:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913 case I2C_SMBUS_PROC_CALL:
1914 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
1915 break;
1916 case I2C_SMBUS_I2C_BLOCK_DATA:
Jean Delvare4b2643d2007-07-12 14:12:29 +02001917 for (i = 0; i < data->block[0]; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 data->block[i+1] = msgbuf1[i];
1919 break;
Jean Delvare209d27c2007-05-01 23:26:29 +02001920 case I2C_SMBUS_BLOCK_DATA:
1921 case I2C_SMBUS_BLOCK_PROC_CALL:
1922 for (i = 0; i < msgbuf1[0] + 1; i++)
1923 data->block[i] = msgbuf1[i];
1924 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925 }
1926 return 0;
1927}
1928
David Brownella1cdeda2008-07-14 22:38:24 +02001929/**
1930 * i2c_smbus_xfer - execute SMBus protocol operations
1931 * @adapter: Handle to I2C bus
1932 * @addr: Address of SMBus slave on that bus
1933 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
1934 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
1935 * @command: Byte interpreted by slave, for protocols which use such bytes
1936 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
1937 * @data: Data to be read or written
1938 *
1939 * This executes an SMBus protocol operation, and returns a negative
1940 * errno code else zero on success.
1941 */
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01001942s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
David Brownella1cdeda2008-07-14 22:38:24 +02001943 char read_write, u8 command, int protocol,
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01001944 union i2c_smbus_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001945{
Clifford Wolf66b650f2009-06-15 18:01:46 +02001946 unsigned long orig_jiffies;
1947 int try;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948 s32 res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949
1950 flags &= I2C_M_TEN | I2C_CLIENT_PEC;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951
1952 if (adapter->algo->smbus_xfer) {
Mika Kuoppala194684e2009-12-06 17:06:22 +01001953 rt_mutex_lock(&adapter->bus_lock);
Clifford Wolf66b650f2009-06-15 18:01:46 +02001954
1955 /* Retry automatically on arbitration loss */
1956 orig_jiffies = jiffies;
1957 for (res = 0, try = 0; try <= adapter->retries; try++) {
1958 res = adapter->algo->smbus_xfer(adapter, addr, flags,
1959 read_write, command,
1960 protocol, data);
1961 if (res != -EAGAIN)
1962 break;
1963 if (time_after(jiffies,
1964 orig_jiffies + adapter->timeout))
1965 break;
1966 }
Mika Kuoppala194684e2009-12-06 17:06:22 +01001967 rt_mutex_unlock(&adapter->bus_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968 } else
1969 res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
David Brownella1cdeda2008-07-14 22:38:24 +02001970 command, protocol, data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001971
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972 return res;
1973}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001974EXPORT_SYMBOL(i2c_smbus_xfer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975
1976MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
1977MODULE_DESCRIPTION("I2C-Bus main module");
1978MODULE_LICENSE("GPL");