blob: 0f2f8484e8ec1f51ca8e265bd160d3cbee5c7885 [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 Delvare7c81c602014-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 Sangb4e2f6a2015-05-19 21:04:40 +020030#include <dt-bindings/i2c/i2c.h>
Wolfram Sang53feedf2016-02-20 23:33:38 +010031#include <asm/uaccess.h>
32#include <linux/acpi.h>
Sylwester Nawrocki86be4082014-06-18 17:29:32 +020033#include <linux/clk/clk-conf.h>
Jean Delvareb8d6f452007-02-13 22:09:00 +010034#include <linux/completion.h>
Wolfram Sang53feedf2016-02-20 23:33:38 +010035#include <linux/delay.h>
Pantelis Antonioua430a3452014-10-28 22:36:02 +020036#include <linux/err.h>
Wolfram Sang53feedf2016-02-20 23:33:38 +010037#include <linux/errno.h>
38#include <linux/gpio.h>
39#include <linux/hardirq.h>
40#include <linux/i2c.h>
41#include <linux/idr.h>
42#include <linux/init.h>
43#include <linux/irqflags.h>
44#include <linux/jump_label.h>
45#include <linux/kernel.h>
46#include <linux/module.h>
47#include <linux/mutex.h>
48#include <linux/of_device.h>
49#include <linux/of.h>
50#include <linux/of_irq.h>
51#include <linux/pm_domain.h>
52#include <linux/pm_runtime.h>
53#include <linux/pm_wakeirq.h>
Wolfram Sange1dba012015-12-08 10:37:46 +010054#include <linux/property.h>
Wolfram Sang53feedf2016-02-20 23:33:38 +010055#include <linux/rwsem.h>
56#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070057
David Brownell9c1600e2007-05-01 23:26:31 +020058#include "i2c-core.h"
59
David Howellsd9a83d62014-03-06 13:35:59 +000060#define CREATE_TRACE_POINTS
61#include <trace/events/i2c.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070062
Wolfram Sangda899f52015-05-18 21:09:12 +020063#define I2C_ADDR_OFFSET_TEN_BIT 0xa000
64#define I2C_ADDR_OFFSET_SLAVE 0x1000
65
Jean Delvare6629dcf2010-05-04 11:09:28 +020066/* core_lock protects i2c_adapter_idr, and guarantees
Jean Delvare35fc37f2009-06-19 16:58:19 +020067 that device detection, deletion of detected devices, and attach_adapter
Lars-Peter Clausen19baba42013-03-09 08:16:44 +000068 calls are serialized */
Jean Delvarecaada322008-01-27 18:14:49 +010069static DEFINE_MUTEX(core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070070static DEFINE_IDR(i2c_adapter_idr);
71
Jean Delvare4f8cf822009-09-18 22:45:46 +020072static struct device_type i2c_client_type;
Jean Delvare4735c982008-07-14 22:38:36 +020073static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
David Brownellf37dd802007-02-13 22:09:00 +010074
David Howellsd9a83d62014-03-06 13:35:59 +000075static struct static_key i2c_trace_msg = STATIC_KEY_INIT_FALSE;
Sudip Mukherjee95026652016-03-07 17:19:17 +053076static bool is_registered;
David Howellsd9a83d62014-03-06 13:35:59 +000077
78void i2c_transfer_trace_reg(void)
79{
80 static_key_slow_inc(&i2c_trace_msg);
81}
82
83void i2c_transfer_trace_unreg(void)
84{
85 static_key_slow_dec(&i2c_trace_msg);
86}
87
Wolfram Sang17f4a5c2014-09-22 19:41:00 +020088#if defined(CONFIG_ACPI)
89struct acpi_i2c_handler_data {
90 struct acpi_connection_info info;
91 struct i2c_adapter *adapter;
92};
93
94struct gsb_buffer {
95 u8 status;
96 u8 len;
97 union {
98 u16 wdata;
99 u8 bdata;
100 u8 data[0];
101 };
102} __packed;
103
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300104struct acpi_i2c_lookup {
105 struct i2c_board_info *info;
106 acpi_handle adapter_handle;
107 acpi_handle device_handle;
108};
109
110static int acpi_i2c_find_address(struct acpi_resource *ares, void *data)
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200111{
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300112 struct acpi_i2c_lookup *lookup = data;
113 struct i2c_board_info *info = lookup->info;
114 struct acpi_resource_i2c_serialbus *sb;
115 acpi_handle adapter_handle;
116 acpi_status status;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200117
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300118 if (info->addr || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS)
119 return 1;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200120
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300121 sb = &ares->data.i2c_serial_bus;
122 if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C)
123 return 1;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200124
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300125 /*
126 * Extract the ResourceSource and make sure that the handle matches
127 * with the I2C adapter handle.
128 */
129 status = acpi_get_handle(lookup->device_handle,
130 sb->resource_source.string_ptr,
131 &adapter_handle);
132 if (ACPI_SUCCESS(status) && adapter_handle == lookup->adapter_handle) {
133 info->addr = sb->slave_address;
134 if (sb->access_mode == ACPI_I2C_10BIT_MODE)
135 info->flags |= I2C_CLIENT_TEN;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200136 }
137
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200138 return 1;
139}
140
141static acpi_status acpi_i2c_add_device(acpi_handle handle, u32 level,
142 void *data, void **return_value)
143{
144 struct i2c_adapter *adapter = data;
145 struct list_head resource_list;
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300146 struct acpi_i2c_lookup lookup;
147 struct resource_entry *entry;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200148 struct i2c_board_info info;
149 struct acpi_device *adev;
150 int ret;
151
152 if (acpi_bus_get_device(handle, &adev))
153 return AE_OK;
154 if (acpi_bus_get_status(adev) || !adev->status.present)
155 return AE_OK;
156
157 memset(&info, 0, sizeof(info));
Rafael J. Wysockice793482015-03-16 23:49:03 +0100158 info.fwnode = acpi_fwnode_handle(adev);
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200159
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300160 memset(&lookup, 0, sizeof(lookup));
Dustin Byford8eb5c872015-10-23 12:27:07 -0700161 lookup.adapter_handle = ACPI_HANDLE(&adapter->dev);
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300162 lookup.device_handle = handle;
163 lookup.info = &info;
164
165 /*
166 * Look up for I2cSerialBus resource with ResourceSource that
167 * matches with this adapter.
168 */
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200169 INIT_LIST_HEAD(&resource_list);
170 ret = acpi_dev_get_resources(adev, &resource_list,
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300171 acpi_i2c_find_address, &lookup);
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200172 acpi_dev_free_resource_list(&resource_list);
173
174 if (ret < 0 || !info.addr)
175 return AE_OK;
176
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300177 /* Then fill IRQ number if any */
178 ret = acpi_dev_get_resources(adev, &resource_list, NULL, NULL);
179 if (ret < 0)
180 return AE_OK;
181
182 resource_list_for_each_entry(entry, &resource_list) {
183 if (resource_type(entry->res) == IORESOURCE_IRQ) {
184 info.irq = entry->res->start;
185 break;
186 }
187 }
188
189 acpi_dev_free_resource_list(&resource_list);
190
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200191 adev->power.flags.ignore_parent = true;
192 strlcpy(info.type, dev_name(&adev->dev), sizeof(info.type));
193 if (!i2c_new_device(adapter, &info)) {
194 adev->power.flags.ignore_parent = false;
195 dev_err(&adapter->dev,
196 "failed to add I2C device %s from ACPI\n",
197 dev_name(&adev->dev));
198 }
199
200 return AE_OK;
201}
202
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300203#define ACPI_I2C_MAX_SCAN_DEPTH 32
204
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200205/**
206 * acpi_i2c_register_devices - enumerate I2C slave devices behind adapter
207 * @adap: pointer to adapter
208 *
209 * Enumerate all I2C slave devices behind this adapter by walking the ACPI
210 * namespace. When a device is found it will be added to the Linux device
211 * model and bound to the corresponding ACPI handle.
212 */
213static void acpi_i2c_register_devices(struct i2c_adapter *adap)
214{
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200215 acpi_status status;
216
Dustin Byford8eb5c872015-10-23 12:27:07 -0700217 if (!has_acpi_companion(&adap->dev))
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200218 return;
219
Mika Westerberg166c2ba2015-10-07 13:18:44 +0300220 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
221 ACPI_I2C_MAX_SCAN_DEPTH,
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200222 acpi_i2c_add_device, NULL,
223 adap, NULL);
224 if (ACPI_FAILURE(status))
225 dev_warn(&adap->dev, "failed to enumerate I2C slaves\n");
226}
227
228#else /* CONFIG_ACPI */
229static inline void acpi_i2c_register_devices(struct i2c_adapter *adap) { }
230#endif /* CONFIG_ACPI */
231
232#ifdef CONFIG_ACPI_I2C_OPREGION
233static int acpi_gsb_i2c_read_bytes(struct i2c_client *client,
234 u8 cmd, u8 *data, u8 data_len)
235{
236
237 struct i2c_msg msgs[2];
238 int ret;
239 u8 *buffer;
240
241 buffer = kzalloc(data_len, GFP_KERNEL);
242 if (!buffer)
243 return AE_NO_MEMORY;
244
245 msgs[0].addr = client->addr;
246 msgs[0].flags = client->flags;
247 msgs[0].len = 1;
248 msgs[0].buf = &cmd;
249
250 msgs[1].addr = client->addr;
251 msgs[1].flags = client->flags | I2C_M_RD;
252 msgs[1].len = data_len;
253 msgs[1].buf = buffer;
254
255 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
256 if (ret < 0)
257 dev_err(&client->adapter->dev, "i2c read failed\n");
258 else
259 memcpy(data, buffer, data_len);
260
261 kfree(buffer);
262 return ret;
263}
264
265static int acpi_gsb_i2c_write_bytes(struct i2c_client *client,
266 u8 cmd, u8 *data, u8 data_len)
267{
268
269 struct i2c_msg msgs[1];
270 u8 *buffer;
271 int ret = AE_OK;
272
273 buffer = kzalloc(data_len + 1, GFP_KERNEL);
274 if (!buffer)
275 return AE_NO_MEMORY;
276
277 buffer[0] = cmd;
278 memcpy(buffer + 1, data, data_len);
279
280 msgs[0].addr = client->addr;
281 msgs[0].flags = client->flags;
282 msgs[0].len = data_len + 1;
283 msgs[0].buf = buffer;
284
285 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
286 if (ret < 0)
287 dev_err(&client->adapter->dev, "i2c write failed\n");
288
289 kfree(buffer);
290 return ret;
291}
292
293static acpi_status
294acpi_i2c_space_handler(u32 function, acpi_physical_address command,
295 u32 bits, u64 *value64,
296 void *handler_context, void *region_context)
297{
298 struct gsb_buffer *gsb = (struct gsb_buffer *)value64;
299 struct acpi_i2c_handler_data *data = handler_context;
300 struct acpi_connection_info *info = &data->info;
301 struct acpi_resource_i2c_serialbus *sb;
302 struct i2c_adapter *adapter = data->adapter;
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300303 struct i2c_client *client;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200304 struct acpi_resource *ares;
305 u32 accessor_type = function >> 16;
306 u8 action = function & ACPI_IO_MASK;
Wolfram Sang4470c722014-11-18 15:12:43 +0100307 acpi_status ret;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200308 int status;
309
310 ret = acpi_buffer_to_resource(info->connection, info->length, &ares);
311 if (ACPI_FAILURE(ret))
312 return ret;
313
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300314 client = kzalloc(sizeof(*client), GFP_KERNEL);
315 if (!client) {
316 ret = AE_NO_MEMORY;
317 goto err;
318 }
319
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200320 if (!value64 || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) {
321 ret = AE_BAD_PARAMETER;
322 goto err;
323 }
324
325 sb = &ares->data.i2c_serial_bus;
326 if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C) {
327 ret = AE_BAD_PARAMETER;
328 goto err;
329 }
330
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300331 client->adapter = adapter;
332 client->addr = sb->slave_address;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200333
334 if (sb->access_mode == ACPI_I2C_10BIT_MODE)
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300335 client->flags |= I2C_CLIENT_TEN;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200336
337 switch (accessor_type) {
338 case ACPI_GSB_ACCESS_ATTRIB_SEND_RCV:
339 if (action == ACPI_READ) {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300340 status = i2c_smbus_read_byte(client);
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200341 if (status >= 0) {
342 gsb->bdata = status;
343 status = 0;
344 }
345 } else {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300346 status = i2c_smbus_write_byte(client, gsb->bdata);
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200347 }
348 break;
349
350 case ACPI_GSB_ACCESS_ATTRIB_BYTE:
351 if (action == ACPI_READ) {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300352 status = i2c_smbus_read_byte_data(client, command);
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200353 if (status >= 0) {
354 gsb->bdata = status;
355 status = 0;
356 }
357 } else {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300358 status = i2c_smbus_write_byte_data(client, command,
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200359 gsb->bdata);
360 }
361 break;
362
363 case ACPI_GSB_ACCESS_ATTRIB_WORD:
364 if (action == ACPI_READ) {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300365 status = i2c_smbus_read_word_data(client, command);
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200366 if (status >= 0) {
367 gsb->wdata = status;
368 status = 0;
369 }
370 } else {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300371 status = i2c_smbus_write_word_data(client, command,
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200372 gsb->wdata);
373 }
374 break;
375
376 case ACPI_GSB_ACCESS_ATTRIB_BLOCK:
377 if (action == ACPI_READ) {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300378 status = i2c_smbus_read_block_data(client, command,
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200379 gsb->data);
380 if (status >= 0) {
381 gsb->len = status;
382 status = 0;
383 }
384 } else {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300385 status = i2c_smbus_write_block_data(client, command,
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200386 gsb->len, gsb->data);
387 }
388 break;
389
390 case ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE:
391 if (action == ACPI_READ) {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300392 status = acpi_gsb_i2c_read_bytes(client, command,
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200393 gsb->data, info->access_length);
394 if (status > 0)
395 status = 0;
396 } else {
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300397 status = acpi_gsb_i2c_write_bytes(client, command,
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200398 gsb->data, info->access_length);
399 }
400 break;
401
402 default:
403 pr_info("protocol(0x%02x) is not supported.\n", accessor_type);
404 ret = AE_BAD_PARAMETER;
405 goto err;
406 }
407
408 gsb->status = status;
409
410 err:
Jarkko Nikula7ef85f52015-05-20 16:36:52 +0300411 kfree(client);
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200412 ACPI_FREE(ares);
413 return ret;
414}
415
416
417static int acpi_i2c_install_space_handler(struct i2c_adapter *adapter)
418{
Peter Hüwe0aef44e2014-09-12 21:09:47 +0200419 acpi_handle handle;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200420 struct acpi_i2c_handler_data *data;
421 acpi_status status;
422
Peter Hüwe0aef44e2014-09-12 21:09:47 +0200423 if (!adapter->dev.parent)
424 return -ENODEV;
425
426 handle = ACPI_HANDLE(adapter->dev.parent);
427
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200428 if (!handle)
429 return -ENODEV;
430
431 data = kzalloc(sizeof(struct acpi_i2c_handler_data),
432 GFP_KERNEL);
433 if (!data)
434 return -ENOMEM;
435
436 data->adapter = adapter;
437 status = acpi_bus_attach_private_data(handle, (void *)data);
438 if (ACPI_FAILURE(status)) {
439 kfree(data);
440 return -ENOMEM;
441 }
442
443 status = acpi_install_address_space_handler(handle,
444 ACPI_ADR_SPACE_GSBUS,
445 &acpi_i2c_space_handler,
446 NULL,
447 data);
448 if (ACPI_FAILURE(status)) {
449 dev_err(&adapter->dev, "Error installing i2c space handler\n");
450 acpi_bus_detach_private_data(handle);
451 kfree(data);
452 return -ENOMEM;
453 }
454
Lan Tianyu40e7fcb2014-11-23 21:22:54 +0800455 acpi_walk_dep_device_list(handle);
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200456 return 0;
457}
458
459static void acpi_i2c_remove_space_handler(struct i2c_adapter *adapter)
460{
Peter Hüwe0aef44e2014-09-12 21:09:47 +0200461 acpi_handle handle;
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200462 struct acpi_i2c_handler_data *data;
463 acpi_status status;
464
Peter Hüwe0aef44e2014-09-12 21:09:47 +0200465 if (!adapter->dev.parent)
466 return;
467
468 handle = ACPI_HANDLE(adapter->dev.parent);
469
Wolfram Sang17f4a5c2014-09-22 19:41:00 +0200470 if (!handle)
471 return;
472
473 acpi_remove_address_space_handler(handle,
474 ACPI_ADR_SPACE_GSBUS,
475 &acpi_i2c_space_handler);
476
477 status = acpi_bus_get_private_data(handle, (void **)&data);
478 if (ACPI_SUCCESS(status))
479 kfree(data);
480
481 acpi_bus_detach_private_data(handle);
482}
483#else /* CONFIG_ACPI_I2C_OPREGION */
484static inline void acpi_i2c_remove_space_handler(struct i2c_adapter *adapter)
485{ }
486
487static inline int acpi_i2c_install_space_handler(struct i2c_adapter *adapter)
488{ return 0; }
489#endif /* CONFIG_ACPI_I2C_OPREGION */
490
David Brownellf37dd802007-02-13 22:09:00 +0100491/* ------------------------------------------------------------------------- */
492
Jean Delvared2653e92008-04-29 23:11:39 +0200493static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
494 const struct i2c_client *client)
495{
496 while (id->name[0]) {
497 if (strcmp(client->name, id->name) == 0)
498 return id;
499 id++;
500 }
501 return NULL;
502}
503
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504static int i2c_device_match(struct device *dev, struct device_driver *drv)
505{
Jean Delvare51298d12009-09-18 22:45:45 +0200506 struct i2c_client *client = i2c_verify_client(dev);
507 struct i2c_driver *driver;
David Brownell7b4fbc52007-05-01 23:26:30 +0200508
Jean Delvare51298d12009-09-18 22:45:45 +0200509 if (!client)
510 return 0;
511
Grant Likely959e85f2010-06-08 07:48:19 -0600512 /* Attempt an OF style match */
513 if (of_driver_match_device(dev, drv))
514 return 1;
515
Mika Westerberg907ddf82012-11-23 12:23:40 +0100516 /* Then ACPI style match */
517 if (acpi_driver_match_device(dev, drv))
518 return 1;
519
Jean Delvare51298d12009-09-18 22:45:45 +0200520 driver = to_i2c_driver(drv);
Jean Delvared2653e92008-04-29 23:11:39 +0200521 /* match on an id table if there is one */
522 if (driver->id_table)
523 return i2c_match_id(driver->id_table, client) != NULL;
524
Jean Delvareeb8a7902008-05-18 20:49:41 +0200525 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526}
527
David Brownell7b4fbc52007-05-01 23:26:30 +0200528
529/* uevent helps with hotplug: modprobe -q $(MODALIAS) */
Kay Sievers7eff2e72007-08-14 15:15:12 +0200530static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
David Brownell7b4fbc52007-05-01 23:26:30 +0200531{
532 struct i2c_client *client = to_i2c_client(dev);
Zhang Rui8c4ff6d2014-01-14 16:46:37 +0800533 int rc;
534
535 rc = acpi_device_uevent_modalias(dev, env);
536 if (rc != -ENODEV)
537 return rc;
David Brownell7b4fbc52007-05-01 23:26:30 +0200538
Jean Delvareeb8a7902008-05-18 20:49:41 +0200539 if (add_uevent_var(env, "MODALIAS=%s%s",
540 I2C_MODULE_PREFIX, client->name))
541 return -ENOMEM;
David Brownell7b4fbc52007-05-01 23:26:30 +0200542 dev_dbg(dev, "uevent\n");
543 return 0;
544}
545
Viresh Kumar5f9296b2012-02-28 18:26:31 +0530546/* i2c bus recovery routines */
547static int get_scl_gpio_value(struct i2c_adapter *adap)
548{
549 return gpio_get_value(adap->bus_recovery_info->scl_gpio);
550}
551
552static void set_scl_gpio_value(struct i2c_adapter *adap, int val)
553{
554 gpio_set_value(adap->bus_recovery_info->scl_gpio, val);
555}
556
557static int get_sda_gpio_value(struct i2c_adapter *adap)
558{
559 return gpio_get_value(adap->bus_recovery_info->sda_gpio);
560}
561
562static int i2c_get_gpios_for_recovery(struct i2c_adapter *adap)
563{
564 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
565 struct device *dev = &adap->dev;
566 int ret = 0;
567
568 ret = gpio_request_one(bri->scl_gpio, GPIOF_OPEN_DRAIN |
569 GPIOF_OUT_INIT_HIGH, "i2c-scl");
570 if (ret) {
571 dev_warn(dev, "Can't get SCL gpio: %d\n", bri->scl_gpio);
572 return ret;
573 }
574
575 if (bri->get_sda) {
576 if (gpio_request_one(bri->sda_gpio, GPIOF_IN, "i2c-sda")) {
577 /* work without SDA polling */
578 dev_warn(dev, "Can't get SDA gpio: %d. Not using SDA polling\n",
579 bri->sda_gpio);
580 bri->get_sda = NULL;
581 }
582 }
583
584 return ret;
585}
586
587static void i2c_put_gpios_for_recovery(struct i2c_adapter *adap)
588{
589 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
590
591 if (bri->get_sda)
592 gpio_free(bri->sda_gpio);
593
594 gpio_free(bri->scl_gpio);
595}
596
597/*
598 * We are generating clock pulses. ndelay() determines durating of clk pulses.
599 * We will generate clock with rate 100 KHz and so duration of both clock levels
600 * is: delay in ns = (10^6 / 100) / 2
601 */
602#define RECOVERY_NDELAY 5000
603#define RECOVERY_CLK_CNT 9
604
605static int i2c_generic_recovery(struct i2c_adapter *adap)
606{
607 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
608 int i = 0, val = 1, ret = 0;
609
610 if (bri->prepare_recovery)
Grygorii Strashko2b2190a2015-04-06 15:38:39 +0300611 bri->prepare_recovery(adap);
Viresh Kumar5f9296b2012-02-28 18:26:31 +0530612
Jan Luebbe8b062602015-07-08 16:35:06 +0200613 bri->set_scl(adap, val);
614 ndelay(RECOVERY_NDELAY);
615
Viresh Kumar5f9296b2012-02-28 18:26:31 +0530616 /*
617 * By this time SCL is high, as we need to give 9 falling-rising edges
618 */
619 while (i++ < RECOVERY_CLK_CNT * 2) {
620 if (val) {
621 /* Break if SDA is high */
622 if (bri->get_sda && bri->get_sda(adap))
623 break;
624 /* SCL shouldn't be low here */
625 if (!bri->get_scl(adap)) {
626 dev_err(&adap->dev,
627 "SCL is stuck low, exit recovery\n");
628 ret = -EBUSY;
629 break;
630 }
631 }
632
633 val = !val;
634 bri->set_scl(adap, val);
635 ndelay(RECOVERY_NDELAY);
636 }
637
638 if (bri->unprepare_recovery)
Grygorii Strashko2b2190a2015-04-06 15:38:39 +0300639 bri->unprepare_recovery(adap);
Viresh Kumar5f9296b2012-02-28 18:26:31 +0530640
641 return ret;
642}
643
644int i2c_generic_scl_recovery(struct i2c_adapter *adap)
645{
Viresh Kumar5f9296b2012-02-28 18:26:31 +0530646 return i2c_generic_recovery(adap);
647}
Mark Brownc1c21f42015-04-15 19:18:39 +0100648EXPORT_SYMBOL_GPL(i2c_generic_scl_recovery);
Viresh Kumar5f9296b2012-02-28 18:26:31 +0530649
650int i2c_generic_gpio_recovery(struct i2c_adapter *adap)
651{
652 int ret;
653
654 ret = i2c_get_gpios_for_recovery(adap);
655 if (ret)
656 return ret;
657
658 ret = i2c_generic_recovery(adap);
659 i2c_put_gpios_for_recovery(adap);
660
661 return ret;
662}
Mark Brownc1c21f42015-04-15 19:18:39 +0100663EXPORT_SYMBOL_GPL(i2c_generic_gpio_recovery);
Viresh Kumar5f9296b2012-02-28 18:26:31 +0530664
665int i2c_recover_bus(struct i2c_adapter *adap)
666{
667 if (!adap->bus_recovery_info)
668 return -EOPNOTSUPP;
669
670 dev_dbg(&adap->dev, "Trying i2c bus recovery\n");
671 return adap->bus_recovery_info->recover_bus(adap);
672}
Mark Brownc1c21f42015-04-15 19:18:39 +0100673EXPORT_SYMBOL_GPL(i2c_recover_bus);
Viresh Kumar5f9296b2012-02-28 18:26:31 +0530674
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675static int i2c_device_probe(struct device *dev)
676{
Jean Delvare51298d12009-09-18 22:45:45 +0200677 struct i2c_client *client = i2c_verify_client(dev);
678 struct i2c_driver *driver;
Hans Verkuil50c33042008-03-12 14:15:00 +0100679 int status;
David Brownell7b4fbc52007-05-01 23:26:30 +0200680
Jean Delvare51298d12009-09-18 22:45:45 +0200681 if (!client)
682 return 0;
683
Mika Westerberg845c8772015-05-06 13:29:08 +0300684 if (!client->irq) {
685 int irq = -ENOENT;
686
Dmitry Torokhov3fffd122015-08-17 23:52:51 -0700687 if (dev->of_node) {
688 irq = of_irq_get_byname(dev->of_node, "irq");
689 if (irq == -EINVAL || irq == -ENODATA)
690 irq = of_irq_get(dev->of_node, 0);
691 } else if (ACPI_COMPANION(dev)) {
Mika Westerberg845c8772015-05-06 13:29:08 +0300692 irq = acpi_dev_gpio_irq_get(ACPI_COMPANION(dev), 0);
Dmitry Torokhov3fffd122015-08-17 23:52:51 -0700693 }
Geert Uytterhoeven6f34be72014-11-17 12:43:00 +0100694 if (irq == -EPROBE_DEFER)
Laurent Pinchart2fd36c552014-10-30 15:59:38 +0200695 return irq;
Geert Uytterhoeven6f34be72014-11-17 12:43:00 +0100696 if (irq < 0)
697 irq = 0;
Laurent Pinchart2fd36c552014-10-30 15:59:38 +0200698
699 client->irq = irq;
700 }
701
Jean Delvare51298d12009-09-18 22:45:45 +0200702 driver = to_i2c_driver(dev->driver);
Jean Delvaree0457442008-07-14 22:38:30 +0200703 if (!driver->probe || !driver->id_table)
David Brownell7b4fbc52007-05-01 23:26:30 +0200704 return -ENODEV;
Lars-Peter Clausen0acc2b32013-09-29 10:51:06 +0200705
Dmitry Torokhov3fffd122015-08-17 23:52:51 -0700706 if (client->flags & I2C_CLIENT_WAKE) {
707 int wakeirq = -ENOENT;
708
709 if (dev->of_node) {
710 wakeirq = of_irq_get_byname(dev->of_node, "wakeup");
711 if (wakeirq == -EPROBE_DEFER)
712 return wakeirq;
713 }
714
715 device_init_wakeup(&client->dev, true);
716
717 if (wakeirq > 0 && wakeirq != client->irq)
718 status = dev_pm_set_dedicated_wake_irq(dev, wakeirq);
719 else if (client->irq > 0)
Grygorii Strashkoc18fba22015-11-12 15:42:26 +0200720 status = dev_pm_set_wake_irq(dev, client->irq);
Dmitry Torokhov3fffd122015-08-17 23:52:51 -0700721 else
722 status = 0;
723
724 if (status)
725 dev_warn(&client->dev, "failed to set up wakeup irq");
726 }
727
David Brownell7b4fbc52007-05-01 23:26:30 +0200728 dev_dbg(dev, "probe\n");
Jean Delvared2653e92008-04-29 23:11:39 +0200729
Sylwester Nawrocki86be4082014-06-18 17:29:32 +0200730 status = of_clk_set_defaults(dev->of_node, false);
731 if (status < 0)
Dmitry Torokhov3fffd122015-08-17 23:52:51 -0700732 goto err_clear_wakeup_irq;
Sylwester Nawrocki86be4082014-06-18 17:29:32 +0200733
Ulf Hanssone09b0d42014-09-19 20:27:39 +0200734 status = dev_pm_domain_attach(&client->dev, true);
Kieran Bingham74cedd32015-10-12 21:54:43 +0100735 if (status == -EPROBE_DEFER)
736 goto err_clear_wakeup_irq;
737
738 status = driver->probe(client, i2c_match_id(driver->id_table, client));
739 if (status)
740 goto err_detach_pm_domain;
Wolfram Sang72fa8182014-01-21 17:48:34 +0100741
Dmitry Torokhov3fffd122015-08-17 23:52:51 -0700742 return 0;
743
744err_detach_pm_domain:
745 dev_pm_domain_detach(&client->dev, true);
746err_clear_wakeup_irq:
747 dev_pm_clear_wake_irq(&client->dev);
748 device_init_wakeup(&client->dev, false);
Hans Verkuil50c33042008-03-12 14:15:00 +0100749 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750}
751
752static int i2c_device_remove(struct device *dev)
753{
Jean Delvare51298d12009-09-18 22:45:45 +0200754 struct i2c_client *client = i2c_verify_client(dev);
David Brownella1d9e6e2007-05-01 23:26:30 +0200755 struct i2c_driver *driver;
Wolfram Sang72fa8182014-01-21 17:48:34 +0100756 int status = 0;
David Brownella1d9e6e2007-05-01 23:26:30 +0200757
Jean Delvare51298d12009-09-18 22:45:45 +0200758 if (!client || !dev->driver)
David Brownella1d9e6e2007-05-01 23:26:30 +0200759 return 0;
760
761 driver = to_i2c_driver(dev->driver);
762 if (driver->remove) {
763 dev_dbg(dev, "remove\n");
764 status = driver->remove(client);
David Brownella1d9e6e2007-05-01 23:26:30 +0200765 }
Wolfram Sang72fa8182014-01-21 17:48:34 +0100766
Ulf Hanssone09b0d42014-09-19 20:27:39 +0200767 dev_pm_domain_detach(&client->dev, true);
Dmitry Torokhov3fffd122015-08-17 23:52:51 -0700768
769 dev_pm_clear_wake_irq(&client->dev);
770 device_init_wakeup(&client->dev, false);
771
David Brownella1d9e6e2007-05-01 23:26:30 +0200772 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773}
774
David Brownellf37dd802007-02-13 22:09:00 +0100775static void i2c_device_shutdown(struct device *dev)
776{
Jean Delvare51298d12009-09-18 22:45:45 +0200777 struct i2c_client *client = i2c_verify_client(dev);
David Brownellf37dd802007-02-13 22:09:00 +0100778 struct i2c_driver *driver;
779
Jean Delvare51298d12009-09-18 22:45:45 +0200780 if (!client || !dev->driver)
David Brownellf37dd802007-02-13 22:09:00 +0100781 return;
782 driver = to_i2c_driver(dev->driver);
783 if (driver->shutdown)
Jean Delvare51298d12009-09-18 22:45:45 +0200784 driver->shutdown(client);
David Brownellf37dd802007-02-13 22:09:00 +0100785}
786
David Brownell9c1600e2007-05-01 23:26:31 +0200787static void i2c_client_dev_release(struct device *dev)
788{
789 kfree(to_i2c_client(dev));
790}
791
Zhenwen Xu09b8ce02009-03-28 21:34:46 +0100792static ssize_t
Jean Delvare4f8cf822009-09-18 22:45:46 +0200793show_name(struct device *dev, struct device_attribute *attr, char *buf)
David Brownell7b4fbc52007-05-01 23:26:30 +0200794{
Jean Delvare4f8cf822009-09-18 22:45:46 +0200795 return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
796 to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
David Brownell7b4fbc52007-05-01 23:26:30 +0200797}
Wolfram Sanga5eb71b2015-01-19 20:12:24 +0100798static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
David Brownell7b4fbc52007-05-01 23:26:30 +0200799
Zhenwen Xu09b8ce02009-03-28 21:34:46 +0100800static ssize_t
801show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
David Brownell7b4fbc52007-05-01 23:26:30 +0200802{
803 struct i2c_client *client = to_i2c_client(dev);
Zhang Rui8c4ff6d2014-01-14 16:46:37 +0800804 int len;
805
806 len = acpi_device_modalias(dev, buf, PAGE_SIZE -1);
807 if (len != -ENODEV)
808 return len;
809
Jean Delvareeb8a7902008-05-18 20:49:41 +0200810 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
David Brownell7b4fbc52007-05-01 23:26:30 +0200811}
Jean Delvare51298d12009-09-18 22:45:45 +0200812static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
813
814static struct attribute *i2c_dev_attrs[] = {
815 &dev_attr_name.attr,
David Brownell7b4fbc52007-05-01 23:26:30 +0200816 /* modalias helps coldplug: modprobe $(cat .../modalias) */
Jean Delvare51298d12009-09-18 22:45:45 +0200817 &dev_attr_modalias.attr,
818 NULL
819};
Wolfram Sanga5eb71b2015-01-19 20:12:24 +0100820ATTRIBUTE_GROUPS(i2c_dev);
sonic zhang54067ee2009-12-14 21:17:30 +0100821
Jon Smirle9ca9eb2008-07-14 22:38:35 +0200822struct bus_type i2c_bus_type = {
David Brownellf37dd802007-02-13 22:09:00 +0100823 .name = "i2c",
824 .match = i2c_device_match,
825 .probe = i2c_device_probe,
826 .remove = i2c_device_remove,
827 .shutdown = i2c_device_shutdown,
Russell Kingb864c7d2006-01-05 14:37:50 +0000828};
Jon Smirle9ca9eb2008-07-14 22:38:35 +0200829EXPORT_SYMBOL_GPL(i2c_bus_type);
Russell Kingb864c7d2006-01-05 14:37:50 +0000830
Jean Delvare51298d12009-09-18 22:45:45 +0200831static struct device_type i2c_client_type = {
Wolfram Sanga5eb71b2015-01-19 20:12:24 +0100832 .groups = i2c_dev_groups,
Jean Delvare51298d12009-09-18 22:45:45 +0200833 .uevent = i2c_device_uevent,
834 .release = i2c_client_dev_release,
835};
836
David Brownell9b766b82008-01-27 18:14:51 +0100837
838/**
839 * i2c_verify_client - return parameter as i2c_client, or NULL
840 * @dev: device, probably from some driver model iterator
841 *
842 * When traversing the driver model tree, perhaps using driver model
843 * iterators like @device_for_each_child(), you can't assume very much
844 * about the nodes you find. Use this function to avoid oopses caused
845 * by wrongly treating some non-I2C device as an i2c_client.
846 */
847struct i2c_client *i2c_verify_client(struct device *dev)
848{
Jean Delvare51298d12009-09-18 22:45:45 +0200849 return (dev->type == &i2c_client_type)
David Brownell9b766b82008-01-27 18:14:51 +0100850 ? to_i2c_client(dev)
851 : NULL;
852}
853EXPORT_SYMBOL(i2c_verify_client);
854
855
Wolfram Sangda899f52015-05-18 21:09:12 +0200856/* Return a unique address which takes the flags of the client into account */
857static unsigned short i2c_encode_flags_to_addr(struct i2c_client *client)
858{
859 unsigned short addr = client->addr;
860
861 /* For some client flags, add an arbitrary offset to avoid collisions */
862 if (client->flags & I2C_CLIENT_TEN)
863 addr |= I2C_ADDR_OFFSET_TEN_BIT;
864
865 if (client->flags & I2C_CLIENT_SLAVE)
866 addr |= I2C_ADDR_OFFSET_SLAVE;
867
868 return addr;
869}
870
Jean Delvare3a89db52010-06-03 11:33:52 +0200871/* This is a permissive address validity check, I2C address map constraints
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300872 * are purposely not enforced, except for the general call address. */
Wolfram Sangc4019b72015-07-17 12:50:06 +0200873static int i2c_check_addr_validity(unsigned addr, unsigned short flags)
Jean Delvare3a89db52010-06-03 11:33:52 +0200874{
Wolfram Sangc4019b72015-07-17 12:50:06 +0200875 if (flags & I2C_CLIENT_TEN) {
Jean Delvare3a89db52010-06-03 11:33:52 +0200876 /* 10-bit address, all values are valid */
Wolfram Sangc4019b72015-07-17 12:50:06 +0200877 if (addr > 0x3ff)
Jean Delvare3a89db52010-06-03 11:33:52 +0200878 return -EINVAL;
879 } else {
880 /* 7-bit address, reject the general call address */
Wolfram Sangc4019b72015-07-17 12:50:06 +0200881 if (addr == 0x00 || addr > 0x7f)
Jean Delvare3a89db52010-06-03 11:33:52 +0200882 return -EINVAL;
883 }
884 return 0;
885}
886
Jean Delvare656b8762010-06-03 11:33:53 +0200887/* And this is a strict address validity check, used when probing. If a
888 * device uses a reserved address, then it shouldn't be probed. 7-bit
889 * addressing is assumed, 10-bit address devices are rare and should be
890 * explicitly enumerated. */
Wolfram Sang66be60562015-07-17 12:43:22 +0200891static int i2c_check_7bit_addr_validity_strict(unsigned short addr)
Jean Delvare656b8762010-06-03 11:33:53 +0200892{
893 /*
894 * Reserved addresses per I2C specification:
895 * 0x00 General call address / START byte
896 * 0x01 CBUS address
897 * 0x02 Reserved for different bus format
898 * 0x03 Reserved for future purposes
899 * 0x04-0x07 Hs-mode master code
900 * 0x78-0x7b 10-bit slave addressing
901 * 0x7c-0x7f Reserved for future purposes
902 */
903 if (addr < 0x08 || addr > 0x77)
904 return -EINVAL;
905 return 0;
906}
907
Jean Delvare3b5f7942010-06-03 11:33:55 +0200908static int __i2c_check_addr_busy(struct device *dev, void *addrp)
909{
910 struct i2c_client *client = i2c_verify_client(dev);
911 int addr = *(int *)addrp;
912
Wolfram Sang9bccc702015-07-17 14:48:56 +0200913 if (client && i2c_encode_flags_to_addr(client) == addr)
Jean Delvare3b5f7942010-06-03 11:33:55 +0200914 return -EBUSY;
915 return 0;
916}
917
Michael Lawnick08263742010-08-11 18:21:02 +0200918/* walk up mux tree */
919static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
920{
Jean Delvare97cc4d42010-10-24 18:16:57 +0200921 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
Michael Lawnick08263742010-08-11 18:21:02 +0200922 int result;
923
924 result = device_for_each_child(&adapter->dev, &addr,
925 __i2c_check_addr_busy);
926
Jean Delvare97cc4d42010-10-24 18:16:57 +0200927 if (!result && parent)
928 result = i2c_check_mux_parents(parent, addr);
Michael Lawnick08263742010-08-11 18:21:02 +0200929
930 return result;
931}
932
933/* recurse down mux tree */
934static int i2c_check_mux_children(struct device *dev, void *addrp)
935{
936 int result;
937
938 if (dev->type == &i2c_adapter_type)
939 result = device_for_each_child(dev, addrp,
940 i2c_check_mux_children);
941 else
942 result = __i2c_check_addr_busy(dev, addrp);
943
944 return result;
945}
946
Jean Delvare3b5f7942010-06-03 11:33:55 +0200947static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
948{
Jean Delvare97cc4d42010-10-24 18:16:57 +0200949 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
Michael Lawnick08263742010-08-11 18:21:02 +0200950 int result = 0;
951
Jean Delvare97cc4d42010-10-24 18:16:57 +0200952 if (parent)
953 result = i2c_check_mux_parents(parent, addr);
Michael Lawnick08263742010-08-11 18:21:02 +0200954
955 if (!result)
956 result = device_for_each_child(&adapter->dev, &addr,
957 i2c_check_mux_children);
958
959 return result;
Jean Delvare3b5f7942010-06-03 11:33:55 +0200960}
961
David Brownell9c1600e2007-05-01 23:26:31 +0200962/**
Jean Delvarefe61e072010-08-11 18:20:58 +0200963 * i2c_lock_adapter - Get exclusive access to an I2C bus segment
964 * @adapter: Target I2C bus segment
965 */
966void i2c_lock_adapter(struct i2c_adapter *adapter)
967{
Jean Delvare97cc4d42010-10-24 18:16:57 +0200968 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
969
970 if (parent)
971 i2c_lock_adapter(parent);
Michael Lawnick08263742010-08-11 18:21:02 +0200972 else
973 rt_mutex_lock(&adapter->bus_lock);
Jean Delvarefe61e072010-08-11 18:20:58 +0200974}
975EXPORT_SYMBOL_GPL(i2c_lock_adapter);
976
977/**
978 * i2c_trylock_adapter - Try to get exclusive access to an I2C bus segment
979 * @adapter: Target I2C bus segment
980 */
981static int i2c_trylock_adapter(struct i2c_adapter *adapter)
982{
Jean Delvare97cc4d42010-10-24 18:16:57 +0200983 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
984
985 if (parent)
986 return i2c_trylock_adapter(parent);
Michael Lawnick08263742010-08-11 18:21:02 +0200987 else
988 return rt_mutex_trylock(&adapter->bus_lock);
Jean Delvarefe61e072010-08-11 18:20:58 +0200989}
990
991/**
992 * i2c_unlock_adapter - Release exclusive access to an I2C bus segment
993 * @adapter: Target I2C bus segment
994 */
995void i2c_unlock_adapter(struct i2c_adapter *adapter)
996{
Jean Delvare97cc4d42010-10-24 18:16:57 +0200997 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
998
999 if (parent)
1000 i2c_unlock_adapter(parent);
Michael Lawnick08263742010-08-11 18:21:02 +02001001 else
1002 rt_mutex_unlock(&adapter->bus_lock);
Jean Delvarefe61e072010-08-11 18:20:58 +02001003}
1004EXPORT_SYMBOL_GPL(i2c_unlock_adapter);
1005
Jarkko Nikula70762ab2013-11-14 14:03:52 +02001006static void i2c_dev_set_name(struct i2c_adapter *adap,
1007 struct i2c_client *client)
1008{
1009 struct acpi_device *adev = ACPI_COMPANION(&client->dev);
1010
1011 if (adev) {
1012 dev_set_name(&client->dev, "i2c-%s", acpi_dev_name(adev));
1013 return;
1014 }
1015
Jarkko Nikula70762ab2013-11-14 14:03:52 +02001016 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
Wolfram Sangda899f52015-05-18 21:09:12 +02001017 i2c_encode_flags_to_addr(client));
Jarkko Nikula70762ab2013-11-14 14:03:52 +02001018}
1019
Jean Delvarefe61e072010-08-11 18:20:58 +02001020/**
Jean Delvaref8a227e2009-06-19 16:58:18 +02001021 * i2c_new_device - instantiate an i2c device
David Brownell9c1600e2007-05-01 23:26:31 +02001022 * @adap: the adapter managing the device
1023 * @info: describes one I2C device; bus_num is ignored
David Brownelld64f73b2007-07-12 14:12:28 +02001024 * Context: can sleep
David Brownell9c1600e2007-05-01 23:26:31 +02001025 *
Jean Delvaref8a227e2009-06-19 16:58:18 +02001026 * Create an i2c device. Binding is handled through driver model
1027 * probe()/remove() methods. A driver may be bound to this device when we
1028 * return from this function, or any later moment (e.g. maybe hotplugging will
1029 * load the driver module). This call is not appropriate for use by mainboard
1030 * initialization logic, which usually runs during an arch_initcall() long
1031 * before any i2c_adapter could exist.
David Brownell9c1600e2007-05-01 23:26:31 +02001032 *
1033 * This returns the new i2c client, which may be saved for later use with
1034 * i2c_unregister_device(); or NULL to indicate an error.
1035 */
1036struct i2c_client *
1037i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
1038{
1039 struct i2c_client *client;
1040 int status;
1041
1042 client = kzalloc(sizeof *client, GFP_KERNEL);
1043 if (!client)
1044 return NULL;
1045
1046 client->adapter = adap;
1047
1048 client->dev.platform_data = info->platform_data;
David Brownell3bbb8352007-10-13 23:56:29 +02001049
Anton Vorontsov11f1f2a2008-10-22 20:21:33 +02001050 if (info->archdata)
1051 client->dev.archdata = *info->archdata;
1052
Marc Pignatee354252008-08-28 08:33:22 +02001053 client->flags = info->flags;
David Brownell9c1600e2007-05-01 23:26:31 +02001054 client->addr = info->addr;
1055 client->irq = info->irq;
1056
David Brownell9c1600e2007-05-01 23:26:31 +02001057 strlcpy(client->name, info->type, sizeof(client->name));
1058
Wolfram Sangc4019b72015-07-17 12:50:06 +02001059 status = i2c_check_addr_validity(client->addr, client->flags);
Jean Delvare3a89db52010-06-03 11:33:52 +02001060 if (status) {
1061 dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
1062 client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
1063 goto out_err_silent;
1064 }
1065
Jean Delvaref8a227e2009-06-19 16:58:18 +02001066 /* Check for address business */
Wolfram Sang9bccc702015-07-17 14:48:56 +02001067 status = i2c_check_addr_busy(adap, i2c_encode_flags_to_addr(client));
Jean Delvaref8a227e2009-06-19 16:58:18 +02001068 if (status)
1069 goto out_err;
1070
1071 client->dev.parent = &client->adapter->dev;
1072 client->dev.bus = &i2c_bus_type;
Jean Delvare51298d12009-09-18 22:45:45 +02001073 client->dev.type = &i2c_client_type;
Grant Likelyd12d42f2010-04-13 16:12:28 -07001074 client->dev.of_node = info->of_node;
Rafael J. Wysockice793482015-03-16 23:49:03 +01001075 client->dev.fwnode = info->fwnode;
Jean Delvaref8a227e2009-06-19 16:58:18 +02001076
Jarkko Nikula70762ab2013-11-14 14:03:52 +02001077 i2c_dev_set_name(adap, client);
Jean Delvaref8a227e2009-06-19 16:58:18 +02001078 status = device_register(&client->dev);
1079 if (status)
1080 goto out_err;
1081
Jean Delvaref8a227e2009-06-19 16:58:18 +02001082 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
1083 client->name, dev_name(&client->dev));
1084
David Brownell9c1600e2007-05-01 23:26:31 +02001085 return client;
Jean Delvaref8a227e2009-06-19 16:58:18 +02001086
1087out_err:
1088 dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
1089 "(%d)\n", client->name, client->addr, status);
Jean Delvare3a89db52010-06-03 11:33:52 +02001090out_err_silent:
Jean Delvaref8a227e2009-06-19 16:58:18 +02001091 kfree(client);
1092 return NULL;
David Brownell9c1600e2007-05-01 23:26:31 +02001093}
1094EXPORT_SYMBOL_GPL(i2c_new_device);
1095
1096
1097/**
1098 * i2c_unregister_device - reverse effect of i2c_new_device()
1099 * @client: value returned from i2c_new_device()
David Brownelld64f73b2007-07-12 14:12:28 +02001100 * Context: can sleep
David Brownell9c1600e2007-05-01 23:26:31 +02001101 */
1102void i2c_unregister_device(struct i2c_client *client)
David Brownella1d9e6e2007-05-01 23:26:30 +02001103{
Pantelis Antoniou4f001fd2015-01-24 09:16:29 +02001104 if (client->dev.of_node)
1105 of_node_clear_flag(client->dev.of_node, OF_POPULATED);
David Brownella1d9e6e2007-05-01 23:26:30 +02001106 device_unregister(&client->dev);
1107}
David Brownell9c1600e2007-05-01 23:26:31 +02001108EXPORT_SYMBOL_GPL(i2c_unregister_device);
David Brownella1d9e6e2007-05-01 23:26:30 +02001109
1110
Jean Delvare60b129d2008-05-11 20:37:06 +02001111static const struct i2c_device_id dummy_id[] = {
1112 { "dummy", 0 },
1113 { },
1114};
1115
Jean Delvared2653e92008-04-29 23:11:39 +02001116static int dummy_probe(struct i2c_client *client,
1117 const struct i2c_device_id *id)
1118{
1119 return 0;
1120}
1121
1122static int dummy_remove(struct i2c_client *client)
David Brownelle9f13732008-01-27 18:14:52 +01001123{
1124 return 0;
1125}
1126
1127static struct i2c_driver dummy_driver = {
1128 .driver.name = "dummy",
Jean Delvared2653e92008-04-29 23:11:39 +02001129 .probe = dummy_probe,
1130 .remove = dummy_remove,
Jean Delvare60b129d2008-05-11 20:37:06 +02001131 .id_table = dummy_id,
David Brownelle9f13732008-01-27 18:14:52 +01001132};
1133
1134/**
1135 * i2c_new_dummy - return a new i2c device bound to a dummy driver
1136 * @adapter: the adapter managing the device
1137 * @address: seven bit address to be used
David Brownelle9f13732008-01-27 18:14:52 +01001138 * Context: can sleep
1139 *
1140 * This returns an I2C client bound to the "dummy" driver, intended for use
1141 * with devices that consume multiple addresses. Examples of such chips
1142 * include various EEPROMS (like 24c04 and 24c08 models).
1143 *
1144 * These dummy devices have two main uses. First, most I2C and SMBus calls
1145 * except i2c_transfer() need a client handle; the dummy will be that handle.
1146 * And second, this prevents the specified address from being bound to a
1147 * different driver.
1148 *
1149 * This returns the new i2c client, which should be saved for later use with
1150 * i2c_unregister_device(); or NULL to indicate an error.
1151 */
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01001152struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
David Brownelle9f13732008-01-27 18:14:52 +01001153{
1154 struct i2c_board_info info = {
Jean Delvare60b129d2008-05-11 20:37:06 +02001155 I2C_BOARD_INFO("dummy", address),
David Brownelle9f13732008-01-27 18:14:52 +01001156 };
1157
David Brownelle9f13732008-01-27 18:14:52 +01001158 return i2c_new_device(adapter, &info);
1159}
1160EXPORT_SYMBOL_GPL(i2c_new_dummy);
1161
David Brownellf37dd802007-02-13 22:09:00 +01001162/* ------------------------------------------------------------------------- */
1163
David Brownell16ffadf2007-05-01 23:26:28 +02001164/* I2C bus adapters -- one roots each I2C or SMBUS segment */
1165
Adrian Bunk83eaaed2007-10-13 23:56:30 +02001166static void i2c_adapter_dev_release(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167{
David Brownellef2c83212007-05-01 23:26:28 +02001168 struct i2c_adapter *adap = to_i2c_adapter(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169 complete(&adap->dev_released);
1170}
1171
Jean Delvare99cd8e22009-06-19 16:58:20 +02001172/*
Jean Delvare390946b2012-09-10 10:14:02 +02001173 * This function is only needed for mutex_lock_nested, so it is never
1174 * called unless locking correctness checking is enabled. Thus we
1175 * make it inline to avoid a compiler warning. That's what gcc ends up
1176 * doing anyway.
1177 */
1178static inline unsigned int i2c_adapter_depth(struct i2c_adapter *adapter)
1179{
1180 unsigned int depth = 0;
1181
1182 while ((adapter = i2c_parent_is_i2c_adapter(adapter)))
1183 depth++;
1184
1185 return depth;
1186}
1187
1188/*
Jean Delvare99cd8e22009-06-19 16:58:20 +02001189 * Let users instantiate I2C devices through sysfs. This can be used when
1190 * platform initialization code doesn't contain the proper data for
1191 * whatever reason. Also useful for drivers that do device detection and
1192 * detection fails, either because the device uses an unexpected address,
1193 * or this is a compatible device with different ID register values.
1194 *
1195 * Parameter checking may look overzealous, but we really don't want
1196 * the user to provide incorrect parameters.
1197 */
1198static ssize_t
1199i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
1200 const char *buf, size_t count)
1201{
1202 struct i2c_adapter *adap = to_i2c_adapter(dev);
1203 struct i2c_board_info info;
1204 struct i2c_client *client;
1205 char *blank, end;
1206 int res;
1207
Jean Delvare99cd8e22009-06-19 16:58:20 +02001208 memset(&info, 0, sizeof(struct i2c_board_info));
1209
1210 blank = strchr(buf, ' ');
1211 if (!blank) {
1212 dev_err(dev, "%s: Missing parameters\n", "new_device");
1213 return -EINVAL;
1214 }
1215 if (blank - buf > I2C_NAME_SIZE - 1) {
1216 dev_err(dev, "%s: Invalid device name\n", "new_device");
1217 return -EINVAL;
1218 }
1219 memcpy(info.type, buf, blank - buf);
1220
1221 /* Parse remaining parameters, reject extra parameters */
1222 res = sscanf(++blank, "%hi%c", &info.addr, &end);
1223 if (res < 1) {
1224 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
1225 return -EINVAL;
1226 }
1227 if (res > 1 && end != '\n') {
1228 dev_err(dev, "%s: Extra parameters\n", "new_device");
1229 return -EINVAL;
1230 }
1231
Wolfram Sangcfa03272015-07-27 14:03:38 +02001232 if ((info.addr & I2C_ADDR_OFFSET_TEN_BIT) == I2C_ADDR_OFFSET_TEN_BIT) {
1233 info.addr &= ~I2C_ADDR_OFFSET_TEN_BIT;
1234 info.flags |= I2C_CLIENT_TEN;
1235 }
1236
1237 if (info.addr & I2C_ADDR_OFFSET_SLAVE) {
1238 info.addr &= ~I2C_ADDR_OFFSET_SLAVE;
1239 info.flags |= I2C_CLIENT_SLAVE;
1240 }
1241
Jean Delvare99cd8e22009-06-19 16:58:20 +02001242 client = i2c_new_device(adap, &info);
1243 if (!client)
Jean Delvare3a89db52010-06-03 11:33:52 +02001244 return -EINVAL;
Jean Delvare99cd8e22009-06-19 16:58:20 +02001245
1246 /* Keep track of the added device */
Jean Delvaredafc50d2010-08-11 18:21:01 +02001247 mutex_lock(&adap->userspace_clients_lock);
Jean Delvare6629dcf2010-05-04 11:09:28 +02001248 list_add_tail(&client->detected, &adap->userspace_clients);
Jean Delvaredafc50d2010-08-11 18:21:01 +02001249 mutex_unlock(&adap->userspace_clients_lock);
Jean Delvare99cd8e22009-06-19 16:58:20 +02001250 dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
1251 info.type, info.addr);
1252
1253 return count;
1254}
Wolfram Sanga5eb71b2015-01-19 20:12:24 +01001255static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
Jean Delvare99cd8e22009-06-19 16:58:20 +02001256
1257/*
1258 * And of course let the users delete the devices they instantiated, if
1259 * they got it wrong. This interface can only be used to delete devices
1260 * instantiated by i2c_sysfs_new_device above. This guarantees that we
1261 * don't delete devices to which some kernel code still has references.
1262 *
1263 * Parameter checking may look overzealous, but we really don't want
1264 * the user to delete the wrong device.
1265 */
1266static ssize_t
1267i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
1268 const char *buf, size_t count)
1269{
1270 struct i2c_adapter *adap = to_i2c_adapter(dev);
1271 struct i2c_client *client, *next;
1272 unsigned short addr;
1273 char end;
1274 int res;
1275
1276 /* Parse parameters, reject extra parameters */
1277 res = sscanf(buf, "%hi%c", &addr, &end);
1278 if (res < 1) {
1279 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
1280 return -EINVAL;
1281 }
1282 if (res > 1 && end != '\n') {
1283 dev_err(dev, "%s: Extra parameters\n", "delete_device");
1284 return -EINVAL;
1285 }
1286
1287 /* Make sure the device was added through sysfs */
1288 res = -ENOENT;
Jean Delvare390946b2012-09-10 10:14:02 +02001289 mutex_lock_nested(&adap->userspace_clients_lock,
1290 i2c_adapter_depth(adap));
Jean Delvare6629dcf2010-05-04 11:09:28 +02001291 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1292 detected) {
Wolfram Sangcfa03272015-07-27 14:03:38 +02001293 if (i2c_encode_flags_to_addr(client) == addr) {
Jean Delvare99cd8e22009-06-19 16:58:20 +02001294 dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
1295 "delete_device", client->name, client->addr);
1296
1297 list_del(&client->detected);
1298 i2c_unregister_device(client);
1299 res = count;
1300 break;
1301 }
1302 }
Jean Delvaredafc50d2010-08-11 18:21:01 +02001303 mutex_unlock(&adap->userspace_clients_lock);
Jean Delvare99cd8e22009-06-19 16:58:20 +02001304
1305 if (res < 0)
1306 dev_err(dev, "%s: Can't find device in list\n",
1307 "delete_device");
1308 return res;
1309}
Alexander Sverdline9b526f2013-05-17 14:56:35 +02001310static DEVICE_ATTR_IGNORE_LOCKDEP(delete_device, S_IWUSR, NULL,
1311 i2c_sysfs_delete_device);
Jean Delvare4f8cf822009-09-18 22:45:46 +02001312
1313static struct attribute *i2c_adapter_attrs[] = {
1314 &dev_attr_name.attr,
1315 &dev_attr_new_device.attr,
1316 &dev_attr_delete_device.attr,
1317 NULL
David Brownell16ffadf2007-05-01 23:26:28 +02001318};
Wolfram Sanga5eb71b2015-01-19 20:12:24 +01001319ATTRIBUTE_GROUPS(i2c_adapter);
Jean Delvare4f8cf822009-09-18 22:45:46 +02001320
Michael Lawnick08263742010-08-11 18:21:02 +02001321struct device_type i2c_adapter_type = {
Wolfram Sanga5eb71b2015-01-19 20:12:24 +01001322 .groups = i2c_adapter_groups,
Jean Delvare4f8cf822009-09-18 22:45:46 +02001323 .release = i2c_adapter_dev_release,
David Brownell16ffadf2007-05-01 23:26:28 +02001324};
Michael Lawnick08263742010-08-11 18:21:02 +02001325EXPORT_SYMBOL_GPL(i2c_adapter_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326
Stephen Warren643dd092012-04-17 12:43:33 -06001327/**
1328 * i2c_verify_adapter - return parameter as i2c_adapter or NULL
1329 * @dev: device, probably from some driver model iterator
1330 *
1331 * When traversing the driver model tree, perhaps using driver model
1332 * iterators like @device_for_each_child(), you can't assume very much
1333 * about the nodes you find. Use this function to avoid oopses caused
1334 * by wrongly treating some non-I2C device as an i2c_adapter.
1335 */
1336struct i2c_adapter *i2c_verify_adapter(struct device *dev)
1337{
1338 return (dev->type == &i2c_adapter_type)
1339 ? to_i2c_adapter(dev)
1340 : NULL;
1341}
1342EXPORT_SYMBOL(i2c_verify_adapter);
1343
Jean Delvare2bb50952009-09-18 22:45:46 +02001344#ifdef CONFIG_I2C_COMPAT
1345static struct class_compat *i2c_adapter_compat_class;
1346#endif
1347
David Brownell9c1600e2007-05-01 23:26:31 +02001348static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
1349{
1350 struct i2c_devinfo *devinfo;
1351
Rodolfo Giomettif18c41d2009-06-19 16:58:20 +02001352 down_read(&__i2c_board_lock);
David Brownell9c1600e2007-05-01 23:26:31 +02001353 list_for_each_entry(devinfo, &__i2c_board_list, list) {
1354 if (devinfo->busnum == adapter->nr
1355 && !i2c_new_device(adapter,
1356 &devinfo->board_info))
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01001357 dev_err(&adapter->dev,
1358 "Can't create device at 0x%02x\n",
David Brownell9c1600e2007-05-01 23:26:31 +02001359 devinfo->board_info.addr);
1360 }
Rodolfo Giomettif18c41d2009-06-19 16:58:20 +02001361 up_read(&__i2c_board_lock);
David Brownell9c1600e2007-05-01 23:26:31 +02001362}
1363
Wolfram Sang687b81d2013-07-11 12:56:15 +01001364/* OF support code */
1365
1366#if IS_ENABLED(CONFIG_OF)
Pantelis Antonioua430a3452014-10-28 22:36:02 +02001367static struct i2c_client *of_i2c_register_device(struct i2c_adapter *adap,
1368 struct device_node *node)
1369{
1370 struct i2c_client *result;
1371 struct i2c_board_info info = {};
1372 struct dev_archdata dev_ad = {};
Wolfram Sangb4e2f6a2015-05-19 21:04:40 +02001373 const __be32 *addr_be;
1374 u32 addr;
Pantelis Antonioua430a3452014-10-28 22:36:02 +02001375 int len;
1376
1377 dev_dbg(&adap->dev, "of_i2c: register %s\n", node->full_name);
1378
1379 if (of_modalias_node(node, info.type, sizeof(info.type)) < 0) {
1380 dev_err(&adap->dev, "of_i2c: modalias failure on %s\n",
1381 node->full_name);
1382 return ERR_PTR(-EINVAL);
1383 }
1384
Wolfram Sangb4e2f6a2015-05-19 21:04:40 +02001385 addr_be = of_get_property(node, "reg", &len);
1386 if (!addr_be || (len < sizeof(*addr_be))) {
Pantelis Antonioua430a3452014-10-28 22:36:02 +02001387 dev_err(&adap->dev, "of_i2c: invalid reg on %s\n",
1388 node->full_name);
1389 return ERR_PTR(-EINVAL);
1390 }
1391
Wolfram Sangb4e2f6a2015-05-19 21:04:40 +02001392 addr = be32_to_cpup(addr_be);
1393 if (addr & I2C_TEN_BIT_ADDRESS) {
1394 addr &= ~I2C_TEN_BIT_ADDRESS;
1395 info.flags |= I2C_CLIENT_TEN;
1396 }
1397
1398 if (addr & I2C_OWN_SLAVE_ADDRESS) {
1399 addr &= ~I2C_OWN_SLAVE_ADDRESS;
1400 info.flags |= I2C_CLIENT_SLAVE;
1401 }
1402
1403 if (i2c_check_addr_validity(addr, info.flags)) {
Pantelis Antonioua430a3452014-10-28 22:36:02 +02001404 dev_err(&adap->dev, "of_i2c: invalid addr=%x on %s\n",
1405 info.addr, node->full_name);
1406 return ERR_PTR(-EINVAL);
1407 }
1408
Wolfram Sangb4e2f6a2015-05-19 21:04:40 +02001409 info.addr = addr;
Pantelis Antonioua430a3452014-10-28 22:36:02 +02001410 info.of_node = of_node_get(node);
1411 info.archdata = &dev_ad;
1412
1413 if (of_get_property(node, "wakeup-source", NULL))
1414 info.flags |= I2C_CLIENT_WAKE;
1415
Pantelis Antonioua430a3452014-10-28 22:36:02 +02001416 result = i2c_new_device(adap, &info);
1417 if (result == NULL) {
1418 dev_err(&adap->dev, "of_i2c: Failure registering %s\n",
1419 node->full_name);
1420 of_node_put(node);
Pantelis Antonioua430a3452014-10-28 22:36:02 +02001421 return ERR_PTR(-EINVAL);
1422 }
1423 return result;
1424}
1425
Wolfram Sang687b81d2013-07-11 12:56:15 +01001426static void of_i2c_register_devices(struct i2c_adapter *adap)
1427{
Wolfram Sang687b81d2013-07-11 12:56:15 +01001428 struct device_node *node;
1429
1430 /* Only register child devices if the adapter has a node pointer set */
1431 if (!adap->dev.of_node)
1432 return;
1433
1434 dev_dbg(&adap->dev, "of_i2c: walking child nodes\n");
1435
Pantelis Antoniou4f001fd2015-01-24 09:16:29 +02001436 for_each_available_child_of_node(adap->dev.of_node, node) {
1437 if (of_node_test_and_set_flag(node, OF_POPULATED))
1438 continue;
Pantelis Antonioua430a3452014-10-28 22:36:02 +02001439 of_i2c_register_device(adap, node);
Pantelis Antoniou4f001fd2015-01-24 09:16:29 +02001440 }
Wolfram Sang687b81d2013-07-11 12:56:15 +01001441}
1442
1443static int of_dev_node_match(struct device *dev, void *data)
1444{
1445 return dev->of_node == data;
1446}
1447
1448/* must call put_device() when done with returned i2c_client device */
1449struct i2c_client *of_find_i2c_device_by_node(struct device_node *node)
1450{
1451 struct device *dev;
Vladimir Zapolskiye3311462015-07-27 17:30:48 +03001452 struct i2c_client *client;
Wolfram Sang687b81d2013-07-11 12:56:15 +01001453
Vladimir Zapolskiye3311462015-07-27 17:30:48 +03001454 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
Wolfram Sang687b81d2013-07-11 12:56:15 +01001455 if (!dev)
1456 return NULL;
1457
Vladimir Zapolskiye3311462015-07-27 17:30:48 +03001458 client = i2c_verify_client(dev);
1459 if (!client)
1460 put_device(dev);
1461
1462 return client;
Wolfram Sang687b81d2013-07-11 12:56:15 +01001463}
1464EXPORT_SYMBOL(of_find_i2c_device_by_node);
1465
1466/* must call put_device() when done with returned i2c_adapter device */
1467struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node)
1468{
1469 struct device *dev;
Vladimir Zapolskiye3311462015-07-27 17:30:48 +03001470 struct i2c_adapter *adapter;
Wolfram Sang687b81d2013-07-11 12:56:15 +01001471
Vladimir Zapolskiye3311462015-07-27 17:30:48 +03001472 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
Wolfram Sang687b81d2013-07-11 12:56:15 +01001473 if (!dev)
1474 return NULL;
1475
Vladimir Zapolskiye3311462015-07-27 17:30:48 +03001476 adapter = i2c_verify_adapter(dev);
1477 if (!adapter)
1478 put_device(dev);
1479
1480 return adapter;
Wolfram Sang687b81d2013-07-11 12:56:15 +01001481}
1482EXPORT_SYMBOL(of_find_i2c_adapter_by_node);
Vladimir Zapolskiy48e97432015-07-27 17:30:50 +03001483
1484/* must call i2c_put_adapter() when done with returned i2c_adapter device */
1485struct i2c_adapter *of_get_i2c_adapter_by_node(struct device_node *node)
1486{
1487 struct i2c_adapter *adapter;
1488
1489 adapter = of_find_i2c_adapter_by_node(node);
1490 if (!adapter)
1491 return NULL;
1492
1493 if (!try_module_get(adapter->owner)) {
1494 put_device(&adapter->dev);
1495 adapter = NULL;
1496 }
1497
1498 return adapter;
1499}
1500EXPORT_SYMBOL(of_get_i2c_adapter_by_node);
Wolfram Sang687b81d2013-07-11 12:56:15 +01001501#else
1502static void of_i2c_register_devices(struct i2c_adapter *adap) { }
1503#endif /* CONFIG_OF */
1504
Jean Delvare69b00892009-12-06 17:06:27 +01001505static int i2c_do_add_adapter(struct i2c_driver *driver,
1506 struct i2c_adapter *adap)
Jean Delvare026526f2008-01-27 18:14:49 +01001507{
Jean Delvare4735c982008-07-14 22:38:36 +02001508 /* Detect supported devices on that bus, and instantiate them */
1509 i2c_detect(adap, driver);
1510
1511 /* Let legacy drivers scan this bus for matching devices */
Jean Delvare026526f2008-01-27 18:14:49 +01001512 if (driver->attach_adapter) {
Jean Delvarea920ff42011-04-17 10:20:19 +02001513 dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
1514 driver->driver.name);
Jean Delvarefe6fc252011-03-20 14:50:53 +01001515 dev_warn(&adap->dev, "Please use another way to instantiate "
1516 "your i2c_client\n");
Jean Delvare026526f2008-01-27 18:14:49 +01001517 /* We ignore the return code; if it fails, too bad */
1518 driver->attach_adapter(adap);
1519 }
1520 return 0;
1521}
1522
Jean Delvare69b00892009-12-06 17:06:27 +01001523static int __process_new_adapter(struct device_driver *d, void *data)
1524{
1525 return i2c_do_add_adapter(to_i2c_driver(d), data);
1526}
1527
David Brownell6e13e642007-05-01 23:26:31 +02001528static int i2c_register_adapter(struct i2c_adapter *adap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529{
Jean Delvared6703282010-08-11 18:20:59 +02001530 int res = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531
David Brownell1d0b19c2008-10-14 17:30:05 +02001532 /* Can't register until after driver model init */
Sudip Mukherjee95026652016-03-07 17:19:17 +05301533 if (WARN_ON(!is_registered)) {
Jean Delvare35fc37f2009-06-19 16:58:19 +02001534 res = -EAGAIN;
1535 goto out_list;
1536 }
David Brownell1d0b19c2008-10-14 17:30:05 +02001537
Jean Delvare2236baa2010-11-15 22:40:38 +01001538 /* Sanity checks */
1539 if (unlikely(adap->name[0] == '\0')) {
1540 pr_err("i2c-core: Attempt to register an adapter with "
1541 "no name!\n");
1542 return -EINVAL;
1543 }
1544 if (unlikely(!adap->algo)) {
1545 pr_err("i2c-core: Attempt to register adapter '%s' with "
1546 "no algo!\n", adap->name);
1547 return -EINVAL;
1548 }
1549
Mika Kuoppala194684e2009-12-06 17:06:22 +01001550 rt_mutex_init(&adap->bus_lock);
Jean Delvaredafc50d2010-08-11 18:21:01 +02001551 mutex_init(&adap->userspace_clients_lock);
Jean Delvare6629dcf2010-05-04 11:09:28 +02001552 INIT_LIST_HEAD(&adap->userspace_clients);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001553
Jean Delvare8fcfef62009-03-28 21:34:43 +01001554 /* Set default timeout to 1 second if not already set */
1555 if (adap->timeout == 0)
1556 adap->timeout = HZ;
1557
Kay Sievers27d9c182009-01-07 14:29:16 +01001558 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
Jean Delvare4f8cf822009-09-18 22:45:46 +02001559 adap->dev.bus = &i2c_bus_type;
1560 adap->dev.type = &i2c_adapter_type;
Jean Delvareb119c6c2006-08-15 18:26:30 +02001561 res = device_register(&adap->dev);
1562 if (res)
1563 goto out_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564
Jean Delvareb6d7b3d2005-07-31 19:02:53 +02001565 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
1566
Charles Keepax6ada5c12015-04-16 13:05:19 +01001567 pm_runtime_no_callbacks(&adap->dev);
Wolfram Sang9f924162015-12-23 18:19:28 +01001568 pm_runtime_enable(&adap->dev);
Charles Keepax6ada5c12015-04-16 13:05:19 +01001569
Jean Delvare2bb50952009-09-18 22:45:46 +02001570#ifdef CONFIG_I2C_COMPAT
1571 res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
1572 adap->dev.parent);
1573 if (res)
1574 dev_warn(&adap->dev,
1575 "Failed to create compatibility class link\n");
1576#endif
1577
Viresh Kumar5f9296b2012-02-28 18:26:31 +05301578 /* bus recovery specific initialization */
1579 if (adap->bus_recovery_info) {
1580 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
1581
1582 if (!bri->recover_bus) {
1583 dev_err(&adap->dev, "No recover_bus() found, not using recovery\n");
1584 adap->bus_recovery_info = NULL;
1585 goto exit_recovery;
1586 }
1587
1588 /* Generic GPIO recovery */
1589 if (bri->recover_bus == i2c_generic_gpio_recovery) {
1590 if (!gpio_is_valid(bri->scl_gpio)) {
1591 dev_err(&adap->dev, "Invalid SCL gpio, not using recovery\n");
1592 adap->bus_recovery_info = NULL;
1593 goto exit_recovery;
1594 }
1595
1596 if (gpio_is_valid(bri->sda_gpio))
1597 bri->get_sda = get_sda_gpio_value;
1598 else
1599 bri->get_sda = NULL;
1600
1601 bri->get_scl = get_scl_gpio_value;
1602 bri->set_scl = set_scl_gpio_value;
1603 } else if (!bri->set_scl || !bri->get_scl) {
1604 /* Generic SCL recovery */
1605 dev_err(&adap->dev, "No {get|set}_gpio() found, not using recovery\n");
1606 adap->bus_recovery_info = NULL;
1607 }
1608 }
1609
1610exit_recovery:
Jean Delvare729d6dd2009-06-19 16:58:18 +02001611 /* create pre-declared device nodes */
Wolfram Sang687b81d2013-07-11 12:56:15 +01001612 of_i2c_register_devices(adap);
Mika Westerberg55e71ed2013-08-21 17:28:23 +03001613 acpi_i2c_register_devices(adap);
Lan Tianyu5d98e612014-05-20 20:59:23 +08001614 acpi_i2c_install_space_handler(adap);
Wolfram Sang687b81d2013-07-11 12:56:15 +01001615
David Brownell6e13e642007-05-01 23:26:31 +02001616 if (adap->nr < __i2c_first_dynamic_bus_num)
1617 i2c_scan_static_board_info(adap);
1618
Jean Delvare4735c982008-07-14 22:38:36 +02001619 /* Notify drivers */
Jean Delvare35fc37f2009-06-19 16:58:19 +02001620 mutex_lock(&core_lock);
Jean Delvared6703282010-08-11 18:20:59 +02001621 bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
Jean Delvarecaada322008-01-27 18:14:49 +01001622 mutex_unlock(&core_lock);
Jean Delvare35fc37f2009-06-19 16:58:19 +02001623
1624 return 0;
Jean Delvareb119c6c2006-08-15 18:26:30 +02001625
Jean Delvareb119c6c2006-08-15 18:26:30 +02001626out_list:
Jean Delvare35fc37f2009-06-19 16:58:19 +02001627 mutex_lock(&core_lock);
Jean Delvareb119c6c2006-08-15 18:26:30 +02001628 idr_remove(&i2c_adapter_idr, adap->nr);
Jean Delvare35fc37f2009-06-19 16:58:19 +02001629 mutex_unlock(&core_lock);
1630 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631}
1632
David Brownell6e13e642007-05-01 23:26:31 +02001633/**
Doug Andersonee5c2742013-03-01 08:57:31 -08001634 * __i2c_add_numbered_adapter - i2c_add_numbered_adapter where nr is never -1
1635 * @adap: the adapter to register (with adap->nr initialized)
1636 * Context: can sleep
1637 *
1638 * See i2c_add_numbered_adapter() for details.
1639 */
1640static int __i2c_add_numbered_adapter(struct i2c_adapter *adap)
1641{
1642 int id;
1643
1644 mutex_lock(&core_lock);
1645 id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1,
1646 GFP_KERNEL);
1647 mutex_unlock(&core_lock);
1648 if (id < 0)
1649 return id == -ENOSPC ? -EBUSY : id;
1650
1651 return i2c_register_adapter(adap);
1652}
1653
1654/**
David Brownell6e13e642007-05-01 23:26:31 +02001655 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
1656 * @adapter: the adapter to add
David Brownelld64f73b2007-07-12 14:12:28 +02001657 * Context: can sleep
David Brownell6e13e642007-05-01 23:26:31 +02001658 *
1659 * This routine is used to declare an I2C adapter when its bus number
Doug Andersonee5c2742013-03-01 08:57:31 -08001660 * doesn't matter or when its bus number is specified by an dt alias.
1661 * Examples of bases when the bus number doesn't matter: I2C adapters
1662 * dynamically added by USB links or PCI plugin cards.
David Brownell6e13e642007-05-01 23:26:31 +02001663 *
1664 * When this returns zero, a new bus number was allocated and stored
1665 * in adap->nr, and the specified adapter became available for clients.
1666 * Otherwise, a negative errno value is returned.
1667 */
1668int i2c_add_adapter(struct i2c_adapter *adapter)
1669{
Doug Andersonee5c2742013-03-01 08:57:31 -08001670 struct device *dev = &adapter->dev;
Tejun Heo4ae42b0f2013-02-27 17:04:15 -08001671 int id;
David Brownell6e13e642007-05-01 23:26:31 +02001672
Doug Andersonee5c2742013-03-01 08:57:31 -08001673 if (dev->of_node) {
1674 id = of_alias_get_id(dev->of_node, "i2c");
1675 if (id >= 0) {
1676 adapter->nr = id;
1677 return __i2c_add_numbered_adapter(adapter);
1678 }
1679 }
1680
Jean Delvarecaada322008-01-27 18:14:49 +01001681 mutex_lock(&core_lock);
Tejun Heo4ae42b0f2013-02-27 17:04:15 -08001682 id = idr_alloc(&i2c_adapter_idr, adapter,
1683 __i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
Jean Delvarecaada322008-01-27 18:14:49 +01001684 mutex_unlock(&core_lock);
Tejun Heo4ae42b0f2013-02-27 17:04:15 -08001685 if (id < 0)
1686 return id;
David Brownell6e13e642007-05-01 23:26:31 +02001687
1688 adapter->nr = id;
Tejun Heo4ae42b0f2013-02-27 17:04:15 -08001689
David Brownell6e13e642007-05-01 23:26:31 +02001690 return i2c_register_adapter(adapter);
1691}
1692EXPORT_SYMBOL(i2c_add_adapter);
1693
1694/**
1695 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
1696 * @adap: the adapter to register (with adap->nr initialized)
David Brownelld64f73b2007-07-12 14:12:28 +02001697 * Context: can sleep
David Brownell6e13e642007-05-01 23:26:31 +02001698 *
1699 * This routine is used to declare an I2C adapter when its bus number
Randy Dunlap8c07e462008-03-23 20:28:20 +01001700 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
1701 * or otherwise built in to the system's mainboard, and where i2c_board_info
David Brownell6e13e642007-05-01 23:26:31 +02001702 * is used to properly configure I2C devices.
1703 *
Grant Likely488bf312011-07-25 17:49:43 +02001704 * If the requested bus number is set to -1, then this function will behave
1705 * identically to i2c_add_adapter, and will dynamically assign a bus number.
1706 *
David Brownell6e13e642007-05-01 23:26:31 +02001707 * If no devices have pre-been declared for this bus, then be sure to
1708 * register the adapter before any dynamically allocated ones. Otherwise
1709 * the required bus ID may not be available.
1710 *
1711 * When this returns zero, the specified adapter became available for
1712 * clients using the bus number provided in adap->nr. Also, the table
1713 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
1714 * and the appropriate driver model device nodes are created. Otherwise, a
1715 * negative errno value is returned.
1716 */
1717int i2c_add_numbered_adapter(struct i2c_adapter *adap)
1718{
Grant Likely488bf312011-07-25 17:49:43 +02001719 if (adap->nr == -1) /* -1 means dynamically assign bus id */
1720 return i2c_add_adapter(adap);
David Brownell6e13e642007-05-01 23:26:31 +02001721
Doug Andersonee5c2742013-03-01 08:57:31 -08001722 return __i2c_add_numbered_adapter(adap);
David Brownell6e13e642007-05-01 23:26:31 +02001723}
1724EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
1725
Lars-Peter Clausen19baba42013-03-09 08:16:44 +00001726static void i2c_do_del_adapter(struct i2c_driver *driver,
Jean Delvare69b00892009-12-06 17:06:27 +01001727 struct i2c_adapter *adapter)
Jean Delvare026526f2008-01-27 18:14:49 +01001728{
Jean Delvare4735c982008-07-14 22:38:36 +02001729 struct i2c_client *client, *_n;
Jean Delvare026526f2008-01-27 18:14:49 +01001730
Jean Delvareacec2112009-03-28 21:34:40 +01001731 /* Remove the devices we created ourselves as the result of hardware
1732 * probing (using a driver's detect method) */
Jean Delvare4735c982008-07-14 22:38:36 +02001733 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
1734 if (client->adapter == adapter) {
1735 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
1736 client->name, client->addr);
1737 list_del(&client->detected);
1738 i2c_unregister_device(client);
1739 }
1740 }
Jean Delvare026526f2008-01-27 18:14:49 +01001741}
1742
Jean Delvaree549c2b2009-06-19 16:58:19 +02001743static int __unregister_client(struct device *dev, void *dummy)
1744{
1745 struct i2c_client *client = i2c_verify_client(dev);
Jean Delvare5219bf82011-01-14 22:03:49 +01001746 if (client && strcmp(client->name, "dummy"))
1747 i2c_unregister_device(client);
1748 return 0;
1749}
1750
1751static int __unregister_dummy(struct device *dev, void *dummy)
1752{
1753 struct i2c_client *client = i2c_verify_client(dev);
Jean Delvaree549c2b2009-06-19 16:58:19 +02001754 if (client)
1755 i2c_unregister_device(client);
1756 return 0;
1757}
1758
Jean Delvare69b00892009-12-06 17:06:27 +01001759static int __process_removed_adapter(struct device_driver *d, void *data)
1760{
Lars-Peter Clausen19baba42013-03-09 08:16:44 +00001761 i2c_do_del_adapter(to_i2c_driver(d), data);
1762 return 0;
Jean Delvare69b00892009-12-06 17:06:27 +01001763}
1764
David Brownelld64f73b2007-07-12 14:12:28 +02001765/**
1766 * i2c_del_adapter - unregister I2C adapter
1767 * @adap: the adapter being unregistered
1768 * Context: can sleep
1769 *
1770 * This unregisters an I2C adapter which was previously registered
1771 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
1772 */
Lars-Peter Clausen71546302013-03-09 08:16:47 +00001773void i2c_del_adapter(struct i2c_adapter *adap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774{
Jean Delvare35fc37f2009-06-19 16:58:19 +02001775 struct i2c_adapter *found;
Jean Delvarebbd2d9c2009-11-26 09:22:33 +01001776 struct i2c_client *client, *next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777
1778 /* First make sure that this adapter was ever added */
Jean Delvare35fc37f2009-06-19 16:58:19 +02001779 mutex_lock(&core_lock);
1780 found = idr_find(&i2c_adapter_idr, adap->nr);
1781 mutex_unlock(&core_lock);
1782 if (found != adap) {
Jean Delvareb6d7b3d2005-07-31 19:02:53 +02001783 pr_debug("i2c-core: attempting to delete unregistered "
1784 "adapter [%s]\n", adap->name);
Lars-Peter Clausen71546302013-03-09 08:16:47 +00001785 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786 }
1787
Lan Tianyu5d98e612014-05-20 20:59:23 +08001788 acpi_i2c_remove_space_handler(adap);
Jean Delvare026526f2008-01-27 18:14:49 +01001789 /* Tell drivers about this removal */
Jean Delvare35fc37f2009-06-19 16:58:19 +02001790 mutex_lock(&core_lock);
Lars-Peter Clausen19baba42013-03-09 08:16:44 +00001791 bus_for_each_drv(&i2c_bus_type, NULL, adap,
Jean Delvare69b00892009-12-06 17:06:27 +01001792 __process_removed_adapter);
Jean Delvare35fc37f2009-06-19 16:58:19 +02001793 mutex_unlock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794
Jean Delvarebbd2d9c2009-11-26 09:22:33 +01001795 /* Remove devices instantiated from sysfs */
Jean Delvare390946b2012-09-10 10:14:02 +02001796 mutex_lock_nested(&adap->userspace_clients_lock,
1797 i2c_adapter_depth(adap));
Jean Delvare6629dcf2010-05-04 11:09:28 +02001798 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1799 detected) {
1800 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
1801 client->addr);
1802 list_del(&client->detected);
1803 i2c_unregister_device(client);
Jean Delvarebbd2d9c2009-11-26 09:22:33 +01001804 }
Jean Delvaredafc50d2010-08-11 18:21:01 +02001805 mutex_unlock(&adap->userspace_clients_lock);
Jean Delvarebbd2d9c2009-11-26 09:22:33 +01001806
Jean Delvaree549c2b2009-06-19 16:58:19 +02001807 /* Detach any active clients. This can't fail, thus we do not
Jean Delvare5219bf82011-01-14 22:03:49 +01001808 * check the returned value. This is a two-pass process, because
1809 * we can't remove the dummy devices during the first pass: they
1810 * could have been instantiated by real devices wishing to clean
1811 * them up properly, so we give them a chance to do that first. */
Lars-Peter Clausen19baba42013-03-09 08:16:44 +00001812 device_for_each_child(&adap->dev, NULL, __unregister_client);
1813 device_for_each_child(&adap->dev, NULL, __unregister_dummy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814
Jean Delvare2bb50952009-09-18 22:45:46 +02001815#ifdef CONFIG_I2C_COMPAT
1816 class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
1817 adap->dev.parent);
1818#endif
1819
Thadeu Lima de Souza Cascardoc5567522010-01-16 20:43:13 +01001820 /* device name is gone after device_unregister */
1821 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
1822
Wolfram Sang9f924162015-12-23 18:19:28 +01001823 pm_runtime_disable(&adap->dev);
1824
Wolfram Sang26680ee2015-01-29 22:45:09 +01001825 /* wait until all references to the device are gone
1826 *
1827 * FIXME: This is old code and should ideally be replaced by an
1828 * alternative which results in decoupling the lifetime of the struct
1829 * device from the i2c_adapter, like spi or netdev do. Any solution
Shailendra Verma95cc1e32015-05-18 22:24:01 +05301830 * should be thoroughly tested with DEBUG_KOBJECT_RELEASE enabled!
Wolfram Sang26680ee2015-01-29 22:45:09 +01001831 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832 init_completion(&adap->dev_released);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001833 device_unregister(&adap->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834 wait_for_completion(&adap->dev_released);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835
David Brownell6e13e642007-05-01 23:26:31 +02001836 /* free bus id */
Jean Delvare35fc37f2009-06-19 16:58:19 +02001837 mutex_lock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838 idr_remove(&i2c_adapter_idr, adap->nr);
Jean Delvare35fc37f2009-06-19 16:58:19 +02001839 mutex_unlock(&core_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001840
Jean Delvarebd4bc3db2008-07-16 19:30:05 +02001841 /* Clear the device structure in case this adapter is ever going to be
1842 added again */
1843 memset(&adap->dev, 0, sizeof(adap->dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844}
David Brownellc0564602007-05-01 23:26:31 +02001845EXPORT_SYMBOL(i2c_del_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846
Wolfram Sang54177cc2015-12-17 13:32:36 +01001847/**
1848 * i2c_parse_fw_timings - get I2C related timing parameters from firmware
1849 * @dev: The device to scan for I2C timing properties
1850 * @t: the i2c_timings struct to be filled with values
1851 * @use_defaults: bool to use sane defaults derived from the I2C specification
1852 * when properties are not found, otherwise use 0
1853 *
1854 * Scan the device for the generic I2C properties describing timing parameters
1855 * for the signal and fill the given struct with the results. If a property was
1856 * not found and use_defaults was true, then maximum timings are assumed which
1857 * are derived from the I2C specification. If use_defaults is not used, the
1858 * results will be 0, so drivers can apply their own defaults later. The latter
1859 * is mainly intended for avoiding regressions of existing drivers which want
1860 * to switch to this function. New drivers almost always should use the defaults.
1861 */
1862
1863void i2c_parse_fw_timings(struct device *dev, struct i2c_timings *t, bool use_defaults)
1864{
1865 int ret;
1866
1867 memset(t, 0, sizeof(*t));
1868
1869 ret = device_property_read_u32(dev, "clock-frequency", &t->bus_freq_hz);
1870 if (ret && use_defaults)
1871 t->bus_freq_hz = 100000;
1872
1873 ret = device_property_read_u32(dev, "i2c-scl-rising-time-ns", &t->scl_rise_ns);
1874 if (ret && use_defaults) {
1875 if (t->bus_freq_hz <= 100000)
1876 t->scl_rise_ns = 1000;
1877 else if (t->bus_freq_hz <= 400000)
1878 t->scl_rise_ns = 300;
1879 else
1880 t->scl_rise_ns = 120;
1881 }
1882
1883 ret = device_property_read_u32(dev, "i2c-scl-falling-time-ns", &t->scl_fall_ns);
1884 if (ret && use_defaults) {
1885 if (t->bus_freq_hz <= 400000)
1886 t->scl_fall_ns = 300;
1887 else
1888 t->scl_fall_ns = 120;
1889 }
1890
1891 device_property_read_u32(dev, "i2c-scl-internal-delay-ns", &t->scl_int_delay_ns);
1892
1893 ret = device_property_read_u32(dev, "i2c-sda-falling-time-ns", &t->sda_fall_ns);
1894 if (ret && use_defaults)
1895 t->sda_fall_ns = t->scl_fall_ns;
1896}
1897EXPORT_SYMBOL_GPL(i2c_parse_fw_timings);
1898
David Brownell7b4fbc52007-05-01 23:26:30 +02001899/* ------------------------------------------------------------------------- */
1900
Jean Delvare7ae31482011-03-20 14:50:52 +01001901int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
1902{
1903 int res;
1904
1905 mutex_lock(&core_lock);
1906 res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
1907 mutex_unlock(&core_lock);
1908
1909 return res;
1910}
1911EXPORT_SYMBOL_GPL(i2c_for_each_dev);
1912
Jean Delvare69b00892009-12-06 17:06:27 +01001913static int __process_new_driver(struct device *dev, void *data)
Dave Young7f101a92008-07-14 22:38:19 +02001914{
Jean Delvare4f8cf822009-09-18 22:45:46 +02001915 if (dev->type != &i2c_adapter_type)
1916 return 0;
Jean Delvare69b00892009-12-06 17:06:27 +01001917 return i2c_do_add_adapter(data, to_i2c_adapter(dev));
Dave Young7f101a92008-07-14 22:38:19 +02001918}
1919
David Brownell7b4fbc52007-05-01 23:26:30 +02001920/*
1921 * An i2c_driver is used with one or more i2c_client (device) nodes to access
Jean Delvare729d6dd2009-06-19 16:58:18 +02001922 * i2c slave chips, on a bus instance associated with some i2c_adapter.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923 */
1924
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -08001925int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926{
Jean Delvare7eebcb72006-02-05 23:28:21 +01001927 int res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928
David Brownell1d0b19c2008-10-14 17:30:05 +02001929 /* Can't register until after driver model init */
Sudip Mukherjee95026652016-03-07 17:19:17 +05301930 if (WARN_ON(!is_registered))
David Brownell1d0b19c2008-10-14 17:30:05 +02001931 return -EAGAIN;
1932
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933 /* add the driver to the list of i2c drivers in the driver core */
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -08001934 driver->driver.owner = owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935 driver->driver.bus = &i2c_bus_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001936
Jean Delvare729d6dd2009-06-19 16:58:18 +02001937 /* When registration returns, the driver core
David Brownell6e13e642007-05-01 23:26:31 +02001938 * will have called probe() for all matching-but-unbound devices.
1939 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940 res = driver_register(&driver->driver);
1941 if (res)
Jean Delvare7eebcb72006-02-05 23:28:21 +01001942 return res;
David Brownell438d6c22006-12-10 21:21:31 +01001943
Laurent Riffard35d8b2e2005-11-26 20:34:05 +01001944 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001945
Jean Delvare4735c982008-07-14 22:38:36 +02001946 INIT_LIST_HEAD(&driver->clients);
1947 /* Walk the adapters that are already present */
Jean Delvare7ae31482011-03-20 14:50:52 +01001948 i2c_for_each_dev(driver, __process_new_driver);
Jean Delvare35fc37f2009-06-19 16:58:19 +02001949
Jean Delvare7eebcb72006-02-05 23:28:21 +01001950 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951}
Greg Kroah-Hartmande59cf92005-12-06 15:33:15 -08001952EXPORT_SYMBOL(i2c_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001953
Jean Delvare69b00892009-12-06 17:06:27 +01001954static int __process_removed_driver(struct device *dev, void *data)
Dave Young7f101a92008-07-14 22:38:19 +02001955{
Lars-Peter Clausen19baba42013-03-09 08:16:44 +00001956 if (dev->type == &i2c_adapter_type)
1957 i2c_do_del_adapter(data, to_i2c_adapter(dev));
1958 return 0;
Dave Young7f101a92008-07-14 22:38:19 +02001959}
1960
David Brownella1d9e6e2007-05-01 23:26:30 +02001961/**
1962 * i2c_del_driver - unregister I2C driver
1963 * @driver: the driver being unregistered
David Brownelld64f73b2007-07-12 14:12:28 +02001964 * Context: can sleep
David Brownella1d9e6e2007-05-01 23:26:30 +02001965 */
Jean Delvareb3e82092007-05-01 23:26:32 +02001966void i2c_del_driver(struct i2c_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967{
Jean Delvare7ae31482011-03-20 14:50:52 +01001968 i2c_for_each_dev(driver, __process_removed_driver);
David Brownella1d9e6e2007-05-01 23:26:30 +02001969
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970 driver_unregister(&driver->driver);
Laurent Riffard35d8b2e2005-11-26 20:34:05 +01001971 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972}
David Brownellc0564602007-05-01 23:26:31 +02001973EXPORT_SYMBOL(i2c_del_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001974
David Brownell7b4fbc52007-05-01 23:26:30 +02001975/* ------------------------------------------------------------------------- */
1976
Jean Delvaree48d3312008-01-27 18:14:48 +01001977/**
1978 * i2c_use_client - increments the reference count of the i2c client structure
1979 * @client: the client being referenced
1980 *
1981 * Each live reference to a client should be refcounted. The driver model does
1982 * that automatically as part of driver binding, so that most drivers don't
1983 * need to do this explicitly: they hold a reference until they're unbound
1984 * from the device.
1985 *
1986 * A pointer to the client with the incremented reference counter is returned.
1987 */
1988struct i2c_client *i2c_use_client(struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989{
David Brownell6ea438e2008-07-14 22:38:24 +02001990 if (client && get_device(&client->dev))
1991 return client;
1992 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001993}
David Brownellc0564602007-05-01 23:26:31 +02001994EXPORT_SYMBOL(i2c_use_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995
Jean Delvaree48d3312008-01-27 18:14:48 +01001996/**
1997 * i2c_release_client - release a use of the i2c client structure
1998 * @client: the client being no longer referenced
1999 *
2000 * Must be called when a user of a client is finished with it.
2001 */
2002void i2c_release_client(struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002003{
David Brownell6ea438e2008-07-14 22:38:24 +02002004 if (client)
2005 put_device(&client->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006}
David Brownellc0564602007-05-01 23:26:31 +02002007EXPORT_SYMBOL(i2c_release_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002008
David Brownell9b766b82008-01-27 18:14:51 +01002009struct i2c_cmd_arg {
2010 unsigned cmd;
2011 void *arg;
2012};
2013
2014static int i2c_cmd(struct device *dev, void *_arg)
2015{
2016 struct i2c_client *client = i2c_verify_client(dev);
2017 struct i2c_cmd_arg *arg = _arg;
Lars-Peter Clausen0acc2b32013-09-29 10:51:06 +02002018 struct i2c_driver *driver;
David Brownell9b766b82008-01-27 18:14:51 +01002019
Lars-Peter Clausen0acc2b32013-09-29 10:51:06 +02002020 if (!client || !client->dev.driver)
2021 return 0;
2022
2023 driver = to_i2c_driver(client->dev.driver);
2024 if (driver->command)
2025 driver->command(client, arg->cmd, arg->arg);
David Brownell9b766b82008-01-27 18:14:51 +01002026 return 0;
2027}
2028
Linus Torvalds1da177e2005-04-16 15:20:36 -07002029void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
2030{
David Brownell9b766b82008-01-27 18:14:51 +01002031 struct i2c_cmd_arg cmd_arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002032
David Brownell9b766b82008-01-27 18:14:51 +01002033 cmd_arg.cmd = cmd;
2034 cmd_arg.arg = arg;
2035 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002036}
David Brownellc0564602007-05-01 23:26:31 +02002037EXPORT_SYMBOL(i2c_clients_command);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038
Pantelis Antoniouea7513b2014-10-28 22:36:03 +02002039#if IS_ENABLED(CONFIG_OF_DYNAMIC)
2040static int of_i2c_notify(struct notifier_block *nb, unsigned long action,
2041 void *arg)
2042{
2043 struct of_reconfig_data *rd = arg;
2044 struct i2c_adapter *adap;
2045 struct i2c_client *client;
2046
2047 switch (of_reconfig_get_state_change(action, rd)) {
2048 case OF_RECONFIG_CHANGE_ADD:
2049 adap = of_find_i2c_adapter_by_node(rd->dn->parent);
2050 if (adap == NULL)
2051 return NOTIFY_OK; /* not for us */
2052
Pantelis Antoniou4f001fd2015-01-24 09:16:29 +02002053 if (of_node_test_and_set_flag(rd->dn, OF_POPULATED)) {
2054 put_device(&adap->dev);
2055 return NOTIFY_OK;
2056 }
2057
Pantelis Antoniouea7513b2014-10-28 22:36:03 +02002058 client = of_i2c_register_device(adap, rd->dn);
2059 put_device(&adap->dev);
2060
2061 if (IS_ERR(client)) {
2062 pr_err("%s: failed to create for '%s'\n",
2063 __func__, rd->dn->full_name);
2064 return notifier_from_errno(PTR_ERR(client));
2065 }
2066 break;
2067 case OF_RECONFIG_CHANGE_REMOVE:
Pantelis Antoniou4f001fd2015-01-24 09:16:29 +02002068 /* already depopulated? */
2069 if (!of_node_check_flag(rd->dn, OF_POPULATED))
2070 return NOTIFY_OK;
2071
Pantelis Antoniouea7513b2014-10-28 22:36:03 +02002072 /* find our device by node */
2073 client = of_find_i2c_device_by_node(rd->dn);
2074 if (client == NULL)
2075 return NOTIFY_OK; /* no? not meant for us */
2076
2077 /* unregister takes one ref away */
2078 i2c_unregister_device(client);
2079
2080 /* and put the reference of the find */
2081 put_device(&client->dev);
2082 break;
2083 }
2084
2085 return NOTIFY_OK;
2086}
2087static struct notifier_block i2c_of_notifier = {
2088 .notifier_call = of_i2c_notify,
2089};
2090#else
2091extern struct notifier_block i2c_of_notifier;
2092#endif /* CONFIG_OF_DYNAMIC */
2093
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094static int __init i2c_init(void)
2095{
2096 int retval;
2097
Wolfram Sang03bde7c2015-03-12 17:17:59 +01002098 retval = of_alias_get_highest_id("i2c");
2099
2100 down_write(&__i2c_board_lock);
2101 if (retval >= __i2c_first_dynamic_bus_num)
2102 __i2c_first_dynamic_bus_num = retval + 1;
2103 up_write(&__i2c_board_lock);
2104
Linus Torvalds1da177e2005-04-16 15:20:36 -07002105 retval = bus_register(&i2c_bus_type);
2106 if (retval)
2107 return retval;
Wolfram Sangb980a262016-03-14 10:41:52 +01002108
2109 is_registered = true;
2110
Jean Delvare2bb50952009-09-18 22:45:46 +02002111#ifdef CONFIG_I2C_COMPAT
2112 i2c_adapter_compat_class = class_compat_register("i2c-adapter");
2113 if (!i2c_adapter_compat_class) {
2114 retval = -ENOMEM;
2115 goto bus_err;
2116 }
2117#endif
David Brownelle9f13732008-01-27 18:14:52 +01002118 retval = i2c_add_driver(&dummy_driver);
2119 if (retval)
Jean Delvare2bb50952009-09-18 22:45:46 +02002120 goto class_err;
Pantelis Antoniouea7513b2014-10-28 22:36:03 +02002121
2122 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2123 WARN_ON(of_reconfig_notifier_register(&i2c_of_notifier));
2124
David Brownelle9f13732008-01-27 18:14:52 +01002125 return 0;
2126
Jean Delvare2bb50952009-09-18 22:45:46 +02002127class_err:
2128#ifdef CONFIG_I2C_COMPAT
2129 class_compat_unregister(i2c_adapter_compat_class);
David Brownelle9f13732008-01-27 18:14:52 +01002130bus_err:
Jean Delvare2bb50952009-09-18 22:45:46 +02002131#endif
Wolfram Sangb980a262016-03-14 10:41:52 +01002132 is_registered = false;
David Brownelle9f13732008-01-27 18:14:52 +01002133 bus_unregister(&i2c_bus_type);
2134 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002135}
2136
2137static void __exit i2c_exit(void)
2138{
Pantelis Antoniouea7513b2014-10-28 22:36:03 +02002139 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2140 WARN_ON(of_reconfig_notifier_unregister(&i2c_of_notifier));
David Brownelle9f13732008-01-27 18:14:52 +01002141 i2c_del_driver(&dummy_driver);
Jean Delvare2bb50952009-09-18 22:45:46 +02002142#ifdef CONFIG_I2C_COMPAT
2143 class_compat_unregister(i2c_adapter_compat_class);
2144#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002145 bus_unregister(&i2c_bus_type);
David Howellsd9a83d62014-03-06 13:35:59 +00002146 tracepoint_synchronize_unregister();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002147}
2148
David Brownella10f9e72008-10-14 17:30:06 +02002149/* We must initialize early, because some subsystems register i2c drivers
2150 * in subsys_initcall() code, but are linked (and initialized) before i2c.
2151 */
2152postcore_initcall(i2c_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002153module_exit(i2c_exit);
2154
2155/* ----------------------------------------------------
2156 * the functional interface to the i2c busses.
2157 * ----------------------------------------------------
2158 */
2159
Wolfram Sangb7f62582015-01-05 23:45:59 +01002160/* Check if val is exceeding the quirk IFF quirk is non 0 */
2161#define i2c_quirk_exceeded(val, quirk) ((quirk) && ((val) > (quirk)))
2162
2163static int i2c_quirk_error(struct i2c_adapter *adap, struct i2c_msg *msg, char *err_msg)
2164{
2165 dev_err_ratelimited(&adap->dev, "adapter quirk: %s (addr 0x%04x, size %u, %s)\n",
2166 err_msg, msg->addr, msg->len,
2167 msg->flags & I2C_M_RD ? "read" : "write");
2168 return -EOPNOTSUPP;
2169}
2170
2171static int i2c_check_for_quirks(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2172{
2173 const struct i2c_adapter_quirks *q = adap->quirks;
2174 int max_num = q->max_num_msgs, i;
2175 bool do_len_check = true;
2176
2177 if (q->flags & I2C_AQ_COMB) {
2178 max_num = 2;
2179
2180 /* special checks for combined messages */
2181 if (num == 2) {
2182 if (q->flags & I2C_AQ_COMB_WRITE_FIRST && msgs[0].flags & I2C_M_RD)
2183 return i2c_quirk_error(adap, &msgs[0], "1st comb msg must be write");
2184
2185 if (q->flags & I2C_AQ_COMB_READ_SECOND && !(msgs[1].flags & I2C_M_RD))
2186 return i2c_quirk_error(adap, &msgs[1], "2nd comb msg must be read");
2187
2188 if (q->flags & I2C_AQ_COMB_SAME_ADDR && msgs[0].addr != msgs[1].addr)
2189 return i2c_quirk_error(adap, &msgs[0], "comb msg only to same addr");
2190
2191 if (i2c_quirk_exceeded(msgs[0].len, q->max_comb_1st_msg_len))
2192 return i2c_quirk_error(adap, &msgs[0], "msg too long");
2193
2194 if (i2c_quirk_exceeded(msgs[1].len, q->max_comb_2nd_msg_len))
2195 return i2c_quirk_error(adap, &msgs[1], "msg too long");
2196
2197 do_len_check = false;
2198 }
2199 }
2200
2201 if (i2c_quirk_exceeded(num, max_num))
2202 return i2c_quirk_error(adap, &msgs[0], "too many messages");
2203
2204 for (i = 0; i < num; i++) {
2205 u16 len = msgs[i].len;
2206
2207 if (msgs[i].flags & I2C_M_RD) {
2208 if (do_len_check && i2c_quirk_exceeded(len, q->max_read_len))
2209 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2210 } else {
2211 if (do_len_check && i2c_quirk_exceeded(len, q->max_write_len))
2212 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2213 }
2214 }
2215
2216 return 0;
2217}
2218
David Brownella1cdeda2008-07-14 22:38:24 +02002219/**
Jean Delvareb37d2a32012-06-29 07:47:19 -03002220 * __i2c_transfer - unlocked flavor of i2c_transfer
2221 * @adap: Handle to I2C bus
2222 * @msgs: One or more messages to execute before STOP is issued to
2223 * terminate the operation; each message begins with a START.
2224 * @num: Number of messages to be executed.
2225 *
2226 * Returns negative errno, else the number of messages executed.
2227 *
2228 * Adapter lock must be held when calling this function. No debug logging
2229 * takes place. adap->algo->master_xfer existence isn't checked.
2230 */
2231int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2232{
2233 unsigned long orig_jiffies;
2234 int ret, try;
2235
Wolfram Sangb7f62582015-01-05 23:45:59 +01002236 if (adap->quirks && i2c_check_for_quirks(adap, msgs, num))
2237 return -EOPNOTSUPP;
2238
David Howellsd9a83d62014-03-06 13:35:59 +00002239 /* i2c_trace_msg gets enabled when tracepoint i2c_transfer gets
2240 * enabled. This is an efficient way of keeping the for-loop from
2241 * being executed when not needed.
2242 */
2243 if (static_key_false(&i2c_trace_msg)) {
2244 int i;
2245 for (i = 0; i < num; i++)
2246 if (msgs[i].flags & I2C_M_RD)
2247 trace_i2c_read(adap, &msgs[i], i);
2248 else
2249 trace_i2c_write(adap, &msgs[i], i);
2250 }
2251
Jean Delvareb37d2a32012-06-29 07:47:19 -03002252 /* Retry automatically on arbitration loss */
2253 orig_jiffies = jiffies;
2254 for (ret = 0, try = 0; try <= adap->retries; try++) {
2255 ret = adap->algo->master_xfer(adap, msgs, num);
2256 if (ret != -EAGAIN)
2257 break;
2258 if (time_after(jiffies, orig_jiffies + adap->timeout))
2259 break;
2260 }
2261
David Howellsd9a83d62014-03-06 13:35:59 +00002262 if (static_key_false(&i2c_trace_msg)) {
2263 int i;
2264 for (i = 0; i < ret; i++)
2265 if (msgs[i].flags & I2C_M_RD)
2266 trace_i2c_reply(adap, &msgs[i], i);
2267 trace_i2c_result(adap, i, ret);
2268 }
2269
Jean Delvareb37d2a32012-06-29 07:47:19 -03002270 return ret;
2271}
2272EXPORT_SYMBOL(__i2c_transfer);
2273
2274/**
David Brownella1cdeda2008-07-14 22:38:24 +02002275 * i2c_transfer - execute a single or combined I2C message
2276 * @adap: Handle to I2C bus
2277 * @msgs: One or more messages to execute before STOP is issued to
2278 * terminate the operation; each message begins with a START.
2279 * @num: Number of messages to be executed.
2280 *
2281 * Returns negative errno, else the number of messages executed.
2282 *
2283 * Note that there is no requirement that each message be sent to
2284 * the same slave address, although that is the most common model.
2285 */
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01002286int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002287{
Jean Delvareb37d2a32012-06-29 07:47:19 -03002288 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002289
David Brownella1cdeda2008-07-14 22:38:24 +02002290 /* REVISIT the fault reporting model here is weak:
2291 *
2292 * - When we get an error after receiving N bytes from a slave,
2293 * there is no way to report "N".
2294 *
2295 * - When we get a NAK after transmitting N bytes to a slave,
2296 * there is no way to report "N" ... or to let the master
2297 * continue executing the rest of this combined message, if
2298 * that's the appropriate response.
2299 *
2300 * - When for example "num" is two and we successfully complete
2301 * the first message but get an error part way through the
2302 * second, it's unclear whether that should be reported as
2303 * one (discarding status on the second message) or errno
2304 * (discarding status on the first one).
2305 */
2306
Linus Torvalds1da177e2005-04-16 15:20:36 -07002307 if (adap->algo->master_xfer) {
2308#ifdef DEBUG
2309 for (ret = 0; ret < num; ret++) {
2310 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
Jean Delvare209d27c2007-05-01 23:26:29 +02002311 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
2312 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
2313 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002314 }
2315#endif
2316
Mike Rapoportcea443a2008-01-27 18:14:50 +01002317 if (in_atomic() || irqs_disabled()) {
Jean Delvarefe61e072010-08-11 18:20:58 +02002318 ret = i2c_trylock_adapter(adap);
Mike Rapoportcea443a2008-01-27 18:14:50 +01002319 if (!ret)
2320 /* I2C activity is ongoing. */
2321 return -EAGAIN;
2322 } else {
Jean Delvarefe61e072010-08-11 18:20:58 +02002323 i2c_lock_adapter(adap);
Mike Rapoportcea443a2008-01-27 18:14:50 +01002324 }
2325
Jean Delvareb37d2a32012-06-29 07:47:19 -03002326 ret = __i2c_transfer(adap, msgs, num);
Jean Delvarefe61e072010-08-11 18:20:58 +02002327 i2c_unlock_adapter(adap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002328
2329 return ret;
2330 } else {
2331 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
David Brownell24a5bb72008-07-14 22:38:23 +02002332 return -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002333 }
2334}
David Brownellc0564602007-05-01 23:26:31 +02002335EXPORT_SYMBOL(i2c_transfer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002336
David Brownella1cdeda2008-07-14 22:38:24 +02002337/**
2338 * i2c_master_send - issue a single I2C message in master transmit mode
2339 * @client: Handle to slave device
2340 * @buf: Data that will be written to the slave
Zhangfei Gao0c43ea52010-03-02 12:23:49 +01002341 * @count: How many bytes to write, must be less than 64k since msg.len is u16
David Brownella1cdeda2008-07-14 22:38:24 +02002342 *
2343 * Returns negative errno, or else the number of bytes written.
2344 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01002345int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002346{
2347 int ret;
Farid Hammane7225acf2010-05-21 18:40:58 +02002348 struct i2c_adapter *adap = client->adapter;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002349 struct i2c_msg msg;
2350
Jean Delvare815f55f2005-05-07 22:58:46 +02002351 msg.addr = client->addr;
2352 msg.flags = client->flags & I2C_M_TEN;
2353 msg.len = count;
2354 msg.buf = (char *)buf;
David Brownell438d6c22006-12-10 21:21:31 +01002355
Jean Delvare815f55f2005-05-07 22:58:46 +02002356 ret = i2c_transfer(adap, &msg, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002357
Wolfram Sang834aa6f2012-03-15 18:11:05 +01002358 /*
2359 * If everything went ok (i.e. 1 msg transmitted), return #bytes
2360 * transmitted, else error code.
2361 */
Jean Delvare815f55f2005-05-07 22:58:46 +02002362 return (ret == 1) ? count : ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002363}
David Brownellc0564602007-05-01 23:26:31 +02002364EXPORT_SYMBOL(i2c_master_send);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002365
David Brownella1cdeda2008-07-14 22:38:24 +02002366/**
2367 * i2c_master_recv - issue a single I2C message in master receive mode
2368 * @client: Handle to slave device
2369 * @buf: Where to store data read from slave
Zhangfei Gao0c43ea52010-03-02 12:23:49 +01002370 * @count: How many bytes to read, must be less than 64k since msg.len is u16
David Brownella1cdeda2008-07-14 22:38:24 +02002371 *
2372 * Returns negative errno, or else the number of bytes read.
2373 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01002374int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002375{
Farid Hammane7225acf2010-05-21 18:40:58 +02002376 struct i2c_adapter *adap = client->adapter;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002377 struct i2c_msg msg;
2378 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002379
Jean Delvare815f55f2005-05-07 22:58:46 +02002380 msg.addr = client->addr;
2381 msg.flags = client->flags & I2C_M_TEN;
2382 msg.flags |= I2C_M_RD;
2383 msg.len = count;
2384 msg.buf = buf;
2385
2386 ret = i2c_transfer(adap, &msg, 1);
2387
Wolfram Sang834aa6f2012-03-15 18:11:05 +01002388 /*
2389 * If everything went ok (i.e. 1 msg received), return #bytes received,
2390 * else error code.
2391 */
Jean Delvare815f55f2005-05-07 22:58:46 +02002392 return (ret == 1) ? count : ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002393}
David Brownellc0564602007-05-01 23:26:31 +02002394EXPORT_SYMBOL(i2c_master_recv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002395
Linus Torvalds1da177e2005-04-16 15:20:36 -07002396/* ----------------------------------------------------
2397 * the i2c address scanning function
2398 * Will not work for 10-bit addresses!
2399 * ----------------------------------------------------
2400 */
Jean Delvare9fc6adf2005-07-31 21:20:43 +02002401
Jean Delvare63e4e802010-06-03 11:33:51 +02002402/*
2403 * Legacy default probe function, mostly relevant for SMBus. The default
2404 * probe method is a quick write, but it is known to corrupt the 24RF08
2405 * EEPROMs due to a state machine bug, and could also irreversibly
2406 * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
2407 * we use a short byte read instead. Also, some bus drivers don't implement
2408 * quick write, so we fallback to a byte read in that case too.
2409 * On x86, there is another special case for FSC hardware monitoring chips,
2410 * which want regular byte reads (address 0x73.) Fortunately, these are the
2411 * only known chips using this I2C address on PC hardware.
2412 * Returns 1 if probe succeeded, 0 if not.
2413 */
2414static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
2415{
2416 int err;
2417 union i2c_smbus_data dummy;
2418
2419#ifdef CONFIG_X86
2420 if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
2421 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
2422 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2423 I2C_SMBUS_BYTE_DATA, &dummy);
2424 else
2425#endif
Jean Delvare8031d792010-08-11 18:21:00 +02002426 if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
2427 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
Jean Delvare63e4e802010-06-03 11:33:51 +02002428 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
2429 I2C_SMBUS_QUICK, NULL);
Jean Delvare8031d792010-08-11 18:21:00 +02002430 else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
2431 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2432 I2C_SMBUS_BYTE, &dummy);
2433 else {
Andy Lutomirskid63a9e82013-07-17 13:27:59 -07002434 dev_warn(&adap->dev, "No suitable probing method supported for address 0x%02X\n",
2435 addr);
Jean Delvare8031d792010-08-11 18:21:00 +02002436 err = -EOPNOTSUPP;
2437 }
Jean Delvare63e4e802010-06-03 11:33:51 +02002438
2439 return err >= 0;
2440}
2441
Jean Delvareccfbbd02009-12-06 17:06:25 +01002442static int i2c_detect_address(struct i2c_client *temp_client,
Jean Delvare4735c982008-07-14 22:38:36 +02002443 struct i2c_driver *driver)
2444{
2445 struct i2c_board_info info;
2446 struct i2c_adapter *adapter = temp_client->adapter;
2447 int addr = temp_client->addr;
2448 int err;
2449
2450 /* Make sure the address is valid */
Wolfram Sang66be60562015-07-17 12:43:22 +02002451 err = i2c_check_7bit_addr_validity_strict(addr);
Jean Delvare656b8762010-06-03 11:33:53 +02002452 if (err) {
Jean Delvare4735c982008-07-14 22:38:36 +02002453 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
2454 addr);
Jean Delvare656b8762010-06-03 11:33:53 +02002455 return err;
Jean Delvare4735c982008-07-14 22:38:36 +02002456 }
2457
Wolfram Sang9bccc702015-07-17 14:48:56 +02002458 /* Skip if already in use (7 bit, no need to encode flags) */
Jean Delvare3b5f7942010-06-03 11:33:55 +02002459 if (i2c_check_addr_busy(adapter, addr))
Jean Delvare4735c982008-07-14 22:38:36 +02002460 return 0;
2461
Jean Delvareccfbbd02009-12-06 17:06:25 +01002462 /* Make sure there is something at this address */
Jean Delvare63e4e802010-06-03 11:33:51 +02002463 if (!i2c_default_probe(adapter, addr))
2464 return 0;
Jean Delvare4735c982008-07-14 22:38:36 +02002465
2466 /* Finally call the custom detection function */
2467 memset(&info, 0, sizeof(struct i2c_board_info));
2468 info.addr = addr;
Jean Delvare310ec792009-12-14 21:17:23 +01002469 err = driver->detect(temp_client, &info);
Jean Delvare4735c982008-07-14 22:38:36 +02002470 if (err) {
2471 /* -ENODEV is returned if the detection fails. We catch it
2472 here as this isn't an error. */
2473 return err == -ENODEV ? 0 : err;
2474 }
2475
2476 /* Consistency check */
2477 if (info.type[0] == '\0') {
2478 dev_err(&adapter->dev, "%s detection function provided "
2479 "no name for 0x%x\n", driver->driver.name,
2480 addr);
2481 } else {
2482 struct i2c_client *client;
2483
2484 /* Detection succeeded, instantiate the device */
Wolfram Sang0c176172014-02-10 11:03:56 +01002485 if (adapter->class & I2C_CLASS_DEPRECATED)
2486 dev_warn(&adapter->dev,
2487 "This adapter will soon drop class based instantiation of devices. "
2488 "Please make sure client 0x%02x gets instantiated by other means. "
2489 "Check 'Documentation/i2c/instantiating-devices' for details.\n",
2490 info.addr);
2491
Jean Delvare4735c982008-07-14 22:38:36 +02002492 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
2493 info.type, info.addr);
2494 client = i2c_new_device(adapter, &info);
2495 if (client)
2496 list_add_tail(&client->detected, &driver->clients);
2497 else
2498 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
2499 info.type, info.addr);
2500 }
2501 return 0;
2502}
2503
2504static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
2505{
Jean Delvarec3813d62009-12-14 21:17:25 +01002506 const unsigned short *address_list;
Jean Delvare4735c982008-07-14 22:38:36 +02002507 struct i2c_client *temp_client;
2508 int i, err = 0;
2509 int adap_id = i2c_adapter_id(adapter);
2510
Jean Delvarec3813d62009-12-14 21:17:25 +01002511 address_list = driver->address_list;
2512 if (!driver->detect || !address_list)
Jean Delvare4735c982008-07-14 22:38:36 +02002513 return 0;
2514
Wolfram Sang45552272014-07-10 13:46:21 +02002515 /* Warn that the adapter lost class based instantiation */
2516 if (adapter->class == I2C_CLASS_DEPRECATED) {
2517 dev_dbg(&adapter->dev,
2518 "This adapter dropped support for I2C classes and "
2519 "won't auto-detect %s devices anymore. If you need it, check "
2520 "'Documentation/i2c/instantiating-devices' for alternatives.\n",
2521 driver->driver.name);
2522 return 0;
2523 }
2524
Jean Delvare51b54ba2010-10-24 18:16:58 +02002525 /* Stop here if the classes do not match */
2526 if (!(adapter->class & driver->class))
2527 return 0;
2528
Jean Delvare4735c982008-07-14 22:38:36 +02002529 /* Set up a temporary client to help detect callback */
2530 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
2531 if (!temp_client)
2532 return -ENOMEM;
2533 temp_client->adapter = adapter;
2534
Jean Delvarec3813d62009-12-14 21:17:25 +01002535 for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
Jean Delvare4735c982008-07-14 22:38:36 +02002536 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
Jean Delvarec3813d62009-12-14 21:17:25 +01002537 "addr 0x%02x\n", adap_id, address_list[i]);
2538 temp_client->addr = address_list[i];
Jean Delvareccfbbd02009-12-06 17:06:25 +01002539 err = i2c_detect_address(temp_client, driver);
Jean Delvare51b54ba2010-10-24 18:16:58 +02002540 if (unlikely(err))
2541 break;
Jean Delvare4735c982008-07-14 22:38:36 +02002542 }
2543
Jean Delvare4735c982008-07-14 22:38:36 +02002544 kfree(temp_client);
2545 return err;
2546}
2547
Jean Delvared44f19d2010-08-11 18:20:57 +02002548int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
2549{
2550 return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2551 I2C_SMBUS_QUICK, NULL) >= 0;
2552}
2553EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
2554
Jean Delvare12b5053a2007-05-01 23:26:31 +02002555struct i2c_client *
2556i2c_new_probed_device(struct i2c_adapter *adap,
2557 struct i2c_board_info *info,
Jean Delvare9a942412010-08-11 18:20:56 +02002558 unsigned short const *addr_list,
2559 int (*probe)(struct i2c_adapter *, unsigned short addr))
Jean Delvare12b5053a2007-05-01 23:26:31 +02002560{
2561 int i;
2562
Jean Delvare8031d792010-08-11 18:21:00 +02002563 if (!probe)
Jean Delvare9a942412010-08-11 18:20:56 +02002564 probe = i2c_default_probe;
Jean Delvare12b5053a2007-05-01 23:26:31 +02002565
Jean Delvare12b5053a2007-05-01 23:26:31 +02002566 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
2567 /* Check address validity */
Wolfram Sang66be60562015-07-17 12:43:22 +02002568 if (i2c_check_7bit_addr_validity_strict(addr_list[i]) < 0) {
Jean Delvare12b5053a2007-05-01 23:26:31 +02002569 dev_warn(&adap->dev, "Invalid 7-bit address "
2570 "0x%02x\n", addr_list[i]);
2571 continue;
2572 }
2573
Wolfram Sang9bccc702015-07-17 14:48:56 +02002574 /* Check address availability (7 bit, no need to encode flags) */
Jean Delvare3b5f7942010-06-03 11:33:55 +02002575 if (i2c_check_addr_busy(adap, addr_list[i])) {
Jean Delvare12b5053a2007-05-01 23:26:31 +02002576 dev_dbg(&adap->dev, "Address 0x%02x already in "
2577 "use, not probing\n", addr_list[i]);
2578 continue;
2579 }
2580
Jean Delvare63e4e802010-06-03 11:33:51 +02002581 /* Test address responsiveness */
Jean Delvare9a942412010-08-11 18:20:56 +02002582 if (probe(adap, addr_list[i]))
Jean Delvare63e4e802010-06-03 11:33:51 +02002583 break;
Jean Delvare12b5053a2007-05-01 23:26:31 +02002584 }
Jean Delvare12b5053a2007-05-01 23:26:31 +02002585
2586 if (addr_list[i] == I2C_CLIENT_END) {
2587 dev_dbg(&adap->dev, "Probing failed, no device found\n");
2588 return NULL;
2589 }
2590
2591 info->addr = addr_list[i];
2592 return i2c_new_device(adap, info);
2593}
2594EXPORT_SYMBOL_GPL(i2c_new_probed_device);
2595
Jean Delvared735b342011-03-20 14:50:52 +01002596struct i2c_adapter *i2c_get_adapter(int nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002597{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002598 struct i2c_adapter *adapter;
David Brownell438d6c22006-12-10 21:21:31 +01002599
Jean Delvarecaada322008-01-27 18:14:49 +01002600 mutex_lock(&core_lock);
Jean Delvared735b342011-03-20 14:50:52 +01002601 adapter = idr_find(&i2c_adapter_idr, nr);
Vladimir Zapolskiy611e12e2015-07-27 17:30:49 +03002602 if (!adapter)
2603 goto exit;
2604
2605 if (try_module_get(adapter->owner))
2606 get_device(&adapter->dev);
2607 else
Mark M. Hoffmana0920e12005-06-28 00:21:30 -04002608 adapter = NULL;
2609
Vladimir Zapolskiy611e12e2015-07-27 17:30:49 +03002610 exit:
Jean Delvarecaada322008-01-27 18:14:49 +01002611 mutex_unlock(&core_lock);
Mark M. Hoffmana0920e12005-06-28 00:21:30 -04002612 return adapter;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002613}
David Brownellc0564602007-05-01 23:26:31 +02002614EXPORT_SYMBOL(i2c_get_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002615
2616void i2c_put_adapter(struct i2c_adapter *adap)
2617{
Vladimir Zapolskiy611e12e2015-07-27 17:30:49 +03002618 if (!adap)
2619 return;
2620
2621 put_device(&adap->dev);
2622 module_put(adap->owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002623}
David Brownellc0564602007-05-01 23:26:31 +02002624EXPORT_SYMBOL(i2c_put_adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002625
2626/* The SMBus parts */
2627
David Brownell438d6c22006-12-10 21:21:31 +01002628#define POLY (0x1070U << 3)
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01002629static u8 crc8(u16 data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002630{
2631 int i;
David Brownell438d6c22006-12-10 21:21:31 +01002632
Farid Hammane7225acf2010-05-21 18:40:58 +02002633 for (i = 0; i < 8; i++) {
David Brownell438d6c22006-12-10 21:21:31 +01002634 if (data & 0x8000)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002635 data = data ^ POLY;
2636 data = data << 1;
2637 }
2638 return (u8)(data >> 8);
2639}
2640
Jean Delvare421ef472005-10-26 21:28:55 +02002641/* Incremental CRC8 over count bytes in the array pointed to by p */
2642static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002643{
2644 int i;
2645
Farid Hammane7225acf2010-05-21 18:40:58 +02002646 for (i = 0; i < count; i++)
Jean Delvare421ef472005-10-26 21:28:55 +02002647 crc = crc8((crc ^ p[i]) << 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002648 return crc;
2649}
2650
Jean Delvare421ef472005-10-26 21:28:55 +02002651/* Assume a 7-bit address, which is reasonable for SMBus */
2652static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002653{
Jean Delvare421ef472005-10-26 21:28:55 +02002654 /* The address will be sent first */
2655 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
2656 pec = i2c_smbus_pec(pec, &addr, 1);
2657
2658 /* The data buffer follows */
2659 return i2c_smbus_pec(pec, msg->buf, msg->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002660}
2661
Jean Delvare421ef472005-10-26 21:28:55 +02002662/* Used for write only transactions */
2663static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002664{
Jean Delvare421ef472005-10-26 21:28:55 +02002665 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
2666 msg->len++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002667}
2668
Jean Delvare421ef472005-10-26 21:28:55 +02002669/* Return <0 on CRC error
2670 If there was a write before this read (most cases) we need to take the
2671 partial CRC from the write part into account.
2672 Note that this function does modify the message (we need to decrease the
2673 message length to hide the CRC byte from the caller). */
2674static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002675{
Jean Delvare421ef472005-10-26 21:28:55 +02002676 u8 rpec = msg->buf[--msg->len];
2677 cpec = i2c_smbus_msg_pec(cpec, msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002678
Linus Torvalds1da177e2005-04-16 15:20:36 -07002679 if (rpec != cpec) {
2680 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
2681 rpec, cpec);
David Brownell24a5bb72008-07-14 22:38:23 +02002682 return -EBADMSG;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002683 }
David Brownell438d6c22006-12-10 21:21:31 +01002684 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002685}
2686
David Brownella1cdeda2008-07-14 22:38:24 +02002687/**
2688 * i2c_smbus_read_byte - SMBus "receive byte" protocol
2689 * @client: Handle to slave device
2690 *
2691 * This executes the SMBus "receive byte" protocol, returning negative errno
2692 * else the byte received from the device.
2693 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01002694s32 i2c_smbus_read_byte(const struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002695{
2696 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02002697 int status;
2698
2699 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2700 I2C_SMBUS_READ, 0,
2701 I2C_SMBUS_BYTE, &data);
2702 return (status < 0) ? status : data.byte;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002703}
David Brownellc0564602007-05-01 23:26:31 +02002704EXPORT_SYMBOL(i2c_smbus_read_byte);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002705
David Brownella1cdeda2008-07-14 22:38:24 +02002706/**
2707 * i2c_smbus_write_byte - SMBus "send byte" protocol
2708 * @client: Handle to slave device
2709 * @value: Byte to be sent
2710 *
2711 * This executes the SMBus "send byte" protocol, returning negative errno
2712 * else zero on success.
2713 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01002714s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002715{
Farid Hammane7225acf2010-05-21 18:40:58 +02002716 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
Jean Delvare421ef472005-10-26 21:28:55 +02002717 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002718}
David Brownellc0564602007-05-01 23:26:31 +02002719EXPORT_SYMBOL(i2c_smbus_write_byte);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002720
David Brownella1cdeda2008-07-14 22:38:24 +02002721/**
2722 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
2723 * @client: Handle to slave device
2724 * @command: Byte interpreted by slave
2725 *
2726 * This executes the SMBus "read byte" protocol, returning negative errno
2727 * else a data byte received from the device.
2728 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01002729s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002730{
2731 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02002732 int status;
2733
2734 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2735 I2C_SMBUS_READ, command,
2736 I2C_SMBUS_BYTE_DATA, &data);
2737 return (status < 0) ? status : data.byte;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002738}
David Brownellc0564602007-05-01 23:26:31 +02002739EXPORT_SYMBOL(i2c_smbus_read_byte_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002740
David Brownella1cdeda2008-07-14 22:38:24 +02002741/**
2742 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
2743 * @client: Handle to slave device
2744 * @command: Byte interpreted by slave
2745 * @value: Byte being written
2746 *
2747 * This executes the SMBus "write byte" protocol, returning negative errno
2748 * else zero on success.
2749 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01002750s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
2751 u8 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002752{
2753 union i2c_smbus_data data;
2754 data.byte = value;
Farid Hammane7225acf2010-05-21 18:40:58 +02002755 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2756 I2C_SMBUS_WRITE, command,
2757 I2C_SMBUS_BYTE_DATA, &data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002758}
David Brownellc0564602007-05-01 23:26:31 +02002759EXPORT_SYMBOL(i2c_smbus_write_byte_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002760
David Brownella1cdeda2008-07-14 22:38:24 +02002761/**
2762 * i2c_smbus_read_word_data - SMBus "read word" protocol
2763 * @client: Handle to slave device
2764 * @command: Byte interpreted by slave
2765 *
2766 * This executes the SMBus "read word" protocol, returning negative errno
2767 * else a 16-bit unsigned "word" received from the device.
2768 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01002769s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002770{
2771 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02002772 int status;
2773
2774 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2775 I2C_SMBUS_READ, command,
2776 I2C_SMBUS_WORD_DATA, &data);
2777 return (status < 0) ? status : data.word;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002778}
David Brownellc0564602007-05-01 23:26:31 +02002779EXPORT_SYMBOL(i2c_smbus_read_word_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002780
David Brownella1cdeda2008-07-14 22:38:24 +02002781/**
2782 * i2c_smbus_write_word_data - SMBus "write word" protocol
2783 * @client: Handle to slave device
2784 * @command: Byte interpreted by slave
2785 * @value: 16-bit "word" being written
2786 *
2787 * This executes the SMBus "write word" protocol, returning negative errno
2788 * else zero on success.
2789 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01002790s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
2791 u16 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002792{
2793 union i2c_smbus_data data;
2794 data.word = value;
Farid Hammane7225acf2010-05-21 18:40:58 +02002795 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2796 I2C_SMBUS_WRITE, command,
2797 I2C_SMBUS_WORD_DATA, &data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002798}
David Brownellc0564602007-05-01 23:26:31 +02002799EXPORT_SYMBOL(i2c_smbus_write_word_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002800
David Brownella64ec072007-10-13 23:56:31 +02002801/**
David Brownella1cdeda2008-07-14 22:38:24 +02002802 * i2c_smbus_read_block_data - SMBus "block read" protocol
David Brownella64ec072007-10-13 23:56:31 +02002803 * @client: Handle to slave device
David Brownella1cdeda2008-07-14 22:38:24 +02002804 * @command: Byte interpreted by slave
David Brownella64ec072007-10-13 23:56:31 +02002805 * @values: Byte array into which data will be read; big enough to hold
2806 * the data returned by the slave. SMBus allows at most 32 bytes.
2807 *
David Brownella1cdeda2008-07-14 22:38:24 +02002808 * This executes the SMBus "block read" protocol, returning negative errno
2809 * else the number of data bytes in the slave's response.
David Brownella64ec072007-10-13 23:56:31 +02002810 *
2811 * Note that using this function requires that the client's adapter support
2812 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
2813 * support this; its emulation through I2C messaging relies on a specific
2814 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
2815 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01002816s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
Jean Delvareb86a1bc2007-05-01 23:26:34 +02002817 u8 *values)
2818{
2819 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02002820 int status;
Jean Delvareb86a1bc2007-05-01 23:26:34 +02002821
David Brownell24a5bb72008-07-14 22:38:23 +02002822 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2823 I2C_SMBUS_READ, command,
2824 I2C_SMBUS_BLOCK_DATA, &data);
2825 if (status)
2826 return status;
Jean Delvareb86a1bc2007-05-01 23:26:34 +02002827
2828 memcpy(values, &data.block[1], data.block[0]);
2829 return data.block[0];
2830}
2831EXPORT_SYMBOL(i2c_smbus_read_block_data);
2832
David Brownella1cdeda2008-07-14 22:38:24 +02002833/**
2834 * i2c_smbus_write_block_data - SMBus "block write" protocol
2835 * @client: Handle to slave device
2836 * @command: Byte interpreted by slave
2837 * @length: Size of data block; SMBus allows at most 32 bytes
2838 * @values: Byte array which will be written.
2839 *
2840 * This executes the SMBus "block write" protocol, returning negative errno
2841 * else zero on success.
2842 */
Jean Delvare0cc43a12011-01-10 22:11:23 +01002843s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
Krzysztof Halasa46f5ed72006-06-12 21:42:20 +02002844 u8 length, const u8 *values)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002845{
2846 union i2c_smbus_data data;
Jean Delvare76560322006-01-18 23:14:55 +01002847
Linus Torvalds1da177e2005-04-16 15:20:36 -07002848 if (length > I2C_SMBUS_BLOCK_MAX)
2849 length = I2C_SMBUS_BLOCK_MAX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002850 data.block[0] = length;
Jean Delvare76560322006-01-18 23:14:55 +01002851 memcpy(&data.block[1], values, length);
Farid Hammane7225acf2010-05-21 18:40:58 +02002852 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2853 I2C_SMBUS_WRITE, command,
2854 I2C_SMBUS_BLOCK_DATA, &data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002855}
David Brownellc0564602007-05-01 23:26:31 +02002856EXPORT_SYMBOL(i2c_smbus_write_block_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002857
2858/* Returns the number of read bytes */
Jean Delvare0cc43a12011-01-10 22:11:23 +01002859s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
Jean Delvare4b2643d2007-07-12 14:12:29 +02002860 u8 length, u8 *values)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002861{
2862 union i2c_smbus_data data;
David Brownell24a5bb72008-07-14 22:38:23 +02002863 int status;
Jean Delvare76560322006-01-18 23:14:55 +01002864
Jean Delvare4b2643d2007-07-12 14:12:29 +02002865 if (length > I2C_SMBUS_BLOCK_MAX)
2866 length = I2C_SMBUS_BLOCK_MAX;
2867 data.block[0] = length;
David Brownell24a5bb72008-07-14 22:38:23 +02002868 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2869 I2C_SMBUS_READ, command,
2870 I2C_SMBUS_I2C_BLOCK_DATA, &data);
2871 if (status < 0)
2872 return status;
Jean Delvare76560322006-01-18 23:14:55 +01002873
2874 memcpy(values, &data.block[1], data.block[0]);
2875 return data.block[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002876}
David Brownellc0564602007-05-01 23:26:31 +02002877EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002878
Jean Delvare0cc43a12011-01-10 22:11:23 +01002879s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
Krzysztof Halasa46f5ed72006-06-12 21:42:20 +02002880 u8 length, const u8 *values)
Jean Delvare21bbd692006-01-09 15:19:18 +11002881{
2882 union i2c_smbus_data data;
2883
2884 if (length > I2C_SMBUS_BLOCK_MAX)
2885 length = I2C_SMBUS_BLOCK_MAX;
2886 data.block[0] = length;
2887 memcpy(data.block + 1, values, length);
2888 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2889 I2C_SMBUS_WRITE, command,
2890 I2C_SMBUS_I2C_BLOCK_DATA, &data);
2891}
David Brownellc0564602007-05-01 23:26:31 +02002892EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
Jean Delvare21bbd692006-01-09 15:19:18 +11002893
David Brownell438d6c22006-12-10 21:21:31 +01002894/* Simulate a SMBus command using the i2c protocol
Linus Torvalds1da177e2005-04-16 15:20:36 -07002895 No checking of parameters is done! */
Farid Hammane7225acf2010-05-21 18:40:58 +02002896static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
2897 unsigned short flags,
2898 char read_write, u8 command, int size,
2899 union i2c_smbus_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002900{
2901 /* So we need to generate a series of msgs. In the case of writing, we
2902 need to use only one message; when reading, we need two. We initialize
2903 most things with sane defaults, to keep the code below somewhat
2904 simpler. */
Hideki Iwamoto5c50d182005-09-25 17:01:11 +02002905 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
2906 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
Farid Hammane7225acf2010-05-21 18:40:58 +02002907 int num = read_write == I2C_SMBUS_READ ? 2 : 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002908 int i;
Jean Delvare421ef472005-10-26 21:28:55 +02002909 u8 partial_pec = 0;
David Brownell24a5bb72008-07-14 22:38:23 +02002910 int status;
Shubhrajyoti D230da092012-10-05 22:23:52 +02002911 struct i2c_msg msg[2] = {
2912 {
2913 .addr = addr,
2914 .flags = flags,
2915 .len = 1,
2916 .buf = msgbuf0,
2917 }, {
2918 .addr = addr,
2919 .flags = flags | I2C_M_RD,
2920 .len = 0,
2921 .buf = msgbuf1,
2922 },
2923 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07002924
2925 msgbuf0[0] = command;
Farid Hammane7225acf2010-05-21 18:40:58 +02002926 switch (size) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002927 case I2C_SMBUS_QUICK:
2928 msg[0].len = 0;
2929 /* Special case: The read/write field is used as data */
Roel Kluinf29d2e02009-02-24 19:19:48 +01002930 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
2931 I2C_M_RD : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002932 num = 1;
2933 break;
2934 case I2C_SMBUS_BYTE:
2935 if (read_write == I2C_SMBUS_READ) {
2936 /* Special case: only a read! */
2937 msg[0].flags = I2C_M_RD | flags;
2938 num = 1;
2939 }
2940 break;
2941 case I2C_SMBUS_BYTE_DATA:
2942 if (read_write == I2C_SMBUS_READ)
2943 msg[1].len = 1;
2944 else {
2945 msg[0].len = 2;
2946 msgbuf0[1] = data->byte;
2947 }
2948 break;
2949 case I2C_SMBUS_WORD_DATA:
2950 if (read_write == I2C_SMBUS_READ)
2951 msg[1].len = 2;
2952 else {
Farid Hammane7225acf2010-05-21 18:40:58 +02002953 msg[0].len = 3;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002954 msgbuf0[1] = data->word & 0xff;
Jean Delvare7eff82c2006-09-03 22:24:00 +02002955 msgbuf0[2] = data->word >> 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002956 }
2957 break;
2958 case I2C_SMBUS_PROC_CALL:
2959 num = 2; /* Special case */
2960 read_write = I2C_SMBUS_READ;
2961 msg[0].len = 3;
2962 msg[1].len = 2;
2963 msgbuf0[1] = data->word & 0xff;
Jean Delvare7eff82c2006-09-03 22:24:00 +02002964 msgbuf0[2] = data->word >> 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002965 break;
2966 case I2C_SMBUS_BLOCK_DATA:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002967 if (read_write == I2C_SMBUS_READ) {
Jean Delvare209d27c2007-05-01 23:26:29 +02002968 msg[1].flags |= I2C_M_RECV_LEN;
2969 msg[1].len = 1; /* block length will be added by
2970 the underlying bus driver */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002971 } else {
2972 msg[0].len = data->block[0] + 2;
2973 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
David Brownell24a5bb72008-07-14 22:38:23 +02002974 dev_err(&adapter->dev,
2975 "Invalid block write size %d\n",
2976 data->block[0]);
2977 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002978 }
Hideki Iwamoto5c50d182005-09-25 17:01:11 +02002979 for (i = 1; i < msg[0].len; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002980 msgbuf0[i] = data->block[i-1];
2981 }
2982 break;
2983 case I2C_SMBUS_BLOCK_PROC_CALL:
Jean Delvare209d27c2007-05-01 23:26:29 +02002984 num = 2; /* Another special case */
2985 read_write = I2C_SMBUS_READ;
2986 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
David Brownell24a5bb72008-07-14 22:38:23 +02002987 dev_err(&adapter->dev,
2988 "Invalid block write size %d\n",
Jean Delvare209d27c2007-05-01 23:26:29 +02002989 data->block[0]);
David Brownell24a5bb72008-07-14 22:38:23 +02002990 return -EINVAL;
Jean Delvare209d27c2007-05-01 23:26:29 +02002991 }
2992 msg[0].len = data->block[0] + 2;
2993 for (i = 1; i < msg[0].len; i++)
2994 msgbuf0[i] = data->block[i-1];
2995 msg[1].flags |= I2C_M_RECV_LEN;
2996 msg[1].len = 1; /* block length will be added by
2997 the underlying bus driver */
2998 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002999 case I2C_SMBUS_I2C_BLOCK_DATA:
3000 if (read_write == I2C_SMBUS_READ) {
Jean Delvare4b2643d2007-07-12 14:12:29 +02003001 msg[1].len = data->block[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003002 } else {
3003 msg[0].len = data->block[0] + 1;
Jean Delvare30dac742005-10-08 00:15:59 +02003004 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
David Brownell24a5bb72008-07-14 22:38:23 +02003005 dev_err(&adapter->dev,
3006 "Invalid block write size %d\n",
3007 data->block[0]);
3008 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003009 }
3010 for (i = 1; i <= data->block[0]; i++)
3011 msgbuf0[i] = data->block[i];
3012 }
3013 break;
3014 default:
David Brownell24a5bb72008-07-14 22:38:23 +02003015 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
3016 return -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003017 }
3018
Jean Delvare421ef472005-10-26 21:28:55 +02003019 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
3020 && size != I2C_SMBUS_I2C_BLOCK_DATA);
3021 if (i) {
3022 /* Compute PEC if first message is a write */
3023 if (!(msg[0].flags & I2C_M_RD)) {
David Brownell438d6c22006-12-10 21:21:31 +01003024 if (num == 1) /* Write only */
Jean Delvare421ef472005-10-26 21:28:55 +02003025 i2c_smbus_add_pec(&msg[0]);
3026 else /* Write followed by read */
3027 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
3028 }
3029 /* Ask for PEC if last message is a read */
3030 if (msg[num-1].flags & I2C_M_RD)
David Brownell438d6c22006-12-10 21:21:31 +01003031 msg[num-1].len++;
Jean Delvare421ef472005-10-26 21:28:55 +02003032 }
3033
David Brownell24a5bb72008-07-14 22:38:23 +02003034 status = i2c_transfer(adapter, msg, num);
3035 if (status < 0)
3036 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003037
Jean Delvare421ef472005-10-26 21:28:55 +02003038 /* Check PEC if last message is a read */
3039 if (i && (msg[num-1].flags & I2C_M_RD)) {
David Brownell24a5bb72008-07-14 22:38:23 +02003040 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
3041 if (status < 0)
3042 return status;
Jean Delvare421ef472005-10-26 21:28:55 +02003043 }
3044
Linus Torvalds1da177e2005-04-16 15:20:36 -07003045 if (read_write == I2C_SMBUS_READ)
Farid Hammane7225acf2010-05-21 18:40:58 +02003046 switch (size) {
3047 case I2C_SMBUS_BYTE:
3048 data->byte = msgbuf0[0];
3049 break;
3050 case I2C_SMBUS_BYTE_DATA:
3051 data->byte = msgbuf1[0];
3052 break;
3053 case I2C_SMBUS_WORD_DATA:
3054 case I2C_SMBUS_PROC_CALL:
3055 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
3056 break;
3057 case I2C_SMBUS_I2C_BLOCK_DATA:
3058 for (i = 0; i < data->block[0]; i++)
3059 data->block[i+1] = msgbuf1[i];
3060 break;
3061 case I2C_SMBUS_BLOCK_DATA:
3062 case I2C_SMBUS_BLOCK_PROC_CALL:
3063 for (i = 0; i < msgbuf1[0] + 1; i++)
3064 data->block[i] = msgbuf1[i];
3065 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003066 }
3067 return 0;
3068}
3069
David Brownella1cdeda2008-07-14 22:38:24 +02003070/**
3071 * i2c_smbus_xfer - execute SMBus protocol operations
3072 * @adapter: Handle to I2C bus
3073 * @addr: Address of SMBus slave on that bus
3074 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
3075 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
3076 * @command: Byte interpreted by slave, for protocols which use such bytes
3077 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
3078 * @data: Data to be read or written
3079 *
3080 * This executes an SMBus protocol operation, and returns a negative
3081 * errno code else zero on success.
3082 */
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01003083s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
David Brownella1cdeda2008-07-14 22:38:24 +02003084 char read_write, u8 command, int protocol,
Zhenwen Xu09b8ce02009-03-28 21:34:46 +01003085 union i2c_smbus_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003086{
Clifford Wolf66b650f2009-06-15 18:01:46 +02003087 unsigned long orig_jiffies;
3088 int try;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003089 s32 res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003090
David Howells8a325992014-03-06 13:36:06 +00003091 /* If enabled, the following two tracepoints are conditional on
3092 * read_write and protocol.
3093 */
3094 trace_smbus_write(adapter, addr, flags, read_write,
3095 command, protocol, data);
3096 trace_smbus_read(adapter, addr, flags, read_write,
3097 command, protocol);
3098
Laurent Pinchartd47726c2012-07-24 14:13:59 +02003099 flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003100
3101 if (adapter->algo->smbus_xfer) {
Jean Delvarefe61e072010-08-11 18:20:58 +02003102 i2c_lock_adapter(adapter);
Clifford Wolf66b650f2009-06-15 18:01:46 +02003103
3104 /* Retry automatically on arbitration loss */
3105 orig_jiffies = jiffies;
3106 for (res = 0, try = 0; try <= adapter->retries; try++) {
3107 res = adapter->algo->smbus_xfer(adapter, addr, flags,
3108 read_write, command,
3109 protocol, data);
3110 if (res != -EAGAIN)
3111 break;
3112 if (time_after(jiffies,
3113 orig_jiffies + adapter->timeout))
3114 break;
3115 }
Jean Delvarefe61e072010-08-11 18:20:58 +02003116 i2c_unlock_adapter(adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003117
Laurent Pinchart72fc2c72012-07-24 14:13:59 +02003118 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
David Howells8a325992014-03-06 13:36:06 +00003119 goto trace;
Laurent Pinchart72fc2c72012-07-24 14:13:59 +02003120 /*
3121 * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
3122 * implement native support for the SMBus operation.
3123 */
3124 }
3125
David Howells8a325992014-03-06 13:36:06 +00003126 res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
3127 command, protocol, data);
3128
3129trace:
3130 /* If enabled, the reply tracepoint is conditional on read_write. */
3131 trace_smbus_reply(adapter, addr, flags, read_write,
3132 command, protocol, data);
3133 trace_smbus_result(adapter, addr, flags, read_write,
3134 command, protocol, res);
3135
3136 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003137}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003138EXPORT_SYMBOL(i2c_smbus_xfer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003139
Irina Tirdea01eef962015-08-12 17:31:33 +03003140/**
3141 * i2c_smbus_read_i2c_block_data_or_emulated - read block or emulate
3142 * @client: Handle to slave device
3143 * @command: Byte interpreted by slave
3144 * @length: Size of data block; SMBus allows at most I2C_SMBUS_BLOCK_MAX bytes
3145 * @values: Byte array into which data will be read; big enough to hold
3146 * the data returned by the slave. SMBus allows at most
3147 * I2C_SMBUS_BLOCK_MAX bytes.
3148 *
3149 * This executes the SMBus "block read" protocol if supported by the adapter.
3150 * If block read is not supported, it emulates it using either word or byte
3151 * read protocols depending on availability.
3152 *
3153 * The addresses of the I2C slave device that are accessed with this function
3154 * must be mapped to a linear region, so that a block read will have the same
3155 * effect as a byte read. Before using this function you must double-check
3156 * if the I2C slave does support exchanging a block transfer with a byte
3157 * transfer.
3158 */
3159s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
3160 u8 command, u8 length, u8 *values)
3161{
3162 u8 i = 0;
3163 int status;
3164
3165 if (length > I2C_SMBUS_BLOCK_MAX)
3166 length = I2C_SMBUS_BLOCK_MAX;
3167
3168 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK))
3169 return i2c_smbus_read_i2c_block_data(client, command, length, values);
3170
3171 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA))
3172 return -EOPNOTSUPP;
3173
3174 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_WORD_DATA)) {
3175 while ((i + 2) <= length) {
3176 status = i2c_smbus_read_word_data(client, command + i);
3177 if (status < 0)
3178 return status;
3179 values[i] = status & 0xff;
3180 values[i + 1] = status >> 8;
3181 i += 2;
3182 }
3183 }
3184
3185 while (i < length) {
3186 status = i2c_smbus_read_byte_data(client, command + i);
3187 if (status < 0)
3188 return status;
3189 values[i] = status;
3190 i++;
3191 }
3192
3193 return i;
3194}
3195EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data_or_emulated);
3196
Jean Delvared5fd1202015-01-26 20:59:31 +01003197#if IS_ENABLED(CONFIG_I2C_SLAVE)
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003198int i2c_slave_register(struct i2c_client *client, i2c_slave_cb_t slave_cb)
3199{
3200 int ret;
3201
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003202 if (!client || !slave_cb) {
3203 WARN(1, "insufficent data\n");
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003204 return -EINVAL;
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003205 }
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003206
Wolfram Sangc6909d62015-08-05 21:12:54 +02003207 if (!(client->flags & I2C_CLIENT_SLAVE))
3208 dev_warn(&client->dev, "%s: client slave flag not set. You might see address collisions\n",
3209 __func__);
3210
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003211 if (!(client->flags & I2C_CLIENT_TEN)) {
3212 /* Enforce stricter address checking */
Wolfram Sang66be60562015-07-17 12:43:22 +02003213 ret = i2c_check_7bit_addr_validity_strict(client->addr);
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003214 if (ret) {
3215 dev_err(&client->dev, "%s: invalid address\n", __func__);
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003216 return ret;
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003217 }
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003218 }
3219
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003220 if (!client->adapter->algo->reg_slave) {
3221 dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003222 return -EOPNOTSUPP;
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003223 }
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003224
3225 client->slave_cb = slave_cb;
3226
3227 i2c_lock_adapter(client->adapter);
3228 ret = client->adapter->algo->reg_slave(client);
3229 i2c_unlock_adapter(client->adapter);
3230
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003231 if (ret) {
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003232 client->slave_cb = NULL;
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003233 dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
3234 }
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003235
3236 return ret;
3237}
3238EXPORT_SYMBOL_GPL(i2c_slave_register);
3239
3240int i2c_slave_unregister(struct i2c_client *client)
3241{
3242 int ret;
3243
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003244 if (!client->adapter->algo->unreg_slave) {
3245 dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003246 return -EOPNOTSUPP;
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003247 }
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003248
3249 i2c_lock_adapter(client->adapter);
3250 ret = client->adapter->algo->unreg_slave(client);
3251 i2c_unlock_adapter(client->adapter);
3252
3253 if (ret == 0)
3254 client->slave_cb = NULL;
Wolfram Sang0c7cab92015-05-14 14:40:05 +02003255 else
3256 dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003257
3258 return ret;
3259}
3260EXPORT_SYMBOL_GPL(i2c_slave_unregister);
Jean Delvared5fd1202015-01-26 20:59:31 +01003261#endif
Wolfram Sang4b1acc42014-11-18 17:04:53 +01003262
Linus Torvalds1da177e2005-04-16 15:20:36 -07003263MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
3264MODULE_DESCRIPTION("I2C-Bus main module");
3265MODULE_LICENSE("GPL");