blob: 632057a4461589c3f7135f4d5feac4a0106041b0 [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
Jean Delvare5694f8a2012-03-26 21:47:19 +020017 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
18 MA 02110-1301 USA. */
Linus Torvalds1da177e2005-04-16 15:20:36 -070019/* ------------------------------------------------------------------------- */
20
Jan Engelhardt96de0e22007-10-19 23:21:04 +020021/* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi>.
Linus Torvalds1da177e2005-04-16 15:20:36 -070022 All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl>
Jean Delvare421ef472005-10-26 21:28:55 +020023 SMBus 2.0 support by Mark Studebaker <mdsxyz123@yahoo.com> and
Jean Delvare7c81c602014-01-29 20:40:08 +010024 Jean Delvare <jdelvare@suse.de>
Michael Lawnick08263742010-08-11 18:21:02 +020025 Mux support by Rodolfo Giometti <giometti@enneenne.com> and
Wolfram Sang687b81d2013-07-11 12:56:15 +010026 Michael Lawnick <michael.lawnick.ext@nsn.com>
27 OF support is copyright (c) 2008 Jochen Friedrich <jochen@scram.de>
28 (based on a previous patch from Jon Smirl <jonsmirl@gmail.com>) and
29 (c) 2013 Wolfram Sang <wsa@the-dreams.de>
30 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070031
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <linux/module.h>
33#include <linux/kernel.h>
Viresh Kumar5f9296b2012-02-28 18:26:31 +053034#include <linux/delay.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/errno.h>
Viresh Kumar5f9296b2012-02-28 18:26:31 +053036#include <linux/gpio.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <linux/slab.h>
38#include <linux/i2c.h>
39#include <linux/init.h>
40#include <linux/idr.h>
Arjan van de Venb3585e42006-01-11 10:50:26 +010041#include <linux/mutex.h>
Wolfram Sang687b81d2013-07-11 12:56:15 +010042#include <linux/of.h>
Grant Likely959e85f2010-06-08 07:48:19 -060043#include <linux/of_device.h>
Wolfram Sang687b81d2013-07-11 12:56:15 +010044#include <linux/of_irq.h>
Sylwester Nawrocki86be4082014-06-18 17:29:32 +020045#include <linux/clk/clk-conf.h>
Jean Delvareb8d6f452007-02-13 22:09:00 +010046#include <linux/completion.h>
Mike Rapoportcea443a82008-01-27 18:14:50 +010047#include <linux/hardirq.h>
48#include <linux/irqflags.h>
Rodolfo Giomettif18c41d2009-06-19 16:58:20 +020049#include <linux/rwsem.h>
Mark Brown6de468a2010-03-02 12:23:46 +010050#include <linux/pm_runtime.h>
Mika Westerberg907ddf82012-11-23 12:23:40 +010051#include <linux/acpi.h>
David Howellsd9a83d62014-03-06 13:35:59 +000052#include <linux/jump_label.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070053#include <asm/uaccess.h>
54
David Brownell9c1600e2007-05-01 23:26:31 +020055#include "i2c-core.h"
56
David Howellsd9a83d62014-03-06 13:35:59 +000057#define CREATE_TRACE_POINTS
58#include <trace/events/i2c.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
Jean Delvare6629dcf2010-05-04 11:09:28 +020060/* core_lock protects i2c_adapter_idr, and guarantees
Jean Delvare35fc37f2009-06-19 16:58:19 +020061 that device detection, deletion of detected devices, and attach_adapter
Lars-Peter Clausen19baba42013-03-09 08:16:44 +000062 calls are serialized */
Jean Delvarecaada322008-01-27 18:14:49 +010063static DEFINE_MUTEX(core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070064static DEFINE_IDR(i2c_adapter_idr);
65
Jean Delvare4f8cf822009-09-18 22:45:46 +020066static struct device_type i2c_client_type;
Jean Delvare4735c982008-07-14 22:38:36 +020067static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
David Brownellf37dd802007-02-13 22:09:00 +010068
David Howellsd9a83d62014-03-06 13:35:59 +000069static struct static_key i2c_trace_msg = STATIC_KEY_INIT_FALSE;
70
71void i2c_transfer_trace_reg(void)
72{
73 static_key_slow_inc(&i2c_trace_msg);
74}
75
76void i2c_transfer_trace_unreg(void)
77{
78 static_key_slow_dec(&i2c_trace_msg);
79}
80
David Brownellf37dd802007-02-13 22:09:00 +010081/* ------------------------------------------------------------------------- */
82
Jean Delvared2653e92008-04-29 23:11:39 +020083static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
84 const struct i2c_client *client)
85{
86 while (id->name[0]) {
87 if (strcmp(client->name, id->name) == 0)
88 return id;
89 id++;
90 }
91 return NULL;
92}
93
Linus Torvalds1da177e2005-04-16 15:20:36 -070094static int i2c_device_match(struct device *dev, struct device_driver *drv)
95{
Jean Delvare51298d12009-09-18 22:45:45 +020096 struct i2c_client *client = i2c_verify_client(dev);
97 struct i2c_driver *driver;
David Brownell7b4fbc52007-05-01 23:26:30 +020098
Jean Delvare51298d12009-09-18 22:45:45 +020099 if (!client)
100 return 0;
101
Grant Likely959e85f2010-06-08 07:48:19 -0600102 /* Attempt an OF style match */
103 if (of_driver_match_device(dev, drv))
104 return 1;
105
Mika Westerberg907ddf82012-11-23 12:23:40 +0100106 /* Then ACPI style match */
107 if (acpi_driver_match_device(dev, drv))
108 return 1;
109
Jean Delvare51298d12009-09-18 22:45:45 +0200110 driver = to_i2c_driver(drv);
Jean Delvared2653e92008-04-29 23:11:39 +0200111 /* match on an id table if there is one */
112 if (driver->id_table)
113 return i2c_match_id(driver->id_table, client) != NULL;
114
Jean Delvareeb8a7902008-05-18 20:49:41 +0200115 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116}
117
David Brownell7b4fbc52007-05-01 23:26:30 +0200118
119/* uevent helps with hotplug: modprobe -q $(MODALIAS) */
Kay Sievers7eff2e72007-08-14 15:15:12 +0200120static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
David Brownell7b4fbc52007-05-01 23:26:30 +0200121{
122 struct i2c_client *client = to_i2c_client(dev);
Zhang Rui8c4ff6d2014-01-14 16:46:37 +0800123 int rc;
124
125 rc = acpi_device_uevent_modalias(dev, env);
126 if (rc != -ENODEV)
127 return rc;
David Brownell7b4fbc52007-05-01 23:26:30 +0200128
Jean Delvareeb8a7902008-05-18 20:49:41 +0200129 if (add_uevent_var(env, "MODALIAS=%s%s",
130 I2C_MODULE_PREFIX, client->name))
131 return -ENOMEM;
David Brownell7b4fbc52007-05-01 23:26:30 +0200132 dev_dbg(dev, "uevent\n");
133 return 0;
134}
135
Viresh Kumar5f9296b2012-02-28 18:26:31 +0530136/* i2c bus recovery routines */
137static int get_scl_gpio_value(struct i2c_adapter *adap)
138{
139 return gpio_get_value(adap->bus_recovery_info->scl_gpio);
140}
141
142static void set_scl_gpio_value(struct i2c_adapter *adap, int val)
143{
144 gpio_set_value(adap->bus_recovery_info->scl_gpio, val);
145}
146
147static int get_sda_gpio_value(struct i2c_adapter *adap)
148{
149 return gpio_get_value(adap->bus_recovery_info->sda_gpio);
150}
151
152static int i2c_get_gpios_for_recovery(struct i2c_adapter *adap)
153{
154 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
155 struct device *dev = &adap->dev;
156 int ret = 0;
157
158 ret = gpio_request_one(bri->scl_gpio, GPIOF_OPEN_DRAIN |
159 GPIOF_OUT_INIT_HIGH, "i2c-scl");
160 if (ret) {
161 dev_warn(dev, "Can't get SCL gpio: %d\n", bri->scl_gpio);
162 return ret;
163 }
164
165 if (bri->get_sda) {
166 if (gpio_request_one(bri->sda_gpio, GPIOF_IN, "i2c-sda")) {
167 /* work without SDA polling */
168 dev_warn(dev, "Can't get SDA gpio: %d. Not using SDA polling\n",
169 bri->sda_gpio);
170 bri->get_sda = NULL;
171 }
172 }
173
174 return ret;
175}
176
177static void i2c_put_gpios_for_recovery(struct i2c_adapter *adap)
178{
179 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
180
181 if (bri->get_sda)
182 gpio_free(bri->sda_gpio);
183
184 gpio_free(bri->scl_gpio);
185}
186
187/*
188 * We are generating clock pulses. ndelay() determines durating of clk pulses.
189 * We will generate clock with rate 100 KHz and so duration of both clock levels
190 * is: delay in ns = (10^6 / 100) / 2
191 */
192#define RECOVERY_NDELAY 5000
193#define RECOVERY_CLK_CNT 9
194
195static int i2c_generic_recovery(struct i2c_adapter *adap)
196{
197 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
198 int i = 0, val = 1, ret = 0;
199
200 if (bri->prepare_recovery)
201 bri->prepare_recovery(bri);
202
203 /*
204 * By this time SCL is high, as we need to give 9 falling-rising edges
205 */
206 while (i++ < RECOVERY_CLK_CNT * 2) {
207 if (val) {
208 /* Break if SDA is high */
209 if (bri->get_sda && bri->get_sda(adap))
210 break;
211 /* SCL shouldn't be low here */
212 if (!bri->get_scl(adap)) {
213 dev_err(&adap->dev,
214 "SCL is stuck low, exit recovery\n");
215 ret = -EBUSY;
216 break;
217 }
218 }
219
220 val = !val;
221 bri->set_scl(adap, val);
222 ndelay(RECOVERY_NDELAY);
223 }
224
225 if (bri->unprepare_recovery)
226 bri->unprepare_recovery(bri);
227
228 return ret;
229}
230
231int i2c_generic_scl_recovery(struct i2c_adapter *adap)
232{
233 adap->bus_recovery_info->set_scl(adap, 1);
234 return i2c_generic_recovery(adap);
235}
236
237int i2c_generic_gpio_recovery(struct i2c_adapter *adap)
238{
239 int ret;
240
241 ret = i2c_get_gpios_for_recovery(adap);
242 if (ret)
243 return ret;
244
245 ret = i2c_generic_recovery(adap);
246 i2c_put_gpios_for_recovery(adap);
247
248 return ret;
249}
250
251int i2c_recover_bus(struct i2c_adapter *adap)
252{
253 if (!adap->bus_recovery_info)
254 return -EOPNOTSUPP;
255
256 dev_dbg(&adap->dev, "Trying i2c bus recovery\n");
257 return adap->bus_recovery_info->recover_bus(adap);
258}
259
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260static int i2c_device_probe(struct device *dev)
261{
Jean Delvare51298d12009-09-18 22:45:45 +0200262 struct i2c_client *client = i2c_verify_client(dev);
263 struct i2c_driver *driver;
Hans Verkuil50c33042008-03-12 14:15:00 +0100264 int status;
David Brownell7b4fbc52007-05-01 23:26:30 +0200265
Jean Delvare51298d12009-09-18 22:45:45 +0200266 if (!client)
267 return 0;
268
269 driver = to_i2c_driver(dev->driver);
Jean Delvaree0457442008-07-14 22:38:30 +0200270 if (!driver->probe || !driver->id_table)
David Brownell7b4fbc52007-05-01 23:26:30 +0200271 return -ENODEV;
Lars-Peter Clausen0acc2b32013-09-29 10:51:06 +0200272
Marc Pignatee354252008-08-28 08:33:22 +0200273 if (!device_can_wakeup(&client->dev))
274 device_init_wakeup(&client->dev,
275 client->flags & I2C_CLIENT_WAKE);
David Brownell7b4fbc52007-05-01 23:26:30 +0200276 dev_dbg(dev, "probe\n");
Jean Delvared2653e92008-04-29 23:11:39 +0200277
Sylwester Nawrocki86be4082014-06-18 17:29:32 +0200278 status = of_clk_set_defaults(dev->of_node, false);
279 if (status < 0)
280 return status;
281
Lv Zhenga76e9bd2013-10-10 13:28:47 +0300282 acpi_dev_pm_attach(&client->dev, true);
Jean Delvaree0457442008-07-14 22:38:30 +0200283 status = driver->probe(client, i2c_match_id(driver->id_table, client));
Wolfram Sang72fa8182014-01-21 17:48:34 +0100284 if (status)
Lv Zhenga76e9bd2013-10-10 13:28:47 +0300285 acpi_dev_pm_detach(&client->dev, true);
Wolfram Sang72fa8182014-01-21 17:48:34 +0100286
Hans Verkuil50c33042008-03-12 14:15:00 +0100287 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288}
289
290static int i2c_device_remove(struct device *dev)
291{
Jean Delvare51298d12009-09-18 22:45:45 +0200292 struct i2c_client *client = i2c_verify_client(dev);
David Brownella1d9e6e2007-05-01 23:26:30 +0200293 struct i2c_driver *driver;
Wolfram Sang72fa8182014-01-21 17:48:34 +0100294 int status = 0;
David Brownella1d9e6e2007-05-01 23:26:30 +0200295
Jean Delvare51298d12009-09-18 22:45:45 +0200296 if (!client || !dev->driver)
David Brownella1d9e6e2007-05-01 23:26:30 +0200297 return 0;
298
299 driver = to_i2c_driver(dev->driver);
300 if (driver->remove) {
301 dev_dbg(dev, "remove\n");
302 status = driver->remove(client);
David Brownella1d9e6e2007-05-01 23:26:30 +0200303 }
Wolfram Sang72fa8182014-01-21 17:48:34 +0100304
Lv Zhenga76e9bd2013-10-10 13:28:47 +0300305 acpi_dev_pm_detach(&client->dev, true);
David Brownella1d9e6e2007-05-01 23:26:30 +0200306 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307}
308
David Brownellf37dd802007-02-13 22:09:00 +0100309static void i2c_device_shutdown(struct device *dev)
310{
Jean Delvare51298d12009-09-18 22:45:45 +0200311 struct i2c_client *client = i2c_verify_client(dev);
David Brownellf37dd802007-02-13 22:09:00 +0100312 struct i2c_driver *driver;
313
Jean Delvare51298d12009-09-18 22:45:45 +0200314 if (!client || !dev->driver)
David Brownellf37dd802007-02-13 22:09:00 +0100315 return;
316 driver = to_i2c_driver(dev->driver);
317 if (driver->shutdown)
Jean Delvare51298d12009-09-18 22:45:45 +0200318 driver->shutdown(client);
David Brownellf37dd802007-02-13 22:09:00 +0100319}
320
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200321#ifdef CONFIG_PM_SLEEP
322static int i2c_legacy_suspend(struct device *dev, pm_message_t mesg)
David Brownellf37dd802007-02-13 22:09:00 +0100323{
Jean Delvare51298d12009-09-18 22:45:45 +0200324 struct i2c_client *client = i2c_verify_client(dev);
David Brownellf37dd802007-02-13 22:09:00 +0100325 struct i2c_driver *driver;
326
Jean Delvare51298d12009-09-18 22:45:45 +0200327 if (!client || !dev->driver)
David Brownellf37dd802007-02-13 22:09:00 +0100328 return 0;
329 driver = to_i2c_driver(dev->driver);
330 if (!driver->suspend)
331 return 0;
Jean Delvare51298d12009-09-18 22:45:45 +0200332 return driver->suspend(client, mesg);
David Brownellf37dd802007-02-13 22:09:00 +0100333}
334
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200335static int i2c_legacy_resume(struct device *dev)
David Brownellf37dd802007-02-13 22:09:00 +0100336{
Jean Delvare51298d12009-09-18 22:45:45 +0200337 struct i2c_client *client = i2c_verify_client(dev);
David Brownellf37dd802007-02-13 22:09:00 +0100338 struct i2c_driver *driver;
339
Jean Delvare51298d12009-09-18 22:45:45 +0200340 if (!client || !dev->driver)
David Brownellf37dd802007-02-13 22:09:00 +0100341 return 0;
342 driver = to_i2c_driver(dev->driver);
343 if (!driver->resume)
344 return 0;
Jean Delvare51298d12009-09-18 22:45:45 +0200345 return driver->resume(client);
David Brownellf37dd802007-02-13 22:09:00 +0100346}
347
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200348static int i2c_device_pm_suspend(struct device *dev)
349{
350 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
351
Mark Brownd529de22011-01-14 22:03:49 +0100352 if (pm)
353 return pm_generic_suspend(dev);
354 else
355 return i2c_legacy_suspend(dev, PMSG_SUSPEND);
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200356}
357
358static int i2c_device_pm_resume(struct device *dev)
359{
360 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200361
362 if (pm)
Mark Brownd529de22011-01-14 22:03:49 +0100363 return pm_generic_resume(dev);
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200364 else
Mark Brownd529de22011-01-14 22:03:49 +0100365 return i2c_legacy_resume(dev);
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200366}
367
368static int i2c_device_pm_freeze(struct device *dev)
369{
370 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
371
Mark Brownd529de22011-01-14 22:03:49 +0100372 if (pm)
373 return pm_generic_freeze(dev);
374 else
375 return i2c_legacy_suspend(dev, PMSG_FREEZE);
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200376}
377
378static int i2c_device_pm_thaw(struct device *dev)
379{
380 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
381
Mark Brownd529de22011-01-14 22:03:49 +0100382 if (pm)
383 return pm_generic_thaw(dev);
384 else
385 return i2c_legacy_resume(dev);
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200386}
387
388static int i2c_device_pm_poweroff(struct device *dev)
389{
390 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
391
Mark Brownd529de22011-01-14 22:03:49 +0100392 if (pm)
393 return pm_generic_poweroff(dev);
394 else
395 return i2c_legacy_suspend(dev, PMSG_HIBERNATE);
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200396}
397
398static int i2c_device_pm_restore(struct device *dev)
399{
400 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200401
402 if (pm)
Mark Brownd529de22011-01-14 22:03:49 +0100403 return pm_generic_restore(dev);
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200404 else
Mark Brownd529de22011-01-14 22:03:49 +0100405 return i2c_legacy_resume(dev);
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200406}
407#else /* !CONFIG_PM_SLEEP */
408#define i2c_device_pm_suspend NULL
409#define i2c_device_pm_resume NULL
410#define i2c_device_pm_freeze NULL
411#define i2c_device_pm_thaw NULL
412#define i2c_device_pm_poweroff NULL
413#define i2c_device_pm_restore NULL
414#endif /* !CONFIG_PM_SLEEP */
415
David Brownell9c1600e2007-05-01 23:26:31 +0200416static void i2c_client_dev_release(struct device *dev)
417{
418 kfree(to_i2c_client(dev));
419}
420
Zhenwen Xu09b8ce02009-03-28 21:34:46 +0100421static ssize_t
Jean Delvare4f8cf822009-09-18 22:45:46 +0200422show_name(struct device *dev, struct device_attribute *attr, char *buf)
David Brownell7b4fbc52007-05-01 23:26:30 +0200423{
Jean Delvare4f8cf822009-09-18 22:45:46 +0200424 return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
425 to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
David Brownell7b4fbc52007-05-01 23:26:30 +0200426}
427
Zhenwen Xu09b8ce02009-03-28 21:34:46 +0100428static ssize_t
429show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
David Brownell7b4fbc52007-05-01 23:26:30 +0200430{
431 struct i2c_client *client = to_i2c_client(dev);
Zhang Rui8c4ff6d2014-01-14 16:46:37 +0800432 int len;
433
434 len = acpi_device_modalias(dev, buf, PAGE_SIZE -1);
435 if (len != -ENODEV)
436 return len;
437
Jean Delvareeb8a7902008-05-18 20:49:41 +0200438 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
David Brownell7b4fbc52007-05-01 23:26:30 +0200439}
440
Jean Delvare4f8cf822009-09-18 22:45:46 +0200441static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
Jean Delvare51298d12009-09-18 22:45:45 +0200442static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
443
444static struct attribute *i2c_dev_attrs[] = {
445 &dev_attr_name.attr,
David Brownell7b4fbc52007-05-01 23:26:30 +0200446 /* modalias helps coldplug: modprobe $(cat .../modalias) */
Jean Delvare51298d12009-09-18 22:45:45 +0200447 &dev_attr_modalias.attr,
448 NULL
449};
450
451static struct attribute_group i2c_dev_attr_group = {
452 .attrs = i2c_dev_attrs,
453};
454
455static const struct attribute_group *i2c_dev_attr_groups[] = {
456 &i2c_dev_attr_group,
457 NULL
David Brownell7b4fbc52007-05-01 23:26:30 +0200458};
459
Tobias Klauser0b2c3682010-01-16 20:43:12 +0100460static const struct dev_pm_ops i2c_device_pm_ops = {
sonic zhang54067ee2009-12-14 21:17:30 +0100461 .suspend = i2c_device_pm_suspend,
462 .resume = i2c_device_pm_resume,
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200463 .freeze = i2c_device_pm_freeze,
464 .thaw = i2c_device_pm_thaw,
465 .poweroff = i2c_device_pm_poweroff,
466 .restore = i2c_device_pm_restore,
467 SET_RUNTIME_PM_OPS(
468 pm_generic_runtime_suspend,
469 pm_generic_runtime_resume,
Rafael J. Wysocki45f0a852013-06-03 21:49:52 +0200470 NULL
Rafael J. Wysocki2f60ba72010-05-10 23:09:30 +0200471 )
sonic zhang54067ee2009-12-14 21:17:30 +0100472};
473
Jon Smirle9ca9eb2008-07-14 22:38:35 +0200474struct bus_type i2c_bus_type = {
David Brownellf37dd802007-02-13 22:09:00 +0100475 .name = "i2c",
476 .match = i2c_device_match,
477 .probe = i2c_device_probe,
478 .remove = i2c_device_remove,
479 .shutdown = i2c_device_shutdown,
sonic zhang54067ee2009-12-14 21:17:30 +0100480 .pm = &i2c_device_pm_ops,
Russell Kingb864c7d2006-01-05 14:37:50 +0000481};
Jon Smirle9ca9eb2008-07-14 22:38:35 +0200482EXPORT_SYMBOL_GPL(i2c_bus_type);
Russell Kingb864c7d2006-01-05 14:37:50 +0000483
Jean Delvare51298d12009-09-18 22:45:45 +0200484static struct device_type i2c_client_type = {
485 .groups = i2c_dev_attr_groups,
486 .uevent = i2c_device_uevent,
487 .release = i2c_client_dev_release,
488};
489
David Brownell9b766b82008-01-27 18:14:51 +0100490
491/**
492 * i2c_verify_client - return parameter as i2c_client, or NULL
493 * @dev: device, probably from some driver model iterator
494 *
495 * When traversing the driver model tree, perhaps using driver model
496 * iterators like @device_for_each_child(), you can't assume very much
497 * about the nodes you find. Use this function to avoid oopses caused
498 * by wrongly treating some non-I2C device as an i2c_client.
499 */
500struct i2c_client *i2c_verify_client(struct device *dev)
501{
Jean Delvare51298d12009-09-18 22:45:45 +0200502 return (dev->type == &i2c_client_type)
David Brownell9b766b82008-01-27 18:14:51 +0100503 ? to_i2c_client(dev)
504 : NULL;
505}
506EXPORT_SYMBOL(i2c_verify_client);
507
508
Jean Delvare3a89db52010-06-03 11:33:52 +0200509/* This is a permissive address validity check, I2C address map constraints
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300510 * are purposely not enforced, except for the general call address. */
Jean Delvare3a89db52010-06-03 11:33:52 +0200511static int i2c_check_client_addr_validity(const struct i2c_client *client)
512{
513 if (client->flags & I2C_CLIENT_TEN) {
514 /* 10-bit address, all values are valid */
515 if (client->addr > 0x3ff)
516 return -EINVAL;
517 } else {
518 /* 7-bit address, reject the general call address */
519 if (client->addr == 0x00 || client->addr > 0x7f)
520 return -EINVAL;
521 }
522 return 0;
523}
524
Jean Delvare656b8762010-06-03 11:33:53 +0200525/* And this is a strict address validity check, used when probing. If a
526 * device uses a reserved address, then it shouldn't be probed. 7-bit
527 * addressing is assumed, 10-bit address devices are rare and should be
528 * explicitly enumerated. */
529static int i2c_check_addr_validity(unsigned short addr)
530{
531 /*
532 * Reserved addresses per I2C specification:
533 * 0x00 General call address / START byte
534 * 0x01 CBUS address
535 * 0x02 Reserved for different bus format
536 * 0x03 Reserved for future purposes
537 * 0x04-0x07 Hs-mode master code
538 * 0x78-0x7b 10-bit slave addressing
539 * 0x7c-0x7f Reserved for future purposes
540 */
541 if (addr < 0x08 || addr > 0x77)
542 return -EINVAL;
543 return 0;
544}
545
Jean Delvare3b5f7942010-06-03 11:33:55 +0200546static int __i2c_check_addr_busy(struct device *dev, void *addrp)
547{
548 struct i2c_client *client = i2c_verify_client(dev);
549 int addr = *(int *)addrp;
550
551 if (client && client->addr == addr)
552 return -EBUSY;
553 return 0;
554}
555
Michael Lawnick08263742010-08-11 18:21:02 +0200556/* walk up mux tree */
557static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
558{
Jean Delvare97cc4d42010-10-24 18:16:57 +0200559 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
Michael Lawnick08263742010-08-11 18:21:02 +0200560 int result;
561
562 result = device_for_each_child(&adapter->dev, &addr,
563 __i2c_check_addr_busy);
564
Jean Delvare97cc4d42010-10-24 18:16:57 +0200565 if (!result && parent)
566 result = i2c_check_mux_parents(parent, addr);
Michael Lawnick08263742010-08-11 18:21:02 +0200567
568 return result;
569}
570
571/* recurse down mux tree */
572static int i2c_check_mux_children(struct device *dev, void *addrp)
573{
574 int result;
575
576 if (dev->type == &i2c_adapter_type)
577 result = device_for_each_child(dev, addrp,
578 i2c_check_mux_children);
579 else
580 result = __i2c_check_addr_busy(dev, addrp);
581
582 return result;
583}
584
Jean Delvare3b5f7942010-06-03 11:33:55 +0200585static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
586{
Jean Delvare97cc4d42010-10-24 18:16:57 +0200587 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
Michael Lawnick08263742010-08-11 18:21:02 +0200588 int result = 0;
589
Jean Delvare97cc4d42010-10-24 18:16:57 +0200590 if (parent)
591 result = i2c_check_mux_parents(parent, addr);
Michael Lawnick08263742010-08-11 18:21:02 +0200592
593 if (!result)
594 result = device_for_each_child(&adapter->dev, &addr,
595 i2c_check_mux_children);
596
597 return result;
Jean Delvare3b5f7942010-06-03 11:33:55 +0200598}
599
David Brownell9c1600e2007-05-01 23:26:31 +0200600/**
Jean Delvarefe61e072010-08-11 18:20:58 +0200601 * i2c_lock_adapter - Get exclusive access to an I2C bus segment
602 * @adapter: Target I2C bus segment
603 */
604void i2c_lock_adapter(struct i2c_adapter *adapter)
605{
Jean Delvare97cc4d42010-10-24 18:16:57 +0200606 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
607
608 if (parent)
609 i2c_lock_adapter(parent);
Michael Lawnick08263742010-08-11 18:21:02 +0200610 else
611 rt_mutex_lock(&adapter->bus_lock);
Jean Delvarefe61e072010-08-11 18:20:58 +0200612}
613EXPORT_SYMBOL_GPL(i2c_lock_adapter);
614
615/**
616 * i2c_trylock_adapter - Try to get exclusive access to an I2C bus segment
617 * @adapter: Target I2C bus segment
618 */
619static int i2c_trylock_adapter(struct i2c_adapter *adapter)
620{
Jean Delvare97cc4d42010-10-24 18:16:57 +0200621 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
622
623 if (parent)
624 return i2c_trylock_adapter(parent);
Michael Lawnick08263742010-08-11 18:21:02 +0200625 else
626 return rt_mutex_trylock(&adapter->bus_lock);
Jean Delvarefe61e072010-08-11 18:20:58 +0200627}
628
629/**
630 * i2c_unlock_adapter - Release exclusive access to an I2C bus segment
631 * @adapter: Target I2C bus segment
632 */
633void i2c_unlock_adapter(struct i2c_adapter *adapter)
634{
Jean Delvare97cc4d42010-10-24 18:16:57 +0200635 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
636
637 if (parent)
638 i2c_unlock_adapter(parent);
Michael Lawnick08263742010-08-11 18:21:02 +0200639 else
640 rt_mutex_unlock(&adapter->bus_lock);
Jean Delvarefe61e072010-08-11 18:20:58 +0200641}
642EXPORT_SYMBOL_GPL(i2c_unlock_adapter);
643
Jarkko Nikula70762ab2013-11-14 14:03:52 +0200644static void i2c_dev_set_name(struct i2c_adapter *adap,
645 struct i2c_client *client)
646{
647 struct acpi_device *adev = ACPI_COMPANION(&client->dev);
648
649 if (adev) {
650 dev_set_name(&client->dev, "i2c-%s", acpi_dev_name(adev));
651 return;
652 }
653
654 /* For 10-bit clients, add an arbitrary offset to avoid collisions */
655 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
656 client->addr | ((client->flags & I2C_CLIENT_TEN)
657 ? 0xa000 : 0));
658}
659
Jean Delvarefe61e072010-08-11 18:20:58 +0200660/**
Jean Delvaref8a227e2009-06-19 16:58:18 +0200661 * i2c_new_device - instantiate an i2c device
David Brownell9c1600e2007-05-01 23:26:31 +0200662 * @adap: the adapter managing the device
663 * @info: describes one I2C device; bus_num is ignored
David Brownelld64f73b2007-07-12 14:12:28 +0200664 * Context: can sleep
David Brownell9c1600e2007-05-01 23:26:31 +0200665 *
Jean Delvaref8a227e2009-06-19 16:58:18 +0200666 * Create an i2c device. Binding is handled through driver model
667 * probe()/remove() methods. A driver may be bound to this device when we
668 * return from this function, or any later moment (e.g. maybe hotplugging will
669 * load the driver module). This call is not appropriate for use by mainboard
670 * initialization logic, which usually runs during an arch_initcall() long
671 * before any i2c_adapter could exist.
David Brownell9c1600e2007-05-01 23:26:31 +0200672 *
673 * This returns the new i2c client, which may be saved for later use with
674 * i2c_unregister_device(); or NULL to indicate an error.
675 */
676struct i2c_client *
677i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
678{
679 struct i2c_client *client;
680 int status;
681
682 client = kzalloc(sizeof *client, GFP_KERNEL);
683 if (!client)
684 return NULL;
685
686 client->adapter = adap;
687
688 client->dev.platform_data = info->platform_data;
David Brownell3bbb8352007-10-13 23:56:29 +0200689
Anton Vorontsov11f1f2a2008-10-22 20:21:33 +0200690 if (info->archdata)
691 client->dev.archdata = *info->archdata;
692
Marc Pignatee354252008-08-28 08:33:22 +0200693 client->flags = info->flags;
David Brownell9c1600e2007-05-01 23:26:31 +0200694 client->addr = info->addr;
695 client->irq = info->irq;
696
David Brownell9c1600e2007-05-01 23:26:31 +0200697 strlcpy(client->name, info->type, sizeof(client->name));
698
Jean Delvare3a89db52010-06-03 11:33:52 +0200699 /* Check for address validity */
700 status = i2c_check_client_addr_validity(client);
701 if (status) {
702 dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
703 client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
704 goto out_err_silent;
705 }
706
Jean Delvaref8a227e2009-06-19 16:58:18 +0200707 /* Check for address business */
Jean Delvare3b5f7942010-06-03 11:33:55 +0200708 status = i2c_check_addr_busy(adap, client->addr);
Jean Delvaref8a227e2009-06-19 16:58:18 +0200709 if (status)
710 goto out_err;
711
712 client->dev.parent = &client->adapter->dev;
713 client->dev.bus = &i2c_bus_type;
Jean Delvare51298d12009-09-18 22:45:45 +0200714 client->dev.type = &i2c_client_type;
Grant Likelyd12d42f2010-04-13 16:12:28 -0700715 client->dev.of_node = info->of_node;
Rafael J. Wysocki7b199812013-11-11 22:41:56 +0100716 ACPI_COMPANION_SET(&client->dev, info->acpi_node.companion);
Jean Delvaref8a227e2009-06-19 16:58:18 +0200717
Jarkko Nikula70762ab2013-11-14 14:03:52 +0200718 i2c_dev_set_name(adap, client);
Jean Delvaref8a227e2009-06-19 16:58:18 +0200719 status = device_register(&client->dev);
720 if (status)
721 goto out_err;
722
Jean Delvaref8a227e2009-06-19 16:58:18 +0200723 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
724 client->name, dev_name(&client->dev));
725
David Brownell9c1600e2007-05-01 23:26:31 +0200726 return client;
Jean Delvaref8a227e2009-06-19 16:58:18 +0200727
728out_err:
729 dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
730 "(%d)\n", client->name, client->addr, status);
Jean Delvare3a89db52010-06-03 11:33:52 +0200731out_err_silent:
Jean Delvaref8a227e2009-06-19 16:58:18 +0200732 kfree(client);
733 return NULL;
David Brownell9c1600e2007-05-01 23:26:31 +0200734}
735EXPORT_SYMBOL_GPL(i2c_new_device);
736
737
738/**
739 * i2c_unregister_device - reverse effect of i2c_new_device()
740 * @client: value returned from i2c_new_device()
David Brownelld64f73b2007-07-12 14:12:28 +0200741 * Context: can sleep
David Brownell9c1600e2007-05-01 23:26:31 +0200742 */
743void i2c_unregister_device(struct i2c_client *client)
David Brownella1d9e6e2007-05-01 23:26:30 +0200744{
David Brownella1d9e6e2007-05-01 23:26:30 +0200745 device_unregister(&client->dev);
746}
David Brownell9c1600e2007-05-01 23:26:31 +0200747EXPORT_SYMBOL_GPL(i2c_unregister_device);
David Brownella1d9e6e2007-05-01 23:26:30 +0200748
749
Jean Delvare60b129d2008-05-11 20:37:06 +0200750static const struct i2c_device_id dummy_id[] = {
751 { "dummy", 0 },
752 { },
753};
754
Jean Delvared2653e92008-04-29 23:11:39 +0200755static int dummy_probe(struct i2c_client *client,
756 const struct i2c_device_id *id)
757{
758 return 0;
759}
760
761static int dummy_remove(struct i2c_client *client)
David Brownelle9f13732008-01-27 18:14:52 +0100762{
763 return 0;
764}
765
766static struct i2c_driver dummy_driver = {
767 .driver.name = "dummy",
Jean Delvared2653e92008-04-29 23:11:39 +0200768 .probe = dummy_probe,
769 .remove = dummy_remove,
Jean Delvare60b129d2008-05-11 20:37:06 +0200770 .id_table = dummy_id,
David Brownelle9f13732008-01-27 18:14:52 +0100771};
772
773/**
774 * i2c_new_dummy - return a new i2c device bound to a dummy driver
775 * @adapter: the adapter managing the device
776 * @address: seven bit address to be used
David Brownelle9f13732008-01-27 18:14:52 +0100777 * Context: can sleep
778 *
779 * This returns an I2C client bound to the "dummy" driver, intended for use
780 * with devices that consume multiple addresses. Examples of such chips
781 * include various EEPROMS (like 24c04 and 24c08 models).
782 *
783 * These dummy devices have two main uses. First, most I2C and SMBus calls
784 * except i2c_transfer() need a client handle; the dummy will be that handle.
785 * And second, this prevents the specified address from being bound to a
786 * different driver.
787 *
788 * This returns the new i2c client, which should be saved for later use with
789 * i2c_unregister_device(); or NULL to indicate an error.
790 */
Zhenwen Xu09b8ce02009-03-28 21:34:46 +0100791struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
David Brownelle9f13732008-01-27 18:14:52 +0100792{
793 struct i2c_board_info info = {
Jean Delvare60b129d2008-05-11 20:37:06 +0200794 I2C_BOARD_INFO("dummy", address),
David Brownelle9f13732008-01-27 18:14:52 +0100795 };
796
David Brownelle9f13732008-01-27 18:14:52 +0100797 return i2c_new_device(adapter, &info);
798}
799EXPORT_SYMBOL_GPL(i2c_new_dummy);
800
David Brownellf37dd802007-02-13 22:09:00 +0100801/* ------------------------------------------------------------------------- */
802
David Brownell16ffadf2007-05-01 23:26:28 +0200803/* I2C bus adapters -- one roots each I2C or SMBUS segment */
804
Adrian Bunk83eaaed2007-10-13 23:56:30 +0200805static void i2c_adapter_dev_release(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806{
David Brownellef2c83212007-05-01 23:26:28 +0200807 struct i2c_adapter *adap = to_i2c_adapter(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 complete(&adap->dev_released);
809}
810
Jean Delvare99cd8e22009-06-19 16:58:20 +0200811/*
Jean Delvare390946b2012-09-10 10:14:02 +0200812 * This function is only needed for mutex_lock_nested, so it is never
813 * called unless locking correctness checking is enabled. Thus we
814 * make it inline to avoid a compiler warning. That's what gcc ends up
815 * doing anyway.
816 */
817static inline unsigned int i2c_adapter_depth(struct i2c_adapter *adapter)
818{
819 unsigned int depth = 0;
820
821 while ((adapter = i2c_parent_is_i2c_adapter(adapter)))
822 depth++;
823
824 return depth;
825}
826
827/*
Jean Delvare99cd8e22009-06-19 16:58:20 +0200828 * Let users instantiate I2C devices through sysfs. This can be used when
829 * platform initialization code doesn't contain the proper data for
830 * whatever reason. Also useful for drivers that do device detection and
831 * detection fails, either because the device uses an unexpected address,
832 * or this is a compatible device with different ID register values.
833 *
834 * Parameter checking may look overzealous, but we really don't want
835 * the user to provide incorrect parameters.
836 */
837static ssize_t
838i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
839 const char *buf, size_t count)
840{
841 struct i2c_adapter *adap = to_i2c_adapter(dev);
842 struct i2c_board_info info;
843 struct i2c_client *client;
844 char *blank, end;
845 int res;
846
Jean Delvare99cd8e22009-06-19 16:58:20 +0200847 memset(&info, 0, sizeof(struct i2c_board_info));
848
849 blank = strchr(buf, ' ');
850 if (!blank) {
851 dev_err(dev, "%s: Missing parameters\n", "new_device");
852 return -EINVAL;
853 }
854 if (blank - buf > I2C_NAME_SIZE - 1) {
855 dev_err(dev, "%s: Invalid device name\n", "new_device");
856 return -EINVAL;
857 }
858 memcpy(info.type, buf, blank - buf);
859
860 /* Parse remaining parameters, reject extra parameters */
861 res = sscanf(++blank, "%hi%c", &info.addr, &end);
862 if (res < 1) {
863 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
864 return -EINVAL;
865 }
866 if (res > 1 && end != '\n') {
867 dev_err(dev, "%s: Extra parameters\n", "new_device");
868 return -EINVAL;
869 }
870
Jean Delvare99cd8e22009-06-19 16:58:20 +0200871 client = i2c_new_device(adap, &info);
872 if (!client)
Jean Delvare3a89db52010-06-03 11:33:52 +0200873 return -EINVAL;
Jean Delvare99cd8e22009-06-19 16:58:20 +0200874
875 /* Keep track of the added device */
Jean Delvaredafc50d2010-08-11 18:21:01 +0200876 mutex_lock(&adap->userspace_clients_lock);
Jean Delvare6629dcf2010-05-04 11:09:28 +0200877 list_add_tail(&client->detected, &adap->userspace_clients);
Jean Delvaredafc50d2010-08-11 18:21:01 +0200878 mutex_unlock(&adap->userspace_clients_lock);
Jean Delvare99cd8e22009-06-19 16:58:20 +0200879 dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
880 info.type, info.addr);
881
882 return count;
883}
884
885/*
886 * And of course let the users delete the devices they instantiated, if
887 * they got it wrong. This interface can only be used to delete devices
888 * instantiated by i2c_sysfs_new_device above. This guarantees that we
889 * don't delete devices to which some kernel code still has references.
890 *
891 * Parameter checking may look overzealous, but we really don't want
892 * the user to delete the wrong device.
893 */
894static ssize_t
895i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
896 const char *buf, size_t count)
897{
898 struct i2c_adapter *adap = to_i2c_adapter(dev);
899 struct i2c_client *client, *next;
900 unsigned short addr;
901 char end;
902 int res;
903
904 /* Parse parameters, reject extra parameters */
905 res = sscanf(buf, "%hi%c", &addr, &end);
906 if (res < 1) {
907 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
908 return -EINVAL;
909 }
910 if (res > 1 && end != '\n') {
911 dev_err(dev, "%s: Extra parameters\n", "delete_device");
912 return -EINVAL;
913 }
914
915 /* Make sure the device was added through sysfs */
916 res = -ENOENT;
Jean Delvare390946b2012-09-10 10:14:02 +0200917 mutex_lock_nested(&adap->userspace_clients_lock,
918 i2c_adapter_depth(adap));
Jean Delvare6629dcf2010-05-04 11:09:28 +0200919 list_for_each_entry_safe(client, next, &adap->userspace_clients,
920 detected) {
921 if (client->addr == addr) {
Jean Delvare99cd8e22009-06-19 16:58:20 +0200922 dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
923 "delete_device", client->name, client->addr);
924
925 list_del(&client->detected);
926 i2c_unregister_device(client);
927 res = count;
928 break;
929 }
930 }
Jean Delvaredafc50d2010-08-11 18:21:01 +0200931 mutex_unlock(&adap->userspace_clients_lock);
Jean Delvare99cd8e22009-06-19 16:58:20 +0200932
933 if (res < 0)
934 dev_err(dev, "%s: Can't find device in list\n",
935 "delete_device");
936 return res;
937}
938
Jean Delvare4f8cf822009-09-18 22:45:46 +0200939static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
Alexander Sverdline9b526f2013-05-17 14:56:35 +0200940static DEVICE_ATTR_IGNORE_LOCKDEP(delete_device, S_IWUSR, NULL,
941 i2c_sysfs_delete_device);
Jean Delvare4f8cf822009-09-18 22:45:46 +0200942
943static struct attribute *i2c_adapter_attrs[] = {
944 &dev_attr_name.attr,
945 &dev_attr_new_device.attr,
946 &dev_attr_delete_device.attr,
947 NULL
David Brownell16ffadf2007-05-01 23:26:28 +0200948};
949
Jean Delvare4f8cf822009-09-18 22:45:46 +0200950static struct attribute_group i2c_adapter_attr_group = {
951 .attrs = i2c_adapter_attrs,
952};
953
954static const struct attribute_group *i2c_adapter_attr_groups[] = {
955 &i2c_adapter_attr_group,
956 NULL
957};
958
Michael Lawnick08263742010-08-11 18:21:02 +0200959struct device_type i2c_adapter_type = {
Jean Delvare4f8cf822009-09-18 22:45:46 +0200960 .groups = i2c_adapter_attr_groups,
961 .release = i2c_adapter_dev_release,
David Brownell16ffadf2007-05-01 23:26:28 +0200962};
Michael Lawnick08263742010-08-11 18:21:02 +0200963EXPORT_SYMBOL_GPL(i2c_adapter_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964
Stephen Warren643dd092012-04-17 12:43:33 -0600965/**
966 * i2c_verify_adapter - return parameter as i2c_adapter or NULL
967 * @dev: device, probably from some driver model iterator
968 *
969 * When traversing the driver model tree, perhaps using driver model
970 * iterators like @device_for_each_child(), you can't assume very much
971 * about the nodes you find. Use this function to avoid oopses caused
972 * by wrongly treating some non-I2C device as an i2c_adapter.
973 */
974struct i2c_adapter *i2c_verify_adapter(struct device *dev)
975{
976 return (dev->type == &i2c_adapter_type)
977 ? to_i2c_adapter(dev)
978 : NULL;
979}
980EXPORT_SYMBOL(i2c_verify_adapter);
981
Jean Delvare2bb50952009-09-18 22:45:46 +0200982#ifdef CONFIG_I2C_COMPAT
983static struct class_compat *i2c_adapter_compat_class;
984#endif
985
David Brownell9c1600e2007-05-01 23:26:31 +0200986static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
987{
988 struct i2c_devinfo *devinfo;
989
Rodolfo Giomettif18c41d2009-06-19 16:58:20 +0200990 down_read(&__i2c_board_lock);
David Brownell9c1600e2007-05-01 23:26:31 +0200991 list_for_each_entry(devinfo, &__i2c_board_list, list) {
992 if (devinfo->busnum == adapter->nr
993 && !i2c_new_device(adapter,
994 &devinfo->board_info))
Zhenwen Xu09b8ce02009-03-28 21:34:46 +0100995 dev_err(&adapter->dev,
996 "Can't create device at 0x%02x\n",
David Brownell9c1600e2007-05-01 23:26:31 +0200997 devinfo->board_info.addr);
998 }
Rodolfo Giomettif18c41d2009-06-19 16:58:20 +0200999 up_read(&__i2c_board_lock);
David Brownell9c1600e2007-05-01 23:26:31 +02001000}
1001
Wolfram Sang687b81d2013-07-11 12:56:15 +01001002/* OF support code */
1003
1004#if IS_ENABLED(CONFIG_OF)
1005static void of_i2c_register_devices(struct i2c_adapter *adap)
1006{
1007 void *result;
1008 struct device_node *node;
1009
1010 /* Only register child devices if the adapter has a node pointer set */
1011 if (!adap->dev.of_node)
1012 return;
1013
1014 dev_dbg(&adap->dev, "of_i2c: walking child nodes\n");
1015
1016 for_each_available_child_of_node(adap->dev.of_node, node) {
1017 struct i2c_board_info info = {};
1018 struct dev_archdata dev_ad = {};
1019 const __be32 *addr;
1020 int len;
1021
1022 dev_dbg(&adap->dev, "of_i2c: register %s\n", node->full_name);
1023
1024 if (of_modalias_node(node, info.type, sizeof(info.type)) < 0) {
1025 dev_err(&adap->dev, "of_i2c: modalias failure on %s\n",
1026 node->full_name);
1027 continue;
1028 }
1029
1030 addr = of_get_property(node, "reg", &len);
1031 if (!addr || (len < sizeof(int))) {
1032 dev_err(&adap->dev, "of_i2c: invalid reg on %s\n",
1033 node->full_name);
1034 continue;
1035 }
1036
1037 info.addr = be32_to_cpup(addr);
1038 if (info.addr > (1 << 10) - 1) {
1039 dev_err(&adap->dev, "of_i2c: invalid addr=%x on %s\n",
1040 info.addr, node->full_name);
1041 continue;
1042 }
1043
1044 info.irq = irq_of_parse_and_map(node, 0);
1045 info.of_node = of_node_get(node);
1046 info.archdata = &dev_ad;
1047
1048 if (of_get_property(node, "wakeup-source", NULL))
1049 info.flags |= I2C_CLIENT_WAKE;
1050
1051 request_module("%s%s", I2C_MODULE_PREFIX, info.type);
1052
1053 result = i2c_new_device(adap, &info);
1054 if (result == NULL) {
1055 dev_err(&adap->dev, "of_i2c: Failure registering %s\n",
1056 node->full_name);
1057 of_node_put(node);
1058 irq_dispose_mapping(info.irq);
1059 continue;
1060 }
1061 }
1062}
1063
1064static int of_dev_node_match(struct device *dev, void *data)
1065{
1066 return dev->of_node == data;
1067}
1068
1069/* must call put_device() when done with returned i2c_client device */
1070struct i2c_client *of_find_i2c_device_by_node(struct device_node *node)
1071{
1072 struct device *dev;
1073
1074 dev = bus_find_device(&i2c_bus_type, NULL, node,
1075 of_dev_node_match);
1076 if (!dev)
1077 return NULL;
1078
1079 return i2c_verify_client(dev);
1080}
1081EXPORT_SYMBOL(of_find_i2c_device_by_node);
1082
1083/* must call put_device() when done with returned i2c_adapter device */
1084struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node)
1085{
1086 struct device *dev;
1087
1088 dev = bus_find_device(&i2c_bus_type, NULL, node,
1089 of_dev_node_match);
1090 if (!dev)
1091 return NULL;
1092
1093 return i2c_verify_adapter(dev);
1094}
1095EXPORT_SYMBOL(of_find_i2c_adapter_by_node);
1096#else
1097static void of_i2c_register_devices(struct i2c_adapter *adap) { }
1098#endif /* CONFIG_OF */
1099
Jean Delvare69b00892009-12-06 17:06:27 +01001100static int i2c_do_add_adapter(struct i2c_driver *driver,
1101 struct i2c_adapter *adap)
Jean Delvare026526f2008-01-27 18:14:49 +01001102{
Jean Delvare4735c982008-07-14 22:38:36 +02001103 /* Detect supported devices on that bus, and instantiate them */
1104 i2c_detect(adap, driver);
1105
1106 /* Let legacy drivers scan this bus for matching devices */
Jean Delvare026526f2008-01-27 18:14:49 +01001107 if (driver->attach_adapter) {
Jean Delvarea920ff42011-04-17 10:20:19 +02001108 dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
1109 driver->driver.name);
Jean Delvarefe6fc252011-03-20 14:50:53 +01001110 dev_warn(&adap->dev, "Please use another way to instantiate "
1111 "your i2c_client\n");
Jean Delvare026526f2008-01-27 18:14:49 +01001112 /* We ignore the return code; if it fails, too bad */
1113 driver->attach_adapter(adap);
1114 }
1115 return 0;
1116}
1117
Jean Delvare69b00892009-12-06 17:06:27 +01001118static int __process_new_adapter(struct device_driver *d, void *data)
1119{
1120 return i2c_do_add_adapter(to_i2c_driver(d), data);
1121}
1122
David Brownell6e13e642007-05-01 23:26:31 +02001123static int i2c_register_adapter(struct i2c_adapter *adap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124{
Jean Delvared6703282010-08-11 18:20:59 +02001125 int res = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126
David Brownell1d0b19c2008-10-14 17:30:05 +02001127 /* Can't register until after driver model init */
Jean Delvare35fc37f2009-06-19 16:58:19 +02001128 if (unlikely(WARN_ON(!i2c_bus_type.p))) {
1129 res = -EAGAIN;
1130 goto out_list;
1131 }
David Brownell1d0b19c2008-10-14 17:30:05 +02001132
Jean Delvare2236baa2010-11-15 22:40:38 +01001133 /* Sanity checks */
1134 if (unlikely(adap->name[0] == '\0')) {
1135 pr_err("i2c-core: Attempt to register an adapter with "
1136 "no name!\n");
1137 return -EINVAL;
1138 }
1139 if (unlikely(!adap->algo)) {
1140 pr_err("i2c-core: Attempt to register adapter '%s' with "
1141 "no algo!\n", adap->name);
1142 return -EINVAL;
1143 }
1144
Mika Kuoppala194684e2009-12-06 17:06:22 +01001145 rt_mutex_init(&adap->bus_lock);
Jean Delvaredafc50d2010-08-11 18:21:01 +02001146 mutex_init(&adap->userspace_clients_lock);
Jean Delvare6629dcf2010-05-04 11:09:28 +02001147 INIT_LIST_HEAD(&adap->userspace_clients);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148
Jean Delvare8fcfef62009-03-28 21:34:43 +01001149 /* Set default timeout to 1 second if not already set */
1150 if (adap->timeout == 0)
1151 adap->timeout = HZ;
1152
Kay Sievers27d9c182009-01-07 14:29:16 +01001153 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
Jean Delvare4f8cf822009-09-18 22:45:46 +02001154 adap->dev.bus = &i2c_bus_type;
1155 adap->dev.type = &i2c_adapter_type;
Jean Delvareb119c6c2006-08-15 18:26:30 +02001156 res = device_register(&adap->dev);
1157 if (res)
1158 goto out_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159
Jean Delvareb6d7b3d2005-07-31 19:02:53 +02001160 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
1161
Jean Delvare2bb50952009-09-18 22:45:46 +02001162#ifdef CONFIG_I2C_COMPAT
1163 res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
1164 adap->dev.parent);
1165 if (res)
1166 dev_warn(&adap->dev,
1167 "Failed to create compatibility class link\n");
1168#endif
1169
Viresh Kumar5f9296b2012-02-28 18:26:31 +05301170 /* bus recovery specific initialization */
1171 if (adap->bus_recovery_info) {
1172 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
1173
1174 if (!bri->recover_bus) {
1175 dev_err(&adap->dev, "No recover_bus() found, not using recovery\n");
1176 adap->bus_recovery_info = NULL;
1177 goto exit_recovery;
1178 }
1179
1180 /* Generic GPIO recovery */
1181 if (bri->recover_bus == i2c_generic_gpio_recovery) {
1182 if (!gpio_is_valid(bri->scl_gpio)) {
1183 dev_err(&adap->dev, "Invalid SCL gpio, not using recovery\n");
1184 adap->bus_recovery_info = NULL;
1185 goto exit_recovery;
1186 }
1187
1188 if (gpio_is_valid(bri->sda_gpio))
1189 bri->get_sda = get_sda_gpio_value;
1190 else
1191 bri->get_sda = NULL;
1192
1193 bri->get_scl = get_scl_gpio_value;
1194 bri->set_scl = set_scl_gpio_value;
1195 } else if (!bri->set_scl || !bri->get_scl) {
1196 /* Generic SCL recovery */
1197 dev_err(&adap->dev, "No {get|set}_gpio() found, not using recovery\n");
1198 adap->bus_recovery_info = NULL;
1199 }
1200 }
1201
1202exit_recovery:
Jean Delvare729d6dd2009-06-19 16:58:18 +02001203 /* create pre-declared device nodes */
Wolfram Sang687b81d2013-07-11 12:56:15 +01001204 of_i2c_register_devices(adap);
Mika Westerberg55e71ed2013-08-21 17:28:23 +03001205 acpi_i2c_register_devices(adap);
Lan Tianyu5d98e612014-05-20 20:59:23 +08001206 acpi_i2c_install_space_handler(adap);
Wolfram Sang687b81d2013-07-11 12:56:15 +01001207
David Brownell6e13e642007-05-01 23:26:31 +02001208 if (adap->nr < __i2c_first_dynamic_bus_num)
1209 i2c_scan_static_board_info(adap);
1210
Jean Delvare4735c982008-07-14 22:38:36 +02001211 /* Notify drivers */
Jean Delvare35fc37f2009-06-19 16:58:19 +02001212 mutex_lock(&core_lock);
Jean Delvared6703282010-08-11 18:20:59 +02001213 bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
Jean Delvarecaada322008-01-27 18:14:49 +01001214 mutex_unlock(&core_lock);
Jean Delvare35fc37f2009-06-19 16:58:19 +02001215
1216 return 0;
Jean Delvareb119c6c2006-08-15 18:26:30 +02001217
Jean Delvareb119c6c2006-08-15 18:26:30 +02001218out_list:
Jean Delvare35fc37f2009-06-19 16:58:19 +02001219 mutex_lock(&core_lock);
Jean Delvareb119c6c2006-08-15 18:26:30 +02001220 idr_remove(&i2c_adapter_idr, adap->nr);
Jean Delvare35fc37f2009-06-19 16:58:19 +02001221 mutex_unlock(&core_lock);
1222 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223}
1224
David Brownell6e13e642007-05-01 23:26:31 +02001225/**
Doug Andersonee5c2742013-03-01 08:57:31 -08001226 * __i2c_add_numbered_adapter - i2c_add_numbered_adapter where nr is never -1
1227 * @adap: the adapter to register (with adap->nr initialized)
1228 * Context: can sleep
1229 *
1230 * See i2c_add_numbered_adapter() for details.
1231 */
1232static int __i2c_add_numbered_adapter(struct i2c_adapter *adap)
1233{
1234 int id;
1235
1236 mutex_lock(&core_lock);
1237 id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1,
1238 GFP_KERNEL);
1239 mutex_unlock(&core_lock);
1240 if (id < 0)
1241 return id == -ENOSPC ? -EBUSY : id;
1242
1243 return i2c_register_adapter(adap);
1244}
1245
1246/**
David Brownell6e13e642007-05-01 23:26:31 +02001247 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
1248 * @adapter: the adapter to add
David Brownelld64f73b2007-07-12 14:12:28 +02001249 * Context: can sleep
David Brownell6e13e642007-05-01 23:26:31 +02001250 *
1251 * This routine is used to declare an I2C adapter when its bus number
Doug Andersonee5c2742013-03-01 08:57:31 -08001252 * doesn't matter or when its bus number is specified by an dt alias.
1253 * Examples of bases when the bus number doesn't matter: I2C adapters
1254 * dynamically added by USB links or PCI plugin cards.
David Brownell6e13e642007-05-01 23:26:31 +02001255 *
1256 * When this returns zero, a new bus number was allocated and stored
1257 * in adap->nr, and the specified adapter became available for clients.
1258 * Otherwise, a negative errno value is returned.
1259 */
1260int i2c_add_adapter(struct i2c_adapter *adapter)
1261{
Doug Andersonee5c2742013-03-01 08:57:31 -08001262 struct device *dev = &adapter->dev;
Tejun Heo4ae42b02013-02-27 17:04:15 -08001263 int id;
David Brownell6e13e642007-05-01 23:26:31 +02001264
Doug Andersonee5c2742013-03-01 08:57:31 -08001265 if (dev->of_node) {
1266 id = of_alias_get_id(dev->of_node, "i2c");
1267 if (id >= 0) {
1268 adapter->nr = id;
1269 return __i2c_add_numbered_adapter(adapter);
1270 }
1271 }
1272
Jean Delvarecaada322008-01-27 18:14:49 +01001273 mutex_lock(&core_lock);
Tejun Heo4ae42b02013-02-27 17:04:15 -08001274 id = idr_alloc(&i2c_adapter_idr, adapter,
1275 __i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
Jean Delvarecaada322008-01-27 18:14:49 +01001276 mutex_unlock(&core_lock);
Tejun Heo4ae42b02013-02-27 17:04:15 -08001277 if (id < 0)
1278 return id;
David Brownell6e13e642007-05-01 23:26:31 +02001279
1280 adapter->nr = id;
Tejun Heo4ae42b02013-02-27 17:04:15 -08001281
David Brownell6e13e642007-05-01 23:26:31 +02001282 return i2c_register_adapter(adapter);
1283}
1284EXPORT_SYMBOL(i2c_add_adapter);
1285
1286/**
1287 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
1288 * @adap: the adapter to register (with adap->nr initialized)
David Brownelld64f73b2007-07-12 14:12:28 +02001289 * Context: can sleep
David Brownell6e13e642007-05-01 23:26:31 +02001290 *
1291 * This routine is used to declare an I2C adapter when its bus number
Randy Dunlap8c07e462008-03-23 20:28:20 +01001292 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
1293 * or otherwise built in to the system's mainboard, and where i2c_board_info
David Brownell6e13e642007-05-01 23:26:31 +02001294 * is used to properly configure I2C devices.
1295 *
Grant Likely488bf312011-07-25 17:49:43 +02001296 * If the requested bus number is set to -1, then this function will behave
1297 * identically to i2c_add_adapter, and will dynamically assign a bus number.
1298 *
David Brownell6e13e642007-05-01 23:26:31 +02001299 * If no devices have pre-been declared for this bus, then be sure to
1300 * register the adapter before any dynamically allocated ones. Otherwise
1301 * the required bus ID may not be available.
1302 *
1303 * When this returns zero, the specified adapter became available for
1304 * clients using the bus number provided in adap->nr. Also, the table
1305 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
1306 * and the appropriate driver model device nodes are created. Otherwise, a
1307 * negative errno value is returned.
1308 */
1309int i2c_add_numbered_adapter(struct i2c_adapter *adap)
1310{
Grant Likely488bf312011-07-25 17:49:43 +02001311 if (adap->nr == -1) /* -1 means dynamically assign bus id */
1312 return i2c_add_adapter(adap);
David Brownell6e13e642007-05-01 23:26:31 +02001313
Doug Andersonee5c2742013-03-01 08:57:31 -08001314 return __i2c_add_numbered_adapter(adap);
David Brownell6e13e642007-05-01 23:26:31 +02001315}
1316EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
1317
Lars-Peter Clausen19baba42013-03-09 08:16:44 +00001318static void i2c_do_del_adapter(struct i2c_driver *driver,
Jean Delvare69b00892009-12-06 17:06:27 +01001319 struct i2c_adapter *adapter)
Jean Delvare026526f2008-01-27 18:14:49 +01001320{
Jean Delvare4735c982008-07-14 22:38:36 +02001321 struct i2c_client *client, *_n;
Jean Delvare026526f2008-01-27 18:14:49 +01001322
Jean Delvareacec2112009-03-28 21:34:40 +01001323 /* Remove the devices we created ourselves as the result of hardware
1324 * probing (using a driver's detect method) */
Jean Delvare4735c982008-07-14 22:38:36 +02001325 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
1326 if (client->adapter == adapter) {
1327 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
1328 client->name, client->addr);
1329 list_del(&client->detected);
1330 i2c_unregister_device(client);
1331 }
1332 }
Jean Delvare026526f2008-01-27 18:14:49 +01001333}
1334
Jean Delvaree549c2b2009-06-19 16:58:19 +02001335static int __unregister_client(struct device *dev, void *dummy)
1336{
1337 struct i2c_client *client = i2c_verify_client(dev);
Jean Delvare5219bf82011-01-14 22:03:49 +01001338 if (client && strcmp(client->name, "dummy"))
1339 i2c_unregister_device(client);
1340 return 0;
1341}
1342
1343static int __unregister_dummy(struct device *dev, void *dummy)
1344{
1345 struct i2c_client *client = i2c_verify_client(dev);
Jean Delvaree549c2b2009-06-19 16:58:19 +02001346 if (client)
1347 i2c_unregister_device(client);
1348 return 0;
1349}
1350
Jean Delvare69b00892009-12-06 17:06:27 +01001351static int __process_removed_adapter(struct device_driver *d, void *data)
1352{
Lars-Peter Clausen19baba42013-03-09 08:16:44 +00001353 i2c_do_del_adapter(to_i2c_driver(d), data);
1354 return 0;
Jean Delvare69b00892009-12-06 17:06:27 +01001355}
1356
David Brownelld64f73b2007-07-12 14:12:28 +02001357/**
1358 * i2c_del_adapter - unregister I2C adapter
1359 * @adap: the adapter being unregistered
1360 * Context: can sleep
1361 *
1362 * This unregisters an I2C adapter which was previously registered
1363 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
1364 */
Lars-Peter Clausen71546302013-03-09 08:16:47 +00001365void i2c_del_adapter(struct i2c_adapter *adap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366{
Jean Delvare35fc37f2009-06-19 16:58:19 +02001367 struct i2c_adapter *found;
Jean Delvarebbd2d9c2009-11-26 09:22:33 +01001368 struct i2c_client *client, *next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369
1370 /* First make sure that this adapter was ever added */
Jean Delvare35fc37f2009-06-19 16:58:19 +02001371 mutex_lock(&core_lock);
1372 found = idr_find(&i2c_adapter_idr, adap->nr);
1373 mutex_unlock(&core_lock);
1374 if (found != adap) {
Jean Delvareb6d7b3d2005-07-31 19:02:53 +02001375 pr_debug("i2c-core: attempting to delete unregistered "
1376 "adapter [%s]\n", adap->name);
Lars-Peter Clausen71546302013-03-09 08:16:47 +00001377 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378 }
1379
Lan Tianyu5d98e612014-05-20 20:59:23 +08001380 acpi_i2c_remove_space_handler(adap);
Jean Delvare026526f2008-01-27 18:14:49 +01001381 /* Tell drivers about this removal */
Jean Delvare35fc37f2009-06-19 16:58:19 +02001382 mutex_lock(&core_lock);
Lars-Peter Clausen19baba42013-03-09 08:16:44 +00001383 bus_for_each_drv(&i2c_bus_type, NULL, adap,
Jean Delvare69b00892009-12-06 17:06:27 +01001384 __process_removed_adapter);
Jean Delvare35fc37f2009-06-19 16:58:19 +02001385 mutex_unlock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386
Jean Delvarebbd2d9c2009-11-26 09:22:33 +01001387 /* Remove devices instantiated from sysfs */
Jean Delvare390946b2012-09-10 10:14:02 +02001388 mutex_lock_nested(&adap->userspace_clients_lock,
1389 i2c_adapter_depth(adap));
Jean Delvare6629dcf2010-05-04 11:09:28 +02001390 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1391 detected) {
1392 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
1393 client->addr);
1394 list_del(&client->detected);
1395 i2c_unregister_device(client);
Jean Delvarebbd2d9c2009-11-26 09:22:33 +01001396 }
Jean Delvaredafc50d2010-08-11 18:21:01 +02001397 mutex_unlock(&adap->userspace_clients_lock);
Jean Delvarebbd2d9c2009-11-26 09:22:33 +01001398
Jean Delvaree549c2b2009-06-19 16:58:19 +02001399 /* Detach any active clients. This can't fail, thus we do not
Jean Delvare5219bf82011-01-14 22:03:49 +01001400 * check the returned value. This is a two-pass process, because
1401 * we can't remove the dummy devices during the first pass: they
1402 * could have been instantiated by real devices wishing to clean
1403 * them up properly, so we give them a chance to do that first. */
Lars-Peter Clausen19baba42013-03-09 08:16:44 +00001404 device_for_each_child(&adap->dev, NULL, __unregister_client);
1405 device_for_each_child(&adap->dev, NULL, __unregister_dummy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406
Jean Delvare2bb50952009-09-18 22:45:46 +02001407#ifdef CONFIG_I2C_COMPAT
1408 class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
1409 adap->dev.parent);
1410#endif
1411
Thadeu Lima de Souza Cascardoc5567522010-01-16 20:43:13 +01001412 /* device name is gone after device_unregister */
1413 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
1414
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415 /* clean up the sysfs representation */
1416 init_completion(&adap->dev_released);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417 device_unregister(&adap->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418
1419 /* wait for sysfs to drop all references */
1420 wait_for_completion(&adap->dev_released);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421
David Brownell6e13e642007-05-01 23:26:31 +02001422 /* free bus id */
Jean Delvare35fc37f2009-06-19 16:58:19 +02001423 mutex_lock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424 idr_remove(&i2c_adapter_idr, adap->nr);
Jean Delvare35fc37f2009-06-19 16:58:19 +02001425 mutex_unlock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426
Jean Delvarebd4bc3db2008-07-16 19:30:05 +02001427 /* Clear the device structure in case this adapter is ever going to be
1428 added again */
1429 memset(&adap->dev, 0, sizeof(adap->dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430}
David Brownellc0564602007-05-01 23:26:31 +02001431EXPORT_SYMBOL(i2c_del_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432
David Brownell7b4fbc52007-05-01 23:26:30 +02001433/* ------------------------------------------------------------------------- */
1434
Jean Delvare7ae31482011-03-20 14:50:52 +01001435int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
1436{
1437 int res;
1438
1439 mutex_lock(&core_lock);
1440 res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
1441 mutex_unlock(&core_lock);
1442
1443 return res;
1444}
1445EXPORT_SYMBOL_GPL(i2c_for_each_dev);
1446
Jean Delvare69b00892009-12-06 17:06:27 +01001447static int __process_new_driver(struct device *dev, void *data)
Dave Young7f101a92008-07-14 22:38:19 +02001448{
Jean Delvare4f8cf822009-09-18 22:45:46 +02001449 if (dev->type != &i2c_adapter_type)
1450 return 0;
Jean Delvare69b00892009-12-06 17:06:27 +01001451 return i2c_do_add_adapter(data, to_i2c_adapter(dev));
Dave Young7f101a92008-07-14 22:38:19 +02001452}
1453
David Brownell7b4fbc52007-05-01 23:26:30 +02001454/*
1455 * An i2c_driver is used with one or more i2c_client (device) nodes to access
Jean Delvare729d6dd2009-06-19 16:58:18 +02001456 * i2c slave chips, on a bus instance associated with some i2c_adapter.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 */
1458
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -08001459int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460{
Jean Delvare7eebcb72006-02-05 23:28:21 +01001461 int res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462
David Brownell1d0b19c2008-10-14 17:30:05 +02001463 /* Can't register until after driver model init */
1464 if (unlikely(WARN_ON(!i2c_bus_type.p)))
1465 return -EAGAIN;
1466
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467 /* add the driver to the list of i2c drivers in the driver core */
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -08001468 driver->driver.owner = owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469 driver->driver.bus = &i2c_bus_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470
Jean Delvare729d6dd2009-06-19 16:58:18 +02001471 /* When registration returns, the driver core
David Brownell6e13e642007-05-01 23:26:31 +02001472 * will have called probe() for all matching-but-unbound devices.
1473 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 res = driver_register(&driver->driver);
1475 if (res)
Jean Delvare7eebcb72006-02-05 23:28:21 +01001476 return res;
David Brownell438d6c22006-12-10 21:21:31 +01001477
Mark Brownf4e8db32011-01-14 22:03:50 +01001478 /* Drivers should switch to dev_pm_ops instead. */
1479 if (driver->suspend)
1480 pr_warn("i2c-core: driver [%s] using legacy suspend method\n",
1481 driver->driver.name);
1482 if (driver->resume)
1483 pr_warn("i2c-core: driver [%s] using legacy resume method\n",
1484 driver->driver.name);
1485
Laurent Riffard35d8b2e2005-11-26 20:34:05 +01001486 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487
Jean Delvare4735c982008-07-14 22:38:36 +02001488 INIT_LIST_HEAD(&driver->clients);
1489 /* Walk the adapters that are already present */
Jean Delvare7ae31482011-03-20 14:50:52 +01001490 i2c_for_each_dev(driver, __process_new_driver);
Jean Delvare35fc37f2009-06-19 16:58:19 +02001491
Jean Delvare7eebcb72006-02-05 23:28:21 +01001492 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493}
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -08001494EXPORT_SYMBOL(i2c_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495
Jean Delvare69b00892009-12-06 17:06:27 +01001496static int __process_removed_driver(struct device *dev, void *data)
Dave Young7f101a92008-07-14 22:38:19 +02001497{
Lars-Peter Clausen19baba42013-03-09 08:16:44 +00001498 if (dev->type == &i2c_adapter_type)
1499 i2c_do_del_adapter(data, to_i2c_adapter(dev));
1500 return 0;
Dave Young7f101a92008-07-14 22:38:19 +02001501}
1502
David Brownella1d9e6e2007-05-01 23:26:30 +02001503/**
1504 * i2c_del_driver - unregister I2C driver
1505 * @driver: the driver being unregistered
David Brownelld64f73b2007-07-12 14:12:28 +02001506 * Context: can sleep
David Brownella1d9e6e2007-05-01 23:26:30 +02001507 */
Jean Delvareb3e82092007-05-01 23:26:32 +02001508void i2c_del_driver(struct i2c_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509{
Jean Delvare7ae31482011-03-20 14:50:52 +01001510 i2c_for_each_dev(driver, __process_removed_driver);
David Brownella1d9e6e2007-05-01 23:26:30 +02001511
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512 driver_unregister(&driver->driver);
Laurent Riffard35d8b2e2005-11-26 20:34:05 +01001513 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514}
David Brownellc0564602007-05-01 23:26:31 +02001515EXPORT_SYMBOL(i2c_del_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516
David Brownell7b4fbc52007-05-01 23:26:30 +02001517/* ------------------------------------------------------------------------- */
1518
Jean Delvaree48d3312008-01-27 18:14:48 +01001519/**
1520 * i2c_use_client - increments the reference count of the i2c client structure
1521 * @client: the client being referenced
1522 *
1523 * Each live reference to a client should be refcounted. The driver model does
1524 * that automatically as part of driver binding, so that most drivers don't
1525 * need to do this explicitly: they hold a reference until they're unbound
1526 * from the device.
1527 *
1528 * A pointer to the client with the incremented reference counter is returned.
1529 */
1530struct i2c_client *i2c_use_client(struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531{
David Brownell6ea438e2008-07-14 22:38:24 +02001532 if (client && get_device(&client->dev))
1533 return client;
1534 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535}
David Brownellc0564602007-05-01 23:26:31 +02001536EXPORT_SYMBOL(i2c_use_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537
Jean Delvaree48d3312008-01-27 18:14:48 +01001538/**
1539 * i2c_release_client - release a use of the i2c client structure
1540 * @client: the client being no longer referenced
1541 *
1542 * Must be called when a user of a client is finished with it.
1543 */
1544void i2c_release_client(struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545{
David Brownell6ea438e2008-07-14 22:38:24 +02001546 if (client)
1547 put_device(&client->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001548}
David Brownellc0564602007-05-01 23:26:31 +02001549EXPORT_SYMBOL(i2c_release_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550
David Brownell9b766b82008-01-27 18:14:51 +01001551struct i2c_cmd_arg {
1552 unsigned cmd;
1553 void *arg;
1554};
1555
1556static int i2c_cmd(struct device *dev, void *_arg)
1557{
1558 struct i2c_client *client = i2c_verify_client(dev);
1559 struct i2c_cmd_arg *arg = _arg;
Lars-Peter Clausen0acc2b32013-09-29 10:51:06 +02001560 struct i2c_driver *driver;
David Brownell9b766b82008-01-27 18:14:51 +01001561
Lars-Peter Clausen0acc2b32013-09-29 10:51:06 +02001562 if (!client || !client->dev.driver)
1563 return 0;
1564
1565 driver = to_i2c_driver(client->dev.driver);
1566 if (driver->command)
1567 driver->command(client, arg->cmd, arg->arg);
David Brownell9b766b82008-01-27 18:14:51 +01001568 return 0;
1569}
1570
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
1572{
David Brownell9b766b82008-01-27 18:14:51 +01001573 struct i2c_cmd_arg cmd_arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574
David Brownell9b766b82008-01-27 18:14:51 +01001575 cmd_arg.cmd = cmd;
1576 cmd_arg.arg = arg;
1577 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578}
David Brownellc0564602007-05-01 23:26:31 +02001579EXPORT_SYMBOL(i2c_clients_command);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580
1581static int __init i2c_init(void)
1582{
1583 int retval;
1584
1585 retval = bus_register(&i2c_bus_type);
1586 if (retval)
1587 return retval;
Jean Delvare2bb50952009-09-18 22:45:46 +02001588#ifdef CONFIG_I2C_COMPAT
1589 i2c_adapter_compat_class = class_compat_register("i2c-adapter");
1590 if (!i2c_adapter_compat_class) {
1591 retval = -ENOMEM;
1592 goto bus_err;
1593 }
1594#endif
David Brownelle9f13732008-01-27 18:14:52 +01001595 retval = i2c_add_driver(&dummy_driver);
1596 if (retval)
Jean Delvare2bb50952009-09-18 22:45:46 +02001597 goto class_err;
David Brownelle9f13732008-01-27 18:14:52 +01001598 return 0;
1599
Jean Delvare2bb50952009-09-18 22:45:46 +02001600class_err:
1601#ifdef CONFIG_I2C_COMPAT
1602 class_compat_unregister(i2c_adapter_compat_class);
David Brownelle9f13732008-01-27 18:14:52 +01001603bus_err:
Jean Delvare2bb50952009-09-18 22:45:46 +02001604#endif
David Brownelle9f13732008-01-27 18:14:52 +01001605 bus_unregister(&i2c_bus_type);
1606 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607}
1608
1609static void __exit i2c_exit(void)
1610{
David Brownelle9f13732008-01-27 18:14:52 +01001611 i2c_del_driver(&dummy_driver);
Jean Delvare2bb50952009-09-18 22:45:46 +02001612#ifdef CONFIG_I2C_COMPAT
1613 class_compat_unregister(i2c_adapter_compat_class);
1614#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615 bus_unregister(&i2c_bus_type);
David Howellsd9a83d62014-03-06 13:35:59 +00001616 tracepoint_synchronize_unregister();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617}
1618
David Brownella10f9e72008-10-14 17:30:06 +02001619/* We must initialize early, because some subsystems register i2c drivers
1620 * in subsys_initcall() code, but are linked (and initialized) before i2c.
1621 */
1622postcore_initcall(i2c_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623module_exit(i2c_exit);
1624
1625/* ----------------------------------------------------
1626 * the functional interface to the i2c busses.
1627 * ----------------------------------------------------
1628 */
1629
David Brownella1cdeda2008-07-14 22:38:24 +02001630/**
Jean Delvareb37d2a32012-06-29 07:47:19 -03001631 * __i2c_transfer - unlocked flavor of i2c_transfer
1632 * @adap: Handle to I2C bus
1633 * @msgs: One or more messages to execute before STOP is issued to
1634 * terminate the operation; each message begins with a START.
1635 * @num: Number of messages to be executed.
1636 *
1637 * Returns negative errno, else the number of messages executed.
1638 *
1639 * Adapter lock must be held when calling this function. No debug logging
1640 * takes place. adap->algo->master_xfer existence isn't checked.
1641 */
1642int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
1643{
1644 unsigned long orig_jiffies;
1645 int ret, try;
1646
David Howellsd9a83d62014-03-06 13:35:59 +00001647 /* i2c_trace_msg gets enabled when tracepoint i2c_transfer gets
1648 * enabled. This is an efficient way of keeping the for-loop from
1649 * being executed when not needed.
1650 */
1651 if (static_key_false(&i2c_trace_msg)) {
1652 int i;
1653 for (i = 0; i < num; i++)
1654 if (msgs[i].flags & I2C_M_RD)
1655 trace_i2c_read(adap, &msgs[i], i);
1656 else
1657 trace_i2c_write(adap, &msgs[i], i);
1658 }
1659
Jean Delvareb37d2a32012-06-29 07:47:19 -03001660 /* Retry automatically on arbitration loss */
1661 orig_jiffies = jiffies;
1662 for (ret = 0, try = 0; try <= adap->retries; try++) {
1663 ret = adap->algo->master_xfer(adap, msgs, num);
1664 if (ret != -EAGAIN)
1665 break;
1666 if (time_after(jiffies, orig_jiffies + adap->timeout))
1667 break;
1668 }
1669
David Howellsd9a83d62014-03-06 13:35:59 +00001670 if (static_key_false(&i2c_trace_msg)) {
1671 int i;
1672 for (i = 0; i < ret; i++)
1673 if (msgs[i].flags & I2C_M_RD)
1674 trace_i2c_reply(adap, &msgs[i], i);
1675 trace_i2c_result(adap, i, ret);
1676 }
1677
Jean Delvareb37d2a32012-06-29 07:47:19 -03001678 return ret;
1679}
1680EXPORT_SYMBOL(__i2c_transfer);
1681
1682/**
David Brownella1cdeda2008-07-14 22:38:24 +02001683 * i2c_transfer - execute a single or combined I2C message
1684 * @adap: Handle to I2C bus
1685 * @msgs: One or more messages to execute before STOP is issued to
1686 * terminate the operation; each message begins with a START.
1687 * @num: Number of messages to be executed.
1688 *
1689 * Returns negative errno, else the number of messages executed.
1690 *
1691 * Note that there is no requirement that each message be sent to
1692 * the same slave address, although that is the most common model.
1693 */
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01001694int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695{
Jean Delvareb37d2a32012-06-29 07:47:19 -03001696 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697
David Brownella1cdeda2008-07-14 22:38:24 +02001698 /* REVISIT the fault reporting model here is weak:
1699 *
1700 * - When we get an error after receiving N bytes from a slave,
1701 * there is no way to report "N".
1702 *
1703 * - When we get a NAK after transmitting N bytes to a slave,
1704 * there is no way to report "N" ... or to let the master
1705 * continue executing the rest of this combined message, if
1706 * that's the appropriate response.
1707 *
1708 * - When for example "num" is two and we successfully complete
1709 * the first message but get an error part way through the
1710 * second, it's unclear whether that should be reported as
1711 * one (discarding status on the second message) or errno
1712 * (discarding status on the first one).
1713 */
1714
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715 if (adap->algo->master_xfer) {
1716#ifdef DEBUG
1717 for (ret = 0; ret < num; ret++) {
1718 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
Jean Delvare209d27c2007-05-01 23:26:29 +02001719 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
1720 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
1721 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722 }
1723#endif
1724
Mike Rapoportcea443a82008-01-27 18:14:50 +01001725 if (in_atomic() || irqs_disabled()) {
Jean Delvarefe61e072010-08-11 18:20:58 +02001726 ret = i2c_trylock_adapter(adap);
Mike Rapoportcea443a82008-01-27 18:14:50 +01001727 if (!ret)
1728 /* I2C activity is ongoing. */
1729 return -EAGAIN;
1730 } else {
Jean Delvarefe61e072010-08-11 18:20:58 +02001731 i2c_lock_adapter(adap);
Mike Rapoportcea443a82008-01-27 18:14:50 +01001732 }
1733
Jean Delvareb37d2a32012-06-29 07:47:19 -03001734 ret = __i2c_transfer(adap, msgs, num);
Jean Delvarefe61e072010-08-11 18:20:58 +02001735 i2c_unlock_adapter(adap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736
1737 return ret;
1738 } else {
1739 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
David Brownell24a5bb72008-07-14 22:38:23 +02001740 return -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741 }
1742}
David Brownellc0564602007-05-01 23:26:31 +02001743EXPORT_SYMBOL(i2c_transfer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744
David Brownella1cdeda2008-07-14 22:38:24 +02001745/**
1746 * i2c_master_send - issue a single I2C message in master transmit mode
1747 * @client: Handle to slave device
1748 * @buf: Data that will be written to the slave
Zhangfei Gao0c43ea52010-03-02 12:23:49 +01001749 * @count: How many bytes to write, must be less than 64k since msg.len is u16
David Brownella1cdeda2008-07-14 22:38:24 +02001750 *
1751 * Returns negative errno, or else the number of bytes written.
1752 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01001753int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754{
1755 int ret;
Farid Hammane7225acf2010-05-21 18:40:58 +02001756 struct i2c_adapter *adap = client->adapter;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 struct i2c_msg msg;
1758
Jean Delvare815f55f2005-05-07 22:58:46 +02001759 msg.addr = client->addr;
1760 msg.flags = client->flags & I2C_M_TEN;
1761 msg.len = count;
1762 msg.buf = (char *)buf;
David Brownell438d6c22006-12-10 21:21:31 +01001763
Jean Delvare815f55f2005-05-07 22:58:46 +02001764 ret = i2c_transfer(adap, &msg, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765
Wolfram Sang834aa6f2012-03-15 18:11:05 +01001766 /*
1767 * If everything went ok (i.e. 1 msg transmitted), return #bytes
1768 * transmitted, else error code.
1769 */
Jean Delvare815f55f2005-05-07 22:58:46 +02001770 return (ret == 1) ? count : ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771}
David Brownellc0564602007-05-01 23:26:31 +02001772EXPORT_SYMBOL(i2c_master_send);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773
David Brownella1cdeda2008-07-14 22:38:24 +02001774/**
1775 * i2c_master_recv - issue a single I2C message in master receive mode
1776 * @client: Handle to slave device
1777 * @buf: Where to store data read from slave
Zhangfei Gao0c43ea52010-03-02 12:23:49 +01001778 * @count: How many bytes to read, must be less than 64k since msg.len is u16
David Brownella1cdeda2008-07-14 22:38:24 +02001779 *
1780 * Returns negative errno, or else the number of bytes read.
1781 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01001782int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783{
Farid Hammane7225acf2010-05-21 18:40:58 +02001784 struct i2c_adapter *adap = client->adapter;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785 struct i2c_msg msg;
1786 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001787
Jean Delvare815f55f2005-05-07 22:58:46 +02001788 msg.addr = client->addr;
1789 msg.flags = client->flags & I2C_M_TEN;
1790 msg.flags |= I2C_M_RD;
1791 msg.len = count;
1792 msg.buf = buf;
1793
1794 ret = i2c_transfer(adap, &msg, 1);
1795
Wolfram Sang834aa6f2012-03-15 18:11:05 +01001796 /*
1797 * If everything went ok (i.e. 1 msg received), return #bytes received,
1798 * else error code.
1799 */
Jean Delvare815f55f2005-05-07 22:58:46 +02001800 return (ret == 1) ? count : ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801}
David Brownellc0564602007-05-01 23:26:31 +02001802EXPORT_SYMBOL(i2c_master_recv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001803
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804/* ----------------------------------------------------
1805 * the i2c address scanning function
1806 * Will not work for 10-bit addresses!
1807 * ----------------------------------------------------
1808 */
Jean Delvare9fc6adf2005-07-31 21:20:43 +02001809
Jean Delvare63e4e802010-06-03 11:33:51 +02001810/*
1811 * Legacy default probe function, mostly relevant for SMBus. The default
1812 * probe method is a quick write, but it is known to corrupt the 24RF08
1813 * EEPROMs due to a state machine bug, and could also irreversibly
1814 * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
1815 * we use a short byte read instead. Also, some bus drivers don't implement
1816 * quick write, so we fallback to a byte read in that case too.
1817 * On x86, there is another special case for FSC hardware monitoring chips,
1818 * which want regular byte reads (address 0x73.) Fortunately, these are the
1819 * only known chips using this I2C address on PC hardware.
1820 * Returns 1 if probe succeeded, 0 if not.
1821 */
1822static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
1823{
1824 int err;
1825 union i2c_smbus_data dummy;
1826
1827#ifdef CONFIG_X86
1828 if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
1829 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
1830 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1831 I2C_SMBUS_BYTE_DATA, &dummy);
1832 else
1833#endif
Jean Delvare8031d792010-08-11 18:21:00 +02001834 if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
1835 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
Jean Delvare63e4e802010-06-03 11:33:51 +02001836 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
1837 I2C_SMBUS_QUICK, NULL);
Jean Delvare8031d792010-08-11 18:21:00 +02001838 else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
1839 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1840 I2C_SMBUS_BYTE, &dummy);
1841 else {
Andy Lutomirskid63a9e82013-07-17 13:27:59 -07001842 dev_warn(&adap->dev, "No suitable probing method supported for address 0x%02X\n",
1843 addr);
Jean Delvare8031d792010-08-11 18:21:00 +02001844 err = -EOPNOTSUPP;
1845 }
Jean Delvare63e4e802010-06-03 11:33:51 +02001846
1847 return err >= 0;
1848}
1849
Jean Delvareccfbbd02009-12-06 17:06:25 +01001850static int i2c_detect_address(struct i2c_client *temp_client,
Jean Delvare4735c982008-07-14 22:38:36 +02001851 struct i2c_driver *driver)
1852{
1853 struct i2c_board_info info;
1854 struct i2c_adapter *adapter = temp_client->adapter;
1855 int addr = temp_client->addr;
1856 int err;
1857
1858 /* Make sure the address is valid */
Jean Delvare656b8762010-06-03 11:33:53 +02001859 err = i2c_check_addr_validity(addr);
1860 if (err) {
Jean Delvare4735c982008-07-14 22:38:36 +02001861 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1862 addr);
Jean Delvare656b8762010-06-03 11:33:53 +02001863 return err;
Jean Delvare4735c982008-07-14 22:38:36 +02001864 }
1865
1866 /* Skip if already in use */
Jean Delvare3b5f7942010-06-03 11:33:55 +02001867 if (i2c_check_addr_busy(adapter, addr))
Jean Delvare4735c982008-07-14 22:38:36 +02001868 return 0;
1869
Jean Delvareccfbbd02009-12-06 17:06:25 +01001870 /* Make sure there is something at this address */
Jean Delvare63e4e802010-06-03 11:33:51 +02001871 if (!i2c_default_probe(adapter, addr))
1872 return 0;
Jean Delvare4735c982008-07-14 22:38:36 +02001873
1874 /* Finally call the custom detection function */
1875 memset(&info, 0, sizeof(struct i2c_board_info));
1876 info.addr = addr;
Jean Delvare310ec792009-12-14 21:17:23 +01001877 err = driver->detect(temp_client, &info);
Jean Delvare4735c982008-07-14 22:38:36 +02001878 if (err) {
1879 /* -ENODEV is returned if the detection fails. We catch it
1880 here as this isn't an error. */
1881 return err == -ENODEV ? 0 : err;
1882 }
1883
1884 /* Consistency check */
1885 if (info.type[0] == '\0') {
1886 dev_err(&adapter->dev, "%s detection function provided "
1887 "no name for 0x%x\n", driver->driver.name,
1888 addr);
1889 } else {
1890 struct i2c_client *client;
1891
1892 /* Detection succeeded, instantiate the device */
Wolfram Sang0c176172014-02-10 11:03:56 +01001893 if (adapter->class & I2C_CLASS_DEPRECATED)
1894 dev_warn(&adapter->dev,
1895 "This adapter will soon drop class based instantiation of devices. "
1896 "Please make sure client 0x%02x gets instantiated by other means. "
1897 "Check 'Documentation/i2c/instantiating-devices' for details.\n",
1898 info.addr);
1899
Jean Delvare4735c982008-07-14 22:38:36 +02001900 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
1901 info.type, info.addr);
1902 client = i2c_new_device(adapter, &info);
1903 if (client)
1904 list_add_tail(&client->detected, &driver->clients);
1905 else
1906 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
1907 info.type, info.addr);
1908 }
1909 return 0;
1910}
1911
1912static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
1913{
Jean Delvarec3813d62009-12-14 21:17:25 +01001914 const unsigned short *address_list;
Jean Delvare4735c982008-07-14 22:38:36 +02001915 struct i2c_client *temp_client;
1916 int i, err = 0;
1917 int adap_id = i2c_adapter_id(adapter);
1918
Jean Delvarec3813d62009-12-14 21:17:25 +01001919 address_list = driver->address_list;
1920 if (!driver->detect || !address_list)
Jean Delvare4735c982008-07-14 22:38:36 +02001921 return 0;
1922
Wolfram Sang45552272014-07-10 13:46:21 +02001923 /* Warn that the adapter lost class based instantiation */
1924 if (adapter->class == I2C_CLASS_DEPRECATED) {
1925 dev_dbg(&adapter->dev,
1926 "This adapter dropped support for I2C classes and "
1927 "won't auto-detect %s devices anymore. If you need it, check "
1928 "'Documentation/i2c/instantiating-devices' for alternatives.\n",
1929 driver->driver.name);
1930 return 0;
1931 }
1932
Jean Delvare51b54ba2010-10-24 18:16:58 +02001933 /* Stop here if the classes do not match */
1934 if (!(adapter->class & driver->class))
1935 return 0;
1936
Jean Delvare4735c982008-07-14 22:38:36 +02001937 /* Set up a temporary client to help detect callback */
1938 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
1939 if (!temp_client)
1940 return -ENOMEM;
1941 temp_client->adapter = adapter;
1942
Jean Delvarec3813d62009-12-14 21:17:25 +01001943 for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
Jean Delvare4735c982008-07-14 22:38:36 +02001944 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
Jean Delvarec3813d62009-12-14 21:17:25 +01001945 "addr 0x%02x\n", adap_id, address_list[i]);
1946 temp_client->addr = address_list[i];
Jean Delvareccfbbd02009-12-06 17:06:25 +01001947 err = i2c_detect_address(temp_client, driver);
Jean Delvare51b54ba2010-10-24 18:16:58 +02001948 if (unlikely(err))
1949 break;
Jean Delvare4735c982008-07-14 22:38:36 +02001950 }
1951
Jean Delvare4735c982008-07-14 22:38:36 +02001952 kfree(temp_client);
1953 return err;
1954}
1955
Jean Delvared44f19d2010-08-11 18:20:57 +02001956int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
1957{
1958 return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1959 I2C_SMBUS_QUICK, NULL) >= 0;
1960}
1961EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
1962
Jean Delvare12b5053a2007-05-01 23:26:31 +02001963struct i2c_client *
1964i2c_new_probed_device(struct i2c_adapter *adap,
1965 struct i2c_board_info *info,
Jean Delvare9a942412010-08-11 18:20:56 +02001966 unsigned short const *addr_list,
1967 int (*probe)(struct i2c_adapter *, unsigned short addr))
Jean Delvare12b5053a2007-05-01 23:26:31 +02001968{
1969 int i;
1970
Jean Delvare8031d792010-08-11 18:21:00 +02001971 if (!probe)
Jean Delvare9a942412010-08-11 18:20:56 +02001972 probe = i2c_default_probe;
Jean Delvare12b5053a2007-05-01 23:26:31 +02001973
Jean Delvare12b5053a2007-05-01 23:26:31 +02001974 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1975 /* Check address validity */
Jean Delvare656b8762010-06-03 11:33:53 +02001976 if (i2c_check_addr_validity(addr_list[i]) < 0) {
Jean Delvare12b5053a2007-05-01 23:26:31 +02001977 dev_warn(&adap->dev, "Invalid 7-bit address "
1978 "0x%02x\n", addr_list[i]);
1979 continue;
1980 }
1981
1982 /* Check address availability */
Jean Delvare3b5f7942010-06-03 11:33:55 +02001983 if (i2c_check_addr_busy(adap, addr_list[i])) {
Jean Delvare12b5053a2007-05-01 23:26:31 +02001984 dev_dbg(&adap->dev, "Address 0x%02x already in "
1985 "use, not probing\n", addr_list[i]);
1986 continue;
1987 }
1988
Jean Delvare63e4e802010-06-03 11:33:51 +02001989 /* Test address responsiveness */
Jean Delvare9a942412010-08-11 18:20:56 +02001990 if (probe(adap, addr_list[i]))
Jean Delvare63e4e802010-06-03 11:33:51 +02001991 break;
Jean Delvare12b5053a2007-05-01 23:26:31 +02001992 }
Jean Delvare12b5053a2007-05-01 23:26:31 +02001993
1994 if (addr_list[i] == I2C_CLIENT_END) {
1995 dev_dbg(&adap->dev, "Probing failed, no device found\n");
1996 return NULL;
1997 }
1998
1999 info->addr = addr_list[i];
2000 return i2c_new_device(adap, info);
2001}
2002EXPORT_SYMBOL_GPL(i2c_new_probed_device);
2003
Jean Delvared735b342011-03-20 14:50:52 +01002004struct i2c_adapter *i2c_get_adapter(int nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006 struct i2c_adapter *adapter;
David Brownell438d6c22006-12-10 21:21:31 +01002007
Jean Delvarecaada322008-01-27 18:14:49 +01002008 mutex_lock(&core_lock);
Jean Delvared735b342011-03-20 14:50:52 +01002009 adapter = idr_find(&i2c_adapter_idr, nr);
Mark M. Hoffmana0920e12005-06-28 00:21:30 -04002010 if (adapter && !try_module_get(adapter->owner))
2011 adapter = NULL;
2012
Jean Delvarecaada322008-01-27 18:14:49 +01002013 mutex_unlock(&core_lock);
Mark M. Hoffmana0920e12005-06-28 00:21:30 -04002014 return adapter;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002015}
David Brownellc0564602007-05-01 23:26:31 +02002016EXPORT_SYMBOL(i2c_get_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017
2018void i2c_put_adapter(struct i2c_adapter *adap)
2019{
Sebastian Hesselbarthc66c4cc2013-08-01 14:10:46 +02002020 if (adap)
2021 module_put(adap->owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002022}
David Brownellc0564602007-05-01 23:26:31 +02002023EXPORT_SYMBOL(i2c_put_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024
2025/* The SMBus parts */
2026
David Brownell438d6c22006-12-10 21:21:31 +01002027#define POLY (0x1070U << 3)
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01002028static u8 crc8(u16 data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002029{
2030 int i;
David Brownell438d6c22006-12-10 21:21:31 +01002031
Farid Hammane7225acf2010-05-21 18:40:58 +02002032 for (i = 0; i < 8; i++) {
David Brownell438d6c22006-12-10 21:21:31 +01002033 if (data & 0x8000)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002034 data = data ^ POLY;
2035 data = data << 1;
2036 }
2037 return (u8)(data >> 8);
2038}
2039
Jean Delvare421ef472005-10-26 21:28:55 +02002040/* Incremental CRC8 over count bytes in the array pointed to by p */
2041static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042{
2043 int i;
2044
Farid Hammane7225acf2010-05-21 18:40:58 +02002045 for (i = 0; i < count; i++)
Jean Delvare421ef472005-10-26 21:28:55 +02002046 crc = crc8((crc ^ p[i]) << 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002047 return crc;
2048}
2049
Jean Delvare421ef472005-10-26 21:28:55 +02002050/* Assume a 7-bit address, which is reasonable for SMBus */
2051static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002052{
Jean Delvare421ef472005-10-26 21:28:55 +02002053 /* The address will be sent first */
2054 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
2055 pec = i2c_smbus_pec(pec, &addr, 1);
2056
2057 /* The data buffer follows */
2058 return i2c_smbus_pec(pec, msg->buf, msg->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002059}
2060
Jean Delvare421ef472005-10-26 21:28:55 +02002061/* Used for write only transactions */
2062static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002063{
Jean Delvare421ef472005-10-26 21:28:55 +02002064 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
2065 msg->len++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002066}
2067
Jean Delvare421ef472005-10-26 21:28:55 +02002068/* Return <0 on CRC error
2069 If there was a write before this read (most cases) we need to take the
2070 partial CRC from the write part into account.
2071 Note that this function does modify the message (we need to decrease the
2072 message length to hide the CRC byte from the caller). */
2073static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002074{
Jean Delvare421ef472005-10-26 21:28:55 +02002075 u8 rpec = msg->buf[--msg->len];
2076 cpec = i2c_smbus_msg_pec(cpec, msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077
Linus Torvalds1da177e2005-04-16 15:20:36 -07002078 if (rpec != cpec) {
2079 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
2080 rpec, cpec);
David Brownell24a5bb72008-07-14 22:38:23 +02002081 return -EBADMSG;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002082 }
David Brownell438d6c22006-12-10 21:21:31 +01002083 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002084}
2085
David Brownella1cdeda2008-07-14 22:38:24 +02002086/**
2087 * i2c_smbus_read_byte - SMBus "receive byte" protocol
2088 * @client: Handle to slave device
2089 *
2090 * This executes the SMBus "receive byte" protocol, returning negative errno
2091 * else the byte received from the device.
2092 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01002093s32 i2c_smbus_read_byte(const struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094{
2095 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02002096 int status;
2097
2098 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2099 I2C_SMBUS_READ, 0,
2100 I2C_SMBUS_BYTE, &data);
2101 return (status < 0) ? status : data.byte;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002102}
David Brownellc0564602007-05-01 23:26:31 +02002103EXPORT_SYMBOL(i2c_smbus_read_byte);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002104
David Brownella1cdeda2008-07-14 22:38:24 +02002105/**
2106 * i2c_smbus_write_byte - SMBus "send byte" protocol
2107 * @client: Handle to slave device
2108 * @value: Byte to be sent
2109 *
2110 * This executes the SMBus "send byte" protocol, returning negative errno
2111 * else zero on success.
2112 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01002113s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002114{
Farid Hammane7225acf2010-05-21 18:40:58 +02002115 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
Jean Delvare421ef472005-10-26 21:28:55 +02002116 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002117}
David Brownellc0564602007-05-01 23:26:31 +02002118EXPORT_SYMBOL(i2c_smbus_write_byte);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002119
David Brownella1cdeda2008-07-14 22:38:24 +02002120/**
2121 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
2122 * @client: Handle to slave device
2123 * @command: Byte interpreted by slave
2124 *
2125 * This executes the SMBus "read byte" protocol, returning negative errno
2126 * else a data byte received from the device.
2127 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01002128s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002129{
2130 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02002131 int status;
2132
2133 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2134 I2C_SMBUS_READ, command,
2135 I2C_SMBUS_BYTE_DATA, &data);
2136 return (status < 0) ? status : data.byte;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137}
David Brownellc0564602007-05-01 23:26:31 +02002138EXPORT_SYMBOL(i2c_smbus_read_byte_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002139
David Brownella1cdeda2008-07-14 22:38:24 +02002140/**
2141 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
2142 * @client: Handle to slave device
2143 * @command: Byte interpreted by slave
2144 * @value: Byte being written
2145 *
2146 * This executes the SMBus "write byte" protocol, returning negative errno
2147 * else zero on success.
2148 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01002149s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
2150 u8 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002151{
2152 union i2c_smbus_data data;
2153 data.byte = value;
Farid Hammane7225acf2010-05-21 18:40:58 +02002154 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2155 I2C_SMBUS_WRITE, command,
2156 I2C_SMBUS_BYTE_DATA, &data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002157}
David Brownellc0564602007-05-01 23:26:31 +02002158EXPORT_SYMBOL(i2c_smbus_write_byte_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002159
David Brownella1cdeda2008-07-14 22:38:24 +02002160/**
2161 * i2c_smbus_read_word_data - SMBus "read word" protocol
2162 * @client: Handle to slave device
2163 * @command: Byte interpreted by slave
2164 *
2165 * This executes the SMBus "read word" protocol, returning negative errno
2166 * else a 16-bit unsigned "word" received from the device.
2167 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01002168s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002169{
2170 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02002171 int status;
2172
2173 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2174 I2C_SMBUS_READ, command,
2175 I2C_SMBUS_WORD_DATA, &data);
2176 return (status < 0) ? status : data.word;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177}
David Brownellc0564602007-05-01 23:26:31 +02002178EXPORT_SYMBOL(i2c_smbus_read_word_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179
David Brownella1cdeda2008-07-14 22:38:24 +02002180/**
2181 * i2c_smbus_write_word_data - SMBus "write word" protocol
2182 * @client: Handle to slave device
2183 * @command: Byte interpreted by slave
2184 * @value: 16-bit "word" being written
2185 *
2186 * This executes the SMBus "write word" protocol, returning negative errno
2187 * else zero on success.
2188 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01002189s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
2190 u16 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002191{
2192 union i2c_smbus_data data;
2193 data.word = value;
Farid Hammane7225acf2010-05-21 18:40:58 +02002194 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2195 I2C_SMBUS_WRITE, command,
2196 I2C_SMBUS_WORD_DATA, &data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197}
David Brownellc0564602007-05-01 23:26:31 +02002198EXPORT_SYMBOL(i2c_smbus_write_word_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002199
David Brownella64ec072007-10-13 23:56:31 +02002200/**
David Brownella1cdeda2008-07-14 22:38:24 +02002201 * i2c_smbus_read_block_data - SMBus "block read" protocol
David Brownella64ec072007-10-13 23:56:31 +02002202 * @client: Handle to slave device
David Brownella1cdeda2008-07-14 22:38:24 +02002203 * @command: Byte interpreted by slave
David Brownella64ec072007-10-13 23:56:31 +02002204 * @values: Byte array into which data will be read; big enough to hold
2205 * the data returned by the slave. SMBus allows at most 32 bytes.
2206 *
David Brownella1cdeda2008-07-14 22:38:24 +02002207 * This executes the SMBus "block read" protocol, returning negative errno
2208 * else the number of data bytes in the slave's response.
David Brownella64ec072007-10-13 23:56:31 +02002209 *
2210 * Note that using this function requires that the client's adapter support
2211 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
2212 * support this; its emulation through I2C messaging relies on a specific
2213 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
2214 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01002215s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
Jean Delvareb86a1bc2007-05-01 23:26:34 +02002216 u8 *values)
2217{
2218 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02002219 int status;
Jean Delvareb86a1bc2007-05-01 23:26:34 +02002220
David Brownell24a5bb72008-07-14 22:38:23 +02002221 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2222 I2C_SMBUS_READ, command,
2223 I2C_SMBUS_BLOCK_DATA, &data);
2224 if (status)
2225 return status;
Jean Delvareb86a1bc2007-05-01 23:26:34 +02002226
2227 memcpy(values, &data.block[1], data.block[0]);
2228 return data.block[0];
2229}
2230EXPORT_SYMBOL(i2c_smbus_read_block_data);
2231
David Brownella1cdeda2008-07-14 22:38:24 +02002232/**
2233 * i2c_smbus_write_block_data - SMBus "block write" protocol
2234 * @client: Handle to slave device
2235 * @command: Byte interpreted by slave
2236 * @length: Size of data block; SMBus allows at most 32 bytes
2237 * @values: Byte array which will be written.
2238 *
2239 * This executes the SMBus "block write" protocol, returning negative errno
2240 * else zero on success.
2241 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01002242s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
Krzysztof Halasa46f5ed72006-06-12 21:42:20 +02002243 u8 length, const u8 *values)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244{
2245 union i2c_smbus_data data;
Jean Delvare76560322006-01-18 23:14:55 +01002246
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247 if (length > I2C_SMBUS_BLOCK_MAX)
2248 length = I2C_SMBUS_BLOCK_MAX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002249 data.block[0] = length;
Jean Delvare76560322006-01-18 23:14:55 +01002250 memcpy(&data.block[1], values, length);
Farid Hammane7225acf2010-05-21 18:40:58 +02002251 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2252 I2C_SMBUS_WRITE, command,
2253 I2C_SMBUS_BLOCK_DATA, &data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002254}
David Brownellc0564602007-05-01 23:26:31 +02002255EXPORT_SYMBOL(i2c_smbus_write_block_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002256
2257/* Returns the number of read bytes */
Jean Delvare0cc43a12011-01-10 22:11:23 +01002258s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
Jean Delvare4b2643d2007-07-12 14:12:29 +02002259 u8 length, u8 *values)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260{
2261 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02002262 int status;
Jean Delvare76560322006-01-18 23:14:55 +01002263
Jean Delvare4b2643d2007-07-12 14:12:29 +02002264 if (length > I2C_SMBUS_BLOCK_MAX)
2265 length = I2C_SMBUS_BLOCK_MAX;
2266 data.block[0] = length;
David Brownell24a5bb72008-07-14 22:38:23 +02002267 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2268 I2C_SMBUS_READ, command,
2269 I2C_SMBUS_I2C_BLOCK_DATA, &data);
2270 if (status < 0)
2271 return status;
Jean Delvare76560322006-01-18 23:14:55 +01002272
2273 memcpy(values, &data.block[1], data.block[0]);
2274 return data.block[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002275}
David Brownellc0564602007-05-01 23:26:31 +02002276EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002277
Jean Delvare0cc43a12011-01-10 22:11:23 +01002278s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
Krzysztof Halasa46f5ed72006-06-12 21:42:20 +02002279 u8 length, const u8 *values)
Jean Delvare21bbd692006-01-09 15:19:18 +11002280{
2281 union i2c_smbus_data data;
2282
2283 if (length > I2C_SMBUS_BLOCK_MAX)
2284 length = I2C_SMBUS_BLOCK_MAX;
2285 data.block[0] = length;
2286 memcpy(data.block + 1, values, length);
2287 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2288 I2C_SMBUS_WRITE, command,
2289 I2C_SMBUS_I2C_BLOCK_DATA, &data);
2290}
David Brownellc0564602007-05-01 23:26:31 +02002291EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
Jean Delvare21bbd692006-01-09 15:19:18 +11002292
David Brownell438d6c22006-12-10 21:21:31 +01002293/* Simulate a SMBus command using the i2c protocol
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294 No checking of parameters is done! */
Farid Hammane7225acf2010-05-21 18:40:58 +02002295static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
2296 unsigned short flags,
2297 char read_write, u8 command, int size,
2298 union i2c_smbus_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002299{
2300 /* So we need to generate a series of msgs. In the case of writing, we
2301 need to use only one message; when reading, we need two. We initialize
2302 most things with sane defaults, to keep the code below somewhat
2303 simpler. */
Hideki Iwamoto5c50d182005-09-25 17:01:11 +02002304 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
2305 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
Farid Hammane7225acf2010-05-21 18:40:58 +02002306 int num = read_write == I2C_SMBUS_READ ? 2 : 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002307 int i;
Jean Delvare421ef472005-10-26 21:28:55 +02002308 u8 partial_pec = 0;
David Brownell24a5bb72008-07-14 22:38:23 +02002309 int status;
Shubhrajyoti D230da092012-10-05 22:23:52 +02002310 struct i2c_msg msg[2] = {
2311 {
2312 .addr = addr,
2313 .flags = flags,
2314 .len = 1,
2315 .buf = msgbuf0,
2316 }, {
2317 .addr = addr,
2318 .flags = flags | I2C_M_RD,
2319 .len = 0,
2320 .buf = msgbuf1,
2321 },
2322 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07002323
2324 msgbuf0[0] = command;
Farid Hammane7225acf2010-05-21 18:40:58 +02002325 switch (size) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002326 case I2C_SMBUS_QUICK:
2327 msg[0].len = 0;
2328 /* Special case: The read/write field is used as data */
Roel Kluinf29d2e02009-02-24 19:19:48 +01002329 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
2330 I2C_M_RD : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002331 num = 1;
2332 break;
2333 case I2C_SMBUS_BYTE:
2334 if (read_write == I2C_SMBUS_READ) {
2335 /* Special case: only a read! */
2336 msg[0].flags = I2C_M_RD | flags;
2337 num = 1;
2338 }
2339 break;
2340 case I2C_SMBUS_BYTE_DATA:
2341 if (read_write == I2C_SMBUS_READ)
2342 msg[1].len = 1;
2343 else {
2344 msg[0].len = 2;
2345 msgbuf0[1] = data->byte;
2346 }
2347 break;
2348 case I2C_SMBUS_WORD_DATA:
2349 if (read_write == I2C_SMBUS_READ)
2350 msg[1].len = 2;
2351 else {
Farid Hammane7225acf2010-05-21 18:40:58 +02002352 msg[0].len = 3;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002353 msgbuf0[1] = data->word & 0xff;
Jean Delvare7eff82c2006-09-03 22:24:00 +02002354 msgbuf0[2] = data->word >> 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002355 }
2356 break;
2357 case I2C_SMBUS_PROC_CALL:
2358 num = 2; /* Special case */
2359 read_write = I2C_SMBUS_READ;
2360 msg[0].len = 3;
2361 msg[1].len = 2;
2362 msgbuf0[1] = data->word & 0xff;
Jean Delvare7eff82c2006-09-03 22:24:00 +02002363 msgbuf0[2] = data->word >> 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002364 break;
2365 case I2C_SMBUS_BLOCK_DATA:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002366 if (read_write == I2C_SMBUS_READ) {
Jean Delvare209d27c2007-05-01 23:26:29 +02002367 msg[1].flags |= I2C_M_RECV_LEN;
2368 msg[1].len = 1; /* block length will be added by
2369 the underlying bus driver */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002370 } else {
2371 msg[0].len = data->block[0] + 2;
2372 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
David Brownell24a5bb72008-07-14 22:38:23 +02002373 dev_err(&adapter->dev,
2374 "Invalid block write size %d\n",
2375 data->block[0]);
2376 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002377 }
Hideki Iwamoto5c50d182005-09-25 17:01:11 +02002378 for (i = 1; i < msg[0].len; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002379 msgbuf0[i] = data->block[i-1];
2380 }
2381 break;
2382 case I2C_SMBUS_BLOCK_PROC_CALL:
Jean Delvare209d27c2007-05-01 23:26:29 +02002383 num = 2; /* Another special case */
2384 read_write = I2C_SMBUS_READ;
2385 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
David Brownell24a5bb72008-07-14 22:38:23 +02002386 dev_err(&adapter->dev,
2387 "Invalid block write size %d\n",
Jean Delvare209d27c2007-05-01 23:26:29 +02002388 data->block[0]);
David Brownell24a5bb72008-07-14 22:38:23 +02002389 return -EINVAL;
Jean Delvare209d27c2007-05-01 23:26:29 +02002390 }
2391 msg[0].len = data->block[0] + 2;
2392 for (i = 1; i < msg[0].len; i++)
2393 msgbuf0[i] = data->block[i-1];
2394 msg[1].flags |= I2C_M_RECV_LEN;
2395 msg[1].len = 1; /* block length will be added by
2396 the underlying bus driver */
2397 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002398 case I2C_SMBUS_I2C_BLOCK_DATA:
2399 if (read_write == I2C_SMBUS_READ) {
Jean Delvare4b2643d2007-07-12 14:12:29 +02002400 msg[1].len = data->block[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002401 } else {
2402 msg[0].len = data->block[0] + 1;
Jean Delvare30dac742005-10-08 00:15:59 +02002403 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
David Brownell24a5bb72008-07-14 22:38:23 +02002404 dev_err(&adapter->dev,
2405 "Invalid block write size %d\n",
2406 data->block[0]);
2407 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002408 }
2409 for (i = 1; i <= data->block[0]; i++)
2410 msgbuf0[i] = data->block[i];
2411 }
2412 break;
2413 default:
David Brownell24a5bb72008-07-14 22:38:23 +02002414 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
2415 return -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002416 }
2417
Jean Delvare421ef472005-10-26 21:28:55 +02002418 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
2419 && size != I2C_SMBUS_I2C_BLOCK_DATA);
2420 if (i) {
2421 /* Compute PEC if first message is a write */
2422 if (!(msg[0].flags & I2C_M_RD)) {
David Brownell438d6c22006-12-10 21:21:31 +01002423 if (num == 1) /* Write only */
Jean Delvare421ef472005-10-26 21:28:55 +02002424 i2c_smbus_add_pec(&msg[0]);
2425 else /* Write followed by read */
2426 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
2427 }
2428 /* Ask for PEC if last message is a read */
2429 if (msg[num-1].flags & I2C_M_RD)
David Brownell438d6c22006-12-10 21:21:31 +01002430 msg[num-1].len++;
Jean Delvare421ef472005-10-26 21:28:55 +02002431 }
2432
David Brownell24a5bb72008-07-14 22:38:23 +02002433 status = i2c_transfer(adapter, msg, num);
2434 if (status < 0)
2435 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002436
Jean Delvare421ef472005-10-26 21:28:55 +02002437 /* Check PEC if last message is a read */
2438 if (i && (msg[num-1].flags & I2C_M_RD)) {
David Brownell24a5bb72008-07-14 22:38:23 +02002439 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
2440 if (status < 0)
2441 return status;
Jean Delvare421ef472005-10-26 21:28:55 +02002442 }
2443
Linus Torvalds1da177e2005-04-16 15:20:36 -07002444 if (read_write == I2C_SMBUS_READ)
Farid Hammane7225acf2010-05-21 18:40:58 +02002445 switch (size) {
2446 case I2C_SMBUS_BYTE:
2447 data->byte = msgbuf0[0];
2448 break;
2449 case I2C_SMBUS_BYTE_DATA:
2450 data->byte = msgbuf1[0];
2451 break;
2452 case I2C_SMBUS_WORD_DATA:
2453 case I2C_SMBUS_PROC_CALL:
2454 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
2455 break;
2456 case I2C_SMBUS_I2C_BLOCK_DATA:
2457 for (i = 0; i < data->block[0]; i++)
2458 data->block[i+1] = msgbuf1[i];
2459 break;
2460 case I2C_SMBUS_BLOCK_DATA:
2461 case I2C_SMBUS_BLOCK_PROC_CALL:
2462 for (i = 0; i < msgbuf1[0] + 1; i++)
2463 data->block[i] = msgbuf1[i];
2464 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002465 }
2466 return 0;
2467}
2468
David Brownella1cdeda2008-07-14 22:38:24 +02002469/**
2470 * i2c_smbus_xfer - execute SMBus protocol operations
2471 * @adapter: Handle to I2C bus
2472 * @addr: Address of SMBus slave on that bus
2473 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
2474 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
2475 * @command: Byte interpreted by slave, for protocols which use such bytes
2476 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
2477 * @data: Data to be read or written
2478 *
2479 * This executes an SMBus protocol operation, and returns a negative
2480 * errno code else zero on success.
2481 */
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01002482s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
David Brownella1cdeda2008-07-14 22:38:24 +02002483 char read_write, u8 command, int protocol,
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01002484 union i2c_smbus_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002485{
Clifford Wolf66b650f2009-06-15 18:01:46 +02002486 unsigned long orig_jiffies;
2487 int try;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002488 s32 res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002489
David Howells8a3259972014-03-06 13:36:06 +00002490 /* If enabled, the following two tracepoints are conditional on
2491 * read_write and protocol.
2492 */
2493 trace_smbus_write(adapter, addr, flags, read_write,
2494 command, protocol, data);
2495 trace_smbus_read(adapter, addr, flags, read_write,
2496 command, protocol);
2497
Laurent Pinchartd47726c2012-07-24 14:13:59 +02002498 flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002499
2500 if (adapter->algo->smbus_xfer) {
Jean Delvarefe61e072010-08-11 18:20:58 +02002501 i2c_lock_adapter(adapter);
Clifford Wolf66b650f2009-06-15 18:01:46 +02002502
2503 /* Retry automatically on arbitration loss */
2504 orig_jiffies = jiffies;
2505 for (res = 0, try = 0; try <= adapter->retries; try++) {
2506 res = adapter->algo->smbus_xfer(adapter, addr, flags,
2507 read_write, command,
2508 protocol, data);
2509 if (res != -EAGAIN)
2510 break;
2511 if (time_after(jiffies,
2512 orig_jiffies + adapter->timeout))
2513 break;
2514 }
Jean Delvarefe61e072010-08-11 18:20:58 +02002515 i2c_unlock_adapter(adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002516
Laurent Pinchart72fc2c72012-07-24 14:13:59 +02002517 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
David Howells8a3259972014-03-06 13:36:06 +00002518 goto trace;
Laurent Pinchart72fc2c72012-07-24 14:13:59 +02002519 /*
2520 * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
2521 * implement native support for the SMBus operation.
2522 */
2523 }
2524
David Howells8a3259972014-03-06 13:36:06 +00002525 res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
2526 command, protocol, data);
2527
2528trace:
2529 /* If enabled, the reply tracepoint is conditional on read_write. */
2530 trace_smbus_reply(adapter, addr, flags, read_write,
2531 command, protocol, data);
2532 trace_smbus_result(adapter, addr, flags, read_write,
2533 command, protocol, res);
2534
2535 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002536}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002537EXPORT_SYMBOL(i2c_smbus_xfer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002538
2539MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
2540MODULE_DESCRIPTION("I2C-Bus main module");
2541MODULE_LICENSE("GPL");