blob: d2402bbf6729e55143a9d097aaf455b65c27b1ba [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
Wolfram Sangca1f8da2014-11-04 23:46:27 +010013 GNU General Public License for more details. */
Linus Torvalds1da177e2005-04-16 15:20:36 -070014/* ------------------------------------------------------------------------- */
15
Jan Engelhardt96de0e22007-10-19 23:21:04 +020016/* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi>.
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl>
Jean Delvare421ef472005-10-26 21:28:55 +020018 SMBus 2.0 support by Mark Studebaker <mdsxyz123@yahoo.com> and
Jean Delvare7c81c60f2014-01-29 20:40:08 +010019 Jean Delvare <jdelvare@suse.de>
Michael Lawnick08263742010-08-11 18:21:02 +020020 Mux support by Rodolfo Giometti <giometti@enneenne.com> and
Wolfram Sang687b81d2013-07-11 12:56:15 +010021 Michael Lawnick <michael.lawnick.ext@nsn.com>
22 OF support is copyright (c) 2008 Jochen Friedrich <jochen@scram.de>
23 (based on a previous patch from Jon Smirl <jonsmirl@gmail.com>) and
24 (c) 2013 Wolfram Sang <wsa@the-dreams.de>
Wolfram Sang17f4a5c2014-09-22 19:41:00 +020025 I2C ACPI code Copyright (C) 2014 Intel Corp
26 Author: Lan Tianyu <tianyu.lan@intel.com>
Wolfram Sang4b1acc42014-11-18 17:04:53 +010027 I2C slave support (c) 2014 by Wolfram Sang <wsa@sang-engineering.com>
Wolfram Sang687b81d2013-07-11 12:56:15 +010028 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070029
Wolfram Sang44239a52016-07-09 13:35:04 +090030#define pr_fmt(fmt) "i2c-core: " fmt
31
Wolfram Sangb4e2f6a2015-05-19 21:04:40 +020032#include <dt-bindings/i2c/i2c.h>
Linus Torvalds7c0f6ba2016-12-24 11:46:01 -080033#include <linux/uaccess.h>
Wolfram Sang53feedf2016-02-20 23:33:38 +010034#include <linux/acpi.h>
Sylwester Nawrocki86be4082014-06-18 17:29:32 +020035#include <linux/clk/clk-conf.h>
Jean Delvareb8d6f452007-02-13 22:09:00 +010036#include <linux/completion.h>
Wolfram Sang53feedf2016-02-20 23:33:38 +010037#include <linux/delay.h>
Pantelis Antonioua430a3452014-10-28 22:36:02 +020038#include <linux/err.h>
Wolfram Sang53feedf2016-02-20 23:33:38 +010039#include <linux/errno.h>
40#include <linux/gpio.h>
41#include <linux/hardirq.h>
42#include <linux/i2c.h>
43#include <linux/idr.h>
44#include <linux/init.h>
45#include <linux/irqflags.h>
46#include <linux/jump_label.h>
47#include <linux/kernel.h>
48#include <linux/module.h>
49#include <linux/mutex.h>
50#include <linux/of_device.h>
51#include <linux/of.h>
52#include <linux/of_irq.h>
53#include <linux/pm_domain.h>
54#include <linux/pm_runtime.h>
55#include <linux/pm_wakeirq.h>
Wolfram Sange1dba012015-12-08 10:37:46 +010056#include <linux/property.h>
Wolfram Sang53feedf2016-02-20 23:33:38 +010057#include <linux/rwsem.h>
58#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
David Brownell9c1600e2007-05-01 23:26:31 +020060#include "i2c-core.h"
61
David Howellsd9a83d62014-03-06 13:35:59 +000062#define CREATE_TRACE_POINTS
63#include <trace/events/i2c.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070064
Wolfram Sangda899f52015-05-18 21:09:12 +020065#define I2C_ADDR_OFFSET_TEN_BIT 0xa000
66#define I2C_ADDR_OFFSET_SLAVE 0x1000
67
Benjamin Tissoires4d5538f2016-10-13 14:10:40 +020068#define I2C_ADDR_7BITS_MAX 0x77
69#define I2C_ADDR_7BITS_COUNT (I2C_ADDR_7BITS_MAX + 1)
70
Jean Delvare6629dcf2010-05-04 11:09:28 +020071/* core_lock protects i2c_adapter_idr, and guarantees
Jean Delvare35fc37f2009-06-19 16:58:19 +020072 that device detection, deletion of detected devices, and attach_adapter
Lars-Peter Clausen19baba42013-03-09 08:16:44 +000073 calls are serialized */
Jean Delvarecaada322008-01-27 18:14:49 +010074static DEFINE_MUTEX(core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070075static DEFINE_IDR(i2c_adapter_idr);
76
Jean Delvare4f8cf822009-09-18 22:45:46 +020077static struct device_type i2c_client_type;
Jean Delvare4735c98f2008-07-14 22:38:36 +020078static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
David Brownellf37dd802007-02-13 22:09:00 +010079
David Howellsd9a83d62014-03-06 13:35:59 +000080static struct static_key i2c_trace_msg = STATIC_KEY_INIT_FALSE;
Sudip Mukherjee95026652016-03-07 17:19:17 +053081static bool is_registered;
David Howellsd9a83d62014-03-06 13:35:59 +000082
Steven Rostedt (Red Hat)8cf868a2016-11-28 13:03:21 -050083int i2c_transfer_trace_reg(void)
David Howellsd9a83d62014-03-06 13:35:59 +000084{
85 static_key_slow_inc(&i2c_trace_msg);
Steven Rostedt (Red Hat)8cf868a2016-11-28 13:03:21 -050086 return 0;
David Howellsd9a83d62014-03-06 13:35:59 +000087}
88
89void i2c_transfer_trace_unreg(void)
90{
91 static_key_slow_dec(&i2c_trace_msg);
92}
93
Wolfram Sang17f4a5c2014-09-22 19:41:00 +020094#if defined(CONFIG_ACPI)
Jarkko Nikulaaec809f2016-08-12 17:02:52 +030095struct i2c_acpi_handler_data {
Wolfram Sang17f4a5c2014-09-22 19:41:00 +020096 struct acpi_connection_info info;
97 struct i2c_adapter *adapter;
98};
99
100struct gsb_buffer {
101 u8 status;
102 u8 len;
103 union {
104 u16 wdata;
105 u8 bdata;
106 u8 data[0];
107 };
108} __packed;
109
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300110struct i2c_acpi_lookup {
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300111 struct i2c_board_info *info;
112 acpi_handle adapter_handle;
113 acpi_handle device_handle;
Jarkko Nikula5853b222016-08-12 17:02:53 +0300114 acpi_handle search_handle;
115 u32 speed;
116 u32 min_speed;
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300117};
118
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300119static int i2c_acpi_fill_info(struct acpi_resource *ares, void *data)
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200120{
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300121 struct i2c_acpi_lookup *lookup = data;
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300122 struct i2c_board_info *info = lookup->info;
123 struct acpi_resource_i2c_serialbus *sb;
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300124 acpi_status status;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200125
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300126 if (info->addr || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS)
127 return 1;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200128
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300129 sb = &ares->data.i2c_serial_bus;
130 if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C)
131 return 1;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200132
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300133 status = acpi_get_handle(lookup->device_handle,
134 sb->resource_source.string_ptr,
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300135 &lookup->adapter_handle);
136 if (!ACPI_SUCCESS(status))
137 return 1;
138
139 info->addr = sb->slave_address;
Jarkko Nikula5853b222016-08-12 17:02:53 +0300140 lookup->speed = sb->connection_speed;
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300141 if (sb->access_mode == ACPI_I2C_10BIT_MODE)
142 info->flags |= I2C_CLIENT_TEN;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200143
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200144 return 1;
145}
146
Jarkko Nikula5853b222016-08-12 17:02:53 +0300147static int i2c_acpi_do_lookup(struct acpi_device *adev,
148 struct i2c_acpi_lookup *lookup)
149{
150 struct i2c_board_info *info = lookup->info;
151 struct list_head resource_list;
152 int ret;
153
154 if (acpi_bus_get_status(adev) || !adev->status.present ||
155 acpi_device_enumerated(adev))
156 return -EINVAL;
157
158 memset(info, 0, sizeof(*info));
159 lookup->device_handle = acpi_device_handle(adev);
160
161 /* Look up for I2cSerialBus resource */
162 INIT_LIST_HEAD(&resource_list);
163 ret = acpi_dev_get_resources(adev, &resource_list,
164 i2c_acpi_fill_info, lookup);
165 acpi_dev_free_resource_list(&resource_list);
166
167 if (ret < 0 || !info->addr)
168 return -EINVAL;
169
170 return 0;
171}
172
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300173static int i2c_acpi_get_info(struct acpi_device *adev,
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300174 struct i2c_board_info *info,
Mika Westerberg318ce272016-09-20 16:59:25 +0300175 struct i2c_adapter *adapter,
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300176 acpi_handle *adapter_handle)
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200177{
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200178 struct list_head resource_list;
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300179 struct resource_entry *entry;
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300180 struct i2c_acpi_lookup lookup;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200181 int ret;
182
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300183 memset(&lookup, 0, sizeof(lookup));
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300184 lookup.info = info;
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300185
Jarkko Nikula5853b222016-08-12 17:02:53 +0300186 ret = i2c_acpi_do_lookup(adev, &lookup);
187 if (ret)
188 return ret;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200189
Mika Westerberg318ce272016-09-20 16:59:25 +0300190 if (adapter) {
191 /* The adapter must match the one in I2cSerialBus() connector */
192 if (ACPI_HANDLE(&adapter->dev) != lookup.adapter_handle)
193 return -ENODEV;
194 } else {
195 struct acpi_device *adapter_adev;
196
197 /* The adapter must be present */
198 if (acpi_bus_get_device(lookup.adapter_handle, &adapter_adev))
199 return -ENODEV;
200 if (acpi_bus_get_status(adapter_adev) ||
201 !adapter_adev->status.present)
202 return -ENODEV;
203 }
204
Jarkko Nikula5853b222016-08-12 17:02:53 +0300205 info->fwnode = acpi_fwnode_handle(adev);
Mika Westerberg318ce272016-09-20 16:59:25 +0300206 if (adapter_handle)
207 *adapter_handle = lookup.adapter_handle;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200208
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300209 /* Then fill IRQ number if any */
Jarkko Nikula5853b222016-08-12 17:02:53 +0300210 INIT_LIST_HEAD(&resource_list);
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300211 ret = acpi_dev_get_resources(adev, &resource_list, NULL, NULL);
212 if (ret < 0)
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300213 return -EINVAL;
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300214
215 resource_list_for_each_entry(entry, &resource_list) {
216 if (resource_type(entry->res) == IORESOURCE_IRQ) {
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300217 info->irq = entry->res->start;
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300218 break;
219 }
220 }
221
222 acpi_dev_free_resource_list(&resource_list);
223
Dan O'Donovan622b3072017-02-05 16:30:13 +0000224 acpi_set_modalias(adev, dev_name(&adev->dev), info->type,
225 sizeof(info->type));
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300226
227 return 0;
228}
229
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300230static void i2c_acpi_register_device(struct i2c_adapter *adapter,
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300231 struct acpi_device *adev,
232 struct i2c_board_info *info)
233{
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200234 adev->power.flags.ignore_parent = true;
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300235 acpi_device_set_enumerated(adev);
236
237 if (!i2c_new_device(adapter, info)) {
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200238 adev->power.flags.ignore_parent = false;
239 dev_err(&adapter->dev,
240 "failed to add I2C device %s from ACPI\n",
241 dev_name(&adev->dev));
242 }
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300243}
244
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300245static acpi_status i2c_acpi_add_device(acpi_handle handle, u32 level,
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300246 void *data, void **return_value)
247{
248 struct i2c_adapter *adapter = data;
249 struct acpi_device *adev;
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300250 struct i2c_board_info info;
251
252 if (acpi_bus_get_device(handle, &adev))
253 return AE_OK;
254
Mika Westerberg318ce272016-09-20 16:59:25 +0300255 if (i2c_acpi_get_info(adev, &info, adapter, NULL))
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300256 return AE_OK;
257
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300258 i2c_acpi_register_device(adapter, adev, &info);
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200259
260 return AE_OK;
261}
262
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300263#define I2C_ACPI_MAX_SCAN_DEPTH 32
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300264
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200265/**
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300266 * i2c_acpi_register_devices - enumerate I2C slave devices behind adapter
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200267 * @adap: pointer to adapter
268 *
269 * Enumerate all I2C slave devices behind this adapter by walking the ACPI
270 * namespace. When a device is found it will be added to the Linux device
271 * model and bound to the corresponding ACPI handle.
272 */
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300273static void i2c_acpi_register_devices(struct i2c_adapter *adap)
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200274{
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200275 acpi_status status;
276
Dustin Byford8eb5c872015-10-23 12:27:07 -0700277 if (!has_acpi_companion(&adap->dev))
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200278 return;
279
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300280 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300281 I2C_ACPI_MAX_SCAN_DEPTH,
282 i2c_acpi_add_device, NULL,
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200283 adap, NULL);
284 if (ACPI_FAILURE(status))
285 dev_warn(&adap->dev, "failed to enumerate I2C slaves\n");
286}
287
Jarkko Nikula5853b222016-08-12 17:02:53 +0300288static acpi_status i2c_acpi_lookup_speed(acpi_handle handle, u32 level,
289 void *data, void **return_value)
290{
291 struct i2c_acpi_lookup *lookup = data;
292 struct acpi_device *adev;
293
294 if (acpi_bus_get_device(handle, &adev))
295 return AE_OK;
296
297 if (i2c_acpi_do_lookup(adev, lookup))
298 return AE_OK;
299
300 if (lookup->search_handle != lookup->adapter_handle)
301 return AE_OK;
302
303 if (lookup->speed <= lookup->min_speed)
304 lookup->min_speed = lookup->speed;
305
306 return AE_OK;
307}
308
309/**
310 * i2c_acpi_find_bus_speed - find I2C bus speed from ACPI
311 * @dev: The device owning the bus
312 *
313 * Find the I2C bus speed by walking the ACPI namespace for all I2C slaves
314 * devices connected to this bus and use the speed of slowest device.
315 *
316 * Returns the speed in Hz or zero
317 */
318u32 i2c_acpi_find_bus_speed(struct device *dev)
319{
320 struct i2c_acpi_lookup lookup;
321 struct i2c_board_info dummy;
322 acpi_status status;
323
324 if (!has_acpi_companion(dev))
325 return 0;
326
327 memset(&lookup, 0, sizeof(lookup));
328 lookup.search_handle = ACPI_HANDLE(dev);
329 lookup.min_speed = UINT_MAX;
330 lookup.info = &dummy;
331
332 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
333 I2C_ACPI_MAX_SCAN_DEPTH,
334 i2c_acpi_lookup_speed, NULL,
335 &lookup, NULL);
336
337 if (ACPI_FAILURE(status)) {
338 dev_warn(dev, "unable to find I2C bus speed from ACPI\n");
339 return 0;
340 }
341
342 return lookup.min_speed != UINT_MAX ? lookup.min_speed : 0;
343}
344EXPORT_SYMBOL_GPL(i2c_acpi_find_bus_speed);
345
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300346static int i2c_acpi_match_adapter(struct device *dev, void *data)
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300347{
348 struct i2c_adapter *adapter = i2c_verify_adapter(dev);
349
350 if (!adapter)
351 return 0;
352
353 return ACPI_HANDLE(dev) == (acpi_handle)data;
354}
355
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300356static int i2c_acpi_match_device(struct device *dev, void *data)
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300357{
358 return ACPI_COMPANION(dev) == data;
359}
360
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300361static struct i2c_adapter *i2c_acpi_find_adapter_by_handle(acpi_handle handle)
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300362{
363 struct device *dev;
364
365 dev = bus_find_device(&i2c_bus_type, NULL, handle,
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300366 i2c_acpi_match_adapter);
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300367 return dev ? i2c_verify_adapter(dev) : NULL;
368}
369
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300370static struct i2c_client *i2c_acpi_find_client_by_adev(struct acpi_device *adev)
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300371{
372 struct device *dev;
373
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300374 dev = bus_find_device(&i2c_bus_type, NULL, adev, i2c_acpi_match_device);
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300375 return dev ? i2c_verify_client(dev) : NULL;
376}
377
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300378static int i2c_acpi_notify(struct notifier_block *nb, unsigned long value,
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300379 void *arg)
380{
381 struct acpi_device *adev = arg;
382 struct i2c_board_info info;
383 acpi_handle adapter_handle;
384 struct i2c_adapter *adapter;
385 struct i2c_client *client;
386
387 switch (value) {
388 case ACPI_RECONFIG_DEVICE_ADD:
Mika Westerberg318ce272016-09-20 16:59:25 +0300389 if (i2c_acpi_get_info(adev, &info, NULL, &adapter_handle))
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300390 break;
391
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300392 adapter = i2c_acpi_find_adapter_by_handle(adapter_handle);
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300393 if (!adapter)
394 break;
395
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300396 i2c_acpi_register_device(adapter, adev, &info);
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300397 break;
398 case ACPI_RECONFIG_DEVICE_REMOVE:
399 if (!acpi_device_enumerated(adev))
400 break;
401
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300402 client = i2c_acpi_find_client_by_adev(adev);
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300403 if (!client)
404 break;
405
406 i2c_unregister_device(client);
407 put_device(&client->dev);
408 break;
409 }
410
411 return NOTIFY_OK;
412}
413
414static struct notifier_block i2c_acpi_notifier = {
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300415 .notifier_call = i2c_acpi_notify,
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300416};
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200417#else /* CONFIG_ACPI */
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300418static inline void i2c_acpi_register_devices(struct i2c_adapter *adap) { }
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300419extern struct notifier_block i2c_acpi_notifier;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200420#endif /* CONFIG_ACPI */
421
422#ifdef CONFIG_ACPI_I2C_OPREGION
423static int acpi_gsb_i2c_read_bytes(struct i2c_client *client,
424 u8 cmd, u8 *data, u8 data_len)
425{
426
427 struct i2c_msg msgs[2];
428 int ret;
429 u8 *buffer;
430
431 buffer = kzalloc(data_len, GFP_KERNEL);
432 if (!buffer)
433 return AE_NO_MEMORY;
434
435 msgs[0].addr = client->addr;
436 msgs[0].flags = client->flags;
437 msgs[0].len = 1;
438 msgs[0].buf = &cmd;
439
440 msgs[1].addr = client->addr;
441 msgs[1].flags = client->flags | I2C_M_RD;
442 msgs[1].len = data_len;
443 msgs[1].buf = buffer;
444
445 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
446 if (ret < 0)
447 dev_err(&client->adapter->dev, "i2c read failed\n");
448 else
449 memcpy(data, buffer, data_len);
450
451 kfree(buffer);
452 return ret;
453}
454
455static int acpi_gsb_i2c_write_bytes(struct i2c_client *client,
456 u8 cmd, u8 *data, u8 data_len)
457{
458
459 struct i2c_msg msgs[1];
460 u8 *buffer;
461 int ret = AE_OK;
462
463 buffer = kzalloc(data_len + 1, GFP_KERNEL);
464 if (!buffer)
465 return AE_NO_MEMORY;
466
467 buffer[0] = cmd;
468 memcpy(buffer + 1, data, data_len);
469
470 msgs[0].addr = client->addr;
471 msgs[0].flags = client->flags;
472 msgs[0].len = data_len + 1;
473 msgs[0].buf = buffer;
474
475 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
476 if (ret < 0)
477 dev_err(&client->adapter->dev, "i2c write failed\n");
478
479 kfree(buffer);
480 return ret;
481}
482
483static acpi_status
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300484i2c_acpi_space_handler(u32 function, acpi_physical_address command,
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200485 u32 bits, u64 *value64,
486 void *handler_context, void *region_context)
487{
488 struct gsb_buffer *gsb = (struct gsb_buffer *)value64;
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300489 struct i2c_acpi_handler_data *data = handler_context;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200490 struct acpi_connection_info *info = &data->info;
491 struct acpi_resource_i2c_serialbus *sb;
492 struct i2c_adapter *adapter = data->adapter;
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300493 struct i2c_client *client;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200494 struct acpi_resource *ares;
495 u32 accessor_type = function >> 16;
496 u8 action = function & ACPI_IO_MASK;
Wolfram Sang4470c722014-11-18 15:12:43 +0100497 acpi_status ret;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200498 int status;
499
500 ret = acpi_buffer_to_resource(info->connection, info->length, &ares);
501 if (ACPI_FAILURE(ret))
502 return ret;
503
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300504 client = kzalloc(sizeof(*client), GFP_KERNEL);
505 if (!client) {
506 ret = AE_NO_MEMORY;
507 goto err;
508 }
509
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200510 if (!value64 || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) {
511 ret = AE_BAD_PARAMETER;
512 goto err;
513 }
514
515 sb = &ares->data.i2c_serial_bus;
516 if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C) {
517 ret = AE_BAD_PARAMETER;
518 goto err;
519 }
520
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300521 client->adapter = adapter;
522 client->addr = sb->slave_address;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200523
524 if (sb->access_mode == ACPI_I2C_10BIT_MODE)
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300525 client->flags |= I2C_CLIENT_TEN;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200526
527 switch (accessor_type) {
528 case ACPI_GSB_ACCESS_ATTRIB_SEND_RCV:
529 if (action == ACPI_READ) {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300530 status = i2c_smbus_read_byte(client);
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200531 if (status >= 0) {
532 gsb->bdata = status;
533 status = 0;
534 }
535 } else {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300536 status = i2c_smbus_write_byte(client, gsb->bdata);
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200537 }
538 break;
539
540 case ACPI_GSB_ACCESS_ATTRIB_BYTE:
541 if (action == ACPI_READ) {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300542 status = i2c_smbus_read_byte_data(client, command);
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200543 if (status >= 0) {
544 gsb->bdata = status;
545 status = 0;
546 }
547 } else {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300548 status = i2c_smbus_write_byte_data(client, command,
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200549 gsb->bdata);
550 }
551 break;
552
553 case ACPI_GSB_ACCESS_ATTRIB_WORD:
554 if (action == ACPI_READ) {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300555 status = i2c_smbus_read_word_data(client, command);
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200556 if (status >= 0) {
557 gsb->wdata = status;
558 status = 0;
559 }
560 } else {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300561 status = i2c_smbus_write_word_data(client, command,
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200562 gsb->wdata);
563 }
564 break;
565
566 case ACPI_GSB_ACCESS_ATTRIB_BLOCK:
567 if (action == ACPI_READ) {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300568 status = i2c_smbus_read_block_data(client, command,
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200569 gsb->data);
570 if (status >= 0) {
571 gsb->len = status;
572 status = 0;
573 }
574 } else {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300575 status = i2c_smbus_write_block_data(client, command,
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200576 gsb->len, gsb->data);
577 }
578 break;
579
580 case ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE:
581 if (action == ACPI_READ) {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300582 status = acpi_gsb_i2c_read_bytes(client, command,
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200583 gsb->data, info->access_length);
584 if (status > 0)
585 status = 0;
586 } else {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300587 status = acpi_gsb_i2c_write_bytes(client, command,
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200588 gsb->data, info->access_length);
589 }
590 break;
591
592 default:
Wolfram Sangbe309c32016-07-09 13:35:03 +0900593 dev_warn(&adapter->dev, "protocol 0x%02x not supported for client 0x%02x\n",
594 accessor_type, client->addr);
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200595 ret = AE_BAD_PARAMETER;
596 goto err;
597 }
598
599 gsb->status = status;
600
601 err:
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300602 kfree(client);
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200603 ACPI_FREE(ares);
604 return ret;
605}
606
607
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300608static int i2c_acpi_install_space_handler(struct i2c_adapter *adapter)
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200609{
Peter Hüwe0aef44e2014-09-12 21:09:47 +0200610 acpi_handle handle;
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300611 struct i2c_acpi_handler_data *data;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200612 acpi_status status;
613
Peter Hüwe0aef44e2014-09-12 21:09:47 +0200614 if (!adapter->dev.parent)
615 return -ENODEV;
616
617 handle = ACPI_HANDLE(adapter->dev.parent);
618
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200619 if (!handle)
620 return -ENODEV;
621
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300622 data = kzalloc(sizeof(struct i2c_acpi_handler_data),
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200623 GFP_KERNEL);
624 if (!data)
625 return -ENOMEM;
626
627 data->adapter = adapter;
628 status = acpi_bus_attach_private_data(handle, (void *)data);
629 if (ACPI_FAILURE(status)) {
630 kfree(data);
631 return -ENOMEM;
632 }
633
634 status = acpi_install_address_space_handler(handle,
635 ACPI_ADR_SPACE_GSBUS,
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300636 &i2c_acpi_space_handler,
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200637 NULL,
638 data);
639 if (ACPI_FAILURE(status)) {
640 dev_err(&adapter->dev, "Error installing i2c space handler\n");
641 acpi_bus_detach_private_data(handle);
642 kfree(data);
643 return -ENOMEM;
644 }
645
Lan Tianyu40e7fcb2014-11-23 21:22:54 +0800646 acpi_walk_dep_device_list(handle);
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200647 return 0;
648}
649
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300650static void i2c_acpi_remove_space_handler(struct i2c_adapter *adapter)
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200651{
Peter Hüwe0aef44e2014-09-12 21:09:47 +0200652 acpi_handle handle;
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300653 struct i2c_acpi_handler_data *data;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200654 acpi_status status;
655
Peter Hüwe0aef44e2014-09-12 21:09:47 +0200656 if (!adapter->dev.parent)
657 return;
658
659 handle = ACPI_HANDLE(adapter->dev.parent);
660
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200661 if (!handle)
662 return;
663
664 acpi_remove_address_space_handler(handle,
665 ACPI_ADR_SPACE_GSBUS,
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300666 &i2c_acpi_space_handler);
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200667
668 status = acpi_bus_get_private_data(handle, (void **)&data);
669 if (ACPI_SUCCESS(status))
670 kfree(data);
671
672 acpi_bus_detach_private_data(handle);
673}
674#else /* CONFIG_ACPI_I2C_OPREGION */
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300675static inline void i2c_acpi_remove_space_handler(struct i2c_adapter *adapter)
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200676{ }
677
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300678static inline int i2c_acpi_install_space_handler(struct i2c_adapter *adapter)
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200679{ return 0; }
680#endif /* CONFIG_ACPI_I2C_OPREGION */
681
David Brownellf37dd802007-02-13 22:09:00 +0100682/* ------------------------------------------------------------------------- */
683
Lee Jones5f441fc2016-11-07 12:47:40 +0000684const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
Jean Delvared2653e92008-04-29 23:11:39 +0200685 const struct i2c_client *client)
686{
Lee Jones811073b2016-11-07 12:47:36 +0000687 if (!(id && client))
688 return NULL;
689
Jean Delvared2653e92008-04-29 23:11:39 +0200690 while (id->name[0]) {
691 if (strcmp(client->name, id->name) == 0)
692 return id;
693 id++;
694 }
695 return NULL;
696}
Lee Jones5f441fc2016-11-07 12:47:40 +0000697EXPORT_SYMBOL_GPL(i2c_match_id);
Jean Delvared2653e92008-04-29 23:11:39 +0200698
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699static int i2c_device_match(struct device *dev, struct device_driver *drv)
700{
Jean Delvare51298d12009-09-18 22:45:45 +0200701 struct i2c_client *client = i2c_verify_client(dev);
702 struct i2c_driver *driver;
David Brownell7b4fbc52007-05-01 23:26:30 +0200703
Jean Delvare51298d12009-09-18 22:45:45 +0200704
Grant Likely959e85f2010-06-08 07:48:19 -0600705 /* Attempt an OF style match */
Lee Jonesda10c062016-11-07 12:47:39 +0000706 if (i2c_of_match_device(drv->of_match_table, client))
Grant Likely959e85f2010-06-08 07:48:19 -0600707 return 1;
708
Mika Westerberg907ddf82012-11-23 12:23:40 +0100709 /* Then ACPI style match */
710 if (acpi_driver_match_device(dev, drv))
711 return 1;
712
Jean Delvare51298d12009-09-18 22:45:45 +0200713 driver = to_i2c_driver(drv);
Lee Jones811073b2016-11-07 12:47:36 +0000714
715 /* Finally an I2C match */
716 if (i2c_match_id(driver->id_table, client))
717 return 1;
Jean Delvared2653e92008-04-29 23:11:39 +0200718
Jean Delvareeb8a7902008-05-18 20:49:41 +0200719 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720}
721
Kay Sievers7eff2e72007-08-14 15:15:12 +0200722static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
David Brownell7b4fbc52007-05-01 23:26:30 +0200723{
Wolfram Sang8dcf3212016-03-23 20:47:02 +0100724 struct i2c_client *client = to_i2c_client(dev);
Zhang Rui8c4ff6d2014-01-14 16:46:37 +0800725 int rc;
726
727 rc = acpi_device_uevent_modalias(dev, env);
728 if (rc != -ENODEV)
729 return rc;
David Brownell7b4fbc52007-05-01 23:26:30 +0200730
Wolfram Sang8dcf3212016-03-23 20:47:02 +0100731 return add_uevent_var(env, "MODALIAS=%s%s", I2C_MODULE_PREFIX, client->name);
David Brownell7b4fbc52007-05-01 23:26:30 +0200732}
733
Viresh Kumar5f9296b2012-02-28 18:26:31 +0530734/* i2c bus recovery routines */
735static int get_scl_gpio_value(struct i2c_adapter *adap)
736{
737 return gpio_get_value(adap->bus_recovery_info->scl_gpio);
738}
739
740static void set_scl_gpio_value(struct i2c_adapter *adap, int val)
741{
742 gpio_set_value(adap->bus_recovery_info->scl_gpio, val);
743}
744
745static int get_sda_gpio_value(struct i2c_adapter *adap)
746{
747 return gpio_get_value(adap->bus_recovery_info->sda_gpio);
748}
749
750static int i2c_get_gpios_for_recovery(struct i2c_adapter *adap)
751{
752 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
753 struct device *dev = &adap->dev;
754 int ret = 0;
755
756 ret = gpio_request_one(bri->scl_gpio, GPIOF_OPEN_DRAIN |
757 GPIOF_OUT_INIT_HIGH, "i2c-scl");
758 if (ret) {
759 dev_warn(dev, "Can't get SCL gpio: %d\n", bri->scl_gpio);
760 return ret;
761 }
762
763 if (bri->get_sda) {
764 if (gpio_request_one(bri->sda_gpio, GPIOF_IN, "i2c-sda")) {
765 /* work without SDA polling */
766 dev_warn(dev, "Can't get SDA gpio: %d. Not using SDA polling\n",
767 bri->sda_gpio);
768 bri->get_sda = NULL;
769 }
770 }
771
772 return ret;
773}
774
775static void i2c_put_gpios_for_recovery(struct i2c_adapter *adap)
776{
777 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
778
779 if (bri->get_sda)
780 gpio_free(bri->sda_gpio);
781
782 gpio_free(bri->scl_gpio);
783}
784
785/*
786 * We are generating clock pulses. ndelay() determines durating of clk pulses.
787 * We will generate clock with rate 100 KHz and so duration of both clock levels
788 * is: delay in ns = (10^6 / 100) / 2
789 */
790#define RECOVERY_NDELAY 5000
791#define RECOVERY_CLK_CNT 9
792
793static int i2c_generic_recovery(struct i2c_adapter *adap)
794{
795 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
796 int i = 0, val = 1, ret = 0;
797
798 if (bri->prepare_recovery)
Grygorii Strashko2b2190a2015-04-06 15:38:39 +0300799 bri->prepare_recovery(adap);
Viresh Kumar5f9296b2012-02-28 18:26:31 +0530800
Jan Luebbe8b062602015-07-08 16:35:06 +0200801 bri->set_scl(adap, val);
802 ndelay(RECOVERY_NDELAY);
803
Viresh Kumar5f9296b2012-02-28 18:26:31 +0530804 /*
805 * By this time SCL is high, as we need to give 9 falling-rising edges
806 */
807 while (i++ < RECOVERY_CLK_CNT * 2) {
808 if (val) {
809 /* Break if SDA is high */
810 if (bri->get_sda && bri->get_sda(adap))
811 break;
812 /* SCL shouldn't be low here */
813 if (!bri->get_scl(adap)) {
814 dev_err(&adap->dev,
815 "SCL is stuck low, exit recovery\n");
816 ret = -EBUSY;
817 break;
818 }
819 }
820
821 val = !val;
822 bri->set_scl(adap, val);
823 ndelay(RECOVERY_NDELAY);
824 }
825
826 if (bri->unprepare_recovery)
Grygorii Strashko2b2190a2015-04-06 15:38:39 +0300827 bri->unprepare_recovery(adap);
Viresh Kumar5f9296b2012-02-28 18:26:31 +0530828
829 return ret;
830}
831
832int i2c_generic_scl_recovery(struct i2c_adapter *adap)
833{
Viresh Kumar5f9296b2012-02-28 18:26:31 +0530834 return i2c_generic_recovery(adap);
835}
Mark Brownc1c21f42015-04-15 19:18:39 +0100836EXPORT_SYMBOL_GPL(i2c_generic_scl_recovery);
Viresh Kumar5f9296b2012-02-28 18:26:31 +0530837
838int i2c_generic_gpio_recovery(struct i2c_adapter *adap)
839{
840 int ret;
841
842 ret = i2c_get_gpios_for_recovery(adap);
843 if (ret)
844 return ret;
845
846 ret = i2c_generic_recovery(adap);
847 i2c_put_gpios_for_recovery(adap);
848
849 return ret;
850}
Mark Brownc1c21f42015-04-15 19:18:39 +0100851EXPORT_SYMBOL_GPL(i2c_generic_gpio_recovery);
Viresh Kumar5f9296b2012-02-28 18:26:31 +0530852
853int i2c_recover_bus(struct i2c_adapter *adap)
854{
855 if (!adap->bus_recovery_info)
856 return -EOPNOTSUPP;
857
858 dev_dbg(&adap->dev, "Trying i2c bus recovery\n");
859 return adap->bus_recovery_info->recover_bus(adap);
860}
Mark Brownc1c21f42015-04-15 19:18:39 +0100861EXPORT_SYMBOL_GPL(i2c_recover_bus);
Viresh Kumar5f9296b2012-02-28 18:26:31 +0530862
Wolfram Sangd3b11d82016-07-09 13:34:59 +0900863static void i2c_init_recovery(struct i2c_adapter *adap)
864{
865 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
866 char *err_str;
867
868 if (!bri)
869 return;
870
871 if (!bri->recover_bus) {
872 err_str = "no recover_bus() found";
873 goto err;
874 }
875
876 /* Generic GPIO recovery */
877 if (bri->recover_bus == i2c_generic_gpio_recovery) {
878 if (!gpio_is_valid(bri->scl_gpio)) {
879 err_str = "invalid SCL gpio";
880 goto err;
881 }
882
883 if (gpio_is_valid(bri->sda_gpio))
884 bri->get_sda = get_sda_gpio_value;
885 else
886 bri->get_sda = NULL;
887
888 bri->get_scl = get_scl_gpio_value;
889 bri->set_scl = set_scl_gpio_value;
890 } else if (bri->recover_bus == i2c_generic_scl_recovery) {
891 /* Generic SCL recovery */
892 if (!bri->set_scl || !bri->get_scl) {
893 err_str = "no {get|set}_scl() found";
894 goto err;
895 }
896 }
897
898 return;
899 err:
900 dev_err(&adap->dev, "Not using recovery: %s\n", err_str);
901 adap->bus_recovery_info = NULL;
902}
903
Benjamin Tissoires4d5538f2016-10-13 14:10:40 +0200904static int i2c_smbus_host_notify_to_irq(const struct i2c_client *client)
905{
906 struct i2c_adapter *adap = client->adapter;
907 unsigned int irq;
908
909 if (!adap->host_notify_domain)
910 return -ENXIO;
911
912 if (client->flags & I2C_CLIENT_TEN)
913 return -EINVAL;
914
915 irq = irq_find_mapping(adap->host_notify_domain, client->addr);
916 if (!irq)
917 irq = irq_create_mapping(adap->host_notify_domain,
918 client->addr);
919
920 return irq > 0 ? irq : -ENXIO;
921}
922
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923static int i2c_device_probe(struct device *dev)
924{
Jean Delvare51298d12009-09-18 22:45:45 +0200925 struct i2c_client *client = i2c_verify_client(dev);
926 struct i2c_driver *driver;
Hans Verkuil50c33042008-03-12 14:15:00 +0100927 int status;
David Brownell7b4fbc52007-05-01 23:26:30 +0200928
Jean Delvare51298d12009-09-18 22:45:45 +0200929 if (!client)
930 return 0;
931
Mika Westerberg845c8772015-05-06 13:29:08 +0300932 if (!client->irq) {
933 int irq = -ENOENT;
934
Dmitry Torokhov331c3422017-01-04 20:57:22 -0800935 if (client->flags & I2C_CLIENT_HOST_NOTIFY) {
936 dev_dbg(dev, "Using Host Notify IRQ\n");
937 irq = i2c_smbus_host_notify_to_irq(client);
938 } else if (dev->of_node) {
Dmitry Torokhov3fffd122015-08-17 23:52:51 -0700939 irq = of_irq_get_byname(dev->of_node, "irq");
940 if (irq == -EINVAL || irq == -ENODATA)
941 irq = of_irq_get(dev->of_node, 0);
942 } else if (ACPI_COMPANION(dev)) {
Mika Westerberg845c8772015-05-06 13:29:08 +0300943 irq = acpi_dev_gpio_irq_get(ACPI_COMPANION(dev), 0);
Dmitry Torokhov3fffd122015-08-17 23:52:51 -0700944 }
Geert Uytterhoeven6f34be72014-11-17 12:43:00 +0100945 if (irq == -EPROBE_DEFER)
Laurent Pinchart2fd36c5522014-10-30 15:59:38 +0200946 return irq;
Dmitry Torokhov331c3422017-01-04 20:57:22 -0800947
Geert Uytterhoeven6f34be72014-11-17 12:43:00 +0100948 if (irq < 0)
949 irq = 0;
Laurent Pinchart2fd36c5522014-10-30 15:59:38 +0200950
951 client->irq = irq;
952 }
953
Jean Delvare51298d12009-09-18 22:45:45 +0200954 driver = to_i2c_driver(dev->driver);
Lee Jonesda10c062016-11-07 12:47:39 +0000955
956 /*
957 * An I2C ID table is not mandatory, if and only if, a suitable Device
958 * Tree match table entry is supplied for the probing device.
959 */
960 if (!driver->id_table &&
961 !i2c_of_match_device(dev->driver->of_match_table, client))
David Brownell7b4fbc52007-05-01 23:26:30 +0200962 return -ENODEV;
Lars-Peter Clausen0acc2b32013-09-29 10:51:06 +0200963
Dmitry Torokhov3fffd122015-08-17 23:52:51 -0700964 if (client->flags & I2C_CLIENT_WAKE) {
965 int wakeirq = -ENOENT;
966
967 if (dev->of_node) {
968 wakeirq = of_irq_get_byname(dev->of_node, "wakeup");
969 if (wakeirq == -EPROBE_DEFER)
970 return wakeirq;
971 }
972
973 device_init_wakeup(&client->dev, true);
974
975 if (wakeirq > 0 && wakeirq != client->irq)
976 status = dev_pm_set_dedicated_wake_irq(dev, wakeirq);
977 else if (client->irq > 0)
Grygorii Strashkoc18fba22015-11-12 15:42:26 +0200978 status = dev_pm_set_wake_irq(dev, client->irq);
Dmitry Torokhov3fffd122015-08-17 23:52:51 -0700979 else
980 status = 0;
981
982 if (status)
Andy Shevchenkob93d3d32016-08-25 17:42:10 +0300983 dev_warn(&client->dev, "failed to set up wakeup irq\n");
Dmitry Torokhov3fffd122015-08-17 23:52:51 -0700984 }
985
David Brownell7b4fbc52007-05-01 23:26:30 +0200986 dev_dbg(dev, "probe\n");
Jean Delvared2653e92008-04-29 23:11:39 +0200987
Sylwester Nawrocki86be4082014-06-18 17:29:32 +0200988 status = of_clk_set_defaults(dev->of_node, false);
989 if (status < 0)
Dmitry Torokhov3fffd122015-08-17 23:52:51 -0700990 goto err_clear_wakeup_irq;
Sylwester Nawrocki86be4082014-06-18 17:29:32 +0200991
Ulf Hanssone09b0d42014-09-19 20:27:39 +0200992 status = dev_pm_domain_attach(&client->dev, true);
Kieran Bingham74cedd32015-10-12 21:54:43 +0100993 if (status == -EPROBE_DEFER)
994 goto err_clear_wakeup_irq;
995
Lee Jonesb8a1a4c2016-11-07 12:47:41 +0000996 /*
997 * When there are no more users of probe(),
998 * rename probe_new to probe.
999 */
1000 if (driver->probe_new)
1001 status = driver->probe_new(client);
1002 else if (driver->probe)
1003 status = driver->probe(client,
1004 i2c_match_id(driver->id_table, client));
1005 else
1006 status = -EINVAL;
1007
Kieran Bingham74cedd32015-10-12 21:54:43 +01001008 if (status)
1009 goto err_detach_pm_domain;
Wolfram Sang72fa8182014-01-21 17:48:34 +01001010
Dmitry Torokhov3fffd122015-08-17 23:52:51 -07001011 return 0;
1012
1013err_detach_pm_domain:
1014 dev_pm_domain_detach(&client->dev, true);
1015err_clear_wakeup_irq:
1016 dev_pm_clear_wake_irq(&client->dev);
1017 device_init_wakeup(&client->dev, false);
Hans Verkuil50c33042008-03-12 14:15:00 +01001018 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019}
1020
1021static int i2c_device_remove(struct device *dev)
1022{
Jean Delvare51298d12009-09-18 22:45:45 +02001023 struct i2c_client *client = i2c_verify_client(dev);
David Brownella1d9e6e2007-05-01 23:26:30 +02001024 struct i2c_driver *driver;
Wolfram Sang72fa8182014-01-21 17:48:34 +01001025 int status = 0;
David Brownella1d9e6e2007-05-01 23:26:30 +02001026
Jean Delvare51298d12009-09-18 22:45:45 +02001027 if (!client || !dev->driver)
David Brownella1d9e6e2007-05-01 23:26:30 +02001028 return 0;
1029
1030 driver = to_i2c_driver(dev->driver);
1031 if (driver->remove) {
1032 dev_dbg(dev, "remove\n");
1033 status = driver->remove(client);
David Brownella1d9e6e2007-05-01 23:26:30 +02001034 }
Wolfram Sang72fa8182014-01-21 17:48:34 +01001035
Ulf Hanssone09b0d42014-09-19 20:27:39 +02001036 dev_pm_domain_detach(&client->dev, true);
Dmitry Torokhov3fffd122015-08-17 23:52:51 -07001037
1038 dev_pm_clear_wake_irq(&client->dev);
1039 device_init_wakeup(&client->dev, false);
1040
David Brownella1d9e6e2007-05-01 23:26:30 +02001041 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042}
1043
David Brownellf37dd802007-02-13 22:09:00 +01001044static void i2c_device_shutdown(struct device *dev)
1045{
Jean Delvare51298d12009-09-18 22:45:45 +02001046 struct i2c_client *client = i2c_verify_client(dev);
David Brownellf37dd802007-02-13 22:09:00 +01001047 struct i2c_driver *driver;
1048
Jean Delvare51298d12009-09-18 22:45:45 +02001049 if (!client || !dev->driver)
David Brownellf37dd802007-02-13 22:09:00 +01001050 return;
1051 driver = to_i2c_driver(dev->driver);
1052 if (driver->shutdown)
Jean Delvare51298d12009-09-18 22:45:45 +02001053 driver->shutdown(client);
David Brownellf37dd802007-02-13 22:09:00 +01001054}
1055
David Brownell9c1600e2007-05-01 23:26:31 +02001056static void i2c_client_dev_release(struct device *dev)
1057{
1058 kfree(to_i2c_client(dev));
1059}
1060
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01001061static ssize_t
Jean Delvare4f8cf822009-09-18 22:45:46 +02001062show_name(struct device *dev, struct device_attribute *attr, char *buf)
David Brownell7b4fbc52007-05-01 23:26:30 +02001063{
Jean Delvare4f8cf822009-09-18 22:45:46 +02001064 return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
1065 to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
David Brownell7b4fbc52007-05-01 23:26:30 +02001066}
Wolfram Sanga5eb71b2015-01-19 20:12:24 +01001067static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
David Brownell7b4fbc52007-05-01 23:26:30 +02001068
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01001069static ssize_t
1070show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
David Brownell7b4fbc52007-05-01 23:26:30 +02001071{
1072 struct i2c_client *client = to_i2c_client(dev);
Zhang Rui8c4ff6d2014-01-14 16:46:37 +08001073 int len;
1074
1075 len = acpi_device_modalias(dev, buf, PAGE_SIZE -1);
1076 if (len != -ENODEV)
1077 return len;
1078
Jean Delvareeb8a7902008-05-18 20:49:41 +02001079 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
David Brownell7b4fbc52007-05-01 23:26:30 +02001080}
Jean Delvare51298d12009-09-18 22:45:45 +02001081static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
1082
1083static struct attribute *i2c_dev_attrs[] = {
1084 &dev_attr_name.attr,
David Brownell7b4fbc52007-05-01 23:26:30 +02001085 /* modalias helps coldplug: modprobe $(cat .../modalias) */
Jean Delvare51298d12009-09-18 22:45:45 +02001086 &dev_attr_modalias.attr,
1087 NULL
1088};
Wolfram Sanga5eb71b2015-01-19 20:12:24 +01001089ATTRIBUTE_GROUPS(i2c_dev);
sonic zhang54067ee2009-12-14 21:17:30 +01001090
Jon Smirle9ca9eb2008-07-14 22:38:35 +02001091struct bus_type i2c_bus_type = {
David Brownellf37dd802007-02-13 22:09:00 +01001092 .name = "i2c",
1093 .match = i2c_device_match,
1094 .probe = i2c_device_probe,
1095 .remove = i2c_device_remove,
1096 .shutdown = i2c_device_shutdown,
Russell Kingb864c7d2006-01-05 14:37:50 +00001097};
Jon Smirle9ca9eb2008-07-14 22:38:35 +02001098EXPORT_SYMBOL_GPL(i2c_bus_type);
Russell Kingb864c7d2006-01-05 14:37:50 +00001099
Jean Delvare51298d12009-09-18 22:45:45 +02001100static struct device_type i2c_client_type = {
Wolfram Sanga5eb71b2015-01-19 20:12:24 +01001101 .groups = i2c_dev_groups,
Jean Delvare51298d12009-09-18 22:45:45 +02001102 .uevent = i2c_device_uevent,
1103 .release = i2c_client_dev_release,
1104};
1105
David Brownell9b766b82008-01-27 18:14:51 +01001106
1107/**
1108 * i2c_verify_client - return parameter as i2c_client, or NULL
1109 * @dev: device, probably from some driver model iterator
1110 *
1111 * When traversing the driver model tree, perhaps using driver model
1112 * iterators like @device_for_each_child(), you can't assume very much
1113 * about the nodes you find. Use this function to avoid oopses caused
1114 * by wrongly treating some non-I2C device as an i2c_client.
1115 */
1116struct i2c_client *i2c_verify_client(struct device *dev)
1117{
Jean Delvare51298d12009-09-18 22:45:45 +02001118 return (dev->type == &i2c_client_type)
David Brownell9b766b82008-01-27 18:14:51 +01001119 ? to_i2c_client(dev)
1120 : NULL;
1121}
1122EXPORT_SYMBOL(i2c_verify_client);
1123
1124
Wolfram Sangda899f52015-05-18 21:09:12 +02001125/* Return a unique address which takes the flags of the client into account */
1126static unsigned short i2c_encode_flags_to_addr(struct i2c_client *client)
1127{
1128 unsigned short addr = client->addr;
1129
1130 /* For some client flags, add an arbitrary offset to avoid collisions */
1131 if (client->flags & I2C_CLIENT_TEN)
1132 addr |= I2C_ADDR_OFFSET_TEN_BIT;
1133
1134 if (client->flags & I2C_CLIENT_SLAVE)
1135 addr |= I2C_ADDR_OFFSET_SLAVE;
1136
1137 return addr;
1138}
1139
Jean Delvare3a89db52010-06-03 11:33:52 +02001140/* This is a permissive address validity check, I2C address map constraints
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001141 * are purposely not enforced, except for the general call address. */
Wolfram Sangc4019b72015-07-17 12:50:06 +02001142static int i2c_check_addr_validity(unsigned addr, unsigned short flags)
Jean Delvare3a89db52010-06-03 11:33:52 +02001143{
Wolfram Sangc4019b72015-07-17 12:50:06 +02001144 if (flags & I2C_CLIENT_TEN) {
Jean Delvare3a89db52010-06-03 11:33:52 +02001145 /* 10-bit address, all values are valid */
Wolfram Sangc4019b72015-07-17 12:50:06 +02001146 if (addr > 0x3ff)
Jean Delvare3a89db52010-06-03 11:33:52 +02001147 return -EINVAL;
1148 } else {
1149 /* 7-bit address, reject the general call address */
Wolfram Sangc4019b72015-07-17 12:50:06 +02001150 if (addr == 0x00 || addr > 0x7f)
Jean Delvare3a89db52010-06-03 11:33:52 +02001151 return -EINVAL;
1152 }
1153 return 0;
1154}
1155
Jean Delvare656b8762010-06-03 11:33:53 +02001156/* And this is a strict address validity check, used when probing. If a
1157 * device uses a reserved address, then it shouldn't be probed. 7-bit
1158 * addressing is assumed, 10-bit address devices are rare and should be
1159 * explicitly enumerated. */
Wolfram Sang66be60562015-07-17 12:43:22 +02001160static int i2c_check_7bit_addr_validity_strict(unsigned short addr)
Jean Delvare656b8762010-06-03 11:33:53 +02001161{
1162 /*
1163 * Reserved addresses per I2C specification:
1164 * 0x00 General call address / START byte
1165 * 0x01 CBUS address
1166 * 0x02 Reserved for different bus format
1167 * 0x03 Reserved for future purposes
1168 * 0x04-0x07 Hs-mode master code
1169 * 0x78-0x7b 10-bit slave addressing
1170 * 0x7c-0x7f Reserved for future purposes
1171 */
1172 if (addr < 0x08 || addr > 0x77)
1173 return -EINVAL;
1174 return 0;
1175}
1176
Jean Delvare3b5f7942010-06-03 11:33:55 +02001177static int __i2c_check_addr_busy(struct device *dev, void *addrp)
1178{
1179 struct i2c_client *client = i2c_verify_client(dev);
1180 int addr = *(int *)addrp;
1181
Wolfram Sang9bccc702015-07-17 14:48:56 +02001182 if (client && i2c_encode_flags_to_addr(client) == addr)
Jean Delvare3b5f7942010-06-03 11:33:55 +02001183 return -EBUSY;
1184 return 0;
1185}
1186
Michael Lawnick08263742010-08-11 18:21:02 +02001187/* walk up mux tree */
1188static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
1189{
Jean Delvare97cc4d42010-10-24 18:16:57 +02001190 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
Michael Lawnick08263742010-08-11 18:21:02 +02001191 int result;
1192
1193 result = device_for_each_child(&adapter->dev, &addr,
1194 __i2c_check_addr_busy);
1195
Jean Delvare97cc4d42010-10-24 18:16:57 +02001196 if (!result && parent)
1197 result = i2c_check_mux_parents(parent, addr);
Michael Lawnick08263742010-08-11 18:21:02 +02001198
1199 return result;
1200}
1201
1202/* recurse down mux tree */
1203static int i2c_check_mux_children(struct device *dev, void *addrp)
1204{
1205 int result;
1206
1207 if (dev->type == &i2c_adapter_type)
1208 result = device_for_each_child(dev, addrp,
1209 i2c_check_mux_children);
1210 else
1211 result = __i2c_check_addr_busy(dev, addrp);
1212
1213 return result;
1214}
1215
Jean Delvare3b5f7942010-06-03 11:33:55 +02001216static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
1217{
Jean Delvare97cc4d42010-10-24 18:16:57 +02001218 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
Michael Lawnick08263742010-08-11 18:21:02 +02001219 int result = 0;
1220
Jean Delvare97cc4d42010-10-24 18:16:57 +02001221 if (parent)
1222 result = i2c_check_mux_parents(parent, addr);
Michael Lawnick08263742010-08-11 18:21:02 +02001223
1224 if (!result)
1225 result = device_for_each_child(&adapter->dev, &addr,
1226 i2c_check_mux_children);
1227
1228 return result;
Jean Delvare3b5f7942010-06-03 11:33:55 +02001229}
1230
David Brownell9c1600e2007-05-01 23:26:31 +02001231/**
Peter Rosin8320f492016-05-04 22:15:27 +02001232 * i2c_adapter_lock_bus - Get exclusive access to an I2C bus segment
Jean Delvarefe61e072010-08-11 18:20:58 +02001233 * @adapter: Target I2C bus segment
Peter Rosin8320f492016-05-04 22:15:27 +02001234 * @flags: I2C_LOCK_ROOT_ADAPTER locks the root i2c adapter, I2C_LOCK_SEGMENT
1235 * locks only this branch in the adapter tree
Jean Delvarefe61e072010-08-11 18:20:58 +02001236 */
Peter Rosin8320f492016-05-04 22:15:27 +02001237static void i2c_adapter_lock_bus(struct i2c_adapter *adapter,
1238 unsigned int flags)
Jean Delvarefe61e072010-08-11 18:20:58 +02001239{
Peter Rosinfa96f0c2016-05-04 22:15:28 +02001240 rt_mutex_lock(&adapter->bus_lock);
Jean Delvarefe61e072010-08-11 18:20:58 +02001241}
Jean Delvarefe61e072010-08-11 18:20:58 +02001242
1243/**
Peter Rosin8320f492016-05-04 22:15:27 +02001244 * i2c_adapter_trylock_bus - Try to get exclusive access to an I2C bus segment
Jean Delvarefe61e072010-08-11 18:20:58 +02001245 * @adapter: Target I2C bus segment
Peter Rosin8320f492016-05-04 22:15:27 +02001246 * @flags: I2C_LOCK_ROOT_ADAPTER trylocks the root i2c adapter, I2C_LOCK_SEGMENT
1247 * trylocks only this branch in the adapter tree
Jean Delvarefe61e072010-08-11 18:20:58 +02001248 */
Peter Rosin8320f492016-05-04 22:15:27 +02001249static int i2c_adapter_trylock_bus(struct i2c_adapter *adapter,
1250 unsigned int flags)
Jean Delvarefe61e072010-08-11 18:20:58 +02001251{
Peter Rosinfa96f0c2016-05-04 22:15:28 +02001252 return rt_mutex_trylock(&adapter->bus_lock);
Jean Delvarefe61e072010-08-11 18:20:58 +02001253}
1254
1255/**
Peter Rosin8320f492016-05-04 22:15:27 +02001256 * i2c_adapter_unlock_bus - Release exclusive access to an I2C bus segment
Jean Delvarefe61e072010-08-11 18:20:58 +02001257 * @adapter: Target I2C bus segment
Peter Rosin8320f492016-05-04 22:15:27 +02001258 * @flags: I2C_LOCK_ROOT_ADAPTER unlocks the root i2c adapter, I2C_LOCK_SEGMENT
1259 * unlocks only this branch in the adapter tree
Jean Delvarefe61e072010-08-11 18:20:58 +02001260 */
Peter Rosin8320f492016-05-04 22:15:27 +02001261static void i2c_adapter_unlock_bus(struct i2c_adapter *adapter,
1262 unsigned int flags)
Jean Delvarefe61e072010-08-11 18:20:58 +02001263{
Peter Rosinfa96f0c2016-05-04 22:15:28 +02001264 rt_mutex_unlock(&adapter->bus_lock);
Jean Delvarefe61e072010-08-11 18:20:58 +02001265}
Jean Delvarefe61e072010-08-11 18:20:58 +02001266
Jarkko Nikula70762ab2013-11-14 14:03:52 +02001267static void i2c_dev_set_name(struct i2c_adapter *adap,
1268 struct i2c_client *client)
1269{
1270 struct acpi_device *adev = ACPI_COMPANION(&client->dev);
1271
1272 if (adev) {
1273 dev_set_name(&client->dev, "i2c-%s", acpi_dev_name(adev));
1274 return;
1275 }
1276
Jarkko Nikula70762ab2013-11-14 14:03:52 +02001277 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
Wolfram Sangda899f52015-05-18 21:09:12 +02001278 i2c_encode_flags_to_addr(client));
Jarkko Nikula70762ab2013-11-14 14:03:52 +02001279}
1280
Jean Delvarefe61e072010-08-11 18:20:58 +02001281/**
Jean Delvaref8a227e2009-06-19 16:58:18 +02001282 * i2c_new_device - instantiate an i2c device
David Brownell9c1600e2007-05-01 23:26:31 +02001283 * @adap: the adapter managing the device
1284 * @info: describes one I2C device; bus_num is ignored
David Brownelld64f73b2007-07-12 14:12:28 +02001285 * Context: can sleep
David Brownell9c1600e2007-05-01 23:26:31 +02001286 *
Jean Delvaref8a227e2009-06-19 16:58:18 +02001287 * Create an i2c device. Binding is handled through driver model
1288 * probe()/remove() methods. A driver may be bound to this device when we
1289 * return from this function, or any later moment (e.g. maybe hotplugging will
1290 * load the driver module). This call is not appropriate for use by mainboard
1291 * initialization logic, which usually runs during an arch_initcall() long
1292 * before any i2c_adapter could exist.
David Brownell9c1600e2007-05-01 23:26:31 +02001293 *
1294 * This returns the new i2c client, which may be saved for later use with
1295 * i2c_unregister_device(); or NULL to indicate an error.
1296 */
1297struct i2c_client *
1298i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
1299{
1300 struct i2c_client *client;
1301 int status;
1302
1303 client = kzalloc(sizeof *client, GFP_KERNEL);
1304 if (!client)
1305 return NULL;
1306
1307 client->adapter = adap;
1308
1309 client->dev.platform_data = info->platform_data;
David Brownell3bbb8352007-10-13 23:56:29 +02001310
Anton Vorontsov11f1f2a2008-10-22 20:21:33 +02001311 if (info->archdata)
1312 client->dev.archdata = *info->archdata;
1313
Marc Pignatee354252008-08-28 08:33:22 +02001314 client->flags = info->flags;
David Brownell9c1600e2007-05-01 23:26:31 +02001315 client->addr = info->addr;
1316 client->irq = info->irq;
1317
David Brownell9c1600e2007-05-01 23:26:31 +02001318 strlcpy(client->name, info->type, sizeof(client->name));
1319
Wolfram Sangc4019b72015-07-17 12:50:06 +02001320 status = i2c_check_addr_validity(client->addr, client->flags);
Jean Delvare3a89db52010-06-03 11:33:52 +02001321 if (status) {
1322 dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
1323 client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
1324 goto out_err_silent;
1325 }
1326
Jean Delvaref8a227e2009-06-19 16:58:18 +02001327 /* Check for address business */
Wolfram Sang9bccc702015-07-17 14:48:56 +02001328 status = i2c_check_addr_busy(adap, i2c_encode_flags_to_addr(client));
Jean Delvaref8a227e2009-06-19 16:58:18 +02001329 if (status)
1330 goto out_err;
1331
1332 client->dev.parent = &client->adapter->dev;
1333 client->dev.bus = &i2c_bus_type;
Jean Delvare51298d12009-09-18 22:45:45 +02001334 client->dev.type = &i2c_client_type;
Grant Likelyd12d42f2010-04-13 16:12:28 -07001335 client->dev.of_node = info->of_node;
Rafael J. Wysockice793482015-03-16 23:49:03 +01001336 client->dev.fwnode = info->fwnode;
Jean Delvaref8a227e2009-06-19 16:58:18 +02001337
Jarkko Nikula70762ab2013-11-14 14:03:52 +02001338 i2c_dev_set_name(adap, client);
Dmitry Torokhovd3e1b612017-02-02 17:41:28 -08001339
1340 if (info->properties) {
1341 status = device_add_properties(&client->dev, info->properties);
1342 if (status) {
1343 dev_err(&adap->dev,
1344 "Failed to add properties to client %s: %d\n",
1345 client->name, status);
1346 goto out_err;
1347 }
1348 }
1349
Jean Delvaref8a227e2009-06-19 16:58:18 +02001350 status = device_register(&client->dev);
1351 if (status)
Dmitry Torokhovd3e1b612017-02-02 17:41:28 -08001352 goto out_free_props;
Jean Delvaref8a227e2009-06-19 16:58:18 +02001353
Jean Delvaref8a227e2009-06-19 16:58:18 +02001354 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
1355 client->name, dev_name(&client->dev));
1356
David Brownell9c1600e2007-05-01 23:26:31 +02001357 return client;
Jean Delvaref8a227e2009-06-19 16:58:18 +02001358
Dmitry Torokhovd3e1b612017-02-02 17:41:28 -08001359out_free_props:
1360 if (info->properties)
1361 device_remove_properties(&client->dev);
Jean Delvaref8a227e2009-06-19 16:58:18 +02001362out_err:
Andy Shevchenkob93d3d32016-08-25 17:42:10 +03001363 dev_err(&adap->dev,
1364 "Failed to register i2c client %s at 0x%02x (%d)\n",
1365 client->name, client->addr, status);
Jean Delvare3a89db52010-06-03 11:33:52 +02001366out_err_silent:
Jean Delvaref8a227e2009-06-19 16:58:18 +02001367 kfree(client);
1368 return NULL;
David Brownell9c1600e2007-05-01 23:26:31 +02001369}
1370EXPORT_SYMBOL_GPL(i2c_new_device);
1371
1372
1373/**
1374 * i2c_unregister_device - reverse effect of i2c_new_device()
1375 * @client: value returned from i2c_new_device()
David Brownelld64f73b2007-07-12 14:12:28 +02001376 * Context: can sleep
David Brownell9c1600e2007-05-01 23:26:31 +02001377 */
1378void i2c_unregister_device(struct i2c_client *client)
David Brownella1d9e6e2007-05-01 23:26:30 +02001379{
Pantelis Antoniou4f001fd2015-01-24 09:16:29 +02001380 if (client->dev.of_node)
1381 of_node_clear_flag(client->dev.of_node, OF_POPULATED);
Octavian Purdila525e6fa2016-07-08 19:13:10 +03001382 if (ACPI_COMPANION(&client->dev))
1383 acpi_device_clear_enumerated(ACPI_COMPANION(&client->dev));
David Brownella1d9e6e2007-05-01 23:26:30 +02001384 device_unregister(&client->dev);
1385}
David Brownell9c1600e2007-05-01 23:26:31 +02001386EXPORT_SYMBOL_GPL(i2c_unregister_device);
David Brownella1d9e6e2007-05-01 23:26:30 +02001387
1388
Jean Delvare60b129d2008-05-11 20:37:06 +02001389static const struct i2c_device_id dummy_id[] = {
1390 { "dummy", 0 },
1391 { },
1392};
1393
Jean Delvared2653e92008-04-29 23:11:39 +02001394static int dummy_probe(struct i2c_client *client,
1395 const struct i2c_device_id *id)
1396{
1397 return 0;
1398}
1399
1400static int dummy_remove(struct i2c_client *client)
David Brownelle9f13732008-01-27 18:14:52 +01001401{
1402 return 0;
1403}
1404
1405static struct i2c_driver dummy_driver = {
1406 .driver.name = "dummy",
Jean Delvared2653e92008-04-29 23:11:39 +02001407 .probe = dummy_probe,
1408 .remove = dummy_remove,
Jean Delvare60b129d2008-05-11 20:37:06 +02001409 .id_table = dummy_id,
David Brownelle9f13732008-01-27 18:14:52 +01001410};
1411
1412/**
1413 * i2c_new_dummy - return a new i2c device bound to a dummy driver
1414 * @adapter: the adapter managing the device
1415 * @address: seven bit address to be used
David Brownelle9f13732008-01-27 18:14:52 +01001416 * Context: can sleep
1417 *
1418 * This returns an I2C client bound to the "dummy" driver, intended for use
1419 * with devices that consume multiple addresses. Examples of such chips
1420 * include various EEPROMS (like 24c04 and 24c08 models).
1421 *
1422 * These dummy devices have two main uses. First, most I2C and SMBus calls
1423 * except i2c_transfer() need a client handle; the dummy will be that handle.
1424 * And second, this prevents the specified address from being bound to a
1425 * different driver.
1426 *
1427 * This returns the new i2c client, which should be saved for later use with
1428 * i2c_unregister_device(); or NULL to indicate an error.
1429 */
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01001430struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
David Brownelle9f13732008-01-27 18:14:52 +01001431{
1432 struct i2c_board_info info = {
Jean Delvare60b129d2008-05-11 20:37:06 +02001433 I2C_BOARD_INFO("dummy", address),
David Brownelle9f13732008-01-27 18:14:52 +01001434 };
1435
David Brownelle9f13732008-01-27 18:14:52 +01001436 return i2c_new_device(adapter, &info);
1437}
1438EXPORT_SYMBOL_GPL(i2c_new_dummy);
1439
Jean-Michel Hautbois0f614d82016-01-31 16:33:00 +01001440/**
1441 * i2c_new_secondary_device - Helper to get the instantiated secondary address
1442 * and create the associated device
1443 * @client: Handle to the primary client
1444 * @name: Handle to specify which secondary address to get
1445 * @default_addr: Used as a fallback if no secondary address was specified
1446 * Context: can sleep
1447 *
1448 * I2C clients can be composed of multiple I2C slaves bound together in a single
1449 * component. The I2C client driver then binds to the master I2C slave and needs
1450 * to create I2C dummy clients to communicate with all the other slaves.
1451 *
1452 * This function creates and returns an I2C dummy client whose I2C address is
1453 * retrieved from the platform firmware based on the given slave name. If no
1454 * address is specified by the firmware default_addr is used.
1455 *
1456 * On DT-based platforms the address is retrieved from the "reg" property entry
1457 * cell whose "reg-names" value matches the slave name.
1458 *
1459 * This returns the new i2c client, which should be saved for later use with
1460 * i2c_unregister_device(); or NULL to indicate an error.
1461 */
1462struct i2c_client *i2c_new_secondary_device(struct i2c_client *client,
1463 const char *name,
1464 u16 default_addr)
1465{
1466 struct device_node *np = client->dev.of_node;
1467 u32 addr = default_addr;
1468 int i;
1469
1470 if (np) {
1471 i = of_property_match_string(np, "reg-names", name);
1472 if (i >= 0)
1473 of_property_read_u32_index(np, "reg", i, &addr);
1474 }
1475
1476 dev_dbg(&client->adapter->dev, "Address for %s : 0x%x\n", name, addr);
1477 return i2c_new_dummy(client->adapter, addr);
1478}
1479EXPORT_SYMBOL_GPL(i2c_new_secondary_device);
1480
David Brownellf37dd802007-02-13 22:09:00 +01001481/* ------------------------------------------------------------------------- */
1482
David Brownell16ffadfc2007-05-01 23:26:28 +02001483/* I2C bus adapters -- one roots each I2C or SMBUS segment */
1484
Adrian Bunk83eaaed2007-10-13 23:56:30 +02001485static void i2c_adapter_dev_release(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486{
David Brownellef2c83212007-05-01 23:26:28 +02001487 struct i2c_adapter *adap = to_i2c_adapter(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001488 complete(&adap->dev_released);
1489}
1490
Bartosz Golaszewski8dd1fe12016-09-16 18:02:42 +02001491unsigned int i2c_adapter_depth(struct i2c_adapter *adapter)
Jean Delvare390946b2012-09-10 10:14:02 +02001492{
1493 unsigned int depth = 0;
1494
1495 while ((adapter = i2c_parent_is_i2c_adapter(adapter)))
1496 depth++;
1497
Bartosz Golaszewski2771dc32016-09-16 18:02:44 +02001498 WARN_ONCE(depth >= MAX_LOCKDEP_SUBCLASSES,
1499 "adapter depth exceeds lockdep subclass limit\n");
1500
Jean Delvare390946b2012-09-10 10:14:02 +02001501 return depth;
1502}
Bartosz Golaszewski8dd1fe12016-09-16 18:02:42 +02001503EXPORT_SYMBOL_GPL(i2c_adapter_depth);
Jean Delvare390946b2012-09-10 10:14:02 +02001504
1505/*
Jean Delvare99cd8e22009-06-19 16:58:20 +02001506 * Let users instantiate I2C devices through sysfs. This can be used when
1507 * platform initialization code doesn't contain the proper data for
1508 * whatever reason. Also useful for drivers that do device detection and
1509 * detection fails, either because the device uses an unexpected address,
1510 * or this is a compatible device with different ID register values.
1511 *
1512 * Parameter checking may look overzealous, but we really don't want
1513 * the user to provide incorrect parameters.
1514 */
1515static ssize_t
1516i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
1517 const char *buf, size_t count)
1518{
1519 struct i2c_adapter *adap = to_i2c_adapter(dev);
1520 struct i2c_board_info info;
1521 struct i2c_client *client;
1522 char *blank, end;
1523 int res;
1524
Jean Delvare99cd8e22009-06-19 16:58:20 +02001525 memset(&info, 0, sizeof(struct i2c_board_info));
1526
1527 blank = strchr(buf, ' ');
1528 if (!blank) {
1529 dev_err(dev, "%s: Missing parameters\n", "new_device");
1530 return -EINVAL;
1531 }
1532 if (blank - buf > I2C_NAME_SIZE - 1) {
1533 dev_err(dev, "%s: Invalid device name\n", "new_device");
1534 return -EINVAL;
1535 }
1536 memcpy(info.type, buf, blank - buf);
1537
1538 /* Parse remaining parameters, reject extra parameters */
1539 res = sscanf(++blank, "%hi%c", &info.addr, &end);
1540 if (res < 1) {
1541 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
1542 return -EINVAL;
1543 }
1544 if (res > 1 && end != '\n') {
1545 dev_err(dev, "%s: Extra parameters\n", "new_device");
1546 return -EINVAL;
1547 }
1548
Wolfram Sangcfa03272015-07-27 14:03:38 +02001549 if ((info.addr & I2C_ADDR_OFFSET_TEN_BIT) == I2C_ADDR_OFFSET_TEN_BIT) {
1550 info.addr &= ~I2C_ADDR_OFFSET_TEN_BIT;
1551 info.flags |= I2C_CLIENT_TEN;
1552 }
1553
1554 if (info.addr & I2C_ADDR_OFFSET_SLAVE) {
1555 info.addr &= ~I2C_ADDR_OFFSET_SLAVE;
1556 info.flags |= I2C_CLIENT_SLAVE;
1557 }
1558
Jean Delvare99cd8e22009-06-19 16:58:20 +02001559 client = i2c_new_device(adap, &info);
1560 if (!client)
Jean Delvare3a89db52010-06-03 11:33:52 +02001561 return -EINVAL;
Jean Delvare99cd8e22009-06-19 16:58:20 +02001562
1563 /* Keep track of the added device */
Jean Delvaredafc50d2010-08-11 18:21:01 +02001564 mutex_lock(&adap->userspace_clients_lock);
Jean Delvare6629dcf2010-05-04 11:09:28 +02001565 list_add_tail(&client->detected, &adap->userspace_clients);
Jean Delvaredafc50d2010-08-11 18:21:01 +02001566 mutex_unlock(&adap->userspace_clients_lock);
Jean Delvare99cd8e22009-06-19 16:58:20 +02001567 dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
1568 info.type, info.addr);
1569
1570 return count;
1571}
Wolfram Sanga5eb71b2015-01-19 20:12:24 +01001572static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
Jean Delvare99cd8e22009-06-19 16:58:20 +02001573
1574/*
1575 * And of course let the users delete the devices they instantiated, if
1576 * they got it wrong. This interface can only be used to delete devices
1577 * instantiated by i2c_sysfs_new_device above. This guarantees that we
1578 * don't delete devices to which some kernel code still has references.
1579 *
1580 * Parameter checking may look overzealous, but we really don't want
1581 * the user to delete the wrong device.
1582 */
1583static ssize_t
1584i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
1585 const char *buf, size_t count)
1586{
1587 struct i2c_adapter *adap = to_i2c_adapter(dev);
1588 struct i2c_client *client, *next;
1589 unsigned short addr;
1590 char end;
1591 int res;
1592
1593 /* Parse parameters, reject extra parameters */
1594 res = sscanf(buf, "%hi%c", &addr, &end);
1595 if (res < 1) {
1596 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
1597 return -EINVAL;
1598 }
1599 if (res > 1 && end != '\n') {
1600 dev_err(dev, "%s: Extra parameters\n", "delete_device");
1601 return -EINVAL;
1602 }
1603
1604 /* Make sure the device was added through sysfs */
1605 res = -ENOENT;
Jean Delvare390946b2012-09-10 10:14:02 +02001606 mutex_lock_nested(&adap->userspace_clients_lock,
1607 i2c_adapter_depth(adap));
Jean Delvare6629dcf2010-05-04 11:09:28 +02001608 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1609 detected) {
Wolfram Sangcfa03272015-07-27 14:03:38 +02001610 if (i2c_encode_flags_to_addr(client) == addr) {
Jean Delvare99cd8e22009-06-19 16:58:20 +02001611 dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
1612 "delete_device", client->name, client->addr);
1613
1614 list_del(&client->detected);
1615 i2c_unregister_device(client);
1616 res = count;
1617 break;
1618 }
1619 }
Jean Delvaredafc50d2010-08-11 18:21:01 +02001620 mutex_unlock(&adap->userspace_clients_lock);
Jean Delvare99cd8e22009-06-19 16:58:20 +02001621
1622 if (res < 0)
1623 dev_err(dev, "%s: Can't find device in list\n",
1624 "delete_device");
1625 return res;
1626}
Alexander Sverdline9b526f2013-05-17 14:56:35 +02001627static DEVICE_ATTR_IGNORE_LOCKDEP(delete_device, S_IWUSR, NULL,
1628 i2c_sysfs_delete_device);
Jean Delvare4f8cf822009-09-18 22:45:46 +02001629
1630static struct attribute *i2c_adapter_attrs[] = {
1631 &dev_attr_name.attr,
1632 &dev_attr_new_device.attr,
1633 &dev_attr_delete_device.attr,
1634 NULL
David Brownell16ffadfc2007-05-01 23:26:28 +02001635};
Wolfram Sanga5eb71b2015-01-19 20:12:24 +01001636ATTRIBUTE_GROUPS(i2c_adapter);
Jean Delvare4f8cf822009-09-18 22:45:46 +02001637
Michael Lawnick08263742010-08-11 18:21:02 +02001638struct device_type i2c_adapter_type = {
Wolfram Sanga5eb71b2015-01-19 20:12:24 +01001639 .groups = i2c_adapter_groups,
Jean Delvare4f8cf822009-09-18 22:45:46 +02001640 .release = i2c_adapter_dev_release,
David Brownell16ffadfc2007-05-01 23:26:28 +02001641};
Michael Lawnick08263742010-08-11 18:21:02 +02001642EXPORT_SYMBOL_GPL(i2c_adapter_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643
Stephen Warren643dd092012-04-17 12:43:33 -06001644/**
1645 * i2c_verify_adapter - return parameter as i2c_adapter or NULL
1646 * @dev: device, probably from some driver model iterator
1647 *
1648 * When traversing the driver model tree, perhaps using driver model
1649 * iterators like @device_for_each_child(), you can't assume very much
1650 * about the nodes you find. Use this function to avoid oopses caused
1651 * by wrongly treating some non-I2C device as an i2c_adapter.
1652 */
1653struct i2c_adapter *i2c_verify_adapter(struct device *dev)
1654{
1655 return (dev->type == &i2c_adapter_type)
1656 ? to_i2c_adapter(dev)
1657 : NULL;
1658}
1659EXPORT_SYMBOL(i2c_verify_adapter);
1660
Jean Delvare2bb50952009-09-18 22:45:46 +02001661#ifdef CONFIG_I2C_COMPAT
1662static struct class_compat *i2c_adapter_compat_class;
1663#endif
1664
David Brownell9c1600e2007-05-01 23:26:31 +02001665static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
1666{
1667 struct i2c_devinfo *devinfo;
1668
Rodolfo Giomettif18c41d2009-06-19 16:58:20 +02001669 down_read(&__i2c_board_lock);
David Brownell9c1600e2007-05-01 23:26:31 +02001670 list_for_each_entry(devinfo, &__i2c_board_list, list) {
1671 if (devinfo->busnum == adapter->nr
1672 && !i2c_new_device(adapter,
1673 &devinfo->board_info))
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01001674 dev_err(&adapter->dev,
1675 "Can't create device at 0x%02x\n",
David Brownell9c1600e2007-05-01 23:26:31 +02001676 devinfo->board_info.addr);
1677 }
Rodolfo Giomettif18c41d2009-06-19 16:58:20 +02001678 up_read(&__i2c_board_lock);
David Brownell9c1600e2007-05-01 23:26:31 +02001679}
1680
Wolfram Sang687b81d2013-07-11 12:56:15 +01001681/* OF support code */
1682
1683#if IS_ENABLED(CONFIG_OF)
Pantelis Antonioua430a3452014-10-28 22:36:02 +02001684static struct i2c_client *of_i2c_register_device(struct i2c_adapter *adap,
1685 struct device_node *node)
1686{
1687 struct i2c_client *result;
1688 struct i2c_board_info info = {};
1689 struct dev_archdata dev_ad = {};
Wolfram Sangb4e2f6a2015-05-19 21:04:40 +02001690 const __be32 *addr_be;
1691 u32 addr;
Pantelis Antonioua430a3452014-10-28 22:36:02 +02001692 int len;
1693
1694 dev_dbg(&adap->dev, "of_i2c: register %s\n", node->full_name);
1695
1696 if (of_modalias_node(node, info.type, sizeof(info.type)) < 0) {
1697 dev_err(&adap->dev, "of_i2c: modalias failure on %s\n",
1698 node->full_name);
1699 return ERR_PTR(-EINVAL);
1700 }
1701
Wolfram Sangb4e2f6a2015-05-19 21:04:40 +02001702 addr_be = of_get_property(node, "reg", &len);
1703 if (!addr_be || (len < sizeof(*addr_be))) {
Pantelis Antonioua430a3452014-10-28 22:36:02 +02001704 dev_err(&adap->dev, "of_i2c: invalid reg on %s\n",
1705 node->full_name);
1706 return ERR_PTR(-EINVAL);
1707 }
1708
Wolfram Sangb4e2f6a2015-05-19 21:04:40 +02001709 addr = be32_to_cpup(addr_be);
1710 if (addr & I2C_TEN_BIT_ADDRESS) {
1711 addr &= ~I2C_TEN_BIT_ADDRESS;
1712 info.flags |= I2C_CLIENT_TEN;
1713 }
1714
1715 if (addr & I2C_OWN_SLAVE_ADDRESS) {
1716 addr &= ~I2C_OWN_SLAVE_ADDRESS;
1717 info.flags |= I2C_CLIENT_SLAVE;
1718 }
1719
1720 if (i2c_check_addr_validity(addr, info.flags)) {
Pantelis Antonioua430a3452014-10-28 22:36:02 +02001721 dev_err(&adap->dev, "of_i2c: invalid addr=%x on %s\n",
John Garry6f724fb2017-01-06 19:02:57 +08001722 addr, node->full_name);
Pantelis Antonioua430a3452014-10-28 22:36:02 +02001723 return ERR_PTR(-EINVAL);
1724 }
1725
Wolfram Sangb4e2f6a2015-05-19 21:04:40 +02001726 info.addr = addr;
Pantelis Antonioua430a3452014-10-28 22:36:02 +02001727 info.of_node = of_node_get(node);
1728 info.archdata = &dev_ad;
1729
Dmitry Torokhov331c3422017-01-04 20:57:22 -08001730 if (of_property_read_bool(node, "host-notify"))
1731 info.flags |= I2C_CLIENT_HOST_NOTIFY;
1732
Pantelis Antonioua430a3452014-10-28 22:36:02 +02001733 if (of_get_property(node, "wakeup-source", NULL))
1734 info.flags |= I2C_CLIENT_WAKE;
1735
Pantelis Antonioua430a3452014-10-28 22:36:02 +02001736 result = i2c_new_device(adap, &info);
1737 if (result == NULL) {
1738 dev_err(&adap->dev, "of_i2c: Failure registering %s\n",
1739 node->full_name);
1740 of_node_put(node);
Pantelis Antonioua430a3452014-10-28 22:36:02 +02001741 return ERR_PTR(-EINVAL);
1742 }
1743 return result;
1744}
1745
Wolfram Sang687b81d2013-07-11 12:56:15 +01001746static void of_i2c_register_devices(struct i2c_adapter *adap)
1747{
Jon Hunter7e4c2242016-06-29 10:17:53 +01001748 struct device_node *bus, *node;
Ralf Ramsauer6a676fb2016-10-17 15:59:57 +02001749 struct i2c_client *client;
Wolfram Sang687b81d2013-07-11 12:56:15 +01001750
1751 /* Only register child devices if the adapter has a node pointer set */
1752 if (!adap->dev.of_node)
1753 return;
1754
1755 dev_dbg(&adap->dev, "of_i2c: walking child nodes\n");
1756
Jon Hunter7e4c2242016-06-29 10:17:53 +01001757 bus = of_get_child_by_name(adap->dev.of_node, "i2c-bus");
1758 if (!bus)
1759 bus = of_node_get(adap->dev.of_node);
1760
1761 for_each_available_child_of_node(bus, node) {
Pantelis Antoniou4f001fd2015-01-24 09:16:29 +02001762 if (of_node_test_and_set_flag(node, OF_POPULATED))
1763 continue;
Ralf Ramsauer6a676fb2016-10-17 15:59:57 +02001764
1765 client = of_i2c_register_device(adap, node);
1766 if (IS_ERR(client)) {
1767 dev_warn(&adap->dev,
1768 "Failed to create I2C device for %s\n",
1769 node->full_name);
1770 of_node_clear_flag(node, OF_POPULATED);
1771 }
Pantelis Antoniou4f001fd2015-01-24 09:16:29 +02001772 }
Jon Hunter7e4c2242016-06-29 10:17:53 +01001773
1774 of_node_put(bus);
Wolfram Sang687b81d2013-07-11 12:56:15 +01001775}
1776
1777static int of_dev_node_match(struct device *dev, void *data)
1778{
1779 return dev->of_node == data;
1780}
1781
1782/* must call put_device() when done with returned i2c_client device */
1783struct i2c_client *of_find_i2c_device_by_node(struct device_node *node)
1784{
1785 struct device *dev;
Vladimir Zapolskiye3311462015-07-27 17:30:48 +03001786 struct i2c_client *client;
Wolfram Sang687b81d2013-07-11 12:56:15 +01001787
Vladimir Zapolskiye3311462015-07-27 17:30:48 +03001788 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
Wolfram Sang687b81d2013-07-11 12:56:15 +01001789 if (!dev)
1790 return NULL;
1791
Vladimir Zapolskiye3311462015-07-27 17:30:48 +03001792 client = i2c_verify_client(dev);
1793 if (!client)
1794 put_device(dev);
1795
1796 return client;
Wolfram Sang687b81d2013-07-11 12:56:15 +01001797}
1798EXPORT_SYMBOL(of_find_i2c_device_by_node);
1799
1800/* must call put_device() when done with returned i2c_adapter device */
1801struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node)
1802{
1803 struct device *dev;
Vladimir Zapolskiye3311462015-07-27 17:30:48 +03001804 struct i2c_adapter *adapter;
Wolfram Sang687b81d2013-07-11 12:56:15 +01001805
Vladimir Zapolskiye3311462015-07-27 17:30:48 +03001806 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
Wolfram Sang687b81d2013-07-11 12:56:15 +01001807 if (!dev)
1808 return NULL;
1809
Vladimir Zapolskiye3311462015-07-27 17:30:48 +03001810 adapter = i2c_verify_adapter(dev);
1811 if (!adapter)
1812 put_device(dev);
1813
1814 return adapter;
Wolfram Sang687b81d2013-07-11 12:56:15 +01001815}
1816EXPORT_SYMBOL(of_find_i2c_adapter_by_node);
Vladimir Zapolskiy48e97432015-07-27 17:30:50 +03001817
1818/* must call i2c_put_adapter() when done with returned i2c_adapter device */
1819struct i2c_adapter *of_get_i2c_adapter_by_node(struct device_node *node)
1820{
1821 struct i2c_adapter *adapter;
1822
1823 adapter = of_find_i2c_adapter_by_node(node);
1824 if (!adapter)
1825 return NULL;
1826
1827 if (!try_module_get(adapter->owner)) {
1828 put_device(&adapter->dev);
1829 adapter = NULL;
1830 }
1831
1832 return adapter;
1833}
1834EXPORT_SYMBOL(of_get_i2c_adapter_by_node);
Lee Jonescabcf4f2016-11-07 12:47:37 +00001835
1836static const struct of_device_id*
1837i2c_of_match_device_sysfs(const struct of_device_id *matches,
1838 struct i2c_client *client)
1839{
1840 const char *name;
1841
1842 for (; matches->compatible[0]; matches++) {
1843 /*
1844 * Adding devices through the i2c sysfs interface provides us
1845 * a string to match which may be compatible with the device
1846 * tree compatible strings, however with no actual of_node the
1847 * of_match_device() will not match
1848 */
1849 if (sysfs_streq(client->name, matches->compatible))
1850 return matches;
1851
1852 name = strchr(matches->compatible, ',');
1853 if (!name)
1854 name = matches->compatible;
1855 else
1856 name++;
1857
1858 if (sysfs_streq(client->name, name))
1859 return matches;
1860 }
1861
1862 return NULL;
1863}
1864
Lee Jones298d4de2016-11-07 12:47:38 +00001865const struct of_device_id
1866*i2c_of_match_device(const struct of_device_id *matches,
1867 struct i2c_client *client)
1868{
1869 const struct of_device_id *match;
1870
1871 if (!(client && matches))
1872 return NULL;
1873
1874 match = of_match_device(matches, &client->dev);
1875 if (match)
1876 return match;
1877
1878 return i2c_of_match_device_sysfs(matches, client);
1879}
1880EXPORT_SYMBOL_GPL(i2c_of_match_device);
Wolfram Sang687b81d2013-07-11 12:56:15 +01001881#else
1882static void of_i2c_register_devices(struct i2c_adapter *adap) { }
1883#endif /* CONFIG_OF */
1884
Jean Delvare69b00892009-12-06 17:06:27 +01001885static int i2c_do_add_adapter(struct i2c_driver *driver,
1886 struct i2c_adapter *adap)
Jean Delvare026526f2008-01-27 18:14:49 +01001887{
Jean Delvare4735c98f2008-07-14 22:38:36 +02001888 /* Detect supported devices on that bus, and instantiate them */
1889 i2c_detect(adap, driver);
1890
1891 /* Let legacy drivers scan this bus for matching devices */
Jean Delvare026526f2008-01-27 18:14:49 +01001892 if (driver->attach_adapter) {
Jean Delvarea920ff42011-04-17 10:20:19 +02001893 dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
1894 driver->driver.name);
Andy Shevchenkob93d3d32016-08-25 17:42:10 +03001895 dev_warn(&adap->dev,
1896 "Please use another way to instantiate your i2c_client\n");
Jean Delvare026526f2008-01-27 18:14:49 +01001897 /* We ignore the return code; if it fails, too bad */
1898 driver->attach_adapter(adap);
1899 }
1900 return 0;
1901}
1902
Jean Delvare69b00892009-12-06 17:06:27 +01001903static int __process_new_adapter(struct device_driver *d, void *data)
1904{
1905 return i2c_do_add_adapter(to_i2c_driver(d), data);
1906}
1907
Peter Rosind1ed7982016-08-25 23:07:01 +02001908static const struct i2c_lock_operations i2c_adapter_lock_ops = {
1909 .lock_bus = i2c_adapter_lock_bus,
1910 .trylock_bus = i2c_adapter_trylock_bus,
1911 .unlock_bus = i2c_adapter_unlock_bus,
1912};
1913
Benjamin Tissoires4d5538f2016-10-13 14:10:40 +02001914static void i2c_host_notify_irq_teardown(struct i2c_adapter *adap)
1915{
1916 struct irq_domain *domain = adap->host_notify_domain;
1917 irq_hw_number_t hwirq;
1918
1919 if (!domain)
1920 return;
1921
1922 for (hwirq = 0 ; hwirq < I2C_ADDR_7BITS_COUNT ; hwirq++)
1923 irq_dispose_mapping(irq_find_mapping(domain, hwirq));
1924
1925 irq_domain_remove(domain);
1926 adap->host_notify_domain = NULL;
1927}
1928
1929static int i2c_host_notify_irq_map(struct irq_domain *h,
1930 unsigned int virq,
1931 irq_hw_number_t hw_irq_num)
1932{
1933 irq_set_chip_and_handler(virq, &dummy_irq_chip, handle_simple_irq);
1934
1935 return 0;
1936}
1937
1938static const struct irq_domain_ops i2c_host_notify_irq_ops = {
1939 .map = i2c_host_notify_irq_map,
1940};
1941
1942static int i2c_setup_host_notify_irq_domain(struct i2c_adapter *adap)
1943{
1944 struct irq_domain *domain;
1945
1946 if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_HOST_NOTIFY))
1947 return 0;
1948
1949 domain = irq_domain_create_linear(adap->dev.fwnode,
1950 I2C_ADDR_7BITS_COUNT,
1951 &i2c_host_notify_irq_ops, adap);
1952 if (!domain)
1953 return -ENOMEM;
1954
1955 adap->host_notify_domain = domain;
1956
1957 return 0;
1958}
1959
1960/**
1961 * i2c_handle_smbus_host_notify - Forward a Host Notify event to the correct
1962 * I2C client.
1963 * @adap: the adapter
1964 * @addr: the I2C address of the notifying device
1965 * Context: can't sleep
1966 *
1967 * Helper function to be called from an I2C bus driver's interrupt
1968 * handler. It will schedule the Host Notify IRQ.
1969 */
1970int i2c_handle_smbus_host_notify(struct i2c_adapter *adap, unsigned short addr)
1971{
1972 int irq;
1973
1974 if (!adap)
1975 return -EINVAL;
1976
1977 irq = irq_find_mapping(adap->host_notify_domain, addr);
1978 if (irq <= 0)
1979 return -ENXIO;
1980
1981 generic_handle_irq(irq);
1982
1983 return 0;
1984}
1985EXPORT_SYMBOL_GPL(i2c_handle_smbus_host_notify);
1986
David Brownell6e13e642007-05-01 23:26:31 +02001987static int i2c_register_adapter(struct i2c_adapter *adap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988{
Wolfram Sangce0dffa2016-07-09 13:34:58 +09001989 int res = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001990
David Brownell1d0b19c2008-10-14 17:30:05 +02001991 /* Can't register until after driver model init */
Sudip Mukherjee95026652016-03-07 17:19:17 +05301992 if (WARN_ON(!is_registered)) {
Jean Delvare35fc37f2009-06-19 16:58:19 +02001993 res = -EAGAIN;
1994 goto out_list;
1995 }
David Brownell1d0b19c2008-10-14 17:30:05 +02001996
Jean Delvare2236baa2010-11-15 22:40:38 +01001997 /* Sanity checks */
Wolfram Sang8ddfe412016-07-09 13:35:00 +09001998 if (WARN(!adap->name[0], "i2c adapter has no name"))
Wolfram Sangce0dffa2016-07-09 13:34:58 +09001999 goto out_list;
Wolfram Sang8ddfe412016-07-09 13:35:00 +09002000
2001 if (!adap->algo) {
Wolfram Sang44239a52016-07-09 13:35:04 +09002002 pr_err("adapter '%s': no algo supplied!\n", adap->name);
Wolfram Sangce0dffa2016-07-09 13:34:58 +09002003 goto out_list;
Jean Delvare2236baa2010-11-15 22:40:38 +01002004 }
2005
Peter Rosind1ed7982016-08-25 23:07:01 +02002006 if (!adap->lock_ops)
2007 adap->lock_ops = &i2c_adapter_lock_ops;
Peter Rosin8320f492016-05-04 22:15:27 +02002008
Mika Kuoppala194684e2009-12-06 17:06:22 +01002009 rt_mutex_init(&adap->bus_lock);
Peter Rosin6ef91fc2016-05-04 22:15:29 +02002010 rt_mutex_init(&adap->mux_lock);
Jean Delvaredafc50d2010-08-11 18:21:01 +02002011 mutex_init(&adap->userspace_clients_lock);
Jean Delvare6629dcf2010-05-04 11:09:28 +02002012 INIT_LIST_HEAD(&adap->userspace_clients);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002013
Jean Delvare8fcfef62009-03-28 21:34:43 +01002014 /* Set default timeout to 1 second if not already set */
2015 if (adap->timeout == 0)
2016 adap->timeout = HZ;
2017
Benjamin Tissoires4d5538f2016-10-13 14:10:40 +02002018 /* register soft irqs for Host Notify */
2019 res = i2c_setup_host_notify_irq_domain(adap);
2020 if (res) {
2021 pr_err("adapter '%s': can't create Host Notify IRQs (%d)\n",
2022 adap->name, res);
2023 goto out_list;
2024 }
2025
Kay Sievers27d9c182009-01-07 14:29:16 +01002026 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
Jean Delvare4f8cf822009-09-18 22:45:46 +02002027 adap->dev.bus = &i2c_bus_type;
2028 adap->dev.type = &i2c_adapter_type;
Jean Delvareb119c6c2006-08-15 18:26:30 +02002029 res = device_register(&adap->dev);
Wolfram Sang8ddfe412016-07-09 13:35:00 +09002030 if (res) {
Wolfram Sang44239a52016-07-09 13:35:04 +09002031 pr_err("adapter '%s': can't register device (%d)\n", adap->name, res);
Jean Delvareb119c6c2006-08-15 18:26:30 +02002032 goto out_list;
Wolfram Sang8ddfe412016-07-09 13:35:00 +09002033 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002034
Jean Delvareb6d7b3d2005-07-31 19:02:53 +02002035 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
2036
Charles Keepax6ada5c12015-04-16 13:05:19 +01002037 pm_runtime_no_callbacks(&adap->dev);
Linus Walleij04f59142016-04-12 09:57:35 +02002038 pm_suspend_ignore_children(&adap->dev, true);
Wolfram Sang9f924162015-12-23 18:19:28 +01002039 pm_runtime_enable(&adap->dev);
Charles Keepax6ada5c12015-04-16 13:05:19 +01002040
Jean Delvare2bb50952009-09-18 22:45:46 +02002041#ifdef CONFIG_I2C_COMPAT
2042 res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
2043 adap->dev.parent);
2044 if (res)
2045 dev_warn(&adap->dev,
2046 "Failed to create compatibility class link\n");
2047#endif
2048
Wolfram Sangd3b11d82016-07-09 13:34:59 +09002049 i2c_init_recovery(adap);
Viresh Kumar5f9296b2012-02-28 18:26:31 +05302050
Jean Delvare729d6dd2009-06-19 16:58:18 +02002051 /* create pre-declared device nodes */
Wolfram Sang687b81d2013-07-11 12:56:15 +01002052 of_i2c_register_devices(adap);
Jarkko Nikulaaec809f2016-08-12 17:02:52 +03002053 i2c_acpi_register_devices(adap);
2054 i2c_acpi_install_space_handler(adap);
Wolfram Sang687b81d2013-07-11 12:56:15 +01002055
David Brownell6e13e642007-05-01 23:26:31 +02002056 if (adap->nr < __i2c_first_dynamic_bus_num)
2057 i2c_scan_static_board_info(adap);
2058
Jean Delvare4735c98f2008-07-14 22:38:36 +02002059 /* Notify drivers */
Jean Delvare35fc37f2009-06-19 16:58:19 +02002060 mutex_lock(&core_lock);
Jean Delvared6703282010-08-11 18:20:59 +02002061 bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
Jean Delvarecaada322008-01-27 18:14:49 +01002062 mutex_unlock(&core_lock);
Jean Delvare35fc37f2009-06-19 16:58:19 +02002063
2064 return 0;
Jean Delvareb119c6c2006-08-15 18:26:30 +02002065
Jean Delvareb119c6c2006-08-15 18:26:30 +02002066out_list:
Jean Delvare35fc37f2009-06-19 16:58:19 +02002067 mutex_lock(&core_lock);
Jean Delvareb119c6c2006-08-15 18:26:30 +02002068 idr_remove(&i2c_adapter_idr, adap->nr);
Jean Delvare35fc37f2009-06-19 16:58:19 +02002069 mutex_unlock(&core_lock);
2070 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002071}
2072
David Brownell6e13e642007-05-01 23:26:31 +02002073/**
Doug Andersonee5c2742013-03-01 08:57:31 -08002074 * __i2c_add_numbered_adapter - i2c_add_numbered_adapter where nr is never -1
2075 * @adap: the adapter to register (with adap->nr initialized)
2076 * Context: can sleep
2077 *
2078 * See i2c_add_numbered_adapter() for details.
2079 */
2080static int __i2c_add_numbered_adapter(struct i2c_adapter *adap)
2081{
Wolfram Sang84d0b612016-07-09 13:35:01 +09002082 int id;
Doug Andersonee5c2742013-03-01 08:57:31 -08002083
2084 mutex_lock(&core_lock);
Wolfram Sang84d0b612016-07-09 13:35:01 +09002085 id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1, GFP_KERNEL);
Doug Andersonee5c2742013-03-01 08:57:31 -08002086 mutex_unlock(&core_lock);
Wolfram Sang84d0b612016-07-09 13:35:01 +09002087 if (WARN(id < 0, "couldn't get idr"))
Doug Andersonee5c2742013-03-01 08:57:31 -08002088 return id == -ENOSPC ? -EBUSY : id;
2089
2090 return i2c_register_adapter(adap);
2091}
2092
2093/**
David Brownell6e13e642007-05-01 23:26:31 +02002094 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
2095 * @adapter: the adapter to add
David Brownelld64f73b2007-07-12 14:12:28 +02002096 * Context: can sleep
David Brownell6e13e642007-05-01 23:26:31 +02002097 *
2098 * This routine is used to declare an I2C adapter when its bus number
Doug Andersonee5c2742013-03-01 08:57:31 -08002099 * doesn't matter or when its bus number is specified by an dt alias.
2100 * Examples of bases when the bus number doesn't matter: I2C adapters
2101 * dynamically added by USB links or PCI plugin cards.
David Brownell6e13e642007-05-01 23:26:31 +02002102 *
2103 * When this returns zero, a new bus number was allocated and stored
2104 * in adap->nr, and the specified adapter became available for clients.
2105 * Otherwise, a negative errno value is returned.
2106 */
2107int i2c_add_adapter(struct i2c_adapter *adapter)
2108{
Doug Andersonee5c2742013-03-01 08:57:31 -08002109 struct device *dev = &adapter->dev;
Tejun Heo4ae42b02013-02-27 17:04:15 -08002110 int id;
David Brownell6e13e642007-05-01 23:26:31 +02002111
Doug Andersonee5c2742013-03-01 08:57:31 -08002112 if (dev->of_node) {
2113 id = of_alias_get_id(dev->of_node, "i2c");
2114 if (id >= 0) {
2115 adapter->nr = id;
2116 return __i2c_add_numbered_adapter(adapter);
2117 }
2118 }
2119
Jean Delvarecaada322008-01-27 18:14:49 +01002120 mutex_lock(&core_lock);
Tejun Heo4ae42b02013-02-27 17:04:15 -08002121 id = idr_alloc(&i2c_adapter_idr, adapter,
2122 __i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
Jean Delvarecaada322008-01-27 18:14:49 +01002123 mutex_unlock(&core_lock);
Wolfram Sang84d0b612016-07-09 13:35:01 +09002124 if (WARN(id < 0, "couldn't get idr"))
Tejun Heo4ae42b02013-02-27 17:04:15 -08002125 return id;
David Brownell6e13e642007-05-01 23:26:31 +02002126
2127 adapter->nr = id;
Tejun Heo4ae42b02013-02-27 17:04:15 -08002128
David Brownell6e13e642007-05-01 23:26:31 +02002129 return i2c_register_adapter(adapter);
2130}
2131EXPORT_SYMBOL(i2c_add_adapter);
2132
2133/**
2134 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
2135 * @adap: the adapter to register (with adap->nr initialized)
David Brownelld64f73b2007-07-12 14:12:28 +02002136 * Context: can sleep
David Brownell6e13e642007-05-01 23:26:31 +02002137 *
2138 * This routine is used to declare an I2C adapter when its bus number
Randy Dunlap8c07e462008-03-23 20:28:20 +01002139 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
2140 * or otherwise built in to the system's mainboard, and where i2c_board_info
David Brownell6e13e642007-05-01 23:26:31 +02002141 * is used to properly configure I2C devices.
2142 *
Grant Likely488bf312011-07-25 17:49:43 +02002143 * If the requested bus number is set to -1, then this function will behave
2144 * identically to i2c_add_adapter, and will dynamically assign a bus number.
2145 *
David Brownell6e13e642007-05-01 23:26:31 +02002146 * If no devices have pre-been declared for this bus, then be sure to
2147 * register the adapter before any dynamically allocated ones. Otherwise
2148 * the required bus ID may not be available.
2149 *
2150 * When this returns zero, the specified adapter became available for
2151 * clients using the bus number provided in adap->nr. Also, the table
2152 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
2153 * and the appropriate driver model device nodes are created. Otherwise, a
2154 * negative errno value is returned.
2155 */
2156int i2c_add_numbered_adapter(struct i2c_adapter *adap)
2157{
Grant Likely488bf312011-07-25 17:49:43 +02002158 if (adap->nr == -1) /* -1 means dynamically assign bus id */
2159 return i2c_add_adapter(adap);
David Brownell6e13e642007-05-01 23:26:31 +02002160
Doug Andersonee5c2742013-03-01 08:57:31 -08002161 return __i2c_add_numbered_adapter(adap);
David Brownell6e13e642007-05-01 23:26:31 +02002162}
2163EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
2164
Lars-Peter Clausen19baba42013-03-09 08:16:44 +00002165static void i2c_do_del_adapter(struct i2c_driver *driver,
Jean Delvare69b00892009-12-06 17:06:27 +01002166 struct i2c_adapter *adapter)
Jean Delvare026526f2008-01-27 18:14:49 +01002167{
Jean Delvare4735c98f2008-07-14 22:38:36 +02002168 struct i2c_client *client, *_n;
Jean Delvare026526f2008-01-27 18:14:49 +01002169
Jean Delvareacec2112009-03-28 21:34:40 +01002170 /* Remove the devices we created ourselves as the result of hardware
2171 * probing (using a driver's detect method) */
Jean Delvare4735c98f2008-07-14 22:38:36 +02002172 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
2173 if (client->adapter == adapter) {
2174 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
2175 client->name, client->addr);
2176 list_del(&client->detected);
2177 i2c_unregister_device(client);
2178 }
2179 }
Jean Delvare026526f2008-01-27 18:14:49 +01002180}
2181
Jean Delvaree549c2b2009-06-19 16:58:19 +02002182static int __unregister_client(struct device *dev, void *dummy)
2183{
2184 struct i2c_client *client = i2c_verify_client(dev);
Jean Delvare5219bf82011-01-14 22:03:49 +01002185 if (client && strcmp(client->name, "dummy"))
2186 i2c_unregister_device(client);
2187 return 0;
2188}
2189
2190static int __unregister_dummy(struct device *dev, void *dummy)
2191{
2192 struct i2c_client *client = i2c_verify_client(dev);
Jean Delvaree549c2b2009-06-19 16:58:19 +02002193 if (client)
2194 i2c_unregister_device(client);
2195 return 0;
2196}
2197
Jean Delvare69b00892009-12-06 17:06:27 +01002198static int __process_removed_adapter(struct device_driver *d, void *data)
2199{
Lars-Peter Clausen19baba42013-03-09 08:16:44 +00002200 i2c_do_del_adapter(to_i2c_driver(d), data);
2201 return 0;
Jean Delvare69b00892009-12-06 17:06:27 +01002202}
2203
David Brownelld64f73b2007-07-12 14:12:28 +02002204/**
2205 * i2c_del_adapter - unregister I2C adapter
2206 * @adap: the adapter being unregistered
2207 * Context: can sleep
2208 *
2209 * This unregisters an I2C adapter which was previously registered
2210 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
2211 */
Lars-Peter Clausen71546302013-03-09 08:16:47 +00002212void i2c_del_adapter(struct i2c_adapter *adap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002213{
Jean Delvare35fc37f2009-06-19 16:58:19 +02002214 struct i2c_adapter *found;
Jean Delvarebbd2d9c2009-11-26 09:22:33 +01002215 struct i2c_client *client, *next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002216
2217 /* First make sure that this adapter was ever added */
Jean Delvare35fc37f2009-06-19 16:58:19 +02002218 mutex_lock(&core_lock);
2219 found = idr_find(&i2c_adapter_idr, adap->nr);
2220 mutex_unlock(&core_lock);
2221 if (found != adap) {
Wolfram Sang44239a52016-07-09 13:35:04 +09002222 pr_debug("attempting to delete unregistered adapter [%s]\n", adap->name);
Lars-Peter Clausen71546302013-03-09 08:16:47 +00002223 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002224 }
2225
Jarkko Nikulaaec809f2016-08-12 17:02:52 +03002226 i2c_acpi_remove_space_handler(adap);
Jean Delvare026526f2008-01-27 18:14:49 +01002227 /* Tell drivers about this removal */
Jean Delvare35fc37f2009-06-19 16:58:19 +02002228 mutex_lock(&core_lock);
Lars-Peter Clausen19baba42013-03-09 08:16:44 +00002229 bus_for_each_drv(&i2c_bus_type, NULL, adap,
Jean Delvare69b00892009-12-06 17:06:27 +01002230 __process_removed_adapter);
Jean Delvare35fc37f2009-06-19 16:58:19 +02002231 mutex_unlock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002232
Jean Delvarebbd2d9c2009-11-26 09:22:33 +01002233 /* Remove devices instantiated from sysfs */
Jean Delvare390946b2012-09-10 10:14:02 +02002234 mutex_lock_nested(&adap->userspace_clients_lock,
2235 i2c_adapter_depth(adap));
Jean Delvare6629dcf2010-05-04 11:09:28 +02002236 list_for_each_entry_safe(client, next, &adap->userspace_clients,
2237 detected) {
2238 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
2239 client->addr);
2240 list_del(&client->detected);
2241 i2c_unregister_device(client);
Jean Delvarebbd2d9c2009-11-26 09:22:33 +01002242 }
Jean Delvaredafc50d2010-08-11 18:21:01 +02002243 mutex_unlock(&adap->userspace_clients_lock);
Jean Delvarebbd2d9c2009-11-26 09:22:33 +01002244
Jean Delvaree549c2b2009-06-19 16:58:19 +02002245 /* Detach any active clients. This can't fail, thus we do not
Jean Delvare5219bf82011-01-14 22:03:49 +01002246 * check the returned value. This is a two-pass process, because
2247 * we can't remove the dummy devices during the first pass: they
2248 * could have been instantiated by real devices wishing to clean
2249 * them up properly, so we give them a chance to do that first. */
Lars-Peter Clausen19baba42013-03-09 08:16:44 +00002250 device_for_each_child(&adap->dev, NULL, __unregister_client);
2251 device_for_each_child(&adap->dev, NULL, __unregister_dummy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002252
Jean Delvare2bb50952009-09-18 22:45:46 +02002253#ifdef CONFIG_I2C_COMPAT
2254 class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
2255 adap->dev.parent);
2256#endif
2257
Thadeu Lima de Souza Cascardoc55675212010-01-16 20:43:13 +01002258 /* device name is gone after device_unregister */
2259 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
2260
Wolfram Sang9f924162015-12-23 18:19:28 +01002261 pm_runtime_disable(&adap->dev);
2262
Benjamin Tissoires4d5538f2016-10-13 14:10:40 +02002263 i2c_host_notify_irq_teardown(adap);
2264
Wolfram Sang26680ee2015-01-29 22:45:09 +01002265 /* wait until all references to the device are gone
2266 *
2267 * FIXME: This is old code and should ideally be replaced by an
2268 * alternative which results in decoupling the lifetime of the struct
2269 * device from the i2c_adapter, like spi or netdev do. Any solution
Shailendra Verma95cc1e32015-05-18 22:24:01 +05302270 * should be thoroughly tested with DEBUG_KOBJECT_RELEASE enabled!
Wolfram Sang26680ee2015-01-29 22:45:09 +01002271 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002272 init_completion(&adap->dev_released);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002273 device_unregister(&adap->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002274 wait_for_completion(&adap->dev_released);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002275
David Brownell6e13e642007-05-01 23:26:31 +02002276 /* free bus id */
Jean Delvare35fc37f2009-06-19 16:58:19 +02002277 mutex_lock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002278 idr_remove(&i2c_adapter_idr, adap->nr);
Jean Delvare35fc37f2009-06-19 16:58:19 +02002279 mutex_unlock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002280
Jean Delvarebd4bc3db2008-07-16 19:30:05 +02002281 /* Clear the device structure in case this adapter is ever going to be
2282 added again */
2283 memset(&adap->dev, 0, sizeof(adap->dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002284}
David Brownellc0564602007-05-01 23:26:31 +02002285EXPORT_SYMBOL(i2c_del_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002286
Wolfram Sang54177cc2015-12-17 13:32:36 +01002287/**
2288 * i2c_parse_fw_timings - get I2C related timing parameters from firmware
2289 * @dev: The device to scan for I2C timing properties
2290 * @t: the i2c_timings struct to be filled with values
2291 * @use_defaults: bool to use sane defaults derived from the I2C specification
2292 * when properties are not found, otherwise use 0
2293 *
2294 * Scan the device for the generic I2C properties describing timing parameters
2295 * for the signal and fill the given struct with the results. If a property was
2296 * not found and use_defaults was true, then maximum timings are assumed which
2297 * are derived from the I2C specification. If use_defaults is not used, the
2298 * results will be 0, so drivers can apply their own defaults later. The latter
2299 * is mainly intended for avoiding regressions of existing drivers which want
2300 * to switch to this function. New drivers almost always should use the defaults.
2301 */
2302
2303void i2c_parse_fw_timings(struct device *dev, struct i2c_timings *t, bool use_defaults)
2304{
2305 int ret;
2306
2307 memset(t, 0, sizeof(*t));
2308
2309 ret = device_property_read_u32(dev, "clock-frequency", &t->bus_freq_hz);
2310 if (ret && use_defaults)
2311 t->bus_freq_hz = 100000;
2312
2313 ret = device_property_read_u32(dev, "i2c-scl-rising-time-ns", &t->scl_rise_ns);
2314 if (ret && use_defaults) {
2315 if (t->bus_freq_hz <= 100000)
2316 t->scl_rise_ns = 1000;
2317 else if (t->bus_freq_hz <= 400000)
2318 t->scl_rise_ns = 300;
2319 else
2320 t->scl_rise_ns = 120;
2321 }
2322
2323 ret = device_property_read_u32(dev, "i2c-scl-falling-time-ns", &t->scl_fall_ns);
2324 if (ret && use_defaults) {
2325 if (t->bus_freq_hz <= 400000)
2326 t->scl_fall_ns = 300;
2327 else
2328 t->scl_fall_ns = 120;
2329 }
2330
2331 device_property_read_u32(dev, "i2c-scl-internal-delay-ns", &t->scl_int_delay_ns);
2332
2333 ret = device_property_read_u32(dev, "i2c-sda-falling-time-ns", &t->sda_fall_ns);
2334 if (ret && use_defaults)
2335 t->sda_fall_ns = t->scl_fall_ns;
2336}
2337EXPORT_SYMBOL_GPL(i2c_parse_fw_timings);
2338
David Brownell7b4fbc52007-05-01 23:26:30 +02002339/* ------------------------------------------------------------------------- */
2340
Jean Delvare7ae31482011-03-20 14:50:52 +01002341int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
2342{
2343 int res;
2344
2345 mutex_lock(&core_lock);
2346 res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
2347 mutex_unlock(&core_lock);
2348
2349 return res;
2350}
2351EXPORT_SYMBOL_GPL(i2c_for_each_dev);
2352
Jean Delvare69b00892009-12-06 17:06:27 +01002353static int __process_new_driver(struct device *dev, void *data)
Dave Young7f101a92008-07-14 22:38:19 +02002354{
Jean Delvare4f8cf822009-09-18 22:45:46 +02002355 if (dev->type != &i2c_adapter_type)
2356 return 0;
Jean Delvare69b00892009-12-06 17:06:27 +01002357 return i2c_do_add_adapter(data, to_i2c_adapter(dev));
Dave Young7f101a92008-07-14 22:38:19 +02002358}
2359
David Brownell7b4fbc52007-05-01 23:26:30 +02002360/*
2361 * An i2c_driver is used with one or more i2c_client (device) nodes to access
Jean Delvare729d6dd2009-06-19 16:58:18 +02002362 * i2c slave chips, on a bus instance associated with some i2c_adapter.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002363 */
2364
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -08002365int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002366{
Jean Delvare7eebcb72006-02-05 23:28:21 +01002367 int res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002368
David Brownell1d0b19c2008-10-14 17:30:05 +02002369 /* Can't register until after driver model init */
Sudip Mukherjee95026652016-03-07 17:19:17 +05302370 if (WARN_ON(!is_registered))
David Brownell1d0b19c2008-10-14 17:30:05 +02002371 return -EAGAIN;
2372
Linus Torvalds1da177e2005-04-16 15:20:36 -07002373 /* add the driver to the list of i2c drivers in the driver core */
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -08002374 driver->driver.owner = owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002375 driver->driver.bus = &i2c_bus_type;
Vladimir Zapolskiy147b36d2016-10-31 21:46:24 +02002376 INIT_LIST_HEAD(&driver->clients);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002377
Jean Delvare729d6dd2009-06-19 16:58:18 +02002378 /* When registration returns, the driver core
David Brownell6e13e642007-05-01 23:26:31 +02002379 * will have called probe() for all matching-but-unbound devices.
2380 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002381 res = driver_register(&driver->driver);
2382 if (res)
Jean Delvare7eebcb72006-02-05 23:28:21 +01002383 return res;
David Brownell438d6c22006-12-10 21:21:31 +01002384
Wolfram Sang44239a52016-07-09 13:35:04 +09002385 pr_debug("driver [%s] registered\n", driver->driver.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002386
Jean Delvare4735c98f2008-07-14 22:38:36 +02002387 /* Walk the adapters that are already present */
Jean Delvare7ae31482011-03-20 14:50:52 +01002388 i2c_for_each_dev(driver, __process_new_driver);
Jean Delvare35fc37f2009-06-19 16:58:19 +02002389
Jean Delvare7eebcb72006-02-05 23:28:21 +01002390 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002391}
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -08002392EXPORT_SYMBOL(i2c_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002393
Jean Delvare69b00892009-12-06 17:06:27 +01002394static int __process_removed_driver(struct device *dev, void *data)
Dave Young7f101a92008-07-14 22:38:19 +02002395{
Lars-Peter Clausen19baba42013-03-09 08:16:44 +00002396 if (dev->type == &i2c_adapter_type)
2397 i2c_do_del_adapter(data, to_i2c_adapter(dev));
2398 return 0;
Dave Young7f101a92008-07-14 22:38:19 +02002399}
2400
David Brownella1d9e6e2007-05-01 23:26:30 +02002401/**
2402 * i2c_del_driver - unregister I2C driver
2403 * @driver: the driver being unregistered
David Brownelld64f73b2007-07-12 14:12:28 +02002404 * Context: can sleep
David Brownella1d9e6e2007-05-01 23:26:30 +02002405 */
Jean Delvareb3e82092007-05-01 23:26:32 +02002406void i2c_del_driver(struct i2c_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002407{
Jean Delvare7ae31482011-03-20 14:50:52 +01002408 i2c_for_each_dev(driver, __process_removed_driver);
David Brownella1d9e6e2007-05-01 23:26:30 +02002409
Linus Torvalds1da177e2005-04-16 15:20:36 -07002410 driver_unregister(&driver->driver);
Wolfram Sang44239a52016-07-09 13:35:04 +09002411 pr_debug("driver [%s] unregistered\n", driver->driver.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002412}
David Brownellc0564602007-05-01 23:26:31 +02002413EXPORT_SYMBOL(i2c_del_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002414
David Brownell7b4fbc52007-05-01 23:26:30 +02002415/* ------------------------------------------------------------------------- */
2416
Jean Delvaree48d3312008-01-27 18:14:48 +01002417/**
2418 * i2c_use_client - increments the reference count of the i2c client structure
2419 * @client: the client being referenced
2420 *
2421 * Each live reference to a client should be refcounted. The driver model does
2422 * that automatically as part of driver binding, so that most drivers don't
2423 * need to do this explicitly: they hold a reference until they're unbound
2424 * from the device.
2425 *
2426 * A pointer to the client with the incremented reference counter is returned.
2427 */
2428struct i2c_client *i2c_use_client(struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002429{
David Brownell6ea438e2008-07-14 22:38:24 +02002430 if (client && get_device(&client->dev))
2431 return client;
2432 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002433}
David Brownellc0564602007-05-01 23:26:31 +02002434EXPORT_SYMBOL(i2c_use_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002435
Jean Delvaree48d3312008-01-27 18:14:48 +01002436/**
2437 * i2c_release_client - release a use of the i2c client structure
2438 * @client: the client being no longer referenced
2439 *
2440 * Must be called when a user of a client is finished with it.
2441 */
2442void i2c_release_client(struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002443{
David Brownell6ea438e2008-07-14 22:38:24 +02002444 if (client)
2445 put_device(&client->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002446}
David Brownellc0564602007-05-01 23:26:31 +02002447EXPORT_SYMBOL(i2c_release_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002448
David Brownell9b766b82008-01-27 18:14:51 +01002449struct i2c_cmd_arg {
2450 unsigned cmd;
2451 void *arg;
2452};
2453
2454static int i2c_cmd(struct device *dev, void *_arg)
2455{
2456 struct i2c_client *client = i2c_verify_client(dev);
2457 struct i2c_cmd_arg *arg = _arg;
Lars-Peter Clausen0acc2b32013-09-29 10:51:06 +02002458 struct i2c_driver *driver;
David Brownell9b766b82008-01-27 18:14:51 +01002459
Lars-Peter Clausen0acc2b32013-09-29 10:51:06 +02002460 if (!client || !client->dev.driver)
2461 return 0;
2462
2463 driver = to_i2c_driver(client->dev.driver);
2464 if (driver->command)
2465 driver->command(client, arg->cmd, arg->arg);
David Brownell9b766b82008-01-27 18:14:51 +01002466 return 0;
2467}
2468
Linus Torvalds1da177e2005-04-16 15:20:36 -07002469void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
2470{
David Brownell9b766b82008-01-27 18:14:51 +01002471 struct i2c_cmd_arg cmd_arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002472
David Brownell9b766b82008-01-27 18:14:51 +01002473 cmd_arg.cmd = cmd;
2474 cmd_arg.arg = arg;
2475 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002476}
David Brownellc0564602007-05-01 23:26:31 +02002477EXPORT_SYMBOL(i2c_clients_command);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002478
Pantelis Antoniouea7513b2014-10-28 22:36:03 +02002479#if IS_ENABLED(CONFIG_OF_DYNAMIC)
2480static int of_i2c_notify(struct notifier_block *nb, unsigned long action,
2481 void *arg)
2482{
2483 struct of_reconfig_data *rd = arg;
2484 struct i2c_adapter *adap;
2485 struct i2c_client *client;
2486
2487 switch (of_reconfig_get_state_change(action, rd)) {
2488 case OF_RECONFIG_CHANGE_ADD:
2489 adap = of_find_i2c_adapter_by_node(rd->dn->parent);
2490 if (adap == NULL)
2491 return NOTIFY_OK; /* not for us */
2492
Pantelis Antoniou4f001fd2015-01-24 09:16:29 +02002493 if (of_node_test_and_set_flag(rd->dn, OF_POPULATED)) {
2494 put_device(&adap->dev);
2495 return NOTIFY_OK;
2496 }
2497
Pantelis Antoniouea7513b2014-10-28 22:36:03 +02002498 client = of_i2c_register_device(adap, rd->dn);
2499 put_device(&adap->dev);
2500
2501 if (IS_ERR(client)) {
Wolfram Sang399d62a2016-07-09 13:35:02 +09002502 dev_err(&adap->dev, "failed to create client for '%s'\n",
2503 rd->dn->full_name);
Ralf Ramsauer6a676fb2016-10-17 15:59:57 +02002504 of_node_clear_flag(rd->dn, OF_POPULATED);
Pantelis Antoniouea7513b2014-10-28 22:36:03 +02002505 return notifier_from_errno(PTR_ERR(client));
2506 }
2507 break;
2508 case OF_RECONFIG_CHANGE_REMOVE:
Pantelis Antoniou4f001fd2015-01-24 09:16:29 +02002509 /* already depopulated? */
2510 if (!of_node_check_flag(rd->dn, OF_POPULATED))
2511 return NOTIFY_OK;
2512
Pantelis Antoniouea7513b2014-10-28 22:36:03 +02002513 /* find our device by node */
2514 client = of_find_i2c_device_by_node(rd->dn);
2515 if (client == NULL)
2516 return NOTIFY_OK; /* no? not meant for us */
2517
2518 /* unregister takes one ref away */
2519 i2c_unregister_device(client);
2520
2521 /* and put the reference of the find */
2522 put_device(&client->dev);
2523 break;
2524 }
2525
2526 return NOTIFY_OK;
2527}
2528static struct notifier_block i2c_of_notifier = {
2529 .notifier_call = of_i2c_notify,
2530};
2531#else
2532extern struct notifier_block i2c_of_notifier;
2533#endif /* CONFIG_OF_DYNAMIC */
2534
Linus Torvalds1da177e2005-04-16 15:20:36 -07002535static int __init i2c_init(void)
2536{
2537 int retval;
2538
Wolfram Sang03bde7c2015-03-12 17:17:59 +01002539 retval = of_alias_get_highest_id("i2c");
2540
2541 down_write(&__i2c_board_lock);
2542 if (retval >= __i2c_first_dynamic_bus_num)
2543 __i2c_first_dynamic_bus_num = retval + 1;
2544 up_write(&__i2c_board_lock);
2545
Linus Torvalds1da177e2005-04-16 15:20:36 -07002546 retval = bus_register(&i2c_bus_type);
2547 if (retval)
2548 return retval;
Wolfram Sangb980a262016-03-14 10:41:52 +01002549
2550 is_registered = true;
2551
Jean Delvare2bb50952009-09-18 22:45:46 +02002552#ifdef CONFIG_I2C_COMPAT
2553 i2c_adapter_compat_class = class_compat_register("i2c-adapter");
2554 if (!i2c_adapter_compat_class) {
2555 retval = -ENOMEM;
2556 goto bus_err;
2557 }
2558#endif
David Brownelle9f13732008-01-27 18:14:52 +01002559 retval = i2c_add_driver(&dummy_driver);
2560 if (retval)
Jean Delvare2bb50952009-09-18 22:45:46 +02002561 goto class_err;
Pantelis Antoniouea7513b2014-10-28 22:36:03 +02002562
2563 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2564 WARN_ON(of_reconfig_notifier_register(&i2c_of_notifier));
Octavian Purdila525e6fa2016-07-08 19:13:10 +03002565 if (IS_ENABLED(CONFIG_ACPI))
2566 WARN_ON(acpi_reconfig_notifier_register(&i2c_acpi_notifier));
Pantelis Antoniouea7513b2014-10-28 22:36:03 +02002567
David Brownelle9f13732008-01-27 18:14:52 +01002568 return 0;
2569
Jean Delvare2bb50952009-09-18 22:45:46 +02002570class_err:
2571#ifdef CONFIG_I2C_COMPAT
2572 class_compat_unregister(i2c_adapter_compat_class);
David Brownelle9f13732008-01-27 18:14:52 +01002573bus_err:
Jean Delvare2bb50952009-09-18 22:45:46 +02002574#endif
Wolfram Sangb980a262016-03-14 10:41:52 +01002575 is_registered = false;
David Brownelle9f13732008-01-27 18:14:52 +01002576 bus_unregister(&i2c_bus_type);
2577 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002578}
2579
2580static void __exit i2c_exit(void)
2581{
Octavian Purdila525e6fa2016-07-08 19:13:10 +03002582 if (IS_ENABLED(CONFIG_ACPI))
2583 WARN_ON(acpi_reconfig_notifier_unregister(&i2c_acpi_notifier));
Pantelis Antoniouea7513b2014-10-28 22:36:03 +02002584 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2585 WARN_ON(of_reconfig_notifier_unregister(&i2c_of_notifier));
David Brownelle9f13732008-01-27 18:14:52 +01002586 i2c_del_driver(&dummy_driver);
Jean Delvare2bb50952009-09-18 22:45:46 +02002587#ifdef CONFIG_I2C_COMPAT
2588 class_compat_unregister(i2c_adapter_compat_class);
2589#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002590 bus_unregister(&i2c_bus_type);
David Howellsd9a83d62014-03-06 13:35:59 +00002591 tracepoint_synchronize_unregister();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002592}
2593
David Brownella10f9e72008-10-14 17:30:06 +02002594/* We must initialize early, because some subsystems register i2c drivers
2595 * in subsys_initcall() code, but are linked (and initialized) before i2c.
2596 */
2597postcore_initcall(i2c_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002598module_exit(i2c_exit);
2599
2600/* ----------------------------------------------------
2601 * the functional interface to the i2c busses.
2602 * ----------------------------------------------------
2603 */
2604
Wolfram Sangb7f62582015-01-05 23:45:59 +01002605/* Check if val is exceeding the quirk IFF quirk is non 0 */
2606#define i2c_quirk_exceeded(val, quirk) ((quirk) && ((val) > (quirk)))
2607
2608static int i2c_quirk_error(struct i2c_adapter *adap, struct i2c_msg *msg, char *err_msg)
2609{
2610 dev_err_ratelimited(&adap->dev, "adapter quirk: %s (addr 0x%04x, size %u, %s)\n",
2611 err_msg, msg->addr, msg->len,
2612 msg->flags & I2C_M_RD ? "read" : "write");
2613 return -EOPNOTSUPP;
2614}
2615
2616static int i2c_check_for_quirks(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2617{
2618 const struct i2c_adapter_quirks *q = adap->quirks;
2619 int max_num = q->max_num_msgs, i;
2620 bool do_len_check = true;
2621
2622 if (q->flags & I2C_AQ_COMB) {
2623 max_num = 2;
2624
2625 /* special checks for combined messages */
2626 if (num == 2) {
2627 if (q->flags & I2C_AQ_COMB_WRITE_FIRST && msgs[0].flags & I2C_M_RD)
2628 return i2c_quirk_error(adap, &msgs[0], "1st comb msg must be write");
2629
2630 if (q->flags & I2C_AQ_COMB_READ_SECOND && !(msgs[1].flags & I2C_M_RD))
2631 return i2c_quirk_error(adap, &msgs[1], "2nd comb msg must be read");
2632
2633 if (q->flags & I2C_AQ_COMB_SAME_ADDR && msgs[0].addr != msgs[1].addr)
2634 return i2c_quirk_error(adap, &msgs[0], "comb msg only to same addr");
2635
2636 if (i2c_quirk_exceeded(msgs[0].len, q->max_comb_1st_msg_len))
2637 return i2c_quirk_error(adap, &msgs[0], "msg too long");
2638
2639 if (i2c_quirk_exceeded(msgs[1].len, q->max_comb_2nd_msg_len))
2640 return i2c_quirk_error(adap, &msgs[1], "msg too long");
2641
2642 do_len_check = false;
2643 }
2644 }
2645
2646 if (i2c_quirk_exceeded(num, max_num))
2647 return i2c_quirk_error(adap, &msgs[0], "too many messages");
2648
2649 for (i = 0; i < num; i++) {
2650 u16 len = msgs[i].len;
2651
2652 if (msgs[i].flags & I2C_M_RD) {
2653 if (do_len_check && i2c_quirk_exceeded(len, q->max_read_len))
2654 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2655 } else {
2656 if (do_len_check && i2c_quirk_exceeded(len, q->max_write_len))
2657 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2658 }
2659 }
2660
2661 return 0;
2662}
2663
David Brownella1cdeda2008-07-14 22:38:24 +02002664/**
Jean Delvareb37d2a32012-06-29 07:47:19 -03002665 * __i2c_transfer - unlocked flavor of i2c_transfer
2666 * @adap: Handle to I2C bus
2667 * @msgs: One or more messages to execute before STOP is issued to
2668 * terminate the operation; each message begins with a START.
2669 * @num: Number of messages to be executed.
2670 *
2671 * Returns negative errno, else the number of messages executed.
2672 *
2673 * Adapter lock must be held when calling this function. No debug logging
2674 * takes place. adap->algo->master_xfer existence isn't checked.
2675 */
2676int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2677{
2678 unsigned long orig_jiffies;
2679 int ret, try;
2680
Wolfram Sangb7f62582015-01-05 23:45:59 +01002681 if (adap->quirks && i2c_check_for_quirks(adap, msgs, num))
2682 return -EOPNOTSUPP;
2683
David Howellsd9a83d62014-03-06 13:35:59 +00002684 /* i2c_trace_msg gets enabled when tracepoint i2c_transfer gets
2685 * enabled. This is an efficient way of keeping the for-loop from
2686 * being executed when not needed.
2687 */
2688 if (static_key_false(&i2c_trace_msg)) {
2689 int i;
2690 for (i = 0; i < num; i++)
2691 if (msgs[i].flags & I2C_M_RD)
2692 trace_i2c_read(adap, &msgs[i], i);
2693 else
2694 trace_i2c_write(adap, &msgs[i], i);
2695 }
2696
Jean Delvareb37d2a32012-06-29 07:47:19 -03002697 /* Retry automatically on arbitration loss */
2698 orig_jiffies = jiffies;
2699 for (ret = 0, try = 0; try <= adap->retries; try++) {
2700 ret = adap->algo->master_xfer(adap, msgs, num);
2701 if (ret != -EAGAIN)
2702 break;
2703 if (time_after(jiffies, orig_jiffies + adap->timeout))
2704 break;
2705 }
2706
David Howellsd9a83d62014-03-06 13:35:59 +00002707 if (static_key_false(&i2c_trace_msg)) {
2708 int i;
2709 for (i = 0; i < ret; i++)
2710 if (msgs[i].flags & I2C_M_RD)
2711 trace_i2c_reply(adap, &msgs[i], i);
2712 trace_i2c_result(adap, i, ret);
2713 }
2714
Jean Delvareb37d2a32012-06-29 07:47:19 -03002715 return ret;
2716}
2717EXPORT_SYMBOL(__i2c_transfer);
2718
2719/**
David Brownella1cdeda2008-07-14 22:38:24 +02002720 * i2c_transfer - execute a single or combined I2C message
2721 * @adap: Handle to I2C bus
2722 * @msgs: One or more messages to execute before STOP is issued to
2723 * terminate the operation; each message begins with a START.
2724 * @num: Number of messages to be executed.
2725 *
2726 * Returns negative errno, else the number of messages executed.
2727 *
2728 * Note that there is no requirement that each message be sent to
2729 * the same slave address, although that is the most common model.
2730 */
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01002731int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002732{
Jean Delvareb37d2a32012-06-29 07:47:19 -03002733 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002734
David Brownella1cdeda2008-07-14 22:38:24 +02002735 /* REVISIT the fault reporting model here is weak:
2736 *
2737 * - When we get an error after receiving N bytes from a slave,
2738 * there is no way to report "N".
2739 *
2740 * - When we get a NAK after transmitting N bytes to a slave,
2741 * there is no way to report "N" ... or to let the master
2742 * continue executing the rest of this combined message, if
2743 * that's the appropriate response.
2744 *
2745 * - When for example "num" is two and we successfully complete
2746 * the first message but get an error part way through the
2747 * second, it's unclear whether that should be reported as
2748 * one (discarding status on the second message) or errno
2749 * (discarding status on the first one).
2750 */
2751
Linus Torvalds1da177e2005-04-16 15:20:36 -07002752 if (adap->algo->master_xfer) {
2753#ifdef DEBUG
2754 for (ret = 0; ret < num; ret++) {
Andy Shevchenkob93d3d32016-08-25 17:42:10 +03002755 dev_dbg(&adap->dev,
2756 "master_xfer[%d] %c, addr=0x%02x, len=%d%s\n",
2757 ret, (msgs[ret].flags & I2C_M_RD) ? 'R' : 'W',
2758 msgs[ret].addr, msgs[ret].len,
Jean Delvare209d27c2007-05-01 23:26:29 +02002759 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002760 }
2761#endif
2762
Mike Rapoportcea443a82008-01-27 18:14:50 +01002763 if (in_atomic() || irqs_disabled()) {
Peter Rosinfb79e092016-06-29 15:04:03 +02002764 ret = i2c_trylock_bus(adap, I2C_LOCK_SEGMENT);
Mike Rapoportcea443a82008-01-27 18:14:50 +01002765 if (!ret)
2766 /* I2C activity is ongoing. */
2767 return -EAGAIN;
2768 } else {
Peter Rosin8320f492016-05-04 22:15:27 +02002769 i2c_lock_bus(adap, I2C_LOCK_SEGMENT);
Mike Rapoportcea443a82008-01-27 18:14:50 +01002770 }
2771
Jean Delvareb37d2a32012-06-29 07:47:19 -03002772 ret = __i2c_transfer(adap, msgs, num);
Peter Rosin8320f492016-05-04 22:15:27 +02002773 i2c_unlock_bus(adap, I2C_LOCK_SEGMENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002774
2775 return ret;
2776 } else {
2777 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
David Brownell24a5bb72008-07-14 22:38:23 +02002778 return -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002779 }
2780}
David Brownellc0564602007-05-01 23:26:31 +02002781EXPORT_SYMBOL(i2c_transfer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002782
David Brownella1cdeda2008-07-14 22:38:24 +02002783/**
2784 * i2c_master_send - issue a single I2C message in master transmit mode
2785 * @client: Handle to slave device
2786 * @buf: Data that will be written to the slave
Zhangfei Gao0c43ea52010-03-02 12:23:49 +01002787 * @count: How many bytes to write, must be less than 64k since msg.len is u16
David Brownella1cdeda2008-07-14 22:38:24 +02002788 *
2789 * Returns negative errno, or else the number of bytes written.
2790 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01002791int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002792{
2793 int ret;
Farid Hammane7225acf2010-05-21 18:40:58 +02002794 struct i2c_adapter *adap = client->adapter;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002795 struct i2c_msg msg;
2796
Jean Delvare815f55f2005-05-07 22:58:46 +02002797 msg.addr = client->addr;
2798 msg.flags = client->flags & I2C_M_TEN;
2799 msg.len = count;
2800 msg.buf = (char *)buf;
David Brownell438d6c22006-12-10 21:21:31 +01002801
Jean Delvare815f55f2005-05-07 22:58:46 +02002802 ret = i2c_transfer(adap, &msg, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002803
Wolfram Sang834aa6f2012-03-15 18:11:05 +01002804 /*
2805 * If everything went ok (i.e. 1 msg transmitted), return #bytes
2806 * transmitted, else error code.
2807 */
Jean Delvare815f55f2005-05-07 22:58:46 +02002808 return (ret == 1) ? count : ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002809}
David Brownellc0564602007-05-01 23:26:31 +02002810EXPORT_SYMBOL(i2c_master_send);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002811
David Brownella1cdeda2008-07-14 22:38:24 +02002812/**
2813 * i2c_master_recv - issue a single I2C message in master receive mode
2814 * @client: Handle to slave device
2815 * @buf: Where to store data read from slave
Zhangfei Gao0c43ea52010-03-02 12:23:49 +01002816 * @count: How many bytes to read, must be less than 64k since msg.len is u16
David Brownella1cdeda2008-07-14 22:38:24 +02002817 *
2818 * Returns negative errno, or else the number of bytes read.
2819 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01002820int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002821{
Farid Hammane7225acf2010-05-21 18:40:58 +02002822 struct i2c_adapter *adap = client->adapter;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002823 struct i2c_msg msg;
2824 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002825
Jean Delvare815f55f2005-05-07 22:58:46 +02002826 msg.addr = client->addr;
2827 msg.flags = client->flags & I2C_M_TEN;
2828 msg.flags |= I2C_M_RD;
2829 msg.len = count;
2830 msg.buf = buf;
2831
2832 ret = i2c_transfer(adap, &msg, 1);
2833
Wolfram Sang834aa6f2012-03-15 18:11:05 +01002834 /*
2835 * If everything went ok (i.e. 1 msg received), return #bytes received,
2836 * else error code.
2837 */
Jean Delvare815f55f2005-05-07 22:58:46 +02002838 return (ret == 1) ? count : ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002839}
David Brownellc0564602007-05-01 23:26:31 +02002840EXPORT_SYMBOL(i2c_master_recv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002841
Linus Torvalds1da177e2005-04-16 15:20:36 -07002842/* ----------------------------------------------------
2843 * the i2c address scanning function
2844 * Will not work for 10-bit addresses!
2845 * ----------------------------------------------------
2846 */
Jean Delvare9fc6adf2005-07-31 21:20:43 +02002847
Jean Delvare63e4e802010-06-03 11:33:51 +02002848/*
2849 * Legacy default probe function, mostly relevant for SMBus. The default
2850 * probe method is a quick write, but it is known to corrupt the 24RF08
2851 * EEPROMs due to a state machine bug, and could also irreversibly
2852 * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
2853 * we use a short byte read instead. Also, some bus drivers don't implement
2854 * quick write, so we fallback to a byte read in that case too.
2855 * On x86, there is another special case for FSC hardware monitoring chips,
2856 * which want regular byte reads (address 0x73.) Fortunately, these are the
2857 * only known chips using this I2C address on PC hardware.
2858 * Returns 1 if probe succeeded, 0 if not.
2859 */
2860static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
2861{
2862 int err;
2863 union i2c_smbus_data dummy;
2864
2865#ifdef CONFIG_X86
2866 if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
2867 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
2868 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2869 I2C_SMBUS_BYTE_DATA, &dummy);
2870 else
2871#endif
Jean Delvare8031d792010-08-11 18:21:00 +02002872 if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
2873 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
Jean Delvare63e4e802010-06-03 11:33:51 +02002874 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
2875 I2C_SMBUS_QUICK, NULL);
Jean Delvare8031d792010-08-11 18:21:00 +02002876 else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
2877 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2878 I2C_SMBUS_BYTE, &dummy);
2879 else {
Andy Lutomirskid63a9e82013-07-17 13:27:59 -07002880 dev_warn(&adap->dev, "No suitable probing method supported for address 0x%02X\n",
2881 addr);
Jean Delvare8031d792010-08-11 18:21:00 +02002882 err = -EOPNOTSUPP;
2883 }
Jean Delvare63e4e802010-06-03 11:33:51 +02002884
2885 return err >= 0;
2886}
2887
Jean Delvareccfbbd02009-12-06 17:06:25 +01002888static int i2c_detect_address(struct i2c_client *temp_client,
Jean Delvare4735c98f2008-07-14 22:38:36 +02002889 struct i2c_driver *driver)
2890{
2891 struct i2c_board_info info;
2892 struct i2c_adapter *adapter = temp_client->adapter;
2893 int addr = temp_client->addr;
2894 int err;
2895
2896 /* Make sure the address is valid */
Wolfram Sang66be60562015-07-17 12:43:22 +02002897 err = i2c_check_7bit_addr_validity_strict(addr);
Jean Delvare656b8762010-06-03 11:33:53 +02002898 if (err) {
Jean Delvare4735c98f2008-07-14 22:38:36 +02002899 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
2900 addr);
Jean Delvare656b8762010-06-03 11:33:53 +02002901 return err;
Jean Delvare4735c98f2008-07-14 22:38:36 +02002902 }
2903
Wolfram Sang9bccc702015-07-17 14:48:56 +02002904 /* Skip if already in use (7 bit, no need to encode flags) */
Jean Delvare3b5f7942010-06-03 11:33:55 +02002905 if (i2c_check_addr_busy(adapter, addr))
Jean Delvare4735c98f2008-07-14 22:38:36 +02002906 return 0;
2907
Jean Delvareccfbbd02009-12-06 17:06:25 +01002908 /* Make sure there is something at this address */
Jean Delvare63e4e802010-06-03 11:33:51 +02002909 if (!i2c_default_probe(adapter, addr))
2910 return 0;
Jean Delvare4735c98f2008-07-14 22:38:36 +02002911
2912 /* Finally call the custom detection function */
2913 memset(&info, 0, sizeof(struct i2c_board_info));
2914 info.addr = addr;
Jean Delvare310ec792009-12-14 21:17:23 +01002915 err = driver->detect(temp_client, &info);
Jean Delvare4735c98f2008-07-14 22:38:36 +02002916 if (err) {
2917 /* -ENODEV is returned if the detection fails. We catch it
2918 here as this isn't an error. */
2919 return err == -ENODEV ? 0 : err;
2920 }
2921
2922 /* Consistency check */
2923 if (info.type[0] == '\0') {
Andy Shevchenkob93d3d32016-08-25 17:42:10 +03002924 dev_err(&adapter->dev,
2925 "%s detection function provided no name for 0x%x\n",
2926 driver->driver.name, addr);
Jean Delvare4735c98f2008-07-14 22:38:36 +02002927 } else {
2928 struct i2c_client *client;
2929
2930 /* Detection succeeded, instantiate the device */
Wolfram Sang0c176172014-02-10 11:03:56 +01002931 if (adapter->class & I2C_CLASS_DEPRECATED)
2932 dev_warn(&adapter->dev,
2933 "This adapter will soon drop class based instantiation of devices. "
2934 "Please make sure client 0x%02x gets instantiated by other means. "
2935 "Check 'Documentation/i2c/instantiating-devices' for details.\n",
2936 info.addr);
2937
Jean Delvare4735c98f2008-07-14 22:38:36 +02002938 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
2939 info.type, info.addr);
2940 client = i2c_new_device(adapter, &info);
2941 if (client)
2942 list_add_tail(&client->detected, &driver->clients);
2943 else
2944 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
2945 info.type, info.addr);
2946 }
2947 return 0;
2948}
2949
2950static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
2951{
Jean Delvarec3813d62009-12-14 21:17:25 +01002952 const unsigned short *address_list;
Jean Delvare4735c98f2008-07-14 22:38:36 +02002953 struct i2c_client *temp_client;
2954 int i, err = 0;
2955 int adap_id = i2c_adapter_id(adapter);
2956
Jean Delvarec3813d62009-12-14 21:17:25 +01002957 address_list = driver->address_list;
2958 if (!driver->detect || !address_list)
Jean Delvare4735c98f2008-07-14 22:38:36 +02002959 return 0;
2960
Wolfram Sang45552272014-07-10 13:46:21 +02002961 /* Warn that the adapter lost class based instantiation */
2962 if (adapter->class == I2C_CLASS_DEPRECATED) {
2963 dev_dbg(&adapter->dev,
Andy Shevchenkob93d3d32016-08-25 17:42:10 +03002964 "This adapter dropped support for I2C classes and won't auto-detect %s devices anymore. "
2965 "If you need it, check 'Documentation/i2c/instantiating-devices' for alternatives.\n",
Wolfram Sang45552272014-07-10 13:46:21 +02002966 driver->driver.name);
2967 return 0;
2968 }
2969
Jean Delvare51b54ba2010-10-24 18:16:58 +02002970 /* Stop here if the classes do not match */
2971 if (!(adapter->class & driver->class))
2972 return 0;
2973
Jean Delvare4735c98f2008-07-14 22:38:36 +02002974 /* Set up a temporary client to help detect callback */
2975 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
2976 if (!temp_client)
2977 return -ENOMEM;
2978 temp_client->adapter = adapter;
2979
Jean Delvarec3813d62009-12-14 21:17:25 +01002980 for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
Andy Shevchenkob93d3d32016-08-25 17:42:10 +03002981 dev_dbg(&adapter->dev,
2982 "found normal entry for adapter %d, addr 0x%02x\n",
2983 adap_id, address_list[i]);
Jean Delvarec3813d62009-12-14 21:17:25 +01002984 temp_client->addr = address_list[i];
Jean Delvareccfbbd02009-12-06 17:06:25 +01002985 err = i2c_detect_address(temp_client, driver);
Jean Delvare51b54ba2010-10-24 18:16:58 +02002986 if (unlikely(err))
2987 break;
Jean Delvare4735c98f2008-07-14 22:38:36 +02002988 }
2989
Jean Delvare4735c98f2008-07-14 22:38:36 +02002990 kfree(temp_client);
2991 return err;
2992}
2993
Jean Delvared44f19d2010-08-11 18:20:57 +02002994int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
2995{
2996 return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2997 I2C_SMBUS_QUICK, NULL) >= 0;
2998}
2999EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
3000
Jean Delvare12b5053a2007-05-01 23:26:31 +02003001struct i2c_client *
3002i2c_new_probed_device(struct i2c_adapter *adap,
3003 struct i2c_board_info *info,
Jean Delvare9a942412010-08-11 18:20:56 +02003004 unsigned short const *addr_list,
3005 int (*probe)(struct i2c_adapter *, unsigned short addr))
Jean Delvare12b5053a2007-05-01 23:26:31 +02003006{
3007 int i;
3008
Jean Delvare8031d792010-08-11 18:21:00 +02003009 if (!probe)
Jean Delvare9a942412010-08-11 18:20:56 +02003010 probe = i2c_default_probe;
Jean Delvare12b5053a2007-05-01 23:26:31 +02003011
Jean Delvare12b5053a2007-05-01 23:26:31 +02003012 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
3013 /* Check address validity */
Wolfram Sang66be60562015-07-17 12:43:22 +02003014 if (i2c_check_7bit_addr_validity_strict(addr_list[i]) < 0) {
Andy Shevchenkob93d3d32016-08-25 17:42:10 +03003015 dev_warn(&adap->dev, "Invalid 7-bit address 0x%02x\n",
3016 addr_list[i]);
Jean Delvare12b5053a2007-05-01 23:26:31 +02003017 continue;
3018 }
3019
Wolfram Sang9bccc702015-07-17 14:48:56 +02003020 /* Check address availability (7 bit, no need to encode flags) */
Jean Delvare3b5f7942010-06-03 11:33:55 +02003021 if (i2c_check_addr_busy(adap, addr_list[i])) {
Andy Shevchenkob93d3d32016-08-25 17:42:10 +03003022 dev_dbg(&adap->dev,
3023 "Address 0x%02x already in use, not probing\n",
3024 addr_list[i]);
Jean Delvare12b5053a2007-05-01 23:26:31 +02003025 continue;
3026 }
3027
Jean Delvare63e4e802010-06-03 11:33:51 +02003028 /* Test address responsiveness */
Jean Delvare9a942412010-08-11 18:20:56 +02003029 if (probe(adap, addr_list[i]))
Jean Delvare63e4e802010-06-03 11:33:51 +02003030 break;
Jean Delvare12b5053a2007-05-01 23:26:31 +02003031 }
Jean Delvare12b5053a2007-05-01 23:26:31 +02003032
3033 if (addr_list[i] == I2C_CLIENT_END) {
3034 dev_dbg(&adap->dev, "Probing failed, no device found\n");
3035 return NULL;
3036 }
3037
3038 info->addr = addr_list[i];
3039 return i2c_new_device(adap, info);
3040}
3041EXPORT_SYMBOL_GPL(i2c_new_probed_device);
3042
Jean Delvared735b342011-03-20 14:50:52 +01003043struct i2c_adapter *i2c_get_adapter(int nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003044{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003045 struct i2c_adapter *adapter;
David Brownell438d6c22006-12-10 21:21:31 +01003046
Jean Delvarecaada322008-01-27 18:14:49 +01003047 mutex_lock(&core_lock);
Jean Delvared735b342011-03-20 14:50:52 +01003048 adapter = idr_find(&i2c_adapter_idr, nr);
Vladimir Zapolskiy611e12e2015-07-27 17:30:49 +03003049 if (!adapter)
3050 goto exit;
3051
3052 if (try_module_get(adapter->owner))
3053 get_device(&adapter->dev);
3054 else
Mark M. Hoffmana0920e102005-06-28 00:21:30 -04003055 adapter = NULL;
3056
Vladimir Zapolskiy611e12e2015-07-27 17:30:49 +03003057 exit:
Jean Delvarecaada322008-01-27 18:14:49 +01003058 mutex_unlock(&core_lock);
Mark M. Hoffmana0920e102005-06-28 00:21:30 -04003059 return adapter;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003060}
David Brownellc0564602007-05-01 23:26:31 +02003061EXPORT_SYMBOL(i2c_get_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003062
3063void i2c_put_adapter(struct i2c_adapter *adap)
3064{
Vladimir Zapolskiy611e12e2015-07-27 17:30:49 +03003065 if (!adap)
3066 return;
3067
3068 put_device(&adap->dev);
3069 module_put(adap->owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003070}
David Brownellc0564602007-05-01 23:26:31 +02003071EXPORT_SYMBOL(i2c_put_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003072
3073/* The SMBus parts */
3074
David Brownell438d6c22006-12-10 21:21:31 +01003075#define POLY (0x1070U << 3)
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01003076static u8 crc8(u16 data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003077{
3078 int i;
David Brownell438d6c22006-12-10 21:21:31 +01003079
Farid Hammane7225acf2010-05-21 18:40:58 +02003080 for (i = 0; i < 8; i++) {
David Brownell438d6c22006-12-10 21:21:31 +01003081 if (data & 0x8000)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003082 data = data ^ POLY;
3083 data = data << 1;
3084 }
3085 return (u8)(data >> 8);
3086}
3087
Jean Delvare421ef472005-10-26 21:28:55 +02003088/* Incremental CRC8 over count bytes in the array pointed to by p */
3089static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003090{
3091 int i;
3092
Farid Hammane7225acf2010-05-21 18:40:58 +02003093 for (i = 0; i < count; i++)
Jean Delvare421ef472005-10-26 21:28:55 +02003094 crc = crc8((crc ^ p[i]) << 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003095 return crc;
3096}
3097
Jean Delvare421ef472005-10-26 21:28:55 +02003098/* Assume a 7-bit address, which is reasonable for SMBus */
3099static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003100{
Jean Delvare421ef472005-10-26 21:28:55 +02003101 /* The address will be sent first */
Wolfram Sang041edda2016-04-03 20:44:46 +02003102 u8 addr = i2c_8bit_addr_from_msg(msg);
Jean Delvare421ef472005-10-26 21:28:55 +02003103 pec = i2c_smbus_pec(pec, &addr, 1);
3104
3105 /* The data buffer follows */
3106 return i2c_smbus_pec(pec, msg->buf, msg->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003107}
3108
Jean Delvare421ef472005-10-26 21:28:55 +02003109/* Used for write only transactions */
3110static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003111{
Jean Delvare421ef472005-10-26 21:28:55 +02003112 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
3113 msg->len++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003114}
3115
Jean Delvare421ef472005-10-26 21:28:55 +02003116/* Return <0 on CRC error
3117 If there was a write before this read (most cases) we need to take the
3118 partial CRC from the write part into account.
3119 Note that this function does modify the message (we need to decrease the
3120 message length to hide the CRC byte from the caller). */
3121static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003122{
Jean Delvare421ef472005-10-26 21:28:55 +02003123 u8 rpec = msg->buf[--msg->len];
3124 cpec = i2c_smbus_msg_pec(cpec, msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003125
Linus Torvalds1da177e2005-04-16 15:20:36 -07003126 if (rpec != cpec) {
Wolfram Sang44239a52016-07-09 13:35:04 +09003127 pr_debug("Bad PEC 0x%02x vs. 0x%02x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003128 rpec, cpec);
David Brownell24a5bb72008-07-14 22:38:23 +02003129 return -EBADMSG;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003130 }
David Brownell438d6c22006-12-10 21:21:31 +01003131 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003132}
3133
David Brownella1cdeda2008-07-14 22:38:24 +02003134/**
3135 * i2c_smbus_read_byte - SMBus "receive byte" protocol
3136 * @client: Handle to slave device
3137 *
3138 * This executes the SMBus "receive byte" protocol, returning negative errno
3139 * else the byte received from the device.
3140 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01003141s32 i2c_smbus_read_byte(const struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003142{
3143 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02003144 int status;
3145
3146 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3147 I2C_SMBUS_READ, 0,
3148 I2C_SMBUS_BYTE, &data);
3149 return (status < 0) ? status : data.byte;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003150}
David Brownellc0564602007-05-01 23:26:31 +02003151EXPORT_SYMBOL(i2c_smbus_read_byte);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003152
David Brownella1cdeda2008-07-14 22:38:24 +02003153/**
3154 * i2c_smbus_write_byte - SMBus "send byte" protocol
3155 * @client: Handle to slave device
3156 * @value: Byte to be sent
3157 *
3158 * This executes the SMBus "send byte" protocol, returning negative errno
3159 * else zero on success.
3160 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01003161s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003162{
Farid Hammane7225acf2010-05-21 18:40:58 +02003163 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
Jean Delvare421ef472005-10-26 21:28:55 +02003164 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003165}
David Brownellc0564602007-05-01 23:26:31 +02003166EXPORT_SYMBOL(i2c_smbus_write_byte);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003167
David Brownella1cdeda2008-07-14 22:38:24 +02003168/**
3169 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
3170 * @client: Handle to slave device
3171 * @command: Byte interpreted by slave
3172 *
3173 * This executes the SMBus "read byte" protocol, returning negative errno
3174 * else a data byte received from the device.
3175 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01003176s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003177{
3178 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02003179 int status;
3180
3181 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3182 I2C_SMBUS_READ, command,
3183 I2C_SMBUS_BYTE_DATA, &data);
3184 return (status < 0) ? status : data.byte;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003185}
David Brownellc0564602007-05-01 23:26:31 +02003186EXPORT_SYMBOL(i2c_smbus_read_byte_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003187
David Brownella1cdeda2008-07-14 22:38:24 +02003188/**
3189 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
3190 * @client: Handle to slave device
3191 * @command: Byte interpreted by slave
3192 * @value: Byte being written
3193 *
3194 * This executes the SMBus "write byte" protocol, returning negative errno
3195 * else zero on success.
3196 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01003197s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
3198 u8 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003199{
3200 union i2c_smbus_data data;
3201 data.byte = value;
Farid Hammane7225acf2010-05-21 18:40:58 +02003202 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3203 I2C_SMBUS_WRITE, command,
3204 I2C_SMBUS_BYTE_DATA, &data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003205}
David Brownellc0564602007-05-01 23:26:31 +02003206EXPORT_SYMBOL(i2c_smbus_write_byte_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003207
David Brownella1cdeda2008-07-14 22:38:24 +02003208/**
3209 * i2c_smbus_read_word_data - SMBus "read word" protocol
3210 * @client: Handle to slave device
3211 * @command: Byte interpreted by slave
3212 *
3213 * This executes the SMBus "read word" protocol, returning negative errno
3214 * else a 16-bit unsigned "word" received from the device.
3215 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01003216s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003217{
3218 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02003219 int status;
3220
3221 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3222 I2C_SMBUS_READ, command,
3223 I2C_SMBUS_WORD_DATA, &data);
3224 return (status < 0) ? status : data.word;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003225}
David Brownellc0564602007-05-01 23:26:31 +02003226EXPORT_SYMBOL(i2c_smbus_read_word_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003227
David Brownella1cdeda2008-07-14 22:38:24 +02003228/**
3229 * i2c_smbus_write_word_data - SMBus "write word" protocol
3230 * @client: Handle to slave device
3231 * @command: Byte interpreted by slave
3232 * @value: 16-bit "word" being written
3233 *
3234 * This executes the SMBus "write word" protocol, returning negative errno
3235 * else zero on success.
3236 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01003237s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
3238 u16 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003239{
3240 union i2c_smbus_data data;
3241 data.word = value;
Farid Hammane7225acf2010-05-21 18:40:58 +02003242 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3243 I2C_SMBUS_WRITE, command,
3244 I2C_SMBUS_WORD_DATA, &data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003245}
David Brownellc0564602007-05-01 23:26:31 +02003246EXPORT_SYMBOL(i2c_smbus_write_word_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003247
David Brownella64ec072007-10-13 23:56:31 +02003248/**
David Brownella1cdeda2008-07-14 22:38:24 +02003249 * i2c_smbus_read_block_data - SMBus "block read" protocol
David Brownella64ec072007-10-13 23:56:31 +02003250 * @client: Handle to slave device
David Brownella1cdeda2008-07-14 22:38:24 +02003251 * @command: Byte interpreted by slave
David Brownella64ec072007-10-13 23:56:31 +02003252 * @values: Byte array into which data will be read; big enough to hold
3253 * the data returned by the slave. SMBus allows at most 32 bytes.
3254 *
David Brownella1cdeda2008-07-14 22:38:24 +02003255 * This executes the SMBus "block read" protocol, returning negative errno
3256 * else the number of data bytes in the slave's response.
David Brownella64ec072007-10-13 23:56:31 +02003257 *
3258 * Note that using this function requires that the client's adapter support
3259 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
3260 * support this; its emulation through I2C messaging relies on a specific
3261 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
3262 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01003263s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
Jean Delvareb86a1bc2007-05-01 23:26:34 +02003264 u8 *values)
3265{
3266 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02003267 int status;
Jean Delvareb86a1bc2007-05-01 23:26:34 +02003268
David Brownell24a5bb72008-07-14 22:38:23 +02003269 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3270 I2C_SMBUS_READ, command,
3271 I2C_SMBUS_BLOCK_DATA, &data);
3272 if (status)
3273 return status;
Jean Delvareb86a1bc2007-05-01 23:26:34 +02003274
3275 memcpy(values, &data.block[1], data.block[0]);
3276 return data.block[0];
3277}
3278EXPORT_SYMBOL(i2c_smbus_read_block_data);
3279
David Brownella1cdeda2008-07-14 22:38:24 +02003280/**
3281 * i2c_smbus_write_block_data - SMBus "block write" protocol
3282 * @client: Handle to slave device
3283 * @command: Byte interpreted by slave
3284 * @length: Size of data block; SMBus allows at most 32 bytes
3285 * @values: Byte array which will be written.
3286 *
3287 * This executes the SMBus "block write" protocol, returning negative errno
3288 * else zero on success.
3289 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01003290s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
Krzysztof Halasa46f5ed72006-06-12 21:42:20 +02003291 u8 length, const u8 *values)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003292{
3293 union i2c_smbus_data data;
Jean Delvare7656032b2006-01-18 23:14:55 +01003294
Linus Torvalds1da177e2005-04-16 15:20:36 -07003295 if (length > I2C_SMBUS_BLOCK_MAX)
3296 length = I2C_SMBUS_BLOCK_MAX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003297 data.block[0] = length;
Jean Delvare7656032b2006-01-18 23:14:55 +01003298 memcpy(&data.block[1], values, length);
Farid Hammane7225acf2010-05-21 18:40:58 +02003299 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3300 I2C_SMBUS_WRITE, command,
3301 I2C_SMBUS_BLOCK_DATA, &data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003302}
David Brownellc0564602007-05-01 23:26:31 +02003303EXPORT_SYMBOL(i2c_smbus_write_block_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003304
3305/* Returns the number of read bytes */
Jean Delvare0cc43a12011-01-10 22:11:23 +01003306s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
Jean Delvare4b2643d2007-07-12 14:12:29 +02003307 u8 length, u8 *values)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003308{
3309 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02003310 int status;
Jean Delvare7656032b2006-01-18 23:14:55 +01003311
Jean Delvare4b2643d2007-07-12 14:12:29 +02003312 if (length > I2C_SMBUS_BLOCK_MAX)
3313 length = I2C_SMBUS_BLOCK_MAX;
3314 data.block[0] = length;
David Brownell24a5bb72008-07-14 22:38:23 +02003315 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3316 I2C_SMBUS_READ, command,
3317 I2C_SMBUS_I2C_BLOCK_DATA, &data);
3318 if (status < 0)
3319 return status;
Jean Delvare7656032b2006-01-18 23:14:55 +01003320
3321 memcpy(values, &data.block[1], data.block[0]);
3322 return data.block[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003323}
David Brownellc0564602007-05-01 23:26:31 +02003324EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003325
Jean Delvare0cc43a12011-01-10 22:11:23 +01003326s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
Krzysztof Halasa46f5ed72006-06-12 21:42:20 +02003327 u8 length, const u8 *values)
Jean Delvare21bbd692006-01-09 15:19:18 +11003328{
3329 union i2c_smbus_data data;
3330
3331 if (length > I2C_SMBUS_BLOCK_MAX)
3332 length = I2C_SMBUS_BLOCK_MAX;
3333 data.block[0] = length;
3334 memcpy(data.block + 1, values, length);
3335 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3336 I2C_SMBUS_WRITE, command,
3337 I2C_SMBUS_I2C_BLOCK_DATA, &data);
3338}
David Brownellc0564602007-05-01 23:26:31 +02003339EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
Jean Delvare21bbd692006-01-09 15:19:18 +11003340
David Brownell438d6c22006-12-10 21:21:31 +01003341/* Simulate a SMBus command using the i2c protocol
Linus Torvalds1da177e2005-04-16 15:20:36 -07003342 No checking of parameters is done! */
Farid Hammane7225acf2010-05-21 18:40:58 +02003343static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
3344 unsigned short flags,
3345 char read_write, u8 command, int size,
3346 union i2c_smbus_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003347{
3348 /* So we need to generate a series of msgs. In the case of writing, we
3349 need to use only one message; when reading, we need two. We initialize
3350 most things with sane defaults, to keep the code below somewhat
3351 simpler. */
Hideki Iwamoto5c50d182005-09-25 17:01:11 +02003352 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
3353 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
Farid Hammane7225acf2010-05-21 18:40:58 +02003354 int num = read_write == I2C_SMBUS_READ ? 2 : 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003355 int i;
Jean Delvare421ef472005-10-26 21:28:55 +02003356 u8 partial_pec = 0;
David Brownell24a5bb72008-07-14 22:38:23 +02003357 int status;
Shubhrajyoti D230da092012-10-05 22:23:52 +02003358 struct i2c_msg msg[2] = {
3359 {
3360 .addr = addr,
3361 .flags = flags,
3362 .len = 1,
3363 .buf = msgbuf0,
3364 }, {
3365 .addr = addr,
3366 .flags = flags | I2C_M_RD,
3367 .len = 0,
3368 .buf = msgbuf1,
3369 },
3370 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07003371
3372 msgbuf0[0] = command;
Farid Hammane7225acf2010-05-21 18:40:58 +02003373 switch (size) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003374 case I2C_SMBUS_QUICK:
3375 msg[0].len = 0;
3376 /* Special case: The read/write field is used as data */
Roel Kluinf29d2e02009-02-24 19:19:48 +01003377 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
3378 I2C_M_RD : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003379 num = 1;
3380 break;
3381 case I2C_SMBUS_BYTE:
3382 if (read_write == I2C_SMBUS_READ) {
3383 /* Special case: only a read! */
3384 msg[0].flags = I2C_M_RD | flags;
3385 num = 1;
3386 }
3387 break;
3388 case I2C_SMBUS_BYTE_DATA:
3389 if (read_write == I2C_SMBUS_READ)
3390 msg[1].len = 1;
3391 else {
3392 msg[0].len = 2;
3393 msgbuf0[1] = data->byte;
3394 }
3395 break;
3396 case I2C_SMBUS_WORD_DATA:
3397 if (read_write == I2C_SMBUS_READ)
3398 msg[1].len = 2;
3399 else {
Farid Hammane7225acf2010-05-21 18:40:58 +02003400 msg[0].len = 3;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003401 msgbuf0[1] = data->word & 0xff;
Jean Delvare7eff82c2006-09-03 22:24:00 +02003402 msgbuf0[2] = data->word >> 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003403 }
3404 break;
3405 case I2C_SMBUS_PROC_CALL:
3406 num = 2; /* Special case */
3407 read_write = I2C_SMBUS_READ;
3408 msg[0].len = 3;
3409 msg[1].len = 2;
3410 msgbuf0[1] = data->word & 0xff;
Jean Delvare7eff82c2006-09-03 22:24:00 +02003411 msgbuf0[2] = data->word >> 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003412 break;
3413 case I2C_SMBUS_BLOCK_DATA:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003414 if (read_write == I2C_SMBUS_READ) {
Jean Delvare209d27c2007-05-01 23:26:29 +02003415 msg[1].flags |= I2C_M_RECV_LEN;
3416 msg[1].len = 1; /* block length will be added by
3417 the underlying bus driver */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003418 } else {
3419 msg[0].len = data->block[0] + 2;
3420 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
David Brownell24a5bb72008-07-14 22:38:23 +02003421 dev_err(&adapter->dev,
3422 "Invalid block write size %d\n",
3423 data->block[0]);
3424 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003425 }
Hideki Iwamoto5c50d182005-09-25 17:01:11 +02003426 for (i = 1; i < msg[0].len; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003427 msgbuf0[i] = data->block[i-1];
3428 }
3429 break;
3430 case I2C_SMBUS_BLOCK_PROC_CALL:
Jean Delvare209d27c2007-05-01 23:26:29 +02003431 num = 2; /* Another special case */
3432 read_write = I2C_SMBUS_READ;
3433 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
David Brownell24a5bb72008-07-14 22:38:23 +02003434 dev_err(&adapter->dev,
3435 "Invalid block write size %d\n",
Jean Delvare209d27c2007-05-01 23:26:29 +02003436 data->block[0]);
David Brownell24a5bb72008-07-14 22:38:23 +02003437 return -EINVAL;
Jean Delvare209d27c2007-05-01 23:26:29 +02003438 }
3439 msg[0].len = data->block[0] + 2;
3440 for (i = 1; i < msg[0].len; i++)
3441 msgbuf0[i] = data->block[i-1];
3442 msg[1].flags |= I2C_M_RECV_LEN;
3443 msg[1].len = 1; /* block length will be added by
3444 the underlying bus driver */
3445 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003446 case I2C_SMBUS_I2C_BLOCK_DATA:
3447 if (read_write == I2C_SMBUS_READ) {
Jean Delvare4b2643d2007-07-12 14:12:29 +02003448 msg[1].len = data->block[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003449 } else {
3450 msg[0].len = data->block[0] + 1;
Jean Delvare30dac742005-10-08 00:15:59 +02003451 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
David Brownell24a5bb72008-07-14 22:38:23 +02003452 dev_err(&adapter->dev,
3453 "Invalid block write size %d\n",
3454 data->block[0]);
3455 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003456 }
3457 for (i = 1; i <= data->block[0]; i++)
3458 msgbuf0[i] = data->block[i];
3459 }
3460 break;
3461 default:
David Brownell24a5bb72008-07-14 22:38:23 +02003462 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
3463 return -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003464 }
3465
Jean Delvare421ef472005-10-26 21:28:55 +02003466 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
3467 && size != I2C_SMBUS_I2C_BLOCK_DATA);
3468 if (i) {
3469 /* Compute PEC if first message is a write */
3470 if (!(msg[0].flags & I2C_M_RD)) {
David Brownell438d6c22006-12-10 21:21:31 +01003471 if (num == 1) /* Write only */
Jean Delvare421ef472005-10-26 21:28:55 +02003472 i2c_smbus_add_pec(&msg[0]);
3473 else /* Write followed by read */
3474 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
3475 }
3476 /* Ask for PEC if last message is a read */
3477 if (msg[num-1].flags & I2C_M_RD)
David Brownell438d6c22006-12-10 21:21:31 +01003478 msg[num-1].len++;
Jean Delvare421ef472005-10-26 21:28:55 +02003479 }
3480
David Brownell24a5bb72008-07-14 22:38:23 +02003481 status = i2c_transfer(adapter, msg, num);
3482 if (status < 0)
3483 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003484
Jean Delvare421ef472005-10-26 21:28:55 +02003485 /* Check PEC if last message is a read */
3486 if (i && (msg[num-1].flags & I2C_M_RD)) {
David Brownell24a5bb72008-07-14 22:38:23 +02003487 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
3488 if (status < 0)
3489 return status;
Jean Delvare421ef472005-10-26 21:28:55 +02003490 }
3491
Linus Torvalds1da177e2005-04-16 15:20:36 -07003492 if (read_write == I2C_SMBUS_READ)
Farid Hammane7225acf2010-05-21 18:40:58 +02003493 switch (size) {
3494 case I2C_SMBUS_BYTE:
3495 data->byte = msgbuf0[0];
3496 break;
3497 case I2C_SMBUS_BYTE_DATA:
3498 data->byte = msgbuf1[0];
3499 break;
3500 case I2C_SMBUS_WORD_DATA:
3501 case I2C_SMBUS_PROC_CALL:
3502 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
3503 break;
3504 case I2C_SMBUS_I2C_BLOCK_DATA:
3505 for (i = 0; i < data->block[0]; i++)
3506 data->block[i+1] = msgbuf1[i];
3507 break;
3508 case I2C_SMBUS_BLOCK_DATA:
3509 case I2C_SMBUS_BLOCK_PROC_CALL:
3510 for (i = 0; i < msgbuf1[0] + 1; i++)
3511 data->block[i] = msgbuf1[i];
3512 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003513 }
3514 return 0;
3515}
3516
David Brownella1cdeda2008-07-14 22:38:24 +02003517/**
3518 * i2c_smbus_xfer - execute SMBus protocol operations
3519 * @adapter: Handle to I2C bus
3520 * @addr: Address of SMBus slave on that bus
3521 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
3522 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
3523 * @command: Byte interpreted by slave, for protocols which use such bytes
3524 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
3525 * @data: Data to be read or written
3526 *
3527 * This executes an SMBus protocol operation, and returns a negative
3528 * errno code else zero on success.
3529 */
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01003530s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
David Brownella1cdeda2008-07-14 22:38:24 +02003531 char read_write, u8 command, int protocol,
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01003532 union i2c_smbus_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003533{
Clifford Wolf66b650f2009-06-15 18:01:46 +02003534 unsigned long orig_jiffies;
3535 int try;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003536 s32 res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003537
David Howells8a325992014-03-06 13:36:06 +00003538 /* If enabled, the following two tracepoints are conditional on
3539 * read_write and protocol.
3540 */
3541 trace_smbus_write(adapter, addr, flags, read_write,
3542 command, protocol, data);
3543 trace_smbus_read(adapter, addr, flags, read_write,
3544 command, protocol);
3545
Laurent Pinchartd47726c2012-07-24 14:13:59 +02003546 flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003547
3548 if (adapter->algo->smbus_xfer) {
Peter Rosin8320f492016-05-04 22:15:27 +02003549 i2c_lock_bus(adapter, I2C_LOCK_SEGMENT);
Clifford Wolf66b650f2009-06-15 18:01:46 +02003550
3551 /* Retry automatically on arbitration loss */
3552 orig_jiffies = jiffies;
3553 for (res = 0, try = 0; try <= adapter->retries; try++) {
3554 res = adapter->algo->smbus_xfer(adapter, addr, flags,
3555 read_write, command,
3556 protocol, data);
3557 if (res != -EAGAIN)
3558 break;
3559 if (time_after(jiffies,
3560 orig_jiffies + adapter->timeout))
3561 break;
3562 }
Peter Rosin8320f492016-05-04 22:15:27 +02003563 i2c_unlock_bus(adapter, I2C_LOCK_SEGMENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003564
Laurent Pinchart72fc2c72012-07-24 14:13:59 +02003565 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
David Howells8a325992014-03-06 13:36:06 +00003566 goto trace;
Laurent Pinchart72fc2c72012-07-24 14:13:59 +02003567 /*
3568 * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
3569 * implement native support for the SMBus operation.
3570 */
3571 }
3572
David Howells8a325992014-03-06 13:36:06 +00003573 res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
3574 command, protocol, data);
3575
3576trace:
3577 /* If enabled, the reply tracepoint is conditional on read_write. */
3578 trace_smbus_reply(adapter, addr, flags, read_write,
3579 command, protocol, data);
3580 trace_smbus_result(adapter, addr, flags, read_write,
3581 command, protocol, res);
3582
3583 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003584}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003585EXPORT_SYMBOL(i2c_smbus_xfer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003586
Irina Tirdea01eef962015-08-12 17:31:33 +03003587/**
3588 * i2c_smbus_read_i2c_block_data_or_emulated - read block or emulate
3589 * @client: Handle to slave device
3590 * @command: Byte interpreted by slave
3591 * @length: Size of data block; SMBus allows at most I2C_SMBUS_BLOCK_MAX bytes
3592 * @values: Byte array into which data will be read; big enough to hold
3593 * the data returned by the slave. SMBus allows at most
3594 * I2C_SMBUS_BLOCK_MAX bytes.
3595 *
3596 * This executes the SMBus "block read" protocol if supported by the adapter.
3597 * If block read is not supported, it emulates it using either word or byte
3598 * read protocols depending on availability.
3599 *
3600 * The addresses of the I2C slave device that are accessed with this function
3601 * must be mapped to a linear region, so that a block read will have the same
3602 * effect as a byte read. Before using this function you must double-check
3603 * if the I2C slave does support exchanging a block transfer with a byte
3604 * transfer.
3605 */
3606s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
3607 u8 command, u8 length, u8 *values)
3608{
3609 u8 i = 0;
3610 int status;
3611
3612 if (length > I2C_SMBUS_BLOCK_MAX)
3613 length = I2C_SMBUS_BLOCK_MAX;
3614
3615 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK))
3616 return i2c_smbus_read_i2c_block_data(client, command, length, values);
3617
3618 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA))
3619 return -EOPNOTSUPP;
3620
3621 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_WORD_DATA)) {
3622 while ((i + 2) <= length) {
3623 status = i2c_smbus_read_word_data(client, command + i);
3624 if (status < 0)
3625 return status;
3626 values[i] = status & 0xff;
3627 values[i + 1] = status >> 8;
3628 i += 2;
3629 }
3630 }
3631
3632 while (i < length) {
3633 status = i2c_smbus_read_byte_data(client, command + i);
3634 if (status < 0)
3635 return status;
3636 values[i] = status;
3637 i++;
3638 }
3639
3640 return i;
3641}
3642EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data_or_emulated);
3643
Jean Delvared5fd1202015-01-26 20:59:31 +01003644#if IS_ENABLED(CONFIG_I2C_SLAVE)
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003645int i2c_slave_register(struct i2c_client *client, i2c_slave_cb_t slave_cb)
3646{
3647 int ret;
3648
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003649 if (!client || !slave_cb) {
Colin Ian King26591612016-12-29 22:27:33 +00003650 WARN(1, "insufficient data\n");
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003651 return -EINVAL;
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003652 }
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003653
Wolfram Sangc6909d62015-08-05 21:12:54 +02003654 if (!(client->flags & I2C_CLIENT_SLAVE))
3655 dev_warn(&client->dev, "%s: client slave flag not set. You might see address collisions\n",
3656 __func__);
3657
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003658 if (!(client->flags & I2C_CLIENT_TEN)) {
3659 /* Enforce stricter address checking */
Wolfram Sang66be60562015-07-17 12:43:22 +02003660 ret = i2c_check_7bit_addr_validity_strict(client->addr);
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003661 if (ret) {
3662 dev_err(&client->dev, "%s: invalid address\n", __func__);
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003663 return ret;
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003664 }
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003665 }
3666
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003667 if (!client->adapter->algo->reg_slave) {
3668 dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003669 return -EOPNOTSUPP;
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003670 }
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003671
3672 client->slave_cb = slave_cb;
3673
3674 i2c_lock_adapter(client->adapter);
3675 ret = client->adapter->algo->reg_slave(client);
3676 i2c_unlock_adapter(client->adapter);
3677
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003678 if (ret) {
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003679 client->slave_cb = NULL;
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003680 dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
3681 }
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003682
3683 return ret;
3684}
3685EXPORT_SYMBOL_GPL(i2c_slave_register);
3686
3687int i2c_slave_unregister(struct i2c_client *client)
3688{
3689 int ret;
3690
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003691 if (!client->adapter->algo->unreg_slave) {
3692 dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003693 return -EOPNOTSUPP;
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003694 }
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003695
3696 i2c_lock_adapter(client->adapter);
3697 ret = client->adapter->algo->unreg_slave(client);
3698 i2c_unlock_adapter(client->adapter);
3699
3700 if (ret == 0)
3701 client->slave_cb = NULL;
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003702 else
3703 dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003704
3705 return ret;
3706}
3707EXPORT_SYMBOL_GPL(i2c_slave_unregister);
Luis Oliveiracefae802017-01-26 17:45:32 +00003708
3709/**
3710 * i2c_detect_slave_mode - detect operation mode
3711 * @dev: The device owning the bus
3712 *
3713 * This checks the device nodes for an I2C slave by checking the address
3714 * used in the reg property. If the address match the I2C_OWN_SLAVE_ADDRESS
3715 * flag this means the device is configured to act as a I2C slave and it will
3716 * be listening at that address.
3717 *
3718 * Returns true if an I2C own slave address is detected, otherwise returns
3719 * false.
3720 */
3721bool i2c_detect_slave_mode(struct device *dev)
3722{
3723 if (IS_BUILTIN(CONFIG_OF) && dev->of_node) {
3724 struct device_node *child;
3725 u32 reg;
3726
3727 for_each_child_of_node(dev->of_node, child) {
3728 of_property_read_u32(child, "reg", &reg);
3729 if (reg & I2C_OWN_SLAVE_ADDRESS) {
3730 of_node_put(child);
3731 return true;
3732 }
3733 }
3734 } else if (IS_BUILTIN(CONFIG_ACPI) && ACPI_HANDLE(dev)) {
3735 dev_dbg(dev, "ACPI slave is not supported yet\n");
3736 }
3737 return false;
3738}
3739EXPORT_SYMBOL_GPL(i2c_detect_slave_mode);
3740
Jean Delvared5fd1202015-01-26 20:59:31 +01003741#endif
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003742
Linus Torvalds1da177e2005-04-16 15:20:36 -07003743MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
3744MODULE_DESCRIPTION("I2C-Bus main module");
3745MODULE_LICENSE("GPL");