blob: f72292156faf21abbf109169c061e039ff12a0fd [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 Delvare4735c982008-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
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300224 strlcpy(info->type, dev_name(&adev->dev), sizeof(info->type));
225
226 return 0;
227}
228
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300229static void i2c_acpi_register_device(struct i2c_adapter *adapter,
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300230 struct acpi_device *adev,
231 struct i2c_board_info *info)
232{
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200233 adev->power.flags.ignore_parent = true;
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300234 acpi_device_set_enumerated(adev);
235
236 if (!i2c_new_device(adapter, info)) {
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200237 adev->power.flags.ignore_parent = false;
238 dev_err(&adapter->dev,
239 "failed to add I2C device %s from ACPI\n",
240 dev_name(&adev->dev));
241 }
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300242}
243
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300244static acpi_status i2c_acpi_add_device(acpi_handle handle, u32 level,
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300245 void *data, void **return_value)
246{
247 struct i2c_adapter *adapter = data;
248 struct acpi_device *adev;
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300249 struct i2c_board_info info;
250
251 if (acpi_bus_get_device(handle, &adev))
252 return AE_OK;
253
Mika Westerberg318ce272016-09-20 16:59:25 +0300254 if (i2c_acpi_get_info(adev, &info, adapter, NULL))
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300255 return AE_OK;
256
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300257 i2c_acpi_register_device(adapter, adev, &info);
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200258
259 return AE_OK;
260}
261
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300262#define I2C_ACPI_MAX_SCAN_DEPTH 32
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300263
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200264/**
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300265 * i2c_acpi_register_devices - enumerate I2C slave devices behind adapter
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200266 * @adap: pointer to adapter
267 *
268 * Enumerate all I2C slave devices behind this adapter by walking the ACPI
269 * namespace. When a device is found it will be added to the Linux device
270 * model and bound to the corresponding ACPI handle.
271 */
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300272static void i2c_acpi_register_devices(struct i2c_adapter *adap)
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200273{
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200274 acpi_status status;
275
Dustin Byford8eb5c872015-10-23 12:27:07 -0700276 if (!has_acpi_companion(&adap->dev))
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200277 return;
278
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300279 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300280 I2C_ACPI_MAX_SCAN_DEPTH,
281 i2c_acpi_add_device, NULL,
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200282 adap, NULL);
283 if (ACPI_FAILURE(status))
284 dev_warn(&adap->dev, "failed to enumerate I2C slaves\n");
285}
286
Jarkko Nikula5853b222016-08-12 17:02:53 +0300287static acpi_status i2c_acpi_lookup_speed(acpi_handle handle, u32 level,
288 void *data, void **return_value)
289{
290 struct i2c_acpi_lookup *lookup = data;
291 struct acpi_device *adev;
292
293 if (acpi_bus_get_device(handle, &adev))
294 return AE_OK;
295
296 if (i2c_acpi_do_lookup(adev, lookup))
297 return AE_OK;
298
299 if (lookup->search_handle != lookup->adapter_handle)
300 return AE_OK;
301
302 if (lookup->speed <= lookup->min_speed)
303 lookup->min_speed = lookup->speed;
304
305 return AE_OK;
306}
307
308/**
309 * i2c_acpi_find_bus_speed - find I2C bus speed from ACPI
310 * @dev: The device owning the bus
311 *
312 * Find the I2C bus speed by walking the ACPI namespace for all I2C slaves
313 * devices connected to this bus and use the speed of slowest device.
314 *
315 * Returns the speed in Hz or zero
316 */
317u32 i2c_acpi_find_bus_speed(struct device *dev)
318{
319 struct i2c_acpi_lookup lookup;
320 struct i2c_board_info dummy;
321 acpi_status status;
322
323 if (!has_acpi_companion(dev))
324 return 0;
325
326 memset(&lookup, 0, sizeof(lookup));
327 lookup.search_handle = ACPI_HANDLE(dev);
328 lookup.min_speed = UINT_MAX;
329 lookup.info = &dummy;
330
331 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
332 I2C_ACPI_MAX_SCAN_DEPTH,
333 i2c_acpi_lookup_speed, NULL,
334 &lookup, NULL);
335
336 if (ACPI_FAILURE(status)) {
337 dev_warn(dev, "unable to find I2C bus speed from ACPI\n");
338 return 0;
339 }
340
341 return lookup.min_speed != UINT_MAX ? lookup.min_speed : 0;
342}
343EXPORT_SYMBOL_GPL(i2c_acpi_find_bus_speed);
344
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300345static int i2c_acpi_match_adapter(struct device *dev, void *data)
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300346{
347 struct i2c_adapter *adapter = i2c_verify_adapter(dev);
348
349 if (!adapter)
350 return 0;
351
352 return ACPI_HANDLE(dev) == (acpi_handle)data;
353}
354
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300355static int i2c_acpi_match_device(struct device *dev, void *data)
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300356{
357 return ACPI_COMPANION(dev) == data;
358}
359
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300360static struct i2c_adapter *i2c_acpi_find_adapter_by_handle(acpi_handle handle)
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300361{
362 struct device *dev;
363
364 dev = bus_find_device(&i2c_bus_type, NULL, handle,
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300365 i2c_acpi_match_adapter);
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300366 return dev ? i2c_verify_adapter(dev) : NULL;
367}
368
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300369static struct i2c_client *i2c_acpi_find_client_by_adev(struct acpi_device *adev)
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300370{
371 struct device *dev;
372
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300373 dev = bus_find_device(&i2c_bus_type, NULL, adev, i2c_acpi_match_device);
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300374 return dev ? i2c_verify_client(dev) : NULL;
375}
376
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300377static int i2c_acpi_notify(struct notifier_block *nb, unsigned long value,
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300378 void *arg)
379{
380 struct acpi_device *adev = arg;
381 struct i2c_board_info info;
382 acpi_handle adapter_handle;
383 struct i2c_adapter *adapter;
384 struct i2c_client *client;
385
386 switch (value) {
387 case ACPI_RECONFIG_DEVICE_ADD:
Mika Westerberg318ce272016-09-20 16:59:25 +0300388 if (i2c_acpi_get_info(adev, &info, NULL, &adapter_handle))
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300389 break;
390
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300391 adapter = i2c_acpi_find_adapter_by_handle(adapter_handle);
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300392 if (!adapter)
393 break;
394
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300395 i2c_acpi_register_device(adapter, adev, &info);
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300396 break;
397 case ACPI_RECONFIG_DEVICE_REMOVE:
398 if (!acpi_device_enumerated(adev))
399 break;
400
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300401 client = i2c_acpi_find_client_by_adev(adev);
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300402 if (!client)
403 break;
404
405 i2c_unregister_device(client);
406 put_device(&client->dev);
407 break;
408 }
409
410 return NOTIFY_OK;
411}
412
413static struct notifier_block i2c_acpi_notifier = {
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300414 .notifier_call = i2c_acpi_notify,
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300415};
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200416#else /* CONFIG_ACPI */
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300417static inline void i2c_acpi_register_devices(struct i2c_adapter *adap) { }
Octavian Purdila525e6fa2016-07-08 19:13:10 +0300418extern struct notifier_block i2c_acpi_notifier;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200419#endif /* CONFIG_ACPI */
420
421#ifdef CONFIG_ACPI_I2C_OPREGION
422static int acpi_gsb_i2c_read_bytes(struct i2c_client *client,
423 u8 cmd, u8 *data, u8 data_len)
424{
425
426 struct i2c_msg msgs[2];
427 int ret;
428 u8 *buffer;
429
430 buffer = kzalloc(data_len, GFP_KERNEL);
431 if (!buffer)
432 return AE_NO_MEMORY;
433
434 msgs[0].addr = client->addr;
435 msgs[0].flags = client->flags;
436 msgs[0].len = 1;
437 msgs[0].buf = &cmd;
438
439 msgs[1].addr = client->addr;
440 msgs[1].flags = client->flags | I2C_M_RD;
441 msgs[1].len = data_len;
442 msgs[1].buf = buffer;
443
444 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
445 if (ret < 0)
446 dev_err(&client->adapter->dev, "i2c read failed\n");
447 else
448 memcpy(data, buffer, data_len);
449
450 kfree(buffer);
451 return ret;
452}
453
454static int acpi_gsb_i2c_write_bytes(struct i2c_client *client,
455 u8 cmd, u8 *data, u8 data_len)
456{
457
458 struct i2c_msg msgs[1];
459 u8 *buffer;
460 int ret = AE_OK;
461
462 buffer = kzalloc(data_len + 1, GFP_KERNEL);
463 if (!buffer)
464 return AE_NO_MEMORY;
465
466 buffer[0] = cmd;
467 memcpy(buffer + 1, data, data_len);
468
469 msgs[0].addr = client->addr;
470 msgs[0].flags = client->flags;
471 msgs[0].len = data_len + 1;
472 msgs[0].buf = buffer;
473
474 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
475 if (ret < 0)
476 dev_err(&client->adapter->dev, "i2c write failed\n");
477
478 kfree(buffer);
479 return ret;
480}
481
482static acpi_status
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300483i2c_acpi_space_handler(u32 function, acpi_physical_address command,
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200484 u32 bits, u64 *value64,
485 void *handler_context, void *region_context)
486{
487 struct gsb_buffer *gsb = (struct gsb_buffer *)value64;
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300488 struct i2c_acpi_handler_data *data = handler_context;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200489 struct acpi_connection_info *info = &data->info;
490 struct acpi_resource_i2c_serialbus *sb;
491 struct i2c_adapter *adapter = data->adapter;
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300492 struct i2c_client *client;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200493 struct acpi_resource *ares;
494 u32 accessor_type = function >> 16;
495 u8 action = function & ACPI_IO_MASK;
Wolfram Sang4470c722014-11-18 15:12:43 +0100496 acpi_status ret;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200497 int status;
498
499 ret = acpi_buffer_to_resource(info->connection, info->length, &ares);
500 if (ACPI_FAILURE(ret))
501 return ret;
502
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300503 client = kzalloc(sizeof(*client), GFP_KERNEL);
504 if (!client) {
505 ret = AE_NO_MEMORY;
506 goto err;
507 }
508
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200509 if (!value64 || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) {
510 ret = AE_BAD_PARAMETER;
511 goto err;
512 }
513
514 sb = &ares->data.i2c_serial_bus;
515 if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C) {
516 ret = AE_BAD_PARAMETER;
517 goto err;
518 }
519
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300520 client->adapter = adapter;
521 client->addr = sb->slave_address;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200522
523 if (sb->access_mode == ACPI_I2C_10BIT_MODE)
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300524 client->flags |= I2C_CLIENT_TEN;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200525
526 switch (accessor_type) {
527 case ACPI_GSB_ACCESS_ATTRIB_SEND_RCV:
528 if (action == ACPI_READ) {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300529 status = i2c_smbus_read_byte(client);
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200530 if (status >= 0) {
531 gsb->bdata = status;
532 status = 0;
533 }
534 } else {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300535 status = i2c_smbus_write_byte(client, gsb->bdata);
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200536 }
537 break;
538
539 case ACPI_GSB_ACCESS_ATTRIB_BYTE:
540 if (action == ACPI_READ) {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300541 status = i2c_smbus_read_byte_data(client, command);
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200542 if (status >= 0) {
543 gsb->bdata = status;
544 status = 0;
545 }
546 } else {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300547 status = i2c_smbus_write_byte_data(client, command,
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200548 gsb->bdata);
549 }
550 break;
551
552 case ACPI_GSB_ACCESS_ATTRIB_WORD:
553 if (action == ACPI_READ) {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300554 status = i2c_smbus_read_word_data(client, command);
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200555 if (status >= 0) {
556 gsb->wdata = status;
557 status = 0;
558 }
559 } else {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300560 status = i2c_smbus_write_word_data(client, command,
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200561 gsb->wdata);
562 }
563 break;
564
565 case ACPI_GSB_ACCESS_ATTRIB_BLOCK:
566 if (action == ACPI_READ) {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300567 status = i2c_smbus_read_block_data(client, command,
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200568 gsb->data);
569 if (status >= 0) {
570 gsb->len = status;
571 status = 0;
572 }
573 } else {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300574 status = i2c_smbus_write_block_data(client, command,
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200575 gsb->len, gsb->data);
576 }
577 break;
578
579 case ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE:
580 if (action == ACPI_READ) {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300581 status = acpi_gsb_i2c_read_bytes(client, command,
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200582 gsb->data, info->access_length);
583 if (status > 0)
584 status = 0;
585 } else {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300586 status = acpi_gsb_i2c_write_bytes(client, command,
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200587 gsb->data, info->access_length);
588 }
589 break;
590
591 default:
Wolfram Sangbe309c32016-07-09 13:35:03 +0900592 dev_warn(&adapter->dev, "protocol 0x%02x not supported for client 0x%02x\n",
593 accessor_type, client->addr);
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200594 ret = AE_BAD_PARAMETER;
595 goto err;
596 }
597
598 gsb->status = status;
599
600 err:
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300601 kfree(client);
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200602 ACPI_FREE(ares);
603 return ret;
604}
605
606
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300607static int i2c_acpi_install_space_handler(struct i2c_adapter *adapter)
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200608{
Peter Hüwe0aef44e2014-09-12 21:09:47 +0200609 acpi_handle handle;
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300610 struct i2c_acpi_handler_data *data;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200611 acpi_status status;
612
Peter Hüwe0aef44e2014-09-12 21:09:47 +0200613 if (!adapter->dev.parent)
614 return -ENODEV;
615
616 handle = ACPI_HANDLE(adapter->dev.parent);
617
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200618 if (!handle)
619 return -ENODEV;
620
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300621 data = kzalloc(sizeof(struct i2c_acpi_handler_data),
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200622 GFP_KERNEL);
623 if (!data)
624 return -ENOMEM;
625
626 data->adapter = adapter;
627 status = acpi_bus_attach_private_data(handle, (void *)data);
628 if (ACPI_FAILURE(status)) {
629 kfree(data);
630 return -ENOMEM;
631 }
632
633 status = acpi_install_address_space_handler(handle,
634 ACPI_ADR_SPACE_GSBUS,
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300635 &i2c_acpi_space_handler,
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200636 NULL,
637 data);
638 if (ACPI_FAILURE(status)) {
639 dev_err(&adapter->dev, "Error installing i2c space handler\n");
640 acpi_bus_detach_private_data(handle);
641 kfree(data);
642 return -ENOMEM;
643 }
644
Lan Tianyu40e7fcb2014-11-23 21:22:54 +0800645 acpi_walk_dep_device_list(handle);
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200646 return 0;
647}
648
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300649static void i2c_acpi_remove_space_handler(struct i2c_adapter *adapter)
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200650{
Peter Hüwe0aef44e2014-09-12 21:09:47 +0200651 acpi_handle handle;
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300652 struct i2c_acpi_handler_data *data;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200653 acpi_status status;
654
Peter Hüwe0aef44e2014-09-12 21:09:47 +0200655 if (!adapter->dev.parent)
656 return;
657
658 handle = ACPI_HANDLE(adapter->dev.parent);
659
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200660 if (!handle)
661 return;
662
663 acpi_remove_address_space_handler(handle,
664 ACPI_ADR_SPACE_GSBUS,
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300665 &i2c_acpi_space_handler);
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200666
667 status = acpi_bus_get_private_data(handle, (void **)&data);
668 if (ACPI_SUCCESS(status))
669 kfree(data);
670
671 acpi_bus_detach_private_data(handle);
672}
673#else /* CONFIG_ACPI_I2C_OPREGION */
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300674static inline void i2c_acpi_remove_space_handler(struct i2c_adapter *adapter)
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200675{ }
676
Jarkko Nikulaaec809f2016-08-12 17:02:52 +0300677static inline int i2c_acpi_install_space_handler(struct i2c_adapter *adapter)
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200678{ return 0; }
679#endif /* CONFIG_ACPI_I2C_OPREGION */
680
David Brownellf37dd802007-02-13 22:09:00 +0100681/* ------------------------------------------------------------------------- */
682
Lee Jones5f441fc2016-11-07 12:47:40 +0000683const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
Jean Delvared2653e92008-04-29 23:11:39 +0200684 const struct i2c_client *client)
685{
Lee Jones811073b2016-11-07 12:47:36 +0000686 if (!(id && client))
687 return NULL;
688
Jean Delvared2653e92008-04-29 23:11:39 +0200689 while (id->name[0]) {
690 if (strcmp(client->name, id->name) == 0)
691 return id;
692 id++;
693 }
694 return NULL;
695}
Lee Jones5f441fc2016-11-07 12:47:40 +0000696EXPORT_SYMBOL_GPL(i2c_match_id);
Jean Delvared2653e92008-04-29 23:11:39 +0200697
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698static int i2c_device_match(struct device *dev, struct device_driver *drv)
699{
Jean Delvare51298d12009-09-18 22:45:45 +0200700 struct i2c_client *client = i2c_verify_client(dev);
701 struct i2c_driver *driver;
David Brownell7b4fbc52007-05-01 23:26:30 +0200702
Jean Delvare51298d12009-09-18 22:45:45 +0200703
Grant Likely959e85f2010-06-08 07:48:19 -0600704 /* Attempt an OF style match */
Lee Jonesda10c062016-11-07 12:47:39 +0000705 if (i2c_of_match_device(drv->of_match_table, client))
Grant Likely959e85f2010-06-08 07:48:19 -0600706 return 1;
707
Mika Westerberg907ddf82012-11-23 12:23:40 +0100708 /* Then ACPI style match */
709 if (acpi_driver_match_device(dev, drv))
710 return 1;
711
Jean Delvare51298d12009-09-18 22:45:45 +0200712 driver = to_i2c_driver(drv);
Lee Jones811073b2016-11-07 12:47:36 +0000713
714 /* Finally an I2C match */
715 if (i2c_match_id(driver->id_table, client))
716 return 1;
Jean Delvared2653e92008-04-29 23:11:39 +0200717
Jean Delvareeb8a7902008-05-18 20:49:41 +0200718 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719}
720
Kay Sievers7eff2e72007-08-14 15:15:12 +0200721static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
David Brownell7b4fbc52007-05-01 23:26:30 +0200722{
Wolfram Sang8dcf3212016-03-23 20:47:02 +0100723 struct i2c_client *client = to_i2c_client(dev);
Zhang Rui8c4ff6d2014-01-14 16:46:37 +0800724 int rc;
725
726 rc = acpi_device_uevent_modalias(dev, env);
727 if (rc != -ENODEV)
728 return rc;
David Brownell7b4fbc52007-05-01 23:26:30 +0200729
Wolfram Sang8dcf3212016-03-23 20:47:02 +0100730 return add_uevent_var(env, "MODALIAS=%s%s", I2C_MODULE_PREFIX, client->name);
David Brownell7b4fbc52007-05-01 23:26:30 +0200731}
732
Viresh Kumar5f9296b2012-02-28 18:26:31 +0530733/* i2c bus recovery routines */
734static int get_scl_gpio_value(struct i2c_adapter *adap)
735{
736 return gpio_get_value(adap->bus_recovery_info->scl_gpio);
737}
738
739static void set_scl_gpio_value(struct i2c_adapter *adap, int val)
740{
741 gpio_set_value(adap->bus_recovery_info->scl_gpio, val);
742}
743
744static int get_sda_gpio_value(struct i2c_adapter *adap)
745{
746 return gpio_get_value(adap->bus_recovery_info->sda_gpio);
747}
748
749static int i2c_get_gpios_for_recovery(struct i2c_adapter *adap)
750{
751 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
752 struct device *dev = &adap->dev;
753 int ret = 0;
754
755 ret = gpio_request_one(bri->scl_gpio, GPIOF_OPEN_DRAIN |
756 GPIOF_OUT_INIT_HIGH, "i2c-scl");
757 if (ret) {
758 dev_warn(dev, "Can't get SCL gpio: %d\n", bri->scl_gpio);
759 return ret;
760 }
761
762 if (bri->get_sda) {
763 if (gpio_request_one(bri->sda_gpio, GPIOF_IN, "i2c-sda")) {
764 /* work without SDA polling */
765 dev_warn(dev, "Can't get SDA gpio: %d. Not using SDA polling\n",
766 bri->sda_gpio);
767 bri->get_sda = NULL;
768 }
769 }
770
771 return ret;
772}
773
774static void i2c_put_gpios_for_recovery(struct i2c_adapter *adap)
775{
776 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
777
778 if (bri->get_sda)
779 gpio_free(bri->sda_gpio);
780
781 gpio_free(bri->scl_gpio);
782}
783
784/*
785 * We are generating clock pulses. ndelay() determines durating of clk pulses.
786 * We will generate clock with rate 100 KHz and so duration of both clock levels
787 * is: delay in ns = (10^6 / 100) / 2
788 */
789#define RECOVERY_NDELAY 5000
790#define RECOVERY_CLK_CNT 9
791
792static int i2c_generic_recovery(struct i2c_adapter *adap)
793{
794 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
795 int i = 0, val = 1, ret = 0;
796
797 if (bri->prepare_recovery)
Grygorii Strashko2b2190a2015-04-06 15:38:39 +0300798 bri->prepare_recovery(adap);
Viresh Kumar5f9296b2012-02-28 18:26:31 +0530799
Jan Luebbe8b062602015-07-08 16:35:06 +0200800 bri->set_scl(adap, val);
801 ndelay(RECOVERY_NDELAY);
802
Viresh Kumar5f9296b2012-02-28 18:26:31 +0530803 /*
804 * By this time SCL is high, as we need to give 9 falling-rising edges
805 */
806 while (i++ < RECOVERY_CLK_CNT * 2) {
807 if (val) {
808 /* Break if SDA is high */
809 if (bri->get_sda && bri->get_sda(adap))
810 break;
811 /* SCL shouldn't be low here */
812 if (!bri->get_scl(adap)) {
813 dev_err(&adap->dev,
814 "SCL is stuck low, exit recovery\n");
815 ret = -EBUSY;
816 break;
817 }
818 }
819
820 val = !val;
821 bri->set_scl(adap, val);
822 ndelay(RECOVERY_NDELAY);
823 }
824
825 if (bri->unprepare_recovery)
Grygorii Strashko2b2190a2015-04-06 15:38:39 +0300826 bri->unprepare_recovery(adap);
Viresh Kumar5f9296b2012-02-28 18:26:31 +0530827
828 return ret;
829}
830
831int i2c_generic_scl_recovery(struct i2c_adapter *adap)
832{
Viresh Kumar5f9296b2012-02-28 18:26:31 +0530833 return i2c_generic_recovery(adap);
834}
Mark Brownc1c21f42015-04-15 19:18:39 +0100835EXPORT_SYMBOL_GPL(i2c_generic_scl_recovery);
Viresh Kumar5f9296b2012-02-28 18:26:31 +0530836
837int i2c_generic_gpio_recovery(struct i2c_adapter *adap)
838{
839 int ret;
840
841 ret = i2c_get_gpios_for_recovery(adap);
842 if (ret)
843 return ret;
844
845 ret = i2c_generic_recovery(adap);
846 i2c_put_gpios_for_recovery(adap);
847
848 return ret;
849}
Mark Brownc1c21f42015-04-15 19:18:39 +0100850EXPORT_SYMBOL_GPL(i2c_generic_gpio_recovery);
Viresh Kumar5f9296b2012-02-28 18:26:31 +0530851
852int i2c_recover_bus(struct i2c_adapter *adap)
853{
854 if (!adap->bus_recovery_info)
855 return -EOPNOTSUPP;
856
857 dev_dbg(&adap->dev, "Trying i2c bus recovery\n");
858 return adap->bus_recovery_info->recover_bus(adap);
859}
Mark Brownc1c21f42015-04-15 19:18:39 +0100860EXPORT_SYMBOL_GPL(i2c_recover_bus);
Viresh Kumar5f9296b2012-02-28 18:26:31 +0530861
Wolfram Sangd3b11d82016-07-09 13:34:59 +0900862static void i2c_init_recovery(struct i2c_adapter *adap)
863{
864 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
865 char *err_str;
866
867 if (!bri)
868 return;
869
870 if (!bri->recover_bus) {
871 err_str = "no recover_bus() found";
872 goto err;
873 }
874
875 /* Generic GPIO recovery */
876 if (bri->recover_bus == i2c_generic_gpio_recovery) {
877 if (!gpio_is_valid(bri->scl_gpio)) {
878 err_str = "invalid SCL gpio";
879 goto err;
880 }
881
882 if (gpio_is_valid(bri->sda_gpio))
883 bri->get_sda = get_sda_gpio_value;
884 else
885 bri->get_sda = NULL;
886
887 bri->get_scl = get_scl_gpio_value;
888 bri->set_scl = set_scl_gpio_value;
889 } else if (bri->recover_bus == i2c_generic_scl_recovery) {
890 /* Generic SCL recovery */
891 if (!bri->set_scl || !bri->get_scl) {
892 err_str = "no {get|set}_scl() found";
893 goto err;
894 }
895 }
896
897 return;
898 err:
899 dev_err(&adap->dev, "Not using recovery: %s\n", err_str);
900 adap->bus_recovery_info = NULL;
901}
902
Benjamin Tissoires4d5538f2016-10-13 14:10:40 +0200903static int i2c_smbus_host_notify_to_irq(const struct i2c_client *client)
904{
905 struct i2c_adapter *adap = client->adapter;
906 unsigned int irq;
907
908 if (!adap->host_notify_domain)
909 return -ENXIO;
910
911 if (client->flags & I2C_CLIENT_TEN)
912 return -EINVAL;
913
914 irq = irq_find_mapping(adap->host_notify_domain, client->addr);
915 if (!irq)
916 irq = irq_create_mapping(adap->host_notify_domain,
917 client->addr);
918
919 return irq > 0 ? irq : -ENXIO;
920}
921
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922static int i2c_device_probe(struct device *dev)
923{
Jean Delvare51298d12009-09-18 22:45:45 +0200924 struct i2c_client *client = i2c_verify_client(dev);
925 struct i2c_driver *driver;
Hans Verkuil50c33042008-03-12 14:15:00 +0100926 int status;
David Brownell7b4fbc52007-05-01 23:26:30 +0200927
Jean Delvare51298d12009-09-18 22:45:45 +0200928 if (!client)
929 return 0;
930
Mika Westerberg845c8772015-05-06 13:29:08 +0300931 if (!client->irq) {
932 int irq = -ENOENT;
933
Dmitry Torokhov331c3422017-01-04 20:57:22 -0800934 if (client->flags & I2C_CLIENT_HOST_NOTIFY) {
935 dev_dbg(dev, "Using Host Notify IRQ\n");
936 irq = i2c_smbus_host_notify_to_irq(client);
937 } else if (dev->of_node) {
Dmitry Torokhov3fffd122015-08-17 23:52:51 -0700938 irq = of_irq_get_byname(dev->of_node, "irq");
939 if (irq == -EINVAL || irq == -ENODATA)
940 irq = of_irq_get(dev->of_node, 0);
941 } else if (ACPI_COMPANION(dev)) {
Mika Westerberg845c8772015-05-06 13:29:08 +0300942 irq = acpi_dev_gpio_irq_get(ACPI_COMPANION(dev), 0);
Dmitry Torokhov3fffd122015-08-17 23:52:51 -0700943 }
Geert Uytterhoeven6f34be72014-11-17 12:43:00 +0100944 if (irq == -EPROBE_DEFER)
Laurent Pinchart2fd36c5522014-10-30 15:59:38 +0200945 return irq;
Dmitry Torokhov331c3422017-01-04 20:57:22 -0800946
Geert Uytterhoeven6f34be72014-11-17 12:43:00 +0100947 if (irq < 0)
948 irq = 0;
Laurent Pinchart2fd36c5522014-10-30 15:59:38 +0200949
950 client->irq = irq;
951 }
952
Jean Delvare51298d12009-09-18 22:45:45 +0200953 driver = to_i2c_driver(dev->driver);
Lee Jonesda10c062016-11-07 12:47:39 +0000954
955 /*
956 * An I2C ID table is not mandatory, if and only if, a suitable Device
957 * Tree match table entry is supplied for the probing device.
958 */
959 if (!driver->id_table &&
960 !i2c_of_match_device(dev->driver->of_match_table, client))
David Brownell7b4fbc52007-05-01 23:26:30 +0200961 return -ENODEV;
Lars-Peter Clausen0acc2b32013-09-29 10:51:06 +0200962
Dmitry Torokhov3fffd122015-08-17 23:52:51 -0700963 if (client->flags & I2C_CLIENT_WAKE) {
964 int wakeirq = -ENOENT;
965
966 if (dev->of_node) {
967 wakeirq = of_irq_get_byname(dev->of_node, "wakeup");
968 if (wakeirq == -EPROBE_DEFER)
969 return wakeirq;
970 }
971
972 device_init_wakeup(&client->dev, true);
973
974 if (wakeirq > 0 && wakeirq != client->irq)
975 status = dev_pm_set_dedicated_wake_irq(dev, wakeirq);
976 else if (client->irq > 0)
Grygorii Strashkoc18fba22015-11-12 15:42:26 +0200977 status = dev_pm_set_wake_irq(dev, client->irq);
Dmitry Torokhov3fffd122015-08-17 23:52:51 -0700978 else
979 status = 0;
980
981 if (status)
Andy Shevchenkob93d3d32016-08-25 17:42:10 +0300982 dev_warn(&client->dev, "failed to set up wakeup irq\n");
Dmitry Torokhov3fffd122015-08-17 23:52:51 -0700983 }
984
David Brownell7b4fbc52007-05-01 23:26:30 +0200985 dev_dbg(dev, "probe\n");
Jean Delvared2653e92008-04-29 23:11:39 +0200986
Sylwester Nawrocki86be4082014-06-18 17:29:32 +0200987 status = of_clk_set_defaults(dev->of_node, false);
988 if (status < 0)
Dmitry Torokhov3fffd122015-08-17 23:52:51 -0700989 goto err_clear_wakeup_irq;
Sylwester Nawrocki86be4082014-06-18 17:29:32 +0200990
Ulf Hanssone09b0d42014-09-19 20:27:39 +0200991 status = dev_pm_domain_attach(&client->dev, true);
Kieran Bingham74cedd32015-10-12 21:54:43 +0100992 if (status == -EPROBE_DEFER)
993 goto err_clear_wakeup_irq;
994
Lee Jonesb8a1a4c2016-11-07 12:47:41 +0000995 /*
996 * When there are no more users of probe(),
997 * rename probe_new to probe.
998 */
999 if (driver->probe_new)
1000 status = driver->probe_new(client);
1001 else if (driver->probe)
1002 status = driver->probe(client,
1003 i2c_match_id(driver->id_table, client));
1004 else
1005 status = -EINVAL;
1006
Kieran Bingham74cedd32015-10-12 21:54:43 +01001007 if (status)
1008 goto err_detach_pm_domain;
Wolfram Sang72fa8182014-01-21 17:48:34 +01001009
Dmitry Torokhov3fffd122015-08-17 23:52:51 -07001010 return 0;
1011
1012err_detach_pm_domain:
1013 dev_pm_domain_detach(&client->dev, true);
1014err_clear_wakeup_irq:
1015 dev_pm_clear_wake_irq(&client->dev);
1016 device_init_wakeup(&client->dev, false);
Hans Verkuil50c33042008-03-12 14:15:00 +01001017 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018}
1019
1020static int i2c_device_remove(struct device *dev)
1021{
Jean Delvare51298d12009-09-18 22:45:45 +02001022 struct i2c_client *client = i2c_verify_client(dev);
David Brownella1d9e6e2007-05-01 23:26:30 +02001023 struct i2c_driver *driver;
Wolfram Sang72fa8182014-01-21 17:48:34 +01001024 int status = 0;
David Brownella1d9e6e2007-05-01 23:26:30 +02001025
Jean Delvare51298d12009-09-18 22:45:45 +02001026 if (!client || !dev->driver)
David Brownella1d9e6e2007-05-01 23:26:30 +02001027 return 0;
1028
1029 driver = to_i2c_driver(dev->driver);
1030 if (driver->remove) {
1031 dev_dbg(dev, "remove\n");
1032 status = driver->remove(client);
David Brownella1d9e6e2007-05-01 23:26:30 +02001033 }
Wolfram Sang72fa8182014-01-21 17:48:34 +01001034
Ulf Hanssone09b0d42014-09-19 20:27:39 +02001035 dev_pm_domain_detach(&client->dev, true);
Dmitry Torokhov3fffd122015-08-17 23:52:51 -07001036
1037 dev_pm_clear_wake_irq(&client->dev);
1038 device_init_wakeup(&client->dev, false);
1039
David Brownella1d9e6e2007-05-01 23:26:30 +02001040 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041}
1042
David Brownellf37dd802007-02-13 22:09:00 +01001043static void i2c_device_shutdown(struct device *dev)
1044{
Jean Delvare51298d12009-09-18 22:45:45 +02001045 struct i2c_client *client = i2c_verify_client(dev);
David Brownellf37dd802007-02-13 22:09:00 +01001046 struct i2c_driver *driver;
1047
Jean Delvare51298d12009-09-18 22:45:45 +02001048 if (!client || !dev->driver)
David Brownellf37dd802007-02-13 22:09:00 +01001049 return;
1050 driver = to_i2c_driver(dev->driver);
1051 if (driver->shutdown)
Jean Delvare51298d12009-09-18 22:45:45 +02001052 driver->shutdown(client);
David Brownellf37dd802007-02-13 22:09:00 +01001053}
1054
David Brownell9c1600e2007-05-01 23:26:31 +02001055static void i2c_client_dev_release(struct device *dev)
1056{
1057 kfree(to_i2c_client(dev));
1058}
1059
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01001060static ssize_t
Jean Delvare4f8cf822009-09-18 22:45:46 +02001061show_name(struct device *dev, struct device_attribute *attr, char *buf)
David Brownell7b4fbc52007-05-01 23:26:30 +02001062{
Jean Delvare4f8cf822009-09-18 22:45:46 +02001063 return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
1064 to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
David Brownell7b4fbc52007-05-01 23:26:30 +02001065}
Wolfram Sanga5eb71b2015-01-19 20:12:24 +01001066static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
David Brownell7b4fbc52007-05-01 23:26:30 +02001067
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01001068static ssize_t
1069show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
David Brownell7b4fbc52007-05-01 23:26:30 +02001070{
1071 struct i2c_client *client = to_i2c_client(dev);
Zhang Rui8c4ff6d2014-01-14 16:46:37 +08001072 int len;
1073
1074 len = acpi_device_modalias(dev, buf, PAGE_SIZE -1);
1075 if (len != -ENODEV)
1076 return len;
1077
Jean Delvareeb8a7902008-05-18 20:49:41 +02001078 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
David Brownell7b4fbc52007-05-01 23:26:30 +02001079}
Jean Delvare51298d12009-09-18 22:45:45 +02001080static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
1081
1082static struct attribute *i2c_dev_attrs[] = {
1083 &dev_attr_name.attr,
David Brownell7b4fbc52007-05-01 23:26:30 +02001084 /* modalias helps coldplug: modprobe $(cat .../modalias) */
Jean Delvare51298d12009-09-18 22:45:45 +02001085 &dev_attr_modalias.attr,
1086 NULL
1087};
Wolfram Sanga5eb71b2015-01-19 20:12:24 +01001088ATTRIBUTE_GROUPS(i2c_dev);
sonic zhang54067ee2009-12-14 21:17:30 +01001089
Jon Smirle9ca9eb2008-07-14 22:38:35 +02001090struct bus_type i2c_bus_type = {
David Brownellf37dd802007-02-13 22:09:00 +01001091 .name = "i2c",
1092 .match = i2c_device_match,
1093 .probe = i2c_device_probe,
1094 .remove = i2c_device_remove,
1095 .shutdown = i2c_device_shutdown,
Russell Kingb864c7d2006-01-05 14:37:50 +00001096};
Jon Smirle9ca9eb2008-07-14 22:38:35 +02001097EXPORT_SYMBOL_GPL(i2c_bus_type);
Russell Kingb864c7d2006-01-05 14:37:50 +00001098
Jean Delvare51298d12009-09-18 22:45:45 +02001099static struct device_type i2c_client_type = {
Wolfram Sanga5eb71b2015-01-19 20:12:24 +01001100 .groups = i2c_dev_groups,
Jean Delvare51298d12009-09-18 22:45:45 +02001101 .uevent = i2c_device_uevent,
1102 .release = i2c_client_dev_release,
1103};
1104
David Brownell9b766b82008-01-27 18:14:51 +01001105
1106/**
1107 * i2c_verify_client - return parameter as i2c_client, or NULL
1108 * @dev: device, probably from some driver model iterator
1109 *
1110 * When traversing the driver model tree, perhaps using driver model
1111 * iterators like @device_for_each_child(), you can't assume very much
1112 * about the nodes you find. Use this function to avoid oopses caused
1113 * by wrongly treating some non-I2C device as an i2c_client.
1114 */
1115struct i2c_client *i2c_verify_client(struct device *dev)
1116{
Jean Delvare51298d12009-09-18 22:45:45 +02001117 return (dev->type == &i2c_client_type)
David Brownell9b766b82008-01-27 18:14:51 +01001118 ? to_i2c_client(dev)
1119 : NULL;
1120}
1121EXPORT_SYMBOL(i2c_verify_client);
1122
1123
Wolfram Sangda899f52015-05-18 21:09:12 +02001124/* Return a unique address which takes the flags of the client into account */
1125static unsigned short i2c_encode_flags_to_addr(struct i2c_client *client)
1126{
1127 unsigned short addr = client->addr;
1128
1129 /* For some client flags, add an arbitrary offset to avoid collisions */
1130 if (client->flags & I2C_CLIENT_TEN)
1131 addr |= I2C_ADDR_OFFSET_TEN_BIT;
1132
1133 if (client->flags & I2C_CLIENT_SLAVE)
1134 addr |= I2C_ADDR_OFFSET_SLAVE;
1135
1136 return addr;
1137}
1138
Jean Delvare3a89db52010-06-03 11:33:52 +02001139/* This is a permissive address validity check, I2C address map constraints
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001140 * are purposely not enforced, except for the general call address. */
Wolfram Sangc4019b72015-07-17 12:50:06 +02001141static int i2c_check_addr_validity(unsigned addr, unsigned short flags)
Jean Delvare3a89db52010-06-03 11:33:52 +02001142{
Wolfram Sangc4019b72015-07-17 12:50:06 +02001143 if (flags & I2C_CLIENT_TEN) {
Jean Delvare3a89db52010-06-03 11:33:52 +02001144 /* 10-bit address, all values are valid */
Wolfram Sangc4019b72015-07-17 12:50:06 +02001145 if (addr > 0x3ff)
Jean Delvare3a89db52010-06-03 11:33:52 +02001146 return -EINVAL;
1147 } else {
1148 /* 7-bit address, reject the general call address */
Wolfram Sangc4019b72015-07-17 12:50:06 +02001149 if (addr == 0x00 || addr > 0x7f)
Jean Delvare3a89db52010-06-03 11:33:52 +02001150 return -EINVAL;
1151 }
1152 return 0;
1153}
1154
Jean Delvare656b8762010-06-03 11:33:53 +02001155/* And this is a strict address validity check, used when probing. If a
1156 * device uses a reserved address, then it shouldn't be probed. 7-bit
1157 * addressing is assumed, 10-bit address devices are rare and should be
1158 * explicitly enumerated. */
Wolfram Sang66be60562015-07-17 12:43:22 +02001159static int i2c_check_7bit_addr_validity_strict(unsigned short addr)
Jean Delvare656b8762010-06-03 11:33:53 +02001160{
1161 /*
1162 * Reserved addresses per I2C specification:
1163 * 0x00 General call address / START byte
1164 * 0x01 CBUS address
1165 * 0x02 Reserved for different bus format
1166 * 0x03 Reserved for future purposes
1167 * 0x04-0x07 Hs-mode master code
1168 * 0x78-0x7b 10-bit slave addressing
1169 * 0x7c-0x7f Reserved for future purposes
1170 */
1171 if (addr < 0x08 || addr > 0x77)
1172 return -EINVAL;
1173 return 0;
1174}
1175
Jean Delvare3b5f7942010-06-03 11:33:55 +02001176static int __i2c_check_addr_busy(struct device *dev, void *addrp)
1177{
1178 struct i2c_client *client = i2c_verify_client(dev);
1179 int addr = *(int *)addrp;
1180
Wolfram Sang9bccc702015-07-17 14:48:56 +02001181 if (client && i2c_encode_flags_to_addr(client) == addr)
Jean Delvare3b5f7942010-06-03 11:33:55 +02001182 return -EBUSY;
1183 return 0;
1184}
1185
Michael Lawnick08263742010-08-11 18:21:02 +02001186/* walk up mux tree */
1187static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
1188{
Jean Delvare97cc4d42010-10-24 18:16:57 +02001189 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
Michael Lawnick08263742010-08-11 18:21:02 +02001190 int result;
1191
1192 result = device_for_each_child(&adapter->dev, &addr,
1193 __i2c_check_addr_busy);
1194
Jean Delvare97cc4d42010-10-24 18:16:57 +02001195 if (!result && parent)
1196 result = i2c_check_mux_parents(parent, addr);
Michael Lawnick08263742010-08-11 18:21:02 +02001197
1198 return result;
1199}
1200
1201/* recurse down mux tree */
1202static int i2c_check_mux_children(struct device *dev, void *addrp)
1203{
1204 int result;
1205
1206 if (dev->type == &i2c_adapter_type)
1207 result = device_for_each_child(dev, addrp,
1208 i2c_check_mux_children);
1209 else
1210 result = __i2c_check_addr_busy(dev, addrp);
1211
1212 return result;
1213}
1214
Jean Delvare3b5f7942010-06-03 11:33:55 +02001215static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
1216{
Jean Delvare97cc4d42010-10-24 18:16:57 +02001217 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
Michael Lawnick08263742010-08-11 18:21:02 +02001218 int result = 0;
1219
Jean Delvare97cc4d42010-10-24 18:16:57 +02001220 if (parent)
1221 result = i2c_check_mux_parents(parent, addr);
Michael Lawnick08263742010-08-11 18:21:02 +02001222
1223 if (!result)
1224 result = device_for_each_child(&adapter->dev, &addr,
1225 i2c_check_mux_children);
1226
1227 return result;
Jean Delvare3b5f7942010-06-03 11:33:55 +02001228}
1229
David Brownell9c1600e2007-05-01 23:26:31 +02001230/**
Peter Rosin8320f492016-05-04 22:15:27 +02001231 * i2c_adapter_lock_bus - Get exclusive access to an I2C bus segment
Jean Delvarefe61e072010-08-11 18:20:58 +02001232 * @adapter: Target I2C bus segment
Peter Rosin8320f492016-05-04 22:15:27 +02001233 * @flags: I2C_LOCK_ROOT_ADAPTER locks the root i2c adapter, I2C_LOCK_SEGMENT
1234 * locks only this branch in the adapter tree
Jean Delvarefe61e072010-08-11 18:20:58 +02001235 */
Peter Rosin8320f492016-05-04 22:15:27 +02001236static void i2c_adapter_lock_bus(struct i2c_adapter *adapter,
1237 unsigned int flags)
Jean Delvarefe61e072010-08-11 18:20:58 +02001238{
Peter Rosinfa96f0c2016-05-04 22:15:28 +02001239 rt_mutex_lock(&adapter->bus_lock);
Jean Delvarefe61e072010-08-11 18:20:58 +02001240}
Jean Delvarefe61e072010-08-11 18:20:58 +02001241
1242/**
Peter Rosin8320f492016-05-04 22:15:27 +02001243 * i2c_adapter_trylock_bus - Try to get exclusive access to an I2C bus segment
Jean Delvarefe61e072010-08-11 18:20:58 +02001244 * @adapter: Target I2C bus segment
Peter Rosin8320f492016-05-04 22:15:27 +02001245 * @flags: I2C_LOCK_ROOT_ADAPTER trylocks the root i2c adapter, I2C_LOCK_SEGMENT
1246 * trylocks only this branch in the adapter tree
Jean Delvarefe61e072010-08-11 18:20:58 +02001247 */
Peter Rosin8320f492016-05-04 22:15:27 +02001248static int i2c_adapter_trylock_bus(struct i2c_adapter *adapter,
1249 unsigned int flags)
Jean Delvarefe61e072010-08-11 18:20:58 +02001250{
Peter Rosinfa96f0c2016-05-04 22:15:28 +02001251 return rt_mutex_trylock(&adapter->bus_lock);
Jean Delvarefe61e072010-08-11 18:20:58 +02001252}
1253
1254/**
Peter Rosin8320f492016-05-04 22:15:27 +02001255 * i2c_adapter_unlock_bus - Release exclusive access to an I2C bus segment
Jean Delvarefe61e072010-08-11 18:20:58 +02001256 * @adapter: Target I2C bus segment
Peter Rosin8320f492016-05-04 22:15:27 +02001257 * @flags: I2C_LOCK_ROOT_ADAPTER unlocks the root i2c adapter, I2C_LOCK_SEGMENT
1258 * unlocks only this branch in the adapter tree
Jean Delvarefe61e072010-08-11 18:20:58 +02001259 */
Peter Rosin8320f492016-05-04 22:15:27 +02001260static void i2c_adapter_unlock_bus(struct i2c_adapter *adapter,
1261 unsigned int flags)
Jean Delvarefe61e072010-08-11 18:20:58 +02001262{
Peter Rosinfa96f0c2016-05-04 22:15:28 +02001263 rt_mutex_unlock(&adapter->bus_lock);
Jean Delvarefe61e072010-08-11 18:20:58 +02001264}
Jean Delvarefe61e072010-08-11 18:20:58 +02001265
Jarkko Nikula70762ab2013-11-14 14:03:52 +02001266static void i2c_dev_set_name(struct i2c_adapter *adap,
1267 struct i2c_client *client)
1268{
1269 struct acpi_device *adev = ACPI_COMPANION(&client->dev);
1270
1271 if (adev) {
1272 dev_set_name(&client->dev, "i2c-%s", acpi_dev_name(adev));
1273 return;
1274 }
1275
Jarkko Nikula70762ab2013-11-14 14:03:52 +02001276 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
Wolfram Sangda899f52015-05-18 21:09:12 +02001277 i2c_encode_flags_to_addr(client));
Jarkko Nikula70762ab2013-11-14 14:03:52 +02001278}
1279
Jean Delvarefe61e072010-08-11 18:20:58 +02001280/**
Jean Delvaref8a227e2009-06-19 16:58:18 +02001281 * i2c_new_device - instantiate an i2c device
David Brownell9c1600e2007-05-01 23:26:31 +02001282 * @adap: the adapter managing the device
1283 * @info: describes one I2C device; bus_num is ignored
David Brownelld64f73b2007-07-12 14:12:28 +02001284 * Context: can sleep
David Brownell9c1600e2007-05-01 23:26:31 +02001285 *
Jean Delvaref8a227e2009-06-19 16:58:18 +02001286 * Create an i2c device. Binding is handled through driver model
1287 * probe()/remove() methods. A driver may be bound to this device when we
1288 * return from this function, or any later moment (e.g. maybe hotplugging will
1289 * load the driver module). This call is not appropriate for use by mainboard
1290 * initialization logic, which usually runs during an arch_initcall() long
1291 * before any i2c_adapter could exist.
David Brownell9c1600e2007-05-01 23:26:31 +02001292 *
1293 * This returns the new i2c client, which may be saved for later use with
1294 * i2c_unregister_device(); or NULL to indicate an error.
1295 */
1296struct i2c_client *
1297i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
1298{
1299 struct i2c_client *client;
1300 int status;
1301
1302 client = kzalloc(sizeof *client, GFP_KERNEL);
1303 if (!client)
1304 return NULL;
1305
1306 client->adapter = adap;
1307
1308 client->dev.platform_data = info->platform_data;
David Brownell3bbb8352007-10-13 23:56:29 +02001309
Anton Vorontsov11f1f2a2008-10-22 20:21:33 +02001310 if (info->archdata)
1311 client->dev.archdata = *info->archdata;
1312
Marc Pignatee354252008-08-28 08:33:22 +02001313 client->flags = info->flags;
David Brownell9c1600e2007-05-01 23:26:31 +02001314 client->addr = info->addr;
1315 client->irq = info->irq;
1316
David Brownell9c1600e2007-05-01 23:26:31 +02001317 strlcpy(client->name, info->type, sizeof(client->name));
1318
Wolfram Sangc4019b72015-07-17 12:50:06 +02001319 status = i2c_check_addr_validity(client->addr, client->flags);
Jean Delvare3a89db52010-06-03 11:33:52 +02001320 if (status) {
1321 dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
1322 client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
1323 goto out_err_silent;
1324 }
1325
Jean Delvaref8a227e2009-06-19 16:58:18 +02001326 /* Check for address business */
Wolfram Sang9bccc702015-07-17 14:48:56 +02001327 status = i2c_check_addr_busy(adap, i2c_encode_flags_to_addr(client));
Jean Delvaref8a227e2009-06-19 16:58:18 +02001328 if (status)
1329 goto out_err;
1330
1331 client->dev.parent = &client->adapter->dev;
1332 client->dev.bus = &i2c_bus_type;
Jean Delvare51298d12009-09-18 22:45:45 +02001333 client->dev.type = &i2c_client_type;
Grant Likelyd12d42f2010-04-13 16:12:28 -07001334 client->dev.of_node = info->of_node;
Rafael J. Wysockice793482015-03-16 23:49:03 +01001335 client->dev.fwnode = info->fwnode;
Jean Delvaref8a227e2009-06-19 16:58:18 +02001336
Jarkko Nikula70762ab2013-11-14 14:03:52 +02001337 i2c_dev_set_name(adap, client);
Dmitry Torokhovd3e1b612017-02-02 17:41:28 -08001338
1339 if (info->properties) {
1340 status = device_add_properties(&client->dev, info->properties);
1341 if (status) {
1342 dev_err(&adap->dev,
1343 "Failed to add properties to client %s: %d\n",
1344 client->name, status);
1345 goto out_err;
1346 }
1347 }
1348
Jean Delvaref8a227e2009-06-19 16:58:18 +02001349 status = device_register(&client->dev);
1350 if (status)
Dmitry Torokhovd3e1b612017-02-02 17:41:28 -08001351 goto out_free_props;
Jean Delvaref8a227e2009-06-19 16:58:18 +02001352
Jean Delvaref8a227e2009-06-19 16:58:18 +02001353 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
1354 client->name, dev_name(&client->dev));
1355
David Brownell9c1600e2007-05-01 23:26:31 +02001356 return client;
Jean Delvaref8a227e2009-06-19 16:58:18 +02001357
Dmitry Torokhovd3e1b612017-02-02 17:41:28 -08001358out_free_props:
1359 if (info->properties)
1360 device_remove_properties(&client->dev);
Jean Delvaref8a227e2009-06-19 16:58:18 +02001361out_err:
Andy Shevchenkob93d3d32016-08-25 17:42:10 +03001362 dev_err(&adap->dev,
1363 "Failed to register i2c client %s at 0x%02x (%d)\n",
1364 client->name, client->addr, status);
Jean Delvare3a89db52010-06-03 11:33:52 +02001365out_err_silent:
Jean Delvaref8a227e2009-06-19 16:58:18 +02001366 kfree(client);
1367 return NULL;
David Brownell9c1600e2007-05-01 23:26:31 +02001368}
1369EXPORT_SYMBOL_GPL(i2c_new_device);
1370
1371
1372/**
1373 * i2c_unregister_device - reverse effect of i2c_new_device()
1374 * @client: value returned from i2c_new_device()
David Brownelld64f73b2007-07-12 14:12:28 +02001375 * Context: can sleep
David Brownell9c1600e2007-05-01 23:26:31 +02001376 */
1377void i2c_unregister_device(struct i2c_client *client)
David Brownella1d9e6e2007-05-01 23:26:30 +02001378{
Pantelis Antoniou4f001fd2015-01-24 09:16:29 +02001379 if (client->dev.of_node)
1380 of_node_clear_flag(client->dev.of_node, OF_POPULATED);
Octavian Purdila525e6fa2016-07-08 19:13:10 +03001381 if (ACPI_COMPANION(&client->dev))
1382 acpi_device_clear_enumerated(ACPI_COMPANION(&client->dev));
David Brownella1d9e6e2007-05-01 23:26:30 +02001383 device_unregister(&client->dev);
1384}
David Brownell9c1600e2007-05-01 23:26:31 +02001385EXPORT_SYMBOL_GPL(i2c_unregister_device);
David Brownella1d9e6e2007-05-01 23:26:30 +02001386
1387
Jean Delvare60b129d2008-05-11 20:37:06 +02001388static const struct i2c_device_id dummy_id[] = {
1389 { "dummy", 0 },
1390 { },
1391};
1392
Jean Delvared2653e92008-04-29 23:11:39 +02001393static int dummy_probe(struct i2c_client *client,
1394 const struct i2c_device_id *id)
1395{
1396 return 0;
1397}
1398
1399static int dummy_remove(struct i2c_client *client)
David Brownelle9f13732008-01-27 18:14:52 +01001400{
1401 return 0;
1402}
1403
1404static struct i2c_driver dummy_driver = {
1405 .driver.name = "dummy",
Jean Delvared2653e92008-04-29 23:11:39 +02001406 .probe = dummy_probe,
1407 .remove = dummy_remove,
Jean Delvare60b129d2008-05-11 20:37:06 +02001408 .id_table = dummy_id,
David Brownelle9f13732008-01-27 18:14:52 +01001409};
1410
1411/**
1412 * i2c_new_dummy - return a new i2c device bound to a dummy driver
1413 * @adapter: the adapter managing the device
1414 * @address: seven bit address to be used
David Brownelle9f13732008-01-27 18:14:52 +01001415 * Context: can sleep
1416 *
1417 * This returns an I2C client bound to the "dummy" driver, intended for use
1418 * with devices that consume multiple addresses. Examples of such chips
1419 * include various EEPROMS (like 24c04 and 24c08 models).
1420 *
1421 * These dummy devices have two main uses. First, most I2C and SMBus calls
1422 * except i2c_transfer() need a client handle; the dummy will be that handle.
1423 * And second, this prevents the specified address from being bound to a
1424 * different driver.
1425 *
1426 * This returns the new i2c client, which should be saved for later use with
1427 * i2c_unregister_device(); or NULL to indicate an error.
1428 */
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01001429struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
David Brownelle9f13732008-01-27 18:14:52 +01001430{
1431 struct i2c_board_info info = {
Jean Delvare60b129d2008-05-11 20:37:06 +02001432 I2C_BOARD_INFO("dummy", address),
David Brownelle9f13732008-01-27 18:14:52 +01001433 };
1434
David Brownelle9f13732008-01-27 18:14:52 +01001435 return i2c_new_device(adapter, &info);
1436}
1437EXPORT_SYMBOL_GPL(i2c_new_dummy);
1438
Jean-Michel Hautbois0f614d82016-01-31 16:33:00 +01001439/**
1440 * i2c_new_secondary_device - Helper to get the instantiated secondary address
1441 * and create the associated device
1442 * @client: Handle to the primary client
1443 * @name: Handle to specify which secondary address to get
1444 * @default_addr: Used as a fallback if no secondary address was specified
1445 * Context: can sleep
1446 *
1447 * I2C clients can be composed of multiple I2C slaves bound together in a single
1448 * component. The I2C client driver then binds to the master I2C slave and needs
1449 * to create I2C dummy clients to communicate with all the other slaves.
1450 *
1451 * This function creates and returns an I2C dummy client whose I2C address is
1452 * retrieved from the platform firmware based on the given slave name. If no
1453 * address is specified by the firmware default_addr is used.
1454 *
1455 * On DT-based platforms the address is retrieved from the "reg" property entry
1456 * cell whose "reg-names" value matches the slave name.
1457 *
1458 * This returns the new i2c client, which should be saved for later use with
1459 * i2c_unregister_device(); or NULL to indicate an error.
1460 */
1461struct i2c_client *i2c_new_secondary_device(struct i2c_client *client,
1462 const char *name,
1463 u16 default_addr)
1464{
1465 struct device_node *np = client->dev.of_node;
1466 u32 addr = default_addr;
1467 int i;
1468
1469 if (np) {
1470 i = of_property_match_string(np, "reg-names", name);
1471 if (i >= 0)
1472 of_property_read_u32_index(np, "reg", i, &addr);
1473 }
1474
1475 dev_dbg(&client->adapter->dev, "Address for %s : 0x%x\n", name, addr);
1476 return i2c_new_dummy(client->adapter, addr);
1477}
1478EXPORT_SYMBOL_GPL(i2c_new_secondary_device);
1479
David Brownellf37dd802007-02-13 22:09:00 +01001480/* ------------------------------------------------------------------------- */
1481
David Brownell16ffadf2007-05-01 23:26:28 +02001482/* I2C bus adapters -- one roots each I2C or SMBUS segment */
1483
Adrian Bunk83eaaed2007-10-13 23:56:30 +02001484static void i2c_adapter_dev_release(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485{
David Brownellef2c83212007-05-01 23:26:28 +02001486 struct i2c_adapter *adap = to_i2c_adapter(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487 complete(&adap->dev_released);
1488}
1489
Bartosz Golaszewski8dd1fe12016-09-16 18:02:42 +02001490unsigned int i2c_adapter_depth(struct i2c_adapter *adapter)
Jean Delvare390946b2012-09-10 10:14:02 +02001491{
1492 unsigned int depth = 0;
1493
1494 while ((adapter = i2c_parent_is_i2c_adapter(adapter)))
1495 depth++;
1496
Bartosz Golaszewski2771dc32016-09-16 18:02:44 +02001497 WARN_ONCE(depth >= MAX_LOCKDEP_SUBCLASSES,
1498 "adapter depth exceeds lockdep subclass limit\n");
1499
Jean Delvare390946b2012-09-10 10:14:02 +02001500 return depth;
1501}
Bartosz Golaszewski8dd1fe12016-09-16 18:02:42 +02001502EXPORT_SYMBOL_GPL(i2c_adapter_depth);
Jean Delvare390946b2012-09-10 10:14:02 +02001503
1504/*
Jean Delvare99cd8e22009-06-19 16:58:20 +02001505 * Let users instantiate I2C devices through sysfs. This can be used when
1506 * platform initialization code doesn't contain the proper data for
1507 * whatever reason. Also useful for drivers that do device detection and
1508 * detection fails, either because the device uses an unexpected address,
1509 * or this is a compatible device with different ID register values.
1510 *
1511 * Parameter checking may look overzealous, but we really don't want
1512 * the user to provide incorrect parameters.
1513 */
1514static ssize_t
1515i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
1516 const char *buf, size_t count)
1517{
1518 struct i2c_adapter *adap = to_i2c_adapter(dev);
1519 struct i2c_board_info info;
1520 struct i2c_client *client;
1521 char *blank, end;
1522 int res;
1523
Jean Delvare99cd8e22009-06-19 16:58:20 +02001524 memset(&info, 0, sizeof(struct i2c_board_info));
1525
1526 blank = strchr(buf, ' ');
1527 if (!blank) {
1528 dev_err(dev, "%s: Missing parameters\n", "new_device");
1529 return -EINVAL;
1530 }
1531 if (blank - buf > I2C_NAME_SIZE - 1) {
1532 dev_err(dev, "%s: Invalid device name\n", "new_device");
1533 return -EINVAL;
1534 }
1535 memcpy(info.type, buf, blank - buf);
1536
1537 /* Parse remaining parameters, reject extra parameters */
1538 res = sscanf(++blank, "%hi%c", &info.addr, &end);
1539 if (res < 1) {
1540 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
1541 return -EINVAL;
1542 }
1543 if (res > 1 && end != '\n') {
1544 dev_err(dev, "%s: Extra parameters\n", "new_device");
1545 return -EINVAL;
1546 }
1547
Wolfram Sangcfa03272015-07-27 14:03:38 +02001548 if ((info.addr & I2C_ADDR_OFFSET_TEN_BIT) == I2C_ADDR_OFFSET_TEN_BIT) {
1549 info.addr &= ~I2C_ADDR_OFFSET_TEN_BIT;
1550 info.flags |= I2C_CLIENT_TEN;
1551 }
1552
1553 if (info.addr & I2C_ADDR_OFFSET_SLAVE) {
1554 info.addr &= ~I2C_ADDR_OFFSET_SLAVE;
1555 info.flags |= I2C_CLIENT_SLAVE;
1556 }
1557
Jean Delvare99cd8e22009-06-19 16:58:20 +02001558 client = i2c_new_device(adap, &info);
1559 if (!client)
Jean Delvare3a89db52010-06-03 11:33:52 +02001560 return -EINVAL;
Jean Delvare99cd8e22009-06-19 16:58:20 +02001561
1562 /* Keep track of the added device */
Jean Delvaredafc50d2010-08-11 18:21:01 +02001563 mutex_lock(&adap->userspace_clients_lock);
Jean Delvare6629dcf2010-05-04 11:09:28 +02001564 list_add_tail(&client->detected, &adap->userspace_clients);
Jean Delvaredafc50d2010-08-11 18:21:01 +02001565 mutex_unlock(&adap->userspace_clients_lock);
Jean Delvare99cd8e22009-06-19 16:58:20 +02001566 dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
1567 info.type, info.addr);
1568
1569 return count;
1570}
Wolfram Sanga5eb71b2015-01-19 20:12:24 +01001571static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
Jean Delvare99cd8e22009-06-19 16:58:20 +02001572
1573/*
1574 * And of course let the users delete the devices they instantiated, if
1575 * they got it wrong. This interface can only be used to delete devices
1576 * instantiated by i2c_sysfs_new_device above. This guarantees that we
1577 * don't delete devices to which some kernel code still has references.
1578 *
1579 * Parameter checking may look overzealous, but we really don't want
1580 * the user to delete the wrong device.
1581 */
1582static ssize_t
1583i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
1584 const char *buf, size_t count)
1585{
1586 struct i2c_adapter *adap = to_i2c_adapter(dev);
1587 struct i2c_client *client, *next;
1588 unsigned short addr;
1589 char end;
1590 int res;
1591
1592 /* Parse parameters, reject extra parameters */
1593 res = sscanf(buf, "%hi%c", &addr, &end);
1594 if (res < 1) {
1595 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
1596 return -EINVAL;
1597 }
1598 if (res > 1 && end != '\n') {
1599 dev_err(dev, "%s: Extra parameters\n", "delete_device");
1600 return -EINVAL;
1601 }
1602
1603 /* Make sure the device was added through sysfs */
1604 res = -ENOENT;
Jean Delvare390946b2012-09-10 10:14:02 +02001605 mutex_lock_nested(&adap->userspace_clients_lock,
1606 i2c_adapter_depth(adap));
Jean Delvare6629dcf2010-05-04 11:09:28 +02001607 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1608 detected) {
Wolfram Sangcfa03272015-07-27 14:03:38 +02001609 if (i2c_encode_flags_to_addr(client) == addr) {
Jean Delvare99cd8e22009-06-19 16:58:20 +02001610 dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
1611 "delete_device", client->name, client->addr);
1612
1613 list_del(&client->detected);
1614 i2c_unregister_device(client);
1615 res = count;
1616 break;
1617 }
1618 }
Jean Delvaredafc50d2010-08-11 18:21:01 +02001619 mutex_unlock(&adap->userspace_clients_lock);
Jean Delvare99cd8e22009-06-19 16:58:20 +02001620
1621 if (res < 0)
1622 dev_err(dev, "%s: Can't find device in list\n",
1623 "delete_device");
1624 return res;
1625}
Alexander Sverdline9b526f2013-05-17 14:56:35 +02001626static DEVICE_ATTR_IGNORE_LOCKDEP(delete_device, S_IWUSR, NULL,
1627 i2c_sysfs_delete_device);
Jean Delvare4f8cf822009-09-18 22:45:46 +02001628
1629static struct attribute *i2c_adapter_attrs[] = {
1630 &dev_attr_name.attr,
1631 &dev_attr_new_device.attr,
1632 &dev_attr_delete_device.attr,
1633 NULL
David Brownell16ffadf2007-05-01 23:26:28 +02001634};
Wolfram Sanga5eb71b2015-01-19 20:12:24 +01001635ATTRIBUTE_GROUPS(i2c_adapter);
Jean Delvare4f8cf822009-09-18 22:45:46 +02001636
Michael Lawnick08263742010-08-11 18:21:02 +02001637struct device_type i2c_adapter_type = {
Wolfram Sanga5eb71b2015-01-19 20:12:24 +01001638 .groups = i2c_adapter_groups,
Jean Delvare4f8cf822009-09-18 22:45:46 +02001639 .release = i2c_adapter_dev_release,
David Brownell16ffadf2007-05-01 23:26:28 +02001640};
Michael Lawnick08263742010-08-11 18:21:02 +02001641EXPORT_SYMBOL_GPL(i2c_adapter_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642
Stephen Warren643dd092012-04-17 12:43:33 -06001643/**
1644 * i2c_verify_adapter - return parameter as i2c_adapter or NULL
1645 * @dev: device, probably from some driver model iterator
1646 *
1647 * When traversing the driver model tree, perhaps using driver model
1648 * iterators like @device_for_each_child(), you can't assume very much
1649 * about the nodes you find. Use this function to avoid oopses caused
1650 * by wrongly treating some non-I2C device as an i2c_adapter.
1651 */
1652struct i2c_adapter *i2c_verify_adapter(struct device *dev)
1653{
1654 return (dev->type == &i2c_adapter_type)
1655 ? to_i2c_adapter(dev)
1656 : NULL;
1657}
1658EXPORT_SYMBOL(i2c_verify_adapter);
1659
Jean Delvare2bb50952009-09-18 22:45:46 +02001660#ifdef CONFIG_I2C_COMPAT
1661static struct class_compat *i2c_adapter_compat_class;
1662#endif
1663
David Brownell9c1600e2007-05-01 23:26:31 +02001664static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
1665{
1666 struct i2c_devinfo *devinfo;
1667
Rodolfo Giomettif18c41d2009-06-19 16:58:20 +02001668 down_read(&__i2c_board_lock);
David Brownell9c1600e2007-05-01 23:26:31 +02001669 list_for_each_entry(devinfo, &__i2c_board_list, list) {
1670 if (devinfo->busnum == adapter->nr
1671 && !i2c_new_device(adapter,
1672 &devinfo->board_info))
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01001673 dev_err(&adapter->dev,
1674 "Can't create device at 0x%02x\n",
David Brownell9c1600e2007-05-01 23:26:31 +02001675 devinfo->board_info.addr);
1676 }
Rodolfo Giomettif18c41d2009-06-19 16:58:20 +02001677 up_read(&__i2c_board_lock);
David Brownell9c1600e2007-05-01 23:26:31 +02001678}
1679
Wolfram Sang687b81d2013-07-11 12:56:15 +01001680/* OF support code */
1681
1682#if IS_ENABLED(CONFIG_OF)
Pantelis Antonioua430a3452014-10-28 22:36:02 +02001683static struct i2c_client *of_i2c_register_device(struct i2c_adapter *adap,
1684 struct device_node *node)
1685{
1686 struct i2c_client *result;
1687 struct i2c_board_info info = {};
1688 struct dev_archdata dev_ad = {};
Wolfram Sangb4e2f6a2015-05-19 21:04:40 +02001689 const __be32 *addr_be;
1690 u32 addr;
Pantelis Antonioua430a3452014-10-28 22:36:02 +02001691 int len;
1692
1693 dev_dbg(&adap->dev, "of_i2c: register %s\n", node->full_name);
1694
1695 if (of_modalias_node(node, info.type, sizeof(info.type)) < 0) {
1696 dev_err(&adap->dev, "of_i2c: modalias failure on %s\n",
1697 node->full_name);
1698 return ERR_PTR(-EINVAL);
1699 }
1700
Wolfram Sangb4e2f6a2015-05-19 21:04:40 +02001701 addr_be = of_get_property(node, "reg", &len);
1702 if (!addr_be || (len < sizeof(*addr_be))) {
Pantelis Antonioua430a3452014-10-28 22:36:02 +02001703 dev_err(&adap->dev, "of_i2c: invalid reg on %s\n",
1704 node->full_name);
1705 return ERR_PTR(-EINVAL);
1706 }
1707
Wolfram Sangb4e2f6a2015-05-19 21:04:40 +02001708 addr = be32_to_cpup(addr_be);
1709 if (addr & I2C_TEN_BIT_ADDRESS) {
1710 addr &= ~I2C_TEN_BIT_ADDRESS;
1711 info.flags |= I2C_CLIENT_TEN;
1712 }
1713
1714 if (addr & I2C_OWN_SLAVE_ADDRESS) {
1715 addr &= ~I2C_OWN_SLAVE_ADDRESS;
1716 info.flags |= I2C_CLIENT_SLAVE;
1717 }
1718
1719 if (i2c_check_addr_validity(addr, info.flags)) {
Pantelis Antonioua430a3452014-10-28 22:36:02 +02001720 dev_err(&adap->dev, "of_i2c: invalid addr=%x on %s\n",
John Garry6f724fb2017-01-06 19:02:57 +08001721 addr, node->full_name);
Pantelis Antonioua430a3452014-10-28 22:36:02 +02001722 return ERR_PTR(-EINVAL);
1723 }
1724
Wolfram Sangb4e2f6a2015-05-19 21:04:40 +02001725 info.addr = addr;
Pantelis Antonioua430a3452014-10-28 22:36:02 +02001726 info.of_node = of_node_get(node);
1727 info.archdata = &dev_ad;
1728
Dmitry Torokhov331c3422017-01-04 20:57:22 -08001729 if (of_property_read_bool(node, "host-notify"))
1730 info.flags |= I2C_CLIENT_HOST_NOTIFY;
1731
Pantelis Antonioua430a3452014-10-28 22:36:02 +02001732 if (of_get_property(node, "wakeup-source", NULL))
1733 info.flags |= I2C_CLIENT_WAKE;
1734
Pantelis Antonioua430a3452014-10-28 22:36:02 +02001735 result = i2c_new_device(adap, &info);
1736 if (result == NULL) {
1737 dev_err(&adap->dev, "of_i2c: Failure registering %s\n",
1738 node->full_name);
1739 of_node_put(node);
Pantelis Antonioua430a3452014-10-28 22:36:02 +02001740 return ERR_PTR(-EINVAL);
1741 }
1742 return result;
1743}
1744
Wolfram Sang687b81d2013-07-11 12:56:15 +01001745static void of_i2c_register_devices(struct i2c_adapter *adap)
1746{
Jon Hunter7e4c2242016-06-29 10:17:53 +01001747 struct device_node *bus, *node;
Ralf Ramsauer6a676fb2016-10-17 15:59:57 +02001748 struct i2c_client *client;
Wolfram Sang687b81d2013-07-11 12:56:15 +01001749
1750 /* Only register child devices if the adapter has a node pointer set */
1751 if (!adap->dev.of_node)
1752 return;
1753
1754 dev_dbg(&adap->dev, "of_i2c: walking child nodes\n");
1755
Jon Hunter7e4c2242016-06-29 10:17:53 +01001756 bus = of_get_child_by_name(adap->dev.of_node, "i2c-bus");
1757 if (!bus)
1758 bus = of_node_get(adap->dev.of_node);
1759
1760 for_each_available_child_of_node(bus, node) {
Pantelis Antoniou4f001fd2015-01-24 09:16:29 +02001761 if (of_node_test_and_set_flag(node, OF_POPULATED))
1762 continue;
Ralf Ramsauer6a676fb2016-10-17 15:59:57 +02001763
1764 client = of_i2c_register_device(adap, node);
1765 if (IS_ERR(client)) {
1766 dev_warn(&adap->dev,
1767 "Failed to create I2C device for %s\n",
1768 node->full_name);
1769 of_node_clear_flag(node, OF_POPULATED);
1770 }
Pantelis Antoniou4f001fd2015-01-24 09:16:29 +02001771 }
Jon Hunter7e4c2242016-06-29 10:17:53 +01001772
1773 of_node_put(bus);
Wolfram Sang687b81d2013-07-11 12:56:15 +01001774}
1775
1776static int of_dev_node_match(struct device *dev, void *data)
1777{
1778 return dev->of_node == data;
1779}
1780
1781/* must call put_device() when done with returned i2c_client device */
1782struct i2c_client *of_find_i2c_device_by_node(struct device_node *node)
1783{
1784 struct device *dev;
Vladimir Zapolskiye3311462015-07-27 17:30:48 +03001785 struct i2c_client *client;
Wolfram Sang687b81d2013-07-11 12:56:15 +01001786
Vladimir Zapolskiye3311462015-07-27 17:30:48 +03001787 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
Wolfram Sang687b81d2013-07-11 12:56:15 +01001788 if (!dev)
1789 return NULL;
1790
Vladimir Zapolskiye3311462015-07-27 17:30:48 +03001791 client = i2c_verify_client(dev);
1792 if (!client)
1793 put_device(dev);
1794
1795 return client;
Wolfram Sang687b81d2013-07-11 12:56:15 +01001796}
1797EXPORT_SYMBOL(of_find_i2c_device_by_node);
1798
1799/* must call put_device() when done with returned i2c_adapter device */
1800struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node)
1801{
1802 struct device *dev;
Vladimir Zapolskiye3311462015-07-27 17:30:48 +03001803 struct i2c_adapter *adapter;
Wolfram Sang687b81d2013-07-11 12:56:15 +01001804
Vladimir Zapolskiye3311462015-07-27 17:30:48 +03001805 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
Wolfram Sang687b81d2013-07-11 12:56:15 +01001806 if (!dev)
1807 return NULL;
1808
Vladimir Zapolskiye3311462015-07-27 17:30:48 +03001809 adapter = i2c_verify_adapter(dev);
1810 if (!adapter)
1811 put_device(dev);
1812
1813 return adapter;
Wolfram Sang687b81d2013-07-11 12:56:15 +01001814}
1815EXPORT_SYMBOL(of_find_i2c_adapter_by_node);
Vladimir Zapolskiy48e97432015-07-27 17:30:50 +03001816
1817/* must call i2c_put_adapter() when done with returned i2c_adapter device */
1818struct i2c_adapter *of_get_i2c_adapter_by_node(struct device_node *node)
1819{
1820 struct i2c_adapter *adapter;
1821
1822 adapter = of_find_i2c_adapter_by_node(node);
1823 if (!adapter)
1824 return NULL;
1825
1826 if (!try_module_get(adapter->owner)) {
1827 put_device(&adapter->dev);
1828 adapter = NULL;
1829 }
1830
1831 return adapter;
1832}
1833EXPORT_SYMBOL(of_get_i2c_adapter_by_node);
Lee Jonescabcf4f2016-11-07 12:47:37 +00001834
1835static const struct of_device_id*
1836i2c_of_match_device_sysfs(const struct of_device_id *matches,
1837 struct i2c_client *client)
1838{
1839 const char *name;
1840
1841 for (; matches->compatible[0]; matches++) {
1842 /*
1843 * Adding devices through the i2c sysfs interface provides us
1844 * a string to match which may be compatible with the device
1845 * tree compatible strings, however with no actual of_node the
1846 * of_match_device() will not match
1847 */
1848 if (sysfs_streq(client->name, matches->compatible))
1849 return matches;
1850
1851 name = strchr(matches->compatible, ',');
1852 if (!name)
1853 name = matches->compatible;
1854 else
1855 name++;
1856
1857 if (sysfs_streq(client->name, name))
1858 return matches;
1859 }
1860
1861 return NULL;
1862}
1863
Lee Jones298d4de2016-11-07 12:47:38 +00001864const struct of_device_id
1865*i2c_of_match_device(const struct of_device_id *matches,
1866 struct i2c_client *client)
1867{
1868 const struct of_device_id *match;
1869
1870 if (!(client && matches))
1871 return NULL;
1872
1873 match = of_match_device(matches, &client->dev);
1874 if (match)
1875 return match;
1876
1877 return i2c_of_match_device_sysfs(matches, client);
1878}
1879EXPORT_SYMBOL_GPL(i2c_of_match_device);
Wolfram Sang687b81d2013-07-11 12:56:15 +01001880#else
1881static void of_i2c_register_devices(struct i2c_adapter *adap) { }
1882#endif /* CONFIG_OF */
1883
Jean Delvare69b00892009-12-06 17:06:27 +01001884static int i2c_do_add_adapter(struct i2c_driver *driver,
1885 struct i2c_adapter *adap)
Jean Delvare026526f2008-01-27 18:14:49 +01001886{
Jean Delvare4735c982008-07-14 22:38:36 +02001887 /* Detect supported devices on that bus, and instantiate them */
1888 i2c_detect(adap, driver);
1889
1890 /* Let legacy drivers scan this bus for matching devices */
Jean Delvare026526f2008-01-27 18:14:49 +01001891 if (driver->attach_adapter) {
Jean Delvarea920ff42011-04-17 10:20:19 +02001892 dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
1893 driver->driver.name);
Andy Shevchenkob93d3d32016-08-25 17:42:10 +03001894 dev_warn(&adap->dev,
1895 "Please use another way to instantiate your i2c_client\n");
Jean Delvare026526f2008-01-27 18:14:49 +01001896 /* We ignore the return code; if it fails, too bad */
1897 driver->attach_adapter(adap);
1898 }
1899 return 0;
1900}
1901
Jean Delvare69b00892009-12-06 17:06:27 +01001902static int __process_new_adapter(struct device_driver *d, void *data)
1903{
1904 return i2c_do_add_adapter(to_i2c_driver(d), data);
1905}
1906
Peter Rosind1ed7982016-08-25 23:07:01 +02001907static const struct i2c_lock_operations i2c_adapter_lock_ops = {
1908 .lock_bus = i2c_adapter_lock_bus,
1909 .trylock_bus = i2c_adapter_trylock_bus,
1910 .unlock_bus = i2c_adapter_unlock_bus,
1911};
1912
Benjamin Tissoires4d5538f2016-10-13 14:10:40 +02001913static void i2c_host_notify_irq_teardown(struct i2c_adapter *adap)
1914{
1915 struct irq_domain *domain = adap->host_notify_domain;
1916 irq_hw_number_t hwirq;
1917
1918 if (!domain)
1919 return;
1920
1921 for (hwirq = 0 ; hwirq < I2C_ADDR_7BITS_COUNT ; hwirq++)
1922 irq_dispose_mapping(irq_find_mapping(domain, hwirq));
1923
1924 irq_domain_remove(domain);
1925 adap->host_notify_domain = NULL;
1926}
1927
1928static int i2c_host_notify_irq_map(struct irq_domain *h,
1929 unsigned int virq,
1930 irq_hw_number_t hw_irq_num)
1931{
1932 irq_set_chip_and_handler(virq, &dummy_irq_chip, handle_simple_irq);
1933
1934 return 0;
1935}
1936
1937static const struct irq_domain_ops i2c_host_notify_irq_ops = {
1938 .map = i2c_host_notify_irq_map,
1939};
1940
1941static int i2c_setup_host_notify_irq_domain(struct i2c_adapter *adap)
1942{
1943 struct irq_domain *domain;
1944
1945 if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_HOST_NOTIFY))
1946 return 0;
1947
1948 domain = irq_domain_create_linear(adap->dev.fwnode,
1949 I2C_ADDR_7BITS_COUNT,
1950 &i2c_host_notify_irq_ops, adap);
1951 if (!domain)
1952 return -ENOMEM;
1953
1954 adap->host_notify_domain = domain;
1955
1956 return 0;
1957}
1958
1959/**
1960 * i2c_handle_smbus_host_notify - Forward a Host Notify event to the correct
1961 * I2C client.
1962 * @adap: the adapter
1963 * @addr: the I2C address of the notifying device
1964 * Context: can't sleep
1965 *
1966 * Helper function to be called from an I2C bus driver's interrupt
1967 * handler. It will schedule the Host Notify IRQ.
1968 */
1969int i2c_handle_smbus_host_notify(struct i2c_adapter *adap, unsigned short addr)
1970{
1971 int irq;
1972
1973 if (!adap)
1974 return -EINVAL;
1975
1976 irq = irq_find_mapping(adap->host_notify_domain, addr);
1977 if (irq <= 0)
1978 return -ENXIO;
1979
1980 generic_handle_irq(irq);
1981
1982 return 0;
1983}
1984EXPORT_SYMBOL_GPL(i2c_handle_smbus_host_notify);
1985
David Brownell6e13e642007-05-01 23:26:31 +02001986static int i2c_register_adapter(struct i2c_adapter *adap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987{
Wolfram Sangce0dffa2016-07-09 13:34:58 +09001988 int res = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989
David Brownell1d0b19c2008-10-14 17:30:05 +02001990 /* Can't register until after driver model init */
Sudip Mukherjee95026652016-03-07 17:19:17 +05301991 if (WARN_ON(!is_registered)) {
Jean Delvare35fc37f2009-06-19 16:58:19 +02001992 res = -EAGAIN;
1993 goto out_list;
1994 }
David Brownell1d0b19c2008-10-14 17:30:05 +02001995
Jean Delvare2236baa2010-11-15 22:40:38 +01001996 /* Sanity checks */
Wolfram Sang8ddfe412016-07-09 13:35:00 +09001997 if (WARN(!adap->name[0], "i2c adapter has no name"))
Wolfram Sangce0dffa2016-07-09 13:34:58 +09001998 goto out_list;
Wolfram Sang8ddfe412016-07-09 13:35:00 +09001999
2000 if (!adap->algo) {
Wolfram Sang44239a52016-07-09 13:35:04 +09002001 pr_err("adapter '%s': no algo supplied!\n", adap->name);
Wolfram Sangce0dffa2016-07-09 13:34:58 +09002002 goto out_list;
Jean Delvare2236baa2010-11-15 22:40:38 +01002003 }
2004
Peter Rosind1ed7982016-08-25 23:07:01 +02002005 if (!adap->lock_ops)
2006 adap->lock_ops = &i2c_adapter_lock_ops;
Peter Rosin8320f492016-05-04 22:15:27 +02002007
Mika Kuoppala194684e2009-12-06 17:06:22 +01002008 rt_mutex_init(&adap->bus_lock);
Peter Rosin6ef91fc2016-05-04 22:15:29 +02002009 rt_mutex_init(&adap->mux_lock);
Jean Delvaredafc50d2010-08-11 18:21:01 +02002010 mutex_init(&adap->userspace_clients_lock);
Jean Delvare6629dcf2010-05-04 11:09:28 +02002011 INIT_LIST_HEAD(&adap->userspace_clients);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002012
Jean Delvare8fcfef62009-03-28 21:34:43 +01002013 /* Set default timeout to 1 second if not already set */
2014 if (adap->timeout == 0)
2015 adap->timeout = HZ;
2016
Benjamin Tissoires4d5538f2016-10-13 14:10:40 +02002017 /* register soft irqs for Host Notify */
2018 res = i2c_setup_host_notify_irq_domain(adap);
2019 if (res) {
2020 pr_err("adapter '%s': can't create Host Notify IRQs (%d)\n",
2021 adap->name, res);
2022 goto out_list;
2023 }
2024
Kay Sievers27d9c182009-01-07 14:29:16 +01002025 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
Jean Delvare4f8cf822009-09-18 22:45:46 +02002026 adap->dev.bus = &i2c_bus_type;
2027 adap->dev.type = &i2c_adapter_type;
Jean Delvareb119c6c2006-08-15 18:26:30 +02002028 res = device_register(&adap->dev);
Wolfram Sang8ddfe412016-07-09 13:35:00 +09002029 if (res) {
Wolfram Sang44239a52016-07-09 13:35:04 +09002030 pr_err("adapter '%s': can't register device (%d)\n", adap->name, res);
Jean Delvareb119c6c2006-08-15 18:26:30 +02002031 goto out_list;
Wolfram Sang8ddfe412016-07-09 13:35:00 +09002032 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002033
Jean Delvareb6d7b3d2005-07-31 19:02:53 +02002034 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
2035
Charles Keepax6ada5c12015-04-16 13:05:19 +01002036 pm_runtime_no_callbacks(&adap->dev);
Linus Walleij04f59142016-04-12 09:57:35 +02002037 pm_suspend_ignore_children(&adap->dev, true);
Wolfram Sang9f924162015-12-23 18:19:28 +01002038 pm_runtime_enable(&adap->dev);
Charles Keepax6ada5c12015-04-16 13:05:19 +01002039
Jean Delvare2bb50952009-09-18 22:45:46 +02002040#ifdef CONFIG_I2C_COMPAT
2041 res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
2042 adap->dev.parent);
2043 if (res)
2044 dev_warn(&adap->dev,
2045 "Failed to create compatibility class link\n");
2046#endif
2047
Wolfram Sangd3b11d82016-07-09 13:34:59 +09002048 i2c_init_recovery(adap);
Viresh Kumar5f9296b2012-02-28 18:26:31 +05302049
Jean Delvare729d6dd2009-06-19 16:58:18 +02002050 /* create pre-declared device nodes */
Wolfram Sang687b81d2013-07-11 12:56:15 +01002051 of_i2c_register_devices(adap);
Jarkko Nikulaaec809f2016-08-12 17:02:52 +03002052 i2c_acpi_register_devices(adap);
2053 i2c_acpi_install_space_handler(adap);
Wolfram Sang687b81d2013-07-11 12:56:15 +01002054
David Brownell6e13e642007-05-01 23:26:31 +02002055 if (adap->nr < __i2c_first_dynamic_bus_num)
2056 i2c_scan_static_board_info(adap);
2057
Jean Delvare4735c982008-07-14 22:38:36 +02002058 /* Notify drivers */
Jean Delvare35fc37f2009-06-19 16:58:19 +02002059 mutex_lock(&core_lock);
Jean Delvared6703282010-08-11 18:20:59 +02002060 bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
Jean Delvarecaada322008-01-27 18:14:49 +01002061 mutex_unlock(&core_lock);
Jean Delvare35fc37f2009-06-19 16:58:19 +02002062
2063 return 0;
Jean Delvareb119c6c2006-08-15 18:26:30 +02002064
Jean Delvareb119c6c2006-08-15 18:26:30 +02002065out_list:
Jean Delvare35fc37f2009-06-19 16:58:19 +02002066 mutex_lock(&core_lock);
Jean Delvareb119c6c2006-08-15 18:26:30 +02002067 idr_remove(&i2c_adapter_idr, adap->nr);
Jean Delvare35fc37f2009-06-19 16:58:19 +02002068 mutex_unlock(&core_lock);
2069 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002070}
2071
David Brownell6e13e642007-05-01 23:26:31 +02002072/**
Doug Andersonee5c2742013-03-01 08:57:31 -08002073 * __i2c_add_numbered_adapter - i2c_add_numbered_adapter where nr is never -1
2074 * @adap: the adapter to register (with adap->nr initialized)
2075 * Context: can sleep
2076 *
2077 * See i2c_add_numbered_adapter() for details.
2078 */
2079static int __i2c_add_numbered_adapter(struct i2c_adapter *adap)
2080{
Wolfram Sang84d0b612016-07-09 13:35:01 +09002081 int id;
Doug Andersonee5c2742013-03-01 08:57:31 -08002082
2083 mutex_lock(&core_lock);
Wolfram Sang84d0b612016-07-09 13:35:01 +09002084 id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1, GFP_KERNEL);
Doug Andersonee5c2742013-03-01 08:57:31 -08002085 mutex_unlock(&core_lock);
Wolfram Sang84d0b612016-07-09 13:35:01 +09002086 if (WARN(id < 0, "couldn't get idr"))
Doug Andersonee5c2742013-03-01 08:57:31 -08002087 return id == -ENOSPC ? -EBUSY : id;
2088
2089 return i2c_register_adapter(adap);
2090}
2091
2092/**
David Brownell6e13e642007-05-01 23:26:31 +02002093 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
2094 * @adapter: the adapter to add
David Brownelld64f73b2007-07-12 14:12:28 +02002095 * Context: can sleep
David Brownell6e13e642007-05-01 23:26:31 +02002096 *
2097 * This routine is used to declare an I2C adapter when its bus number
Doug Andersonee5c2742013-03-01 08:57:31 -08002098 * doesn't matter or when its bus number is specified by an dt alias.
2099 * Examples of bases when the bus number doesn't matter: I2C adapters
2100 * dynamically added by USB links or PCI plugin cards.
David Brownell6e13e642007-05-01 23:26:31 +02002101 *
2102 * When this returns zero, a new bus number was allocated and stored
2103 * in adap->nr, and the specified adapter became available for clients.
2104 * Otherwise, a negative errno value is returned.
2105 */
2106int i2c_add_adapter(struct i2c_adapter *adapter)
2107{
Doug Andersonee5c2742013-03-01 08:57:31 -08002108 struct device *dev = &adapter->dev;
Tejun Heo4ae42b02013-02-27 17:04:15 -08002109 int id;
David Brownell6e13e642007-05-01 23:26:31 +02002110
Doug Andersonee5c2742013-03-01 08:57:31 -08002111 if (dev->of_node) {
2112 id = of_alias_get_id(dev->of_node, "i2c");
2113 if (id >= 0) {
2114 adapter->nr = id;
2115 return __i2c_add_numbered_adapter(adapter);
2116 }
2117 }
2118
Jean Delvarecaada322008-01-27 18:14:49 +01002119 mutex_lock(&core_lock);
Tejun Heo4ae42b02013-02-27 17:04:15 -08002120 id = idr_alloc(&i2c_adapter_idr, adapter,
2121 __i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
Jean Delvarecaada322008-01-27 18:14:49 +01002122 mutex_unlock(&core_lock);
Wolfram Sang84d0b612016-07-09 13:35:01 +09002123 if (WARN(id < 0, "couldn't get idr"))
Tejun Heo4ae42b02013-02-27 17:04:15 -08002124 return id;
David Brownell6e13e642007-05-01 23:26:31 +02002125
2126 adapter->nr = id;
Tejun Heo4ae42b02013-02-27 17:04:15 -08002127
David Brownell6e13e642007-05-01 23:26:31 +02002128 return i2c_register_adapter(adapter);
2129}
2130EXPORT_SYMBOL(i2c_add_adapter);
2131
2132/**
2133 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
2134 * @adap: the adapter to register (with adap->nr initialized)
David Brownelld64f73b2007-07-12 14:12:28 +02002135 * Context: can sleep
David Brownell6e13e642007-05-01 23:26:31 +02002136 *
2137 * This routine is used to declare an I2C adapter when its bus number
Randy Dunlap8c07e462008-03-23 20:28:20 +01002138 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
2139 * or otherwise built in to the system's mainboard, and where i2c_board_info
David Brownell6e13e642007-05-01 23:26:31 +02002140 * is used to properly configure I2C devices.
2141 *
Grant Likely488bf312011-07-25 17:49:43 +02002142 * If the requested bus number is set to -1, then this function will behave
2143 * identically to i2c_add_adapter, and will dynamically assign a bus number.
2144 *
David Brownell6e13e642007-05-01 23:26:31 +02002145 * If no devices have pre-been declared for this bus, then be sure to
2146 * register the adapter before any dynamically allocated ones. Otherwise
2147 * the required bus ID may not be available.
2148 *
2149 * When this returns zero, the specified adapter became available for
2150 * clients using the bus number provided in adap->nr. Also, the table
2151 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
2152 * and the appropriate driver model device nodes are created. Otherwise, a
2153 * negative errno value is returned.
2154 */
2155int i2c_add_numbered_adapter(struct i2c_adapter *adap)
2156{
Grant Likely488bf312011-07-25 17:49:43 +02002157 if (adap->nr == -1) /* -1 means dynamically assign bus id */
2158 return i2c_add_adapter(adap);
David Brownell6e13e642007-05-01 23:26:31 +02002159
Doug Andersonee5c2742013-03-01 08:57:31 -08002160 return __i2c_add_numbered_adapter(adap);
David Brownell6e13e642007-05-01 23:26:31 +02002161}
2162EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
2163
Lars-Peter Clausen19baba42013-03-09 08:16:44 +00002164static void i2c_do_del_adapter(struct i2c_driver *driver,
Jean Delvare69b00892009-12-06 17:06:27 +01002165 struct i2c_adapter *adapter)
Jean Delvare026526f2008-01-27 18:14:49 +01002166{
Jean Delvare4735c982008-07-14 22:38:36 +02002167 struct i2c_client *client, *_n;
Jean Delvare026526f2008-01-27 18:14:49 +01002168
Jean Delvareacec2112009-03-28 21:34:40 +01002169 /* Remove the devices we created ourselves as the result of hardware
2170 * probing (using a driver's detect method) */
Jean Delvare4735c982008-07-14 22:38:36 +02002171 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
2172 if (client->adapter == adapter) {
2173 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
2174 client->name, client->addr);
2175 list_del(&client->detected);
2176 i2c_unregister_device(client);
2177 }
2178 }
Jean Delvare026526f2008-01-27 18:14:49 +01002179}
2180
Jean Delvaree549c2b2009-06-19 16:58:19 +02002181static int __unregister_client(struct device *dev, void *dummy)
2182{
2183 struct i2c_client *client = i2c_verify_client(dev);
Jean Delvare5219bf82011-01-14 22:03:49 +01002184 if (client && strcmp(client->name, "dummy"))
2185 i2c_unregister_device(client);
2186 return 0;
2187}
2188
2189static int __unregister_dummy(struct device *dev, void *dummy)
2190{
2191 struct i2c_client *client = i2c_verify_client(dev);
Jean Delvaree549c2b2009-06-19 16:58:19 +02002192 if (client)
2193 i2c_unregister_device(client);
2194 return 0;
2195}
2196
Jean Delvare69b00892009-12-06 17:06:27 +01002197static int __process_removed_adapter(struct device_driver *d, void *data)
2198{
Lars-Peter Clausen19baba42013-03-09 08:16:44 +00002199 i2c_do_del_adapter(to_i2c_driver(d), data);
2200 return 0;
Jean Delvare69b00892009-12-06 17:06:27 +01002201}
2202
David Brownelld64f73b2007-07-12 14:12:28 +02002203/**
2204 * i2c_del_adapter - unregister I2C adapter
2205 * @adap: the adapter being unregistered
2206 * Context: can sleep
2207 *
2208 * This unregisters an I2C adapter which was previously registered
2209 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
2210 */
Lars-Peter Clausen71546302013-03-09 08:16:47 +00002211void i2c_del_adapter(struct i2c_adapter *adap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002212{
Jean Delvare35fc37f2009-06-19 16:58:19 +02002213 struct i2c_adapter *found;
Jean Delvarebbd2d9c2009-11-26 09:22:33 +01002214 struct i2c_client *client, *next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002215
2216 /* First make sure that this adapter was ever added */
Jean Delvare35fc37f2009-06-19 16:58:19 +02002217 mutex_lock(&core_lock);
2218 found = idr_find(&i2c_adapter_idr, adap->nr);
2219 mutex_unlock(&core_lock);
2220 if (found != adap) {
Wolfram Sang44239a52016-07-09 13:35:04 +09002221 pr_debug("attempting to delete unregistered adapter [%s]\n", adap->name);
Lars-Peter Clausen71546302013-03-09 08:16:47 +00002222 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002223 }
2224
Jarkko Nikulaaec809f2016-08-12 17:02:52 +03002225 i2c_acpi_remove_space_handler(adap);
Jean Delvare026526f2008-01-27 18:14:49 +01002226 /* Tell drivers about this removal */
Jean Delvare35fc37f2009-06-19 16:58:19 +02002227 mutex_lock(&core_lock);
Lars-Peter Clausen19baba42013-03-09 08:16:44 +00002228 bus_for_each_drv(&i2c_bus_type, NULL, adap,
Jean Delvare69b00892009-12-06 17:06:27 +01002229 __process_removed_adapter);
Jean Delvare35fc37f2009-06-19 16:58:19 +02002230 mutex_unlock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002231
Jean Delvarebbd2d9c2009-11-26 09:22:33 +01002232 /* Remove devices instantiated from sysfs */
Jean Delvare390946b2012-09-10 10:14:02 +02002233 mutex_lock_nested(&adap->userspace_clients_lock,
2234 i2c_adapter_depth(adap));
Jean Delvare6629dcf2010-05-04 11:09:28 +02002235 list_for_each_entry_safe(client, next, &adap->userspace_clients,
2236 detected) {
2237 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
2238 client->addr);
2239 list_del(&client->detected);
2240 i2c_unregister_device(client);
Jean Delvarebbd2d9c2009-11-26 09:22:33 +01002241 }
Jean Delvaredafc50d2010-08-11 18:21:01 +02002242 mutex_unlock(&adap->userspace_clients_lock);
Jean Delvarebbd2d9c2009-11-26 09:22:33 +01002243
Jean Delvaree549c2b2009-06-19 16:58:19 +02002244 /* Detach any active clients. This can't fail, thus we do not
Jean Delvare5219bf82011-01-14 22:03:49 +01002245 * check the returned value. This is a two-pass process, because
2246 * we can't remove the dummy devices during the first pass: they
2247 * could have been instantiated by real devices wishing to clean
2248 * them up properly, so we give them a chance to do that first. */
Lars-Peter Clausen19baba42013-03-09 08:16:44 +00002249 device_for_each_child(&adap->dev, NULL, __unregister_client);
2250 device_for_each_child(&adap->dev, NULL, __unregister_dummy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002251
Jean Delvare2bb50952009-09-18 22:45:46 +02002252#ifdef CONFIG_I2C_COMPAT
2253 class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
2254 adap->dev.parent);
2255#endif
2256
Thadeu Lima de Souza Cascardoc5567522010-01-16 20:43:13 +01002257 /* device name is gone after device_unregister */
2258 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
2259
Wolfram Sang9f924162015-12-23 18:19:28 +01002260 pm_runtime_disable(&adap->dev);
2261
Benjamin Tissoires4d5538f2016-10-13 14:10:40 +02002262 i2c_host_notify_irq_teardown(adap);
2263
Wolfram Sang26680ee2015-01-29 22:45:09 +01002264 /* wait until all references to the device are gone
2265 *
2266 * FIXME: This is old code and should ideally be replaced by an
2267 * alternative which results in decoupling the lifetime of the struct
2268 * device from the i2c_adapter, like spi or netdev do. Any solution
Shailendra Verma95cc1e32015-05-18 22:24:01 +05302269 * should be thoroughly tested with DEBUG_KOBJECT_RELEASE enabled!
Wolfram Sang26680ee2015-01-29 22:45:09 +01002270 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002271 init_completion(&adap->dev_released);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002272 device_unregister(&adap->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002273 wait_for_completion(&adap->dev_released);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002274
David Brownell6e13e642007-05-01 23:26:31 +02002275 /* free bus id */
Jean Delvare35fc37f2009-06-19 16:58:19 +02002276 mutex_lock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002277 idr_remove(&i2c_adapter_idr, adap->nr);
Jean Delvare35fc37f2009-06-19 16:58:19 +02002278 mutex_unlock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002279
Jean Delvarebd4bc3db2008-07-16 19:30:05 +02002280 /* Clear the device structure in case this adapter is ever going to be
2281 added again */
2282 memset(&adap->dev, 0, sizeof(adap->dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283}
David Brownellc0564602007-05-01 23:26:31 +02002284EXPORT_SYMBOL(i2c_del_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002285
Wolfram Sang54177cc2015-12-17 13:32:36 +01002286/**
2287 * i2c_parse_fw_timings - get I2C related timing parameters from firmware
2288 * @dev: The device to scan for I2C timing properties
2289 * @t: the i2c_timings struct to be filled with values
2290 * @use_defaults: bool to use sane defaults derived from the I2C specification
2291 * when properties are not found, otherwise use 0
2292 *
2293 * Scan the device for the generic I2C properties describing timing parameters
2294 * for the signal and fill the given struct with the results. If a property was
2295 * not found and use_defaults was true, then maximum timings are assumed which
2296 * are derived from the I2C specification. If use_defaults is not used, the
2297 * results will be 0, so drivers can apply their own defaults later. The latter
2298 * is mainly intended for avoiding regressions of existing drivers which want
2299 * to switch to this function. New drivers almost always should use the defaults.
2300 */
2301
2302void i2c_parse_fw_timings(struct device *dev, struct i2c_timings *t, bool use_defaults)
2303{
2304 int ret;
2305
2306 memset(t, 0, sizeof(*t));
2307
2308 ret = device_property_read_u32(dev, "clock-frequency", &t->bus_freq_hz);
2309 if (ret && use_defaults)
2310 t->bus_freq_hz = 100000;
2311
2312 ret = device_property_read_u32(dev, "i2c-scl-rising-time-ns", &t->scl_rise_ns);
2313 if (ret && use_defaults) {
2314 if (t->bus_freq_hz <= 100000)
2315 t->scl_rise_ns = 1000;
2316 else if (t->bus_freq_hz <= 400000)
2317 t->scl_rise_ns = 300;
2318 else
2319 t->scl_rise_ns = 120;
2320 }
2321
2322 ret = device_property_read_u32(dev, "i2c-scl-falling-time-ns", &t->scl_fall_ns);
2323 if (ret && use_defaults) {
2324 if (t->bus_freq_hz <= 400000)
2325 t->scl_fall_ns = 300;
2326 else
2327 t->scl_fall_ns = 120;
2328 }
2329
2330 device_property_read_u32(dev, "i2c-scl-internal-delay-ns", &t->scl_int_delay_ns);
2331
2332 ret = device_property_read_u32(dev, "i2c-sda-falling-time-ns", &t->sda_fall_ns);
2333 if (ret && use_defaults)
2334 t->sda_fall_ns = t->scl_fall_ns;
2335}
2336EXPORT_SYMBOL_GPL(i2c_parse_fw_timings);
2337
David Brownell7b4fbc52007-05-01 23:26:30 +02002338/* ------------------------------------------------------------------------- */
2339
Jean Delvare7ae31482011-03-20 14:50:52 +01002340int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
2341{
2342 int res;
2343
2344 mutex_lock(&core_lock);
2345 res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
2346 mutex_unlock(&core_lock);
2347
2348 return res;
2349}
2350EXPORT_SYMBOL_GPL(i2c_for_each_dev);
2351
Jean Delvare69b00892009-12-06 17:06:27 +01002352static int __process_new_driver(struct device *dev, void *data)
Dave Young7f101a92008-07-14 22:38:19 +02002353{
Jean Delvare4f8cf822009-09-18 22:45:46 +02002354 if (dev->type != &i2c_adapter_type)
2355 return 0;
Jean Delvare69b00892009-12-06 17:06:27 +01002356 return i2c_do_add_adapter(data, to_i2c_adapter(dev));
Dave Young7f101a92008-07-14 22:38:19 +02002357}
2358
David Brownell7b4fbc52007-05-01 23:26:30 +02002359/*
2360 * An i2c_driver is used with one or more i2c_client (device) nodes to access
Jean Delvare729d6dd2009-06-19 16:58:18 +02002361 * i2c slave chips, on a bus instance associated with some i2c_adapter.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002362 */
2363
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -08002364int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002365{
Jean Delvare7eebcb72006-02-05 23:28:21 +01002366 int res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002367
David Brownell1d0b19c2008-10-14 17:30:05 +02002368 /* Can't register until after driver model init */
Sudip Mukherjee95026652016-03-07 17:19:17 +05302369 if (WARN_ON(!is_registered))
David Brownell1d0b19c2008-10-14 17:30:05 +02002370 return -EAGAIN;
2371
Linus Torvalds1da177e2005-04-16 15:20:36 -07002372 /* add the driver to the list of i2c drivers in the driver core */
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -08002373 driver->driver.owner = owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002374 driver->driver.bus = &i2c_bus_type;
Vladimir Zapolskiy147b36d2016-10-31 21:46:24 +02002375 INIT_LIST_HEAD(&driver->clients);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002376
Jean Delvare729d6dd2009-06-19 16:58:18 +02002377 /* When registration returns, the driver core
David Brownell6e13e642007-05-01 23:26:31 +02002378 * will have called probe() for all matching-but-unbound devices.
2379 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002380 res = driver_register(&driver->driver);
2381 if (res)
Jean Delvare7eebcb72006-02-05 23:28:21 +01002382 return res;
David Brownell438d6c22006-12-10 21:21:31 +01002383
Wolfram Sang44239a52016-07-09 13:35:04 +09002384 pr_debug("driver [%s] registered\n", driver->driver.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002385
Jean Delvare4735c982008-07-14 22:38:36 +02002386 /* Walk the adapters that are already present */
Jean Delvare7ae31482011-03-20 14:50:52 +01002387 i2c_for_each_dev(driver, __process_new_driver);
Jean Delvare35fc37f2009-06-19 16:58:19 +02002388
Jean Delvare7eebcb72006-02-05 23:28:21 +01002389 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002390}
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -08002391EXPORT_SYMBOL(i2c_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002392
Jean Delvare69b00892009-12-06 17:06:27 +01002393static int __process_removed_driver(struct device *dev, void *data)
Dave Young7f101a92008-07-14 22:38:19 +02002394{
Lars-Peter Clausen19baba42013-03-09 08:16:44 +00002395 if (dev->type == &i2c_adapter_type)
2396 i2c_do_del_adapter(data, to_i2c_adapter(dev));
2397 return 0;
Dave Young7f101a92008-07-14 22:38:19 +02002398}
2399
David Brownella1d9e6e2007-05-01 23:26:30 +02002400/**
2401 * i2c_del_driver - unregister I2C driver
2402 * @driver: the driver being unregistered
David Brownelld64f73b2007-07-12 14:12:28 +02002403 * Context: can sleep
David Brownella1d9e6e2007-05-01 23:26:30 +02002404 */
Jean Delvareb3e82092007-05-01 23:26:32 +02002405void i2c_del_driver(struct i2c_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002406{
Jean Delvare7ae31482011-03-20 14:50:52 +01002407 i2c_for_each_dev(driver, __process_removed_driver);
David Brownella1d9e6e2007-05-01 23:26:30 +02002408
Linus Torvalds1da177e2005-04-16 15:20:36 -07002409 driver_unregister(&driver->driver);
Wolfram Sang44239a52016-07-09 13:35:04 +09002410 pr_debug("driver [%s] unregistered\n", driver->driver.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002411}
David Brownellc0564602007-05-01 23:26:31 +02002412EXPORT_SYMBOL(i2c_del_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002413
David Brownell7b4fbc52007-05-01 23:26:30 +02002414/* ------------------------------------------------------------------------- */
2415
Jean Delvaree48d3312008-01-27 18:14:48 +01002416/**
2417 * i2c_use_client - increments the reference count of the i2c client structure
2418 * @client: the client being referenced
2419 *
2420 * Each live reference to a client should be refcounted. The driver model does
2421 * that automatically as part of driver binding, so that most drivers don't
2422 * need to do this explicitly: they hold a reference until they're unbound
2423 * from the device.
2424 *
2425 * A pointer to the client with the incremented reference counter is returned.
2426 */
2427struct i2c_client *i2c_use_client(struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002428{
David Brownell6ea438e2008-07-14 22:38:24 +02002429 if (client && get_device(&client->dev))
2430 return client;
2431 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002432}
David Brownellc0564602007-05-01 23:26:31 +02002433EXPORT_SYMBOL(i2c_use_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002434
Jean Delvaree48d3312008-01-27 18:14:48 +01002435/**
2436 * i2c_release_client - release a use of the i2c client structure
2437 * @client: the client being no longer referenced
2438 *
2439 * Must be called when a user of a client is finished with it.
2440 */
2441void i2c_release_client(struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002442{
David Brownell6ea438e2008-07-14 22:38:24 +02002443 if (client)
2444 put_device(&client->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002445}
David Brownellc0564602007-05-01 23:26:31 +02002446EXPORT_SYMBOL(i2c_release_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002447
David Brownell9b766b82008-01-27 18:14:51 +01002448struct i2c_cmd_arg {
2449 unsigned cmd;
2450 void *arg;
2451};
2452
2453static int i2c_cmd(struct device *dev, void *_arg)
2454{
2455 struct i2c_client *client = i2c_verify_client(dev);
2456 struct i2c_cmd_arg *arg = _arg;
Lars-Peter Clausen0acc2b32013-09-29 10:51:06 +02002457 struct i2c_driver *driver;
David Brownell9b766b82008-01-27 18:14:51 +01002458
Lars-Peter Clausen0acc2b32013-09-29 10:51:06 +02002459 if (!client || !client->dev.driver)
2460 return 0;
2461
2462 driver = to_i2c_driver(client->dev.driver);
2463 if (driver->command)
2464 driver->command(client, arg->cmd, arg->arg);
David Brownell9b766b82008-01-27 18:14:51 +01002465 return 0;
2466}
2467
Linus Torvalds1da177e2005-04-16 15:20:36 -07002468void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
2469{
David Brownell9b766b82008-01-27 18:14:51 +01002470 struct i2c_cmd_arg cmd_arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002471
David Brownell9b766b82008-01-27 18:14:51 +01002472 cmd_arg.cmd = cmd;
2473 cmd_arg.arg = arg;
2474 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002475}
David Brownellc0564602007-05-01 23:26:31 +02002476EXPORT_SYMBOL(i2c_clients_command);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002477
Pantelis Antoniouea7513b2014-10-28 22:36:03 +02002478#if IS_ENABLED(CONFIG_OF_DYNAMIC)
2479static int of_i2c_notify(struct notifier_block *nb, unsigned long action,
2480 void *arg)
2481{
2482 struct of_reconfig_data *rd = arg;
2483 struct i2c_adapter *adap;
2484 struct i2c_client *client;
2485
2486 switch (of_reconfig_get_state_change(action, rd)) {
2487 case OF_RECONFIG_CHANGE_ADD:
2488 adap = of_find_i2c_adapter_by_node(rd->dn->parent);
2489 if (adap == NULL)
2490 return NOTIFY_OK; /* not for us */
2491
Pantelis Antoniou4f001fd2015-01-24 09:16:29 +02002492 if (of_node_test_and_set_flag(rd->dn, OF_POPULATED)) {
2493 put_device(&adap->dev);
2494 return NOTIFY_OK;
2495 }
2496
Pantelis Antoniouea7513b2014-10-28 22:36:03 +02002497 client = of_i2c_register_device(adap, rd->dn);
2498 put_device(&adap->dev);
2499
2500 if (IS_ERR(client)) {
Wolfram Sang399d62a2016-07-09 13:35:02 +09002501 dev_err(&adap->dev, "failed to create client for '%s'\n",
2502 rd->dn->full_name);
Ralf Ramsauer6a676fb2016-10-17 15:59:57 +02002503 of_node_clear_flag(rd->dn, OF_POPULATED);
Pantelis Antoniouea7513b2014-10-28 22:36:03 +02002504 return notifier_from_errno(PTR_ERR(client));
2505 }
2506 break;
2507 case OF_RECONFIG_CHANGE_REMOVE:
Pantelis Antoniou4f001fd2015-01-24 09:16:29 +02002508 /* already depopulated? */
2509 if (!of_node_check_flag(rd->dn, OF_POPULATED))
2510 return NOTIFY_OK;
2511
Pantelis Antoniouea7513b2014-10-28 22:36:03 +02002512 /* find our device by node */
2513 client = of_find_i2c_device_by_node(rd->dn);
2514 if (client == NULL)
2515 return NOTIFY_OK; /* no? not meant for us */
2516
2517 /* unregister takes one ref away */
2518 i2c_unregister_device(client);
2519
2520 /* and put the reference of the find */
2521 put_device(&client->dev);
2522 break;
2523 }
2524
2525 return NOTIFY_OK;
2526}
2527static struct notifier_block i2c_of_notifier = {
2528 .notifier_call = of_i2c_notify,
2529};
2530#else
2531extern struct notifier_block i2c_of_notifier;
2532#endif /* CONFIG_OF_DYNAMIC */
2533
Linus Torvalds1da177e2005-04-16 15:20:36 -07002534static int __init i2c_init(void)
2535{
2536 int retval;
2537
Wolfram Sang03bde7c2015-03-12 17:17:59 +01002538 retval = of_alias_get_highest_id("i2c");
2539
2540 down_write(&__i2c_board_lock);
2541 if (retval >= __i2c_first_dynamic_bus_num)
2542 __i2c_first_dynamic_bus_num = retval + 1;
2543 up_write(&__i2c_board_lock);
2544
Linus Torvalds1da177e2005-04-16 15:20:36 -07002545 retval = bus_register(&i2c_bus_type);
2546 if (retval)
2547 return retval;
Wolfram Sangb980a262016-03-14 10:41:52 +01002548
2549 is_registered = true;
2550
Jean Delvare2bb50952009-09-18 22:45:46 +02002551#ifdef CONFIG_I2C_COMPAT
2552 i2c_adapter_compat_class = class_compat_register("i2c-adapter");
2553 if (!i2c_adapter_compat_class) {
2554 retval = -ENOMEM;
2555 goto bus_err;
2556 }
2557#endif
David Brownelle9f13732008-01-27 18:14:52 +01002558 retval = i2c_add_driver(&dummy_driver);
2559 if (retval)
Jean Delvare2bb50952009-09-18 22:45:46 +02002560 goto class_err;
Pantelis Antoniouea7513b2014-10-28 22:36:03 +02002561
2562 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2563 WARN_ON(of_reconfig_notifier_register(&i2c_of_notifier));
Octavian Purdila525e6fa2016-07-08 19:13:10 +03002564 if (IS_ENABLED(CONFIG_ACPI))
2565 WARN_ON(acpi_reconfig_notifier_register(&i2c_acpi_notifier));
Pantelis Antoniouea7513b2014-10-28 22:36:03 +02002566
David Brownelle9f13732008-01-27 18:14:52 +01002567 return 0;
2568
Jean Delvare2bb50952009-09-18 22:45:46 +02002569class_err:
2570#ifdef CONFIG_I2C_COMPAT
2571 class_compat_unregister(i2c_adapter_compat_class);
David Brownelle9f13732008-01-27 18:14:52 +01002572bus_err:
Jean Delvare2bb50952009-09-18 22:45:46 +02002573#endif
Wolfram Sangb980a262016-03-14 10:41:52 +01002574 is_registered = false;
David Brownelle9f13732008-01-27 18:14:52 +01002575 bus_unregister(&i2c_bus_type);
2576 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002577}
2578
2579static void __exit i2c_exit(void)
2580{
Octavian Purdila525e6fa2016-07-08 19:13:10 +03002581 if (IS_ENABLED(CONFIG_ACPI))
2582 WARN_ON(acpi_reconfig_notifier_unregister(&i2c_acpi_notifier));
Pantelis Antoniouea7513b2014-10-28 22:36:03 +02002583 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2584 WARN_ON(of_reconfig_notifier_unregister(&i2c_of_notifier));
David Brownelle9f13732008-01-27 18:14:52 +01002585 i2c_del_driver(&dummy_driver);
Jean Delvare2bb50952009-09-18 22:45:46 +02002586#ifdef CONFIG_I2C_COMPAT
2587 class_compat_unregister(i2c_adapter_compat_class);
2588#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002589 bus_unregister(&i2c_bus_type);
David Howellsd9a83d62014-03-06 13:35:59 +00002590 tracepoint_synchronize_unregister();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002591}
2592
David Brownella10f9e72008-10-14 17:30:06 +02002593/* We must initialize early, because some subsystems register i2c drivers
2594 * in subsys_initcall() code, but are linked (and initialized) before i2c.
2595 */
2596postcore_initcall(i2c_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002597module_exit(i2c_exit);
2598
2599/* ----------------------------------------------------
2600 * the functional interface to the i2c busses.
2601 * ----------------------------------------------------
2602 */
2603
Wolfram Sangb7f62582015-01-05 23:45:59 +01002604/* Check if val is exceeding the quirk IFF quirk is non 0 */
2605#define i2c_quirk_exceeded(val, quirk) ((quirk) && ((val) > (quirk)))
2606
2607static int i2c_quirk_error(struct i2c_adapter *adap, struct i2c_msg *msg, char *err_msg)
2608{
2609 dev_err_ratelimited(&adap->dev, "adapter quirk: %s (addr 0x%04x, size %u, %s)\n",
2610 err_msg, msg->addr, msg->len,
2611 msg->flags & I2C_M_RD ? "read" : "write");
2612 return -EOPNOTSUPP;
2613}
2614
2615static int i2c_check_for_quirks(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2616{
2617 const struct i2c_adapter_quirks *q = adap->quirks;
2618 int max_num = q->max_num_msgs, i;
2619 bool do_len_check = true;
2620
2621 if (q->flags & I2C_AQ_COMB) {
2622 max_num = 2;
2623
2624 /* special checks for combined messages */
2625 if (num == 2) {
2626 if (q->flags & I2C_AQ_COMB_WRITE_FIRST && msgs[0].flags & I2C_M_RD)
2627 return i2c_quirk_error(adap, &msgs[0], "1st comb msg must be write");
2628
2629 if (q->flags & I2C_AQ_COMB_READ_SECOND && !(msgs[1].flags & I2C_M_RD))
2630 return i2c_quirk_error(adap, &msgs[1], "2nd comb msg must be read");
2631
2632 if (q->flags & I2C_AQ_COMB_SAME_ADDR && msgs[0].addr != msgs[1].addr)
2633 return i2c_quirk_error(adap, &msgs[0], "comb msg only to same addr");
2634
2635 if (i2c_quirk_exceeded(msgs[0].len, q->max_comb_1st_msg_len))
2636 return i2c_quirk_error(adap, &msgs[0], "msg too long");
2637
2638 if (i2c_quirk_exceeded(msgs[1].len, q->max_comb_2nd_msg_len))
2639 return i2c_quirk_error(adap, &msgs[1], "msg too long");
2640
2641 do_len_check = false;
2642 }
2643 }
2644
2645 if (i2c_quirk_exceeded(num, max_num))
2646 return i2c_quirk_error(adap, &msgs[0], "too many messages");
2647
2648 for (i = 0; i < num; i++) {
2649 u16 len = msgs[i].len;
2650
2651 if (msgs[i].flags & I2C_M_RD) {
2652 if (do_len_check && i2c_quirk_exceeded(len, q->max_read_len))
2653 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2654 } else {
2655 if (do_len_check && i2c_quirk_exceeded(len, q->max_write_len))
2656 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2657 }
2658 }
2659
2660 return 0;
2661}
2662
David Brownella1cdeda2008-07-14 22:38:24 +02002663/**
Jean Delvareb37d2a32012-06-29 07:47:19 -03002664 * __i2c_transfer - unlocked flavor of i2c_transfer
2665 * @adap: Handle to I2C bus
2666 * @msgs: One or more messages to execute before STOP is issued to
2667 * terminate the operation; each message begins with a START.
2668 * @num: Number of messages to be executed.
2669 *
2670 * Returns negative errno, else the number of messages executed.
2671 *
2672 * Adapter lock must be held when calling this function. No debug logging
2673 * takes place. adap->algo->master_xfer existence isn't checked.
2674 */
2675int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2676{
2677 unsigned long orig_jiffies;
2678 int ret, try;
2679
Wolfram Sangb7f62582015-01-05 23:45:59 +01002680 if (adap->quirks && i2c_check_for_quirks(adap, msgs, num))
2681 return -EOPNOTSUPP;
2682
David Howellsd9a83d62014-03-06 13:35:59 +00002683 /* i2c_trace_msg gets enabled when tracepoint i2c_transfer gets
2684 * enabled. This is an efficient way of keeping the for-loop from
2685 * being executed when not needed.
2686 */
2687 if (static_key_false(&i2c_trace_msg)) {
2688 int i;
2689 for (i = 0; i < num; i++)
2690 if (msgs[i].flags & I2C_M_RD)
2691 trace_i2c_read(adap, &msgs[i], i);
2692 else
2693 trace_i2c_write(adap, &msgs[i], i);
2694 }
2695
Jean Delvareb37d2a32012-06-29 07:47:19 -03002696 /* Retry automatically on arbitration loss */
2697 orig_jiffies = jiffies;
2698 for (ret = 0, try = 0; try <= adap->retries; try++) {
2699 ret = adap->algo->master_xfer(adap, msgs, num);
2700 if (ret != -EAGAIN)
2701 break;
2702 if (time_after(jiffies, orig_jiffies + adap->timeout))
2703 break;
2704 }
2705
David Howellsd9a83d62014-03-06 13:35:59 +00002706 if (static_key_false(&i2c_trace_msg)) {
2707 int i;
2708 for (i = 0; i < ret; i++)
2709 if (msgs[i].flags & I2C_M_RD)
2710 trace_i2c_reply(adap, &msgs[i], i);
2711 trace_i2c_result(adap, i, ret);
2712 }
2713
Jean Delvareb37d2a32012-06-29 07:47:19 -03002714 return ret;
2715}
2716EXPORT_SYMBOL(__i2c_transfer);
2717
2718/**
David Brownella1cdeda2008-07-14 22:38:24 +02002719 * i2c_transfer - execute a single or combined I2C message
2720 * @adap: Handle to I2C bus
2721 * @msgs: One or more messages to execute before STOP is issued to
2722 * terminate the operation; each message begins with a START.
2723 * @num: Number of messages to be executed.
2724 *
2725 * Returns negative errno, else the number of messages executed.
2726 *
2727 * Note that there is no requirement that each message be sent to
2728 * the same slave address, although that is the most common model.
2729 */
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01002730int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002731{
Jean Delvareb37d2a32012-06-29 07:47:19 -03002732 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002733
David Brownella1cdeda2008-07-14 22:38:24 +02002734 /* REVISIT the fault reporting model here is weak:
2735 *
2736 * - When we get an error after receiving N bytes from a slave,
2737 * there is no way to report "N".
2738 *
2739 * - When we get a NAK after transmitting N bytes to a slave,
2740 * there is no way to report "N" ... or to let the master
2741 * continue executing the rest of this combined message, if
2742 * that's the appropriate response.
2743 *
2744 * - When for example "num" is two and we successfully complete
2745 * the first message but get an error part way through the
2746 * second, it's unclear whether that should be reported as
2747 * one (discarding status on the second message) or errno
2748 * (discarding status on the first one).
2749 */
2750
Linus Torvalds1da177e2005-04-16 15:20:36 -07002751 if (adap->algo->master_xfer) {
2752#ifdef DEBUG
2753 for (ret = 0; ret < num; ret++) {
Andy Shevchenkob93d3d32016-08-25 17:42:10 +03002754 dev_dbg(&adap->dev,
2755 "master_xfer[%d] %c, addr=0x%02x, len=%d%s\n",
2756 ret, (msgs[ret].flags & I2C_M_RD) ? 'R' : 'W',
2757 msgs[ret].addr, msgs[ret].len,
Jean Delvare209d27c2007-05-01 23:26:29 +02002758 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002759 }
2760#endif
2761
Mike Rapoportcea443a82008-01-27 18:14:50 +01002762 if (in_atomic() || irqs_disabled()) {
Peter Rosinfb79e092016-06-29 15:04:03 +02002763 ret = i2c_trylock_bus(adap, I2C_LOCK_SEGMENT);
Mike Rapoportcea443a82008-01-27 18:14:50 +01002764 if (!ret)
2765 /* I2C activity is ongoing. */
2766 return -EAGAIN;
2767 } else {
Peter Rosin8320f492016-05-04 22:15:27 +02002768 i2c_lock_bus(adap, I2C_LOCK_SEGMENT);
Mike Rapoportcea443a82008-01-27 18:14:50 +01002769 }
2770
Jean Delvareb37d2a32012-06-29 07:47:19 -03002771 ret = __i2c_transfer(adap, msgs, num);
Peter Rosin8320f492016-05-04 22:15:27 +02002772 i2c_unlock_bus(adap, I2C_LOCK_SEGMENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002773
2774 return ret;
2775 } else {
2776 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
David Brownell24a5bb72008-07-14 22:38:23 +02002777 return -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002778 }
2779}
David Brownellc0564602007-05-01 23:26:31 +02002780EXPORT_SYMBOL(i2c_transfer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002781
David Brownella1cdeda2008-07-14 22:38:24 +02002782/**
2783 * i2c_master_send - issue a single I2C message in master transmit mode
2784 * @client: Handle to slave device
2785 * @buf: Data that will be written to the slave
Zhangfei Gao0c43ea52010-03-02 12:23:49 +01002786 * @count: How many bytes to write, must be less than 64k since msg.len is u16
David Brownella1cdeda2008-07-14 22:38:24 +02002787 *
2788 * Returns negative errno, or else the number of bytes written.
2789 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01002790int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002791{
2792 int ret;
Farid Hammane7225acf2010-05-21 18:40:58 +02002793 struct i2c_adapter *adap = client->adapter;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002794 struct i2c_msg msg;
2795
Jean Delvare815f55f2005-05-07 22:58:46 +02002796 msg.addr = client->addr;
2797 msg.flags = client->flags & I2C_M_TEN;
2798 msg.len = count;
2799 msg.buf = (char *)buf;
David Brownell438d6c22006-12-10 21:21:31 +01002800
Jean Delvare815f55f2005-05-07 22:58:46 +02002801 ret = i2c_transfer(adap, &msg, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002802
Wolfram Sang834aa6f2012-03-15 18:11:05 +01002803 /*
2804 * If everything went ok (i.e. 1 msg transmitted), return #bytes
2805 * transmitted, else error code.
2806 */
Jean Delvare815f55f2005-05-07 22:58:46 +02002807 return (ret == 1) ? count : ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002808}
David Brownellc0564602007-05-01 23:26:31 +02002809EXPORT_SYMBOL(i2c_master_send);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002810
David Brownella1cdeda2008-07-14 22:38:24 +02002811/**
2812 * i2c_master_recv - issue a single I2C message in master receive mode
2813 * @client: Handle to slave device
2814 * @buf: Where to store data read from slave
Zhangfei Gao0c43ea52010-03-02 12:23:49 +01002815 * @count: How many bytes to read, must be less than 64k since msg.len is u16
David Brownella1cdeda2008-07-14 22:38:24 +02002816 *
2817 * Returns negative errno, or else the number of bytes read.
2818 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01002819int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002820{
Farid Hammane7225acf2010-05-21 18:40:58 +02002821 struct i2c_adapter *adap = client->adapter;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002822 struct i2c_msg msg;
2823 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002824
Jean Delvare815f55f2005-05-07 22:58:46 +02002825 msg.addr = client->addr;
2826 msg.flags = client->flags & I2C_M_TEN;
2827 msg.flags |= I2C_M_RD;
2828 msg.len = count;
2829 msg.buf = buf;
2830
2831 ret = i2c_transfer(adap, &msg, 1);
2832
Wolfram Sang834aa6f2012-03-15 18:11:05 +01002833 /*
2834 * If everything went ok (i.e. 1 msg received), return #bytes received,
2835 * else error code.
2836 */
Jean Delvare815f55f2005-05-07 22:58:46 +02002837 return (ret == 1) ? count : ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002838}
David Brownellc0564602007-05-01 23:26:31 +02002839EXPORT_SYMBOL(i2c_master_recv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002840
Linus Torvalds1da177e2005-04-16 15:20:36 -07002841/* ----------------------------------------------------
2842 * the i2c address scanning function
2843 * Will not work for 10-bit addresses!
2844 * ----------------------------------------------------
2845 */
Jean Delvare9fc6adf2005-07-31 21:20:43 +02002846
Jean Delvare63e4e802010-06-03 11:33:51 +02002847/*
2848 * Legacy default probe function, mostly relevant for SMBus. The default
2849 * probe method is a quick write, but it is known to corrupt the 24RF08
2850 * EEPROMs due to a state machine bug, and could also irreversibly
2851 * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
2852 * we use a short byte read instead. Also, some bus drivers don't implement
2853 * quick write, so we fallback to a byte read in that case too.
2854 * On x86, there is another special case for FSC hardware monitoring chips,
2855 * which want regular byte reads (address 0x73.) Fortunately, these are the
2856 * only known chips using this I2C address on PC hardware.
2857 * Returns 1 if probe succeeded, 0 if not.
2858 */
2859static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
2860{
2861 int err;
2862 union i2c_smbus_data dummy;
2863
2864#ifdef CONFIG_X86
2865 if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
2866 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
2867 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2868 I2C_SMBUS_BYTE_DATA, &dummy);
2869 else
2870#endif
Jean Delvare8031d792010-08-11 18:21:00 +02002871 if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
2872 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
Jean Delvare63e4e802010-06-03 11:33:51 +02002873 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
2874 I2C_SMBUS_QUICK, NULL);
Jean Delvare8031d792010-08-11 18:21:00 +02002875 else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
2876 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2877 I2C_SMBUS_BYTE, &dummy);
2878 else {
Andy Lutomirskid63a9e82013-07-17 13:27:59 -07002879 dev_warn(&adap->dev, "No suitable probing method supported for address 0x%02X\n",
2880 addr);
Jean Delvare8031d792010-08-11 18:21:00 +02002881 err = -EOPNOTSUPP;
2882 }
Jean Delvare63e4e802010-06-03 11:33:51 +02002883
2884 return err >= 0;
2885}
2886
Jean Delvareccfbbd02009-12-06 17:06:25 +01002887static int i2c_detect_address(struct i2c_client *temp_client,
Jean Delvare4735c982008-07-14 22:38:36 +02002888 struct i2c_driver *driver)
2889{
2890 struct i2c_board_info info;
2891 struct i2c_adapter *adapter = temp_client->adapter;
2892 int addr = temp_client->addr;
2893 int err;
2894
2895 /* Make sure the address is valid */
Wolfram Sang66be60562015-07-17 12:43:22 +02002896 err = i2c_check_7bit_addr_validity_strict(addr);
Jean Delvare656b8762010-06-03 11:33:53 +02002897 if (err) {
Jean Delvare4735c982008-07-14 22:38:36 +02002898 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
2899 addr);
Jean Delvare656b8762010-06-03 11:33:53 +02002900 return err;
Jean Delvare4735c982008-07-14 22:38:36 +02002901 }
2902
Wolfram Sang9bccc702015-07-17 14:48:56 +02002903 /* Skip if already in use (7 bit, no need to encode flags) */
Jean Delvare3b5f7942010-06-03 11:33:55 +02002904 if (i2c_check_addr_busy(adapter, addr))
Jean Delvare4735c982008-07-14 22:38:36 +02002905 return 0;
2906
Jean Delvareccfbbd02009-12-06 17:06:25 +01002907 /* Make sure there is something at this address */
Jean Delvare63e4e802010-06-03 11:33:51 +02002908 if (!i2c_default_probe(adapter, addr))
2909 return 0;
Jean Delvare4735c982008-07-14 22:38:36 +02002910
2911 /* Finally call the custom detection function */
2912 memset(&info, 0, sizeof(struct i2c_board_info));
2913 info.addr = addr;
Jean Delvare310ec792009-12-14 21:17:23 +01002914 err = driver->detect(temp_client, &info);
Jean Delvare4735c982008-07-14 22:38:36 +02002915 if (err) {
2916 /* -ENODEV is returned if the detection fails. We catch it
2917 here as this isn't an error. */
2918 return err == -ENODEV ? 0 : err;
2919 }
2920
2921 /* Consistency check */
2922 if (info.type[0] == '\0') {
Andy Shevchenkob93d3d32016-08-25 17:42:10 +03002923 dev_err(&adapter->dev,
2924 "%s detection function provided no name for 0x%x\n",
2925 driver->driver.name, addr);
Jean Delvare4735c982008-07-14 22:38:36 +02002926 } else {
2927 struct i2c_client *client;
2928
2929 /* Detection succeeded, instantiate the device */
Wolfram Sang0c176172014-02-10 11:03:56 +01002930 if (adapter->class & I2C_CLASS_DEPRECATED)
2931 dev_warn(&adapter->dev,
2932 "This adapter will soon drop class based instantiation of devices. "
2933 "Please make sure client 0x%02x gets instantiated by other means. "
2934 "Check 'Documentation/i2c/instantiating-devices' for details.\n",
2935 info.addr);
2936
Jean Delvare4735c982008-07-14 22:38:36 +02002937 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
2938 info.type, info.addr);
2939 client = i2c_new_device(adapter, &info);
2940 if (client)
2941 list_add_tail(&client->detected, &driver->clients);
2942 else
2943 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
2944 info.type, info.addr);
2945 }
2946 return 0;
2947}
2948
2949static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
2950{
Jean Delvarec3813d62009-12-14 21:17:25 +01002951 const unsigned short *address_list;
Jean Delvare4735c982008-07-14 22:38:36 +02002952 struct i2c_client *temp_client;
2953 int i, err = 0;
2954 int adap_id = i2c_adapter_id(adapter);
2955
Jean Delvarec3813d62009-12-14 21:17:25 +01002956 address_list = driver->address_list;
2957 if (!driver->detect || !address_list)
Jean Delvare4735c982008-07-14 22:38:36 +02002958 return 0;
2959
Wolfram Sang45552272014-07-10 13:46:21 +02002960 /* Warn that the adapter lost class based instantiation */
2961 if (adapter->class == I2C_CLASS_DEPRECATED) {
2962 dev_dbg(&adapter->dev,
Andy Shevchenkob93d3d32016-08-25 17:42:10 +03002963 "This adapter dropped support for I2C classes and won't auto-detect %s devices anymore. "
2964 "If you need it, check 'Documentation/i2c/instantiating-devices' for alternatives.\n",
Wolfram Sang45552272014-07-10 13:46:21 +02002965 driver->driver.name);
2966 return 0;
2967 }
2968
Jean Delvare51b54ba2010-10-24 18:16:58 +02002969 /* Stop here if the classes do not match */
2970 if (!(adapter->class & driver->class))
2971 return 0;
2972
Jean Delvare4735c982008-07-14 22:38:36 +02002973 /* Set up a temporary client to help detect callback */
2974 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
2975 if (!temp_client)
2976 return -ENOMEM;
2977 temp_client->adapter = adapter;
2978
Jean Delvarec3813d62009-12-14 21:17:25 +01002979 for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
Andy Shevchenkob93d3d32016-08-25 17:42:10 +03002980 dev_dbg(&adapter->dev,
2981 "found normal entry for adapter %d, addr 0x%02x\n",
2982 adap_id, address_list[i]);
Jean Delvarec3813d62009-12-14 21:17:25 +01002983 temp_client->addr = address_list[i];
Jean Delvareccfbbd02009-12-06 17:06:25 +01002984 err = i2c_detect_address(temp_client, driver);
Jean Delvare51b54ba2010-10-24 18:16:58 +02002985 if (unlikely(err))
2986 break;
Jean Delvare4735c982008-07-14 22:38:36 +02002987 }
2988
Jean Delvare4735c982008-07-14 22:38:36 +02002989 kfree(temp_client);
2990 return err;
2991}
2992
Jean Delvared44f19d2010-08-11 18:20:57 +02002993int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
2994{
2995 return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2996 I2C_SMBUS_QUICK, NULL) >= 0;
2997}
2998EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
2999
Jean Delvare12b5053a2007-05-01 23:26:31 +02003000struct i2c_client *
3001i2c_new_probed_device(struct i2c_adapter *adap,
3002 struct i2c_board_info *info,
Jean Delvare9a942412010-08-11 18:20:56 +02003003 unsigned short const *addr_list,
3004 int (*probe)(struct i2c_adapter *, unsigned short addr))
Jean Delvare12b5053a2007-05-01 23:26:31 +02003005{
3006 int i;
3007
Jean Delvare8031d792010-08-11 18:21:00 +02003008 if (!probe)
Jean Delvare9a942412010-08-11 18:20:56 +02003009 probe = i2c_default_probe;
Jean Delvare12b5053a2007-05-01 23:26:31 +02003010
Jean Delvare12b5053a2007-05-01 23:26:31 +02003011 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
3012 /* Check address validity */
Wolfram Sang66be60562015-07-17 12:43:22 +02003013 if (i2c_check_7bit_addr_validity_strict(addr_list[i]) < 0) {
Andy Shevchenkob93d3d32016-08-25 17:42:10 +03003014 dev_warn(&adap->dev, "Invalid 7-bit address 0x%02x\n",
3015 addr_list[i]);
Jean Delvare12b5053a2007-05-01 23:26:31 +02003016 continue;
3017 }
3018
Wolfram Sang9bccc702015-07-17 14:48:56 +02003019 /* Check address availability (7 bit, no need to encode flags) */
Jean Delvare3b5f7942010-06-03 11:33:55 +02003020 if (i2c_check_addr_busy(adap, addr_list[i])) {
Andy Shevchenkob93d3d32016-08-25 17:42:10 +03003021 dev_dbg(&adap->dev,
3022 "Address 0x%02x already in use, not probing\n",
3023 addr_list[i]);
Jean Delvare12b5053a2007-05-01 23:26:31 +02003024 continue;
3025 }
3026
Jean Delvare63e4e802010-06-03 11:33:51 +02003027 /* Test address responsiveness */
Jean Delvare9a942412010-08-11 18:20:56 +02003028 if (probe(adap, addr_list[i]))
Jean Delvare63e4e802010-06-03 11:33:51 +02003029 break;
Jean Delvare12b5053a2007-05-01 23:26:31 +02003030 }
Jean Delvare12b5053a2007-05-01 23:26:31 +02003031
3032 if (addr_list[i] == I2C_CLIENT_END) {
3033 dev_dbg(&adap->dev, "Probing failed, no device found\n");
3034 return NULL;
3035 }
3036
3037 info->addr = addr_list[i];
3038 return i2c_new_device(adap, info);
3039}
3040EXPORT_SYMBOL_GPL(i2c_new_probed_device);
3041
Jean Delvared735b342011-03-20 14:50:52 +01003042struct i2c_adapter *i2c_get_adapter(int nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003043{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003044 struct i2c_adapter *adapter;
David Brownell438d6c22006-12-10 21:21:31 +01003045
Jean Delvarecaada322008-01-27 18:14:49 +01003046 mutex_lock(&core_lock);
Jean Delvared735b342011-03-20 14:50:52 +01003047 adapter = idr_find(&i2c_adapter_idr, nr);
Vladimir Zapolskiy611e12e2015-07-27 17:30:49 +03003048 if (!adapter)
3049 goto exit;
3050
3051 if (try_module_get(adapter->owner))
3052 get_device(&adapter->dev);
3053 else
Mark M. Hoffmana0920e12005-06-28 00:21:30 -04003054 adapter = NULL;
3055
Vladimir Zapolskiy611e12e2015-07-27 17:30:49 +03003056 exit:
Jean Delvarecaada322008-01-27 18:14:49 +01003057 mutex_unlock(&core_lock);
Mark M. Hoffmana0920e12005-06-28 00:21:30 -04003058 return adapter;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003059}
David Brownellc0564602007-05-01 23:26:31 +02003060EXPORT_SYMBOL(i2c_get_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003061
3062void i2c_put_adapter(struct i2c_adapter *adap)
3063{
Vladimir Zapolskiy611e12e2015-07-27 17:30:49 +03003064 if (!adap)
3065 return;
3066
3067 put_device(&adap->dev);
3068 module_put(adap->owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003069}
David Brownellc0564602007-05-01 23:26:31 +02003070EXPORT_SYMBOL(i2c_put_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003071
3072/* The SMBus parts */
3073
David Brownell438d6c22006-12-10 21:21:31 +01003074#define POLY (0x1070U << 3)
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01003075static u8 crc8(u16 data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003076{
3077 int i;
David Brownell438d6c22006-12-10 21:21:31 +01003078
Farid Hammane7225acf2010-05-21 18:40:58 +02003079 for (i = 0; i < 8; i++) {
David Brownell438d6c22006-12-10 21:21:31 +01003080 if (data & 0x8000)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003081 data = data ^ POLY;
3082 data = data << 1;
3083 }
3084 return (u8)(data >> 8);
3085}
3086
Jean Delvare421ef472005-10-26 21:28:55 +02003087/* Incremental CRC8 over count bytes in the array pointed to by p */
3088static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003089{
3090 int i;
3091
Farid Hammane7225acf2010-05-21 18:40:58 +02003092 for (i = 0; i < count; i++)
Jean Delvare421ef472005-10-26 21:28:55 +02003093 crc = crc8((crc ^ p[i]) << 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003094 return crc;
3095}
3096
Jean Delvare421ef472005-10-26 21:28:55 +02003097/* Assume a 7-bit address, which is reasonable for SMBus */
3098static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003099{
Jean Delvare421ef472005-10-26 21:28:55 +02003100 /* The address will be sent first */
Wolfram Sang041edda2016-04-03 20:44:46 +02003101 u8 addr = i2c_8bit_addr_from_msg(msg);
Jean Delvare421ef472005-10-26 21:28:55 +02003102 pec = i2c_smbus_pec(pec, &addr, 1);
3103
3104 /* The data buffer follows */
3105 return i2c_smbus_pec(pec, msg->buf, msg->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003106}
3107
Jean Delvare421ef472005-10-26 21:28:55 +02003108/* Used for write only transactions */
3109static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003110{
Jean Delvare421ef472005-10-26 21:28:55 +02003111 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
3112 msg->len++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003113}
3114
Jean Delvare421ef472005-10-26 21:28:55 +02003115/* Return <0 on CRC error
3116 If there was a write before this read (most cases) we need to take the
3117 partial CRC from the write part into account.
3118 Note that this function does modify the message (we need to decrease the
3119 message length to hide the CRC byte from the caller). */
3120static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003121{
Jean Delvare421ef472005-10-26 21:28:55 +02003122 u8 rpec = msg->buf[--msg->len];
3123 cpec = i2c_smbus_msg_pec(cpec, msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003124
Linus Torvalds1da177e2005-04-16 15:20:36 -07003125 if (rpec != cpec) {
Wolfram Sang44239a52016-07-09 13:35:04 +09003126 pr_debug("Bad PEC 0x%02x vs. 0x%02x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003127 rpec, cpec);
David Brownell24a5bb72008-07-14 22:38:23 +02003128 return -EBADMSG;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003129 }
David Brownell438d6c22006-12-10 21:21:31 +01003130 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003131}
3132
David Brownella1cdeda2008-07-14 22:38:24 +02003133/**
3134 * i2c_smbus_read_byte - SMBus "receive byte" protocol
3135 * @client: Handle to slave device
3136 *
3137 * This executes the SMBus "receive byte" protocol, returning negative errno
3138 * else the byte received from the device.
3139 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01003140s32 i2c_smbus_read_byte(const struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003141{
3142 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02003143 int status;
3144
3145 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3146 I2C_SMBUS_READ, 0,
3147 I2C_SMBUS_BYTE, &data);
3148 return (status < 0) ? status : data.byte;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003149}
David Brownellc0564602007-05-01 23:26:31 +02003150EXPORT_SYMBOL(i2c_smbus_read_byte);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003151
David Brownella1cdeda2008-07-14 22:38:24 +02003152/**
3153 * i2c_smbus_write_byte - SMBus "send byte" protocol
3154 * @client: Handle to slave device
3155 * @value: Byte to be sent
3156 *
3157 * This executes the SMBus "send byte" protocol, returning negative errno
3158 * else zero on success.
3159 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01003160s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003161{
Farid Hammane7225acf2010-05-21 18:40:58 +02003162 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
Jean Delvare421ef472005-10-26 21:28:55 +02003163 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003164}
David Brownellc0564602007-05-01 23:26:31 +02003165EXPORT_SYMBOL(i2c_smbus_write_byte);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003166
David Brownella1cdeda2008-07-14 22:38:24 +02003167/**
3168 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
3169 * @client: Handle to slave device
3170 * @command: Byte interpreted by slave
3171 *
3172 * This executes the SMBus "read byte" protocol, returning negative errno
3173 * else a data byte received from the device.
3174 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01003175s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003176{
3177 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02003178 int status;
3179
3180 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3181 I2C_SMBUS_READ, command,
3182 I2C_SMBUS_BYTE_DATA, &data);
3183 return (status < 0) ? status : data.byte;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003184}
David Brownellc0564602007-05-01 23:26:31 +02003185EXPORT_SYMBOL(i2c_smbus_read_byte_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003186
David Brownella1cdeda2008-07-14 22:38:24 +02003187/**
3188 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
3189 * @client: Handle to slave device
3190 * @command: Byte interpreted by slave
3191 * @value: Byte being written
3192 *
3193 * This executes the SMBus "write byte" protocol, returning negative errno
3194 * else zero on success.
3195 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01003196s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
3197 u8 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003198{
3199 union i2c_smbus_data data;
3200 data.byte = value;
Farid Hammane7225acf2010-05-21 18:40:58 +02003201 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3202 I2C_SMBUS_WRITE, command,
3203 I2C_SMBUS_BYTE_DATA, &data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003204}
David Brownellc0564602007-05-01 23:26:31 +02003205EXPORT_SYMBOL(i2c_smbus_write_byte_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003206
David Brownella1cdeda2008-07-14 22:38:24 +02003207/**
3208 * i2c_smbus_read_word_data - SMBus "read word" protocol
3209 * @client: Handle to slave device
3210 * @command: Byte interpreted by slave
3211 *
3212 * This executes the SMBus "read word" protocol, returning negative errno
3213 * else a 16-bit unsigned "word" received from the device.
3214 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01003215s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003216{
3217 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02003218 int status;
3219
3220 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3221 I2C_SMBUS_READ, command,
3222 I2C_SMBUS_WORD_DATA, &data);
3223 return (status < 0) ? status : data.word;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003224}
David Brownellc0564602007-05-01 23:26:31 +02003225EXPORT_SYMBOL(i2c_smbus_read_word_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003226
David Brownella1cdeda2008-07-14 22:38:24 +02003227/**
3228 * i2c_smbus_write_word_data - SMBus "write word" protocol
3229 * @client: Handle to slave device
3230 * @command: Byte interpreted by slave
3231 * @value: 16-bit "word" being written
3232 *
3233 * This executes the SMBus "write word" protocol, returning negative errno
3234 * else zero on success.
3235 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01003236s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
3237 u16 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003238{
3239 union i2c_smbus_data data;
3240 data.word = value;
Farid Hammane7225acf2010-05-21 18:40:58 +02003241 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3242 I2C_SMBUS_WRITE, command,
3243 I2C_SMBUS_WORD_DATA, &data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003244}
David Brownellc0564602007-05-01 23:26:31 +02003245EXPORT_SYMBOL(i2c_smbus_write_word_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003246
David Brownella64ec072007-10-13 23:56:31 +02003247/**
David Brownella1cdeda2008-07-14 22:38:24 +02003248 * i2c_smbus_read_block_data - SMBus "block read" protocol
David Brownella64ec072007-10-13 23:56:31 +02003249 * @client: Handle to slave device
David Brownella1cdeda2008-07-14 22:38:24 +02003250 * @command: Byte interpreted by slave
David Brownella64ec072007-10-13 23:56:31 +02003251 * @values: Byte array into which data will be read; big enough to hold
3252 * the data returned by the slave. SMBus allows at most 32 bytes.
3253 *
David Brownella1cdeda2008-07-14 22:38:24 +02003254 * This executes the SMBus "block read" protocol, returning negative errno
3255 * else the number of data bytes in the slave's response.
David Brownella64ec072007-10-13 23:56:31 +02003256 *
3257 * Note that using this function requires that the client's adapter support
3258 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
3259 * support this; its emulation through I2C messaging relies on a specific
3260 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
3261 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01003262s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
Jean Delvareb86a1bc2007-05-01 23:26:34 +02003263 u8 *values)
3264{
3265 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02003266 int status;
Jean Delvareb86a1bc2007-05-01 23:26:34 +02003267
David Brownell24a5bb72008-07-14 22:38:23 +02003268 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3269 I2C_SMBUS_READ, command,
3270 I2C_SMBUS_BLOCK_DATA, &data);
3271 if (status)
3272 return status;
Jean Delvareb86a1bc2007-05-01 23:26:34 +02003273
3274 memcpy(values, &data.block[1], data.block[0]);
3275 return data.block[0];
3276}
3277EXPORT_SYMBOL(i2c_smbus_read_block_data);
3278
David Brownella1cdeda2008-07-14 22:38:24 +02003279/**
3280 * i2c_smbus_write_block_data - SMBus "block write" protocol
3281 * @client: Handle to slave device
3282 * @command: Byte interpreted by slave
3283 * @length: Size of data block; SMBus allows at most 32 bytes
3284 * @values: Byte array which will be written.
3285 *
3286 * This executes the SMBus "block write" protocol, returning negative errno
3287 * else zero on success.
3288 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01003289s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
Krzysztof Halasa46f5ed72006-06-12 21:42:20 +02003290 u8 length, const u8 *values)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003291{
3292 union i2c_smbus_data data;
Jean Delvare76560322006-01-18 23:14:55 +01003293
Linus Torvalds1da177e2005-04-16 15:20:36 -07003294 if (length > I2C_SMBUS_BLOCK_MAX)
3295 length = I2C_SMBUS_BLOCK_MAX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003296 data.block[0] = length;
Jean Delvare76560322006-01-18 23:14:55 +01003297 memcpy(&data.block[1], values, length);
Farid Hammane7225acf2010-05-21 18:40:58 +02003298 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3299 I2C_SMBUS_WRITE, command,
3300 I2C_SMBUS_BLOCK_DATA, &data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003301}
David Brownellc0564602007-05-01 23:26:31 +02003302EXPORT_SYMBOL(i2c_smbus_write_block_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003303
3304/* Returns the number of read bytes */
Jean Delvare0cc43a12011-01-10 22:11:23 +01003305s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
Jean Delvare4b2643d2007-07-12 14:12:29 +02003306 u8 length, u8 *values)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003307{
3308 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02003309 int status;
Jean Delvare76560322006-01-18 23:14:55 +01003310
Jean Delvare4b2643d2007-07-12 14:12:29 +02003311 if (length > I2C_SMBUS_BLOCK_MAX)
3312 length = I2C_SMBUS_BLOCK_MAX;
3313 data.block[0] = length;
David Brownell24a5bb72008-07-14 22:38:23 +02003314 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3315 I2C_SMBUS_READ, command,
3316 I2C_SMBUS_I2C_BLOCK_DATA, &data);
3317 if (status < 0)
3318 return status;
Jean Delvare76560322006-01-18 23:14:55 +01003319
3320 memcpy(values, &data.block[1], data.block[0]);
3321 return data.block[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003322}
David Brownellc0564602007-05-01 23:26:31 +02003323EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003324
Jean Delvare0cc43a12011-01-10 22:11:23 +01003325s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
Krzysztof Halasa46f5ed72006-06-12 21:42:20 +02003326 u8 length, const u8 *values)
Jean Delvare21bbd692006-01-09 15:19:18 +11003327{
3328 union i2c_smbus_data data;
3329
3330 if (length > I2C_SMBUS_BLOCK_MAX)
3331 length = I2C_SMBUS_BLOCK_MAX;
3332 data.block[0] = length;
3333 memcpy(data.block + 1, values, length);
3334 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3335 I2C_SMBUS_WRITE, command,
3336 I2C_SMBUS_I2C_BLOCK_DATA, &data);
3337}
David Brownellc0564602007-05-01 23:26:31 +02003338EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
Jean Delvare21bbd692006-01-09 15:19:18 +11003339
David Brownell438d6c22006-12-10 21:21:31 +01003340/* Simulate a SMBus command using the i2c protocol
Linus Torvalds1da177e2005-04-16 15:20:36 -07003341 No checking of parameters is done! */
Farid Hammane7225acf2010-05-21 18:40:58 +02003342static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
3343 unsigned short flags,
3344 char read_write, u8 command, int size,
3345 union i2c_smbus_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003346{
3347 /* So we need to generate a series of msgs. In the case of writing, we
3348 need to use only one message; when reading, we need two. We initialize
3349 most things with sane defaults, to keep the code below somewhat
3350 simpler. */
Hideki Iwamoto5c50d182005-09-25 17:01:11 +02003351 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
3352 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
Farid Hammane7225acf2010-05-21 18:40:58 +02003353 int num = read_write == I2C_SMBUS_READ ? 2 : 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003354 int i;
Jean Delvare421ef472005-10-26 21:28:55 +02003355 u8 partial_pec = 0;
David Brownell24a5bb72008-07-14 22:38:23 +02003356 int status;
Shubhrajyoti D230da092012-10-05 22:23:52 +02003357 struct i2c_msg msg[2] = {
3358 {
3359 .addr = addr,
3360 .flags = flags,
3361 .len = 1,
3362 .buf = msgbuf0,
3363 }, {
3364 .addr = addr,
3365 .flags = flags | I2C_M_RD,
3366 .len = 0,
3367 .buf = msgbuf1,
3368 },
3369 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07003370
3371 msgbuf0[0] = command;
Farid Hammane7225acf2010-05-21 18:40:58 +02003372 switch (size) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003373 case I2C_SMBUS_QUICK:
3374 msg[0].len = 0;
3375 /* Special case: The read/write field is used as data */
Roel Kluinf29d2e02009-02-24 19:19:48 +01003376 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
3377 I2C_M_RD : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003378 num = 1;
3379 break;
3380 case I2C_SMBUS_BYTE:
3381 if (read_write == I2C_SMBUS_READ) {
3382 /* Special case: only a read! */
3383 msg[0].flags = I2C_M_RD | flags;
3384 num = 1;
3385 }
3386 break;
3387 case I2C_SMBUS_BYTE_DATA:
3388 if (read_write == I2C_SMBUS_READ)
3389 msg[1].len = 1;
3390 else {
3391 msg[0].len = 2;
3392 msgbuf0[1] = data->byte;
3393 }
3394 break;
3395 case I2C_SMBUS_WORD_DATA:
3396 if (read_write == I2C_SMBUS_READ)
3397 msg[1].len = 2;
3398 else {
Farid Hammane7225acf2010-05-21 18:40:58 +02003399 msg[0].len = 3;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003400 msgbuf0[1] = data->word & 0xff;
Jean Delvare7eff82c2006-09-03 22:24:00 +02003401 msgbuf0[2] = data->word >> 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003402 }
3403 break;
3404 case I2C_SMBUS_PROC_CALL:
3405 num = 2; /* Special case */
3406 read_write = I2C_SMBUS_READ;
3407 msg[0].len = 3;
3408 msg[1].len = 2;
3409 msgbuf0[1] = data->word & 0xff;
Jean Delvare7eff82c2006-09-03 22:24:00 +02003410 msgbuf0[2] = data->word >> 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003411 break;
3412 case I2C_SMBUS_BLOCK_DATA:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003413 if (read_write == I2C_SMBUS_READ) {
Jean Delvare209d27c2007-05-01 23:26:29 +02003414 msg[1].flags |= I2C_M_RECV_LEN;
3415 msg[1].len = 1; /* block length will be added by
3416 the underlying bus driver */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003417 } else {
3418 msg[0].len = data->block[0] + 2;
3419 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
David Brownell24a5bb72008-07-14 22:38:23 +02003420 dev_err(&adapter->dev,
3421 "Invalid block write size %d\n",
3422 data->block[0]);
3423 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003424 }
Hideki Iwamoto5c50d182005-09-25 17:01:11 +02003425 for (i = 1; i < msg[0].len; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003426 msgbuf0[i] = data->block[i-1];
3427 }
3428 break;
3429 case I2C_SMBUS_BLOCK_PROC_CALL:
Jean Delvare209d27c2007-05-01 23:26:29 +02003430 num = 2; /* Another special case */
3431 read_write = I2C_SMBUS_READ;
3432 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
David Brownell24a5bb72008-07-14 22:38:23 +02003433 dev_err(&adapter->dev,
3434 "Invalid block write size %d\n",
Jean Delvare209d27c2007-05-01 23:26:29 +02003435 data->block[0]);
David Brownell24a5bb72008-07-14 22:38:23 +02003436 return -EINVAL;
Jean Delvare209d27c2007-05-01 23:26:29 +02003437 }
3438 msg[0].len = data->block[0] + 2;
3439 for (i = 1; i < msg[0].len; i++)
3440 msgbuf0[i] = data->block[i-1];
3441 msg[1].flags |= I2C_M_RECV_LEN;
3442 msg[1].len = 1; /* block length will be added by
3443 the underlying bus driver */
3444 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003445 case I2C_SMBUS_I2C_BLOCK_DATA:
3446 if (read_write == I2C_SMBUS_READ) {
Jean Delvare4b2643d2007-07-12 14:12:29 +02003447 msg[1].len = data->block[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003448 } else {
3449 msg[0].len = data->block[0] + 1;
Jean Delvare30dac742005-10-08 00:15:59 +02003450 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
David Brownell24a5bb72008-07-14 22:38:23 +02003451 dev_err(&adapter->dev,
3452 "Invalid block write size %d\n",
3453 data->block[0]);
3454 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003455 }
3456 for (i = 1; i <= data->block[0]; i++)
3457 msgbuf0[i] = data->block[i];
3458 }
3459 break;
3460 default:
David Brownell24a5bb72008-07-14 22:38:23 +02003461 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
3462 return -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003463 }
3464
Jean Delvare421ef472005-10-26 21:28:55 +02003465 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
3466 && size != I2C_SMBUS_I2C_BLOCK_DATA);
3467 if (i) {
3468 /* Compute PEC if first message is a write */
3469 if (!(msg[0].flags & I2C_M_RD)) {
David Brownell438d6c22006-12-10 21:21:31 +01003470 if (num == 1) /* Write only */
Jean Delvare421ef472005-10-26 21:28:55 +02003471 i2c_smbus_add_pec(&msg[0]);
3472 else /* Write followed by read */
3473 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
3474 }
3475 /* Ask for PEC if last message is a read */
3476 if (msg[num-1].flags & I2C_M_RD)
David Brownell438d6c22006-12-10 21:21:31 +01003477 msg[num-1].len++;
Jean Delvare421ef472005-10-26 21:28:55 +02003478 }
3479
David Brownell24a5bb72008-07-14 22:38:23 +02003480 status = i2c_transfer(adapter, msg, num);
3481 if (status < 0)
3482 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003483
Jean Delvare421ef472005-10-26 21:28:55 +02003484 /* Check PEC if last message is a read */
3485 if (i && (msg[num-1].flags & I2C_M_RD)) {
David Brownell24a5bb72008-07-14 22:38:23 +02003486 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
3487 if (status < 0)
3488 return status;
Jean Delvare421ef472005-10-26 21:28:55 +02003489 }
3490
Linus Torvalds1da177e2005-04-16 15:20:36 -07003491 if (read_write == I2C_SMBUS_READ)
Farid Hammane7225acf2010-05-21 18:40:58 +02003492 switch (size) {
3493 case I2C_SMBUS_BYTE:
3494 data->byte = msgbuf0[0];
3495 break;
3496 case I2C_SMBUS_BYTE_DATA:
3497 data->byte = msgbuf1[0];
3498 break;
3499 case I2C_SMBUS_WORD_DATA:
3500 case I2C_SMBUS_PROC_CALL:
3501 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
3502 break;
3503 case I2C_SMBUS_I2C_BLOCK_DATA:
3504 for (i = 0; i < data->block[0]; i++)
3505 data->block[i+1] = msgbuf1[i];
3506 break;
3507 case I2C_SMBUS_BLOCK_DATA:
3508 case I2C_SMBUS_BLOCK_PROC_CALL:
3509 for (i = 0; i < msgbuf1[0] + 1; i++)
3510 data->block[i] = msgbuf1[i];
3511 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003512 }
3513 return 0;
3514}
3515
David Brownella1cdeda2008-07-14 22:38:24 +02003516/**
3517 * i2c_smbus_xfer - execute SMBus protocol operations
3518 * @adapter: Handle to I2C bus
3519 * @addr: Address of SMBus slave on that bus
3520 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
3521 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
3522 * @command: Byte interpreted by slave, for protocols which use such bytes
3523 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
3524 * @data: Data to be read or written
3525 *
3526 * This executes an SMBus protocol operation, and returns a negative
3527 * errno code else zero on success.
3528 */
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01003529s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
David Brownella1cdeda2008-07-14 22:38:24 +02003530 char read_write, u8 command, int protocol,
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01003531 union i2c_smbus_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003532{
Clifford Wolf66b650f2009-06-15 18:01:46 +02003533 unsigned long orig_jiffies;
3534 int try;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003535 s32 res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003536
David Howells8a325992014-03-06 13:36:06 +00003537 /* If enabled, the following two tracepoints are conditional on
3538 * read_write and protocol.
3539 */
3540 trace_smbus_write(adapter, addr, flags, read_write,
3541 command, protocol, data);
3542 trace_smbus_read(adapter, addr, flags, read_write,
3543 command, protocol);
3544
Laurent Pinchartd47726c2012-07-24 14:13:59 +02003545 flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003546
3547 if (adapter->algo->smbus_xfer) {
Peter Rosin8320f492016-05-04 22:15:27 +02003548 i2c_lock_bus(adapter, I2C_LOCK_SEGMENT);
Clifford Wolf66b650f2009-06-15 18:01:46 +02003549
3550 /* Retry automatically on arbitration loss */
3551 orig_jiffies = jiffies;
3552 for (res = 0, try = 0; try <= adapter->retries; try++) {
3553 res = adapter->algo->smbus_xfer(adapter, addr, flags,
3554 read_write, command,
3555 protocol, data);
3556 if (res != -EAGAIN)
3557 break;
3558 if (time_after(jiffies,
3559 orig_jiffies + adapter->timeout))
3560 break;
3561 }
Peter Rosin8320f492016-05-04 22:15:27 +02003562 i2c_unlock_bus(adapter, I2C_LOCK_SEGMENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003563
Laurent Pinchart72fc2c72012-07-24 14:13:59 +02003564 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
David Howells8a325992014-03-06 13:36:06 +00003565 goto trace;
Laurent Pinchart72fc2c72012-07-24 14:13:59 +02003566 /*
3567 * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
3568 * implement native support for the SMBus operation.
3569 */
3570 }
3571
David Howells8a325992014-03-06 13:36:06 +00003572 res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
3573 command, protocol, data);
3574
3575trace:
3576 /* If enabled, the reply tracepoint is conditional on read_write. */
3577 trace_smbus_reply(adapter, addr, flags, read_write,
3578 command, protocol, data);
3579 trace_smbus_result(adapter, addr, flags, read_write,
3580 command, protocol, res);
3581
3582 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003583}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003584EXPORT_SYMBOL(i2c_smbus_xfer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003585
Irina Tirdea01eef962015-08-12 17:31:33 +03003586/**
3587 * i2c_smbus_read_i2c_block_data_or_emulated - read block or emulate
3588 * @client: Handle to slave device
3589 * @command: Byte interpreted by slave
3590 * @length: Size of data block; SMBus allows at most I2C_SMBUS_BLOCK_MAX bytes
3591 * @values: Byte array into which data will be read; big enough to hold
3592 * the data returned by the slave. SMBus allows at most
3593 * I2C_SMBUS_BLOCK_MAX bytes.
3594 *
3595 * This executes the SMBus "block read" protocol if supported by the adapter.
3596 * If block read is not supported, it emulates it using either word or byte
3597 * read protocols depending on availability.
3598 *
3599 * The addresses of the I2C slave device that are accessed with this function
3600 * must be mapped to a linear region, so that a block read will have the same
3601 * effect as a byte read. Before using this function you must double-check
3602 * if the I2C slave does support exchanging a block transfer with a byte
3603 * transfer.
3604 */
3605s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
3606 u8 command, u8 length, u8 *values)
3607{
3608 u8 i = 0;
3609 int status;
3610
3611 if (length > I2C_SMBUS_BLOCK_MAX)
3612 length = I2C_SMBUS_BLOCK_MAX;
3613
3614 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK))
3615 return i2c_smbus_read_i2c_block_data(client, command, length, values);
3616
3617 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA))
3618 return -EOPNOTSUPP;
3619
3620 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_WORD_DATA)) {
3621 while ((i + 2) <= length) {
3622 status = i2c_smbus_read_word_data(client, command + i);
3623 if (status < 0)
3624 return status;
3625 values[i] = status & 0xff;
3626 values[i + 1] = status >> 8;
3627 i += 2;
3628 }
3629 }
3630
3631 while (i < length) {
3632 status = i2c_smbus_read_byte_data(client, command + i);
3633 if (status < 0)
3634 return status;
3635 values[i] = status;
3636 i++;
3637 }
3638
3639 return i;
3640}
3641EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data_or_emulated);
3642
Jean Delvared5fd1202015-01-26 20:59:31 +01003643#if IS_ENABLED(CONFIG_I2C_SLAVE)
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003644int i2c_slave_register(struct i2c_client *client, i2c_slave_cb_t slave_cb)
3645{
3646 int ret;
3647
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003648 if (!client || !slave_cb) {
Colin Ian King26591612016-12-29 22:27:33 +00003649 WARN(1, "insufficient data\n");
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003650 return -EINVAL;
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003651 }
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003652
Wolfram Sangc6909d62015-08-05 21:12:54 +02003653 if (!(client->flags & I2C_CLIENT_SLAVE))
3654 dev_warn(&client->dev, "%s: client slave flag not set. You might see address collisions\n",
3655 __func__);
3656
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003657 if (!(client->flags & I2C_CLIENT_TEN)) {
3658 /* Enforce stricter address checking */
Wolfram Sang66be60562015-07-17 12:43:22 +02003659 ret = i2c_check_7bit_addr_validity_strict(client->addr);
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003660 if (ret) {
3661 dev_err(&client->dev, "%s: invalid address\n", __func__);
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003662 return ret;
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003663 }
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003664 }
3665
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003666 if (!client->adapter->algo->reg_slave) {
3667 dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003668 return -EOPNOTSUPP;
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003669 }
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003670
3671 client->slave_cb = slave_cb;
3672
3673 i2c_lock_adapter(client->adapter);
3674 ret = client->adapter->algo->reg_slave(client);
3675 i2c_unlock_adapter(client->adapter);
3676
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003677 if (ret) {
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003678 client->slave_cb = NULL;
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003679 dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
3680 }
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003681
3682 return ret;
3683}
3684EXPORT_SYMBOL_GPL(i2c_slave_register);
3685
3686int i2c_slave_unregister(struct i2c_client *client)
3687{
3688 int ret;
3689
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003690 if (!client->adapter->algo->unreg_slave) {
3691 dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003692 return -EOPNOTSUPP;
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003693 }
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003694
3695 i2c_lock_adapter(client->adapter);
3696 ret = client->adapter->algo->unreg_slave(client);
3697 i2c_unlock_adapter(client->adapter);
3698
3699 if (ret == 0)
3700 client->slave_cb = NULL;
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003701 else
3702 dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003703
3704 return ret;
3705}
3706EXPORT_SYMBOL_GPL(i2c_slave_unregister);
Jean Delvared5fd1202015-01-26 20:59:31 +01003707#endif
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003708
Linus Torvalds1da177e2005-04-16 15:20:36 -07003709MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
3710MODULE_DESCRIPTION("I2C-Bus main module");
3711MODULE_LICENSE("GPL");