projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'for-linus-4.5' of git://git.kernel.org/pub/scm/linux/kernel/git/mason...
[deliverable/linux.git] / drivers / i2c / i2c-core.c
CommitLineData
1da177e4
LT		 1/* 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
ca1f8da9 13 GNU General Public License for more details. */
1da177e4
LT		 14/* ------------------------------------------------------------------------- */
15
96de0e25 16/* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi>.
1da177e4 17 All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl>
421ef47b 18 SMBus 2.0 support by Mark Studebaker <mdsxyz123@yahoo.com> and
7c81c60f 19 Jean Delvare <jdelvare@suse.de>
0826374b 20 Mux support by Rodolfo Giometti <giometti@enneenne.com> and
687b81d0
WS		 21 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>
17f4a5c4
WS		 25 I2C ACPI code Copyright (C) 2014 Intel Corp
26 Author: Lan Tianyu <tianyu.lan@intel.com>
4b1acc43 27 I2C slave support (c) 2014 by Wolfram Sang <wsa@sang-engineering.com>
687b81d0 28 */
1da177e4 29
b4e2f6ac 30#include <dt-bindings/i2c/i2c.h>
1da177e4
LT		 31#include <linux/module.h>
32#include <linux/kernel.h>
5f9296ba 33#include <linux/delay.h>
1da177e4 34#include <linux/errno.h>
5f9296ba 35#include <linux/gpio.h>
1da177e4
LT		 36#include <linux/slab.h>
37#include <linux/i2c.h>
38#include <linux/init.h>
39#include <linux/idr.h>
b3585e4f 40#include <linux/mutex.h>
687b81d0 41#include <linux/of.h>
959e85f7 42#include <linux/of_device.h>
687b81d0 43#include <linux/of_irq.h>
86be408b 44#include <linux/clk/clk-conf.h>
b8d6f45b 45#include <linux/completion.h>
cea443a8
MR		 46#include <linux/hardirq.h>
47#include <linux/irqflags.h>
f18c41da 48#include <linux/rwsem.h>
6de468ae 49#include <linux/pm_runtime.h>
f48c767c 50#include <linux/pm_domain.h>
3fffd128 51#include <linux/pm_wakeirq.h>
907ddf89 52#include <linux/acpi.h>
d9a83d62 53#include <linux/jump_label.h>
1da177e4 54#include <asm/uaccess.h>
a430a345 55#include <linux/err.h>
e1dba01c 56#include <linux/property.h>
1da177e4 57
9c1600ed
DB		 58#include "i2c-core.h"
59
d9a83d62
DH		 60#define CREATE_TRACE_POINTS
61#include <trace/events/i2c.h>
1da177e4 62
da899f55
WS		 63#define I2C_ADDR_OFFSET_TEN_BIT 0xa000
64#define I2C_ADDR_OFFSET_SLAVE 0x1000
65
6629dcff 66/* core_lock protects i2c_adapter_idr, and guarantees
35fc37f8 67 that device detection, deletion of detected devices, and attach_adapter
19baba4c 68 calls are serialized */
caada32a 69static DEFINE_MUTEX(core_lock);
1da177e4
LT		 70static DEFINE_IDR(i2c_adapter_idr);
71
4f8cf824 72static struct device_type i2c_client_type;
4735c98f 73static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
f37dd80a 74
d9a83d62
DH		 75static struct static_key i2c_trace_msg = STATIC_KEY_INIT_FALSE;
76
77void i2c_transfer_trace_reg(void)
78{
79 static_key_slow_inc(&i2c_trace_msg);
80}
81
82void i2c_transfer_trace_unreg(void)
83{
84 static_key_slow_dec(&i2c_trace_msg);
85}
86
17f4a5c4
WS		 87#if defined(CONFIG_ACPI)
88struct acpi_i2c_handler_data {
89 struct acpi_connection_info info;
90 struct i2c_adapter *adapter;
91};
92
93struct gsb_buffer {
94 u8 status;
95 u8 len;
96 union {
97 u16 wdata;
98 u8 bdata;
99 u8 data[0];
100 };
101} __packed;
102
166c2ba3
MW		 103struct acpi_i2c_lookup {
104 struct i2c_board_info *info;
105 acpi_handle adapter_handle;
106 acpi_handle device_handle;
107};
17f4a5c4 108
166c2ba3
MW		 109static int acpi_i2c_find_address(struct acpi_resource *ares, void *data)
110{
111 struct acpi_i2c_lookup *lookup = data;
112 struct i2c_board_info *info = lookup->info;
113 struct acpi_resource_i2c_serialbus *sb;
114 acpi_handle adapter_handle;
115 acpi_status status;
17f4a5c4 116
166c2ba3
MW		 117 if (info->addr || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS)
118 return 1;
119
120 sb = &ares->data.i2c_serial_bus;
121 if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C)
122 return 1;
123
124 /*
125 * Extract the ResourceSource and make sure that the handle matches
126 * with the I2C adapter handle.
127 */
128 status = acpi_get_handle(lookup->device_handle,
129 sb->resource_source.string_ptr,
130 &adapter_handle);
131 if (ACPI_SUCCESS(status) && adapter_handle == lookup->adapter_handle) {
132 info->addr = sb->slave_address;
133 if (sb->access_mode == ACPI_I2C_10BIT_MODE)
134 info->flags |= I2C_CLIENT_TEN;
17f4a5c4
WS		 135 }
136
17f4a5c4
WS		 137 return 1;
138}
139
140static acpi_status acpi_i2c_add_device(acpi_handle handle, u32 level,
141 void *data, void **return_value)
142{
143 struct i2c_adapter *adapter = data;
144 struct list_head resource_list;
166c2ba3
MW		 145 struct acpi_i2c_lookup lookup;
146 struct resource_entry *entry;
17f4a5c4
WS		 147 struct i2c_board_info info;
148 struct acpi_device *adev;
149 int ret;
150
151 if (acpi_bus_get_device(handle, &adev))
152 return AE_OK;
153 if (acpi_bus_get_status(adev) || !adev->status.present)
154 return AE_OK;
155
156 memset(&info, 0, sizeof(info));
ce793486 157 info.fwnode = acpi_fwnode_handle(adev);
17f4a5c4 158
166c2ba3 159 memset(&lookup, 0, sizeof(lookup));
8eb5c87a 160 lookup.adapter_handle = ACPI_HANDLE(&adapter->dev);
166c2ba3
MW		 161 lookup.device_handle = handle;
162 lookup.info = &info;
163
164 /*
165 * Look up for I2cSerialBus resource with ResourceSource that
166 * matches with this adapter.
167 */
17f4a5c4
WS		 168 INIT_LIST_HEAD(&resource_list);
169 ret = acpi_dev_get_resources(adev, &resource_list,
166c2ba3 170 acpi_i2c_find_address, &lookup);
17f4a5c4
WS		 171 acpi_dev_free_resource_list(&resource_list);
172
173 if (ret < 0 || !info.addr)
174 return AE_OK;
175
166c2ba3
MW		 176 /* Then fill IRQ number if any */
177 ret = acpi_dev_get_resources(adev, &resource_list, NULL, NULL);
178 if (ret < 0)
179 return AE_OK;
180
181 resource_list_for_each_entry(entry, &resource_list) {
182 if (resource_type(entry->res) == IORESOURCE_IRQ) {
183 info.irq = entry->res->start;
184 break;
185 }
186 }
187
188 acpi_dev_free_resource_list(&resource_list);
189
17f4a5c4
WS		 190 adev->power.flags.ignore_parent = true;
191 strlcpy(info.type, dev_name(&adev->dev), sizeof(info.type));
192 if (!i2c_new_device(adapter, &info)) {
193 adev->power.flags.ignore_parent = false;
194 dev_err(&adapter->dev,
195 "failed to add I2C device %s from ACPI\n",
196 dev_name(&adev->dev));
197 }
198
199 return AE_OK;
200}
201
166c2ba3
MW		 202#define ACPI_I2C_MAX_SCAN_DEPTH 32
203
17f4a5c4
WS		 204/**
205 * acpi_i2c_register_devices - enumerate I2C slave devices behind adapter
206 * @adap: pointer to adapter
207 *
208 * Enumerate all I2C slave devices behind this adapter by walking the ACPI
209 * namespace. When a device is found it will be added to the Linux device
210 * model and bound to the corresponding ACPI handle.
211 */
212static void acpi_i2c_register_devices(struct i2c_adapter *adap)
213{
17f4a5c4
WS		 214 acpi_status status;
215
8eb5c87a 216 if (!has_acpi_companion(&adap->dev))
17f4a5c4
WS		 217 return;
218
166c2ba3
MW		 219 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
220 ACPI_I2C_MAX_SCAN_DEPTH,
17f4a5c4
WS		 221 acpi_i2c_add_device, NULL,
222 adap, NULL);
223 if (ACPI_FAILURE(status))
224 dev_warn(&adap->dev, "failed to enumerate I2C slaves\n");
225}
226
227#else /* CONFIG_ACPI */
228static inline void acpi_i2c_register_devices(struct i2c_adapter *adap) { }
229#endif /* CONFIG_ACPI */
230
231#ifdef CONFIG_ACPI_I2C_OPREGION
232static int acpi_gsb_i2c_read_bytes(struct i2c_client *client,
233 u8 cmd, u8 *data, u8 data_len)
234{
235
236 struct i2c_msg msgs[2];
237 int ret;
238 u8 *buffer;
239
240 buffer = kzalloc(data_len, GFP_KERNEL);
241 if (!buffer)
242 return AE_NO_MEMORY;
243
244 msgs[0].addr = client->addr;
245 msgs[0].flags = client->flags;
246 msgs[0].len = 1;
247 msgs[0].buf = &cmd;
248
249 msgs[1].addr = client->addr;
250 msgs[1].flags = client->flags | I2C_M_RD;
251 msgs[1].len = data_len;
252 msgs[1].buf = buffer;
253
254 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
255 if (ret < 0)
256 dev_err(&client->adapter->dev, "i2c read failed\n");
257 else
258 memcpy(data, buffer, data_len);
259
260 kfree(buffer);
261 return ret;
262}
263
264static int acpi_gsb_i2c_write_bytes(struct i2c_client *client,
265 u8 cmd, u8 *data, u8 data_len)
266{
267
268 struct i2c_msg msgs[1];
269 u8 *buffer;
270 int ret = AE_OK;
271
272 buffer = kzalloc(data_len + 1, GFP_KERNEL);
273 if (!buffer)
274 return AE_NO_MEMORY;
275
276 buffer[0] = cmd;
277 memcpy(buffer + 1, data, data_len);
278
279 msgs[0].addr = client->addr;
280 msgs[0].flags = client->flags;
281 msgs[0].len = data_len + 1;
282 msgs[0].buf = buffer;
283
284 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
285 if (ret < 0)
286 dev_err(&client->adapter->dev, "i2c write failed\n");
287
288 kfree(buffer);
289 return ret;
290}
291
292static acpi_status
293acpi_i2c_space_handler(u32 function, acpi_physical_address command,
294 u32 bits, u64 *value64,
295 void *handler_context, void *region_context)
296{
297 struct gsb_buffer *gsb = (struct gsb_buffer *)value64;
298 struct acpi_i2c_handler_data *data = handler_context;
299 struct acpi_connection_info *info = &data->info;
300 struct acpi_resource_i2c_serialbus *sb;
301 struct i2c_adapter *adapter = data->adapter;
7ef85f5f 302 struct i2c_client *client;
17f4a5c4
WS		 303 struct acpi_resource *ares;
304 u32 accessor_type = function >> 16;
305 u8 action = function & ACPI_IO_MASK;
4470c725 306 acpi_status ret;
17f4a5c4
WS		 307 int status;
308
309 ret = acpi_buffer_to_resource(info->connection, info->length, &ares);
310 if (ACPI_FAILURE(ret))
311 return ret;
312
7ef85f5f
JN		 313 client = kzalloc(sizeof(*client), GFP_KERNEL);
314 if (!client) {
315 ret = AE_NO_MEMORY;
316 goto err;
317 }
318
17f4a5c4
WS		 319 if (!value64 || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) {
320 ret = AE_BAD_PARAMETER;
321 goto err;
322 }
323
324 sb = &ares->data.i2c_serial_bus;
325 if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C) {
326 ret = AE_BAD_PARAMETER;
327 goto err;
328 }
329
7ef85f5f
JN		 330 client->adapter = adapter;
331 client->addr = sb->slave_address;
17f4a5c4
WS		 332
333 if (sb->access_mode == ACPI_I2C_10BIT_MODE)
7ef85f5f 334 client->flags |= I2C_CLIENT_TEN;
17f4a5c4
WS		 335
336 switch (accessor_type) {
337 case ACPI_GSB_ACCESS_ATTRIB_SEND_RCV:
338 if (action == ACPI_READ) {
7ef85f5f 339 status = i2c_smbus_read_byte(client);
17f4a5c4
WS		 340 if (status >= 0) {
341 gsb->bdata = status;
342 status = 0;
343 }
344 } else {
7ef85f5f 345 status = i2c_smbus_write_byte(client, gsb->bdata);
17f4a5c4
WS		 346 }
347 break;
348
349 case ACPI_GSB_ACCESS_ATTRIB_BYTE:
350 if (action == ACPI_READ) {
7ef85f5f 351 status = i2c_smbus_read_byte_data(client, command);
17f4a5c4
WS		 352 if (status >= 0) {
353 gsb->bdata = status;
354 status = 0;
355 }
356 } else {
7ef85f5f 357 status = i2c_smbus_write_byte_data(client, command,
17f4a5c4
WS		 358 gsb->bdata);
359 }
360 break;
361
362 case ACPI_GSB_ACCESS_ATTRIB_WORD:
363 if (action == ACPI_READ) {
7ef85f5f 364 status = i2c_smbus_read_word_data(client, command);
17f4a5c4
WS		 365 if (status >= 0) {
366 gsb->wdata = status;
367 status = 0;
368 }
369 } else {
7ef85f5f 370 status = i2c_smbus_write_word_data(client, command,
17f4a5c4
WS		 371 gsb->wdata);
372 }
373 break;
374
375 case ACPI_GSB_ACCESS_ATTRIB_BLOCK:
376 if (action == ACPI_READ) {
7ef85f5f 377 status = i2c_smbus_read_block_data(client, command,
17f4a5c4
WS		 378 gsb->data);
379 if (status >= 0) {
380 gsb->len = status;
381 status = 0;
382 }
383 } else {
7ef85f5f 384 status = i2c_smbus_write_block_data(client, command,
17f4a5c4
WS		 385 gsb->len, gsb->data);
386 }
387 break;
388
389 case ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE:
390 if (action == ACPI_READ) {
7ef85f5f 391 status = acpi_gsb_i2c_read_bytes(client, command,
17f4a5c4
WS		 392 gsb->data, info->access_length);
393 if (status > 0)
394 status = 0;
395 } else {
7ef85f5f 396 status = acpi_gsb_i2c_write_bytes(client, command,
17f4a5c4
WS		 397 gsb->data, info->access_length);
398 }
399 break;
400
401 default:
402 pr_info("protocol(0x%02x) is not supported.\n", accessor_type);
403 ret = AE_BAD_PARAMETER;
404 goto err;
405 }
406
407 gsb->status = status;
408
409 err:
7ef85f5f 410 kfree(client);
17f4a5c4
WS		 411 ACPI_FREE(ares);
412 return ret;
413}
414
415
416static int acpi_i2c_install_space_handler(struct i2c_adapter *adapter)
417{
0aef44e8 418 acpi_handle handle;
17f4a5c4
WS		 419 struct acpi_i2c_handler_data *data;
420 acpi_status status;
421
0aef44e8
PH		 422 if (!adapter->dev.parent)
423 return -ENODEV;
424
425 handle = ACPI_HANDLE(adapter->dev.parent);
426
17f4a5c4
WS		 427 if (!handle)
428 return -ENODEV;
429
430 data = kzalloc(sizeof(struct acpi_i2c_handler_data),
431 GFP_KERNEL);
432 if (!data)
433 return -ENOMEM;
434
435 data->adapter = adapter;
436 status = acpi_bus_attach_private_data(handle, (void *)data);
437 if (ACPI_FAILURE(status)) {
438 kfree(data);
439 return -ENOMEM;
440 }
441
442 status = acpi_install_address_space_handler(handle,
443 ACPI_ADR_SPACE_GSBUS,
444 &acpi_i2c_space_handler,
445 NULL,
446 data);
447 if (ACPI_FAILURE(status)) {
448 dev_err(&adapter->dev, "Error installing i2c space handler\n");
449 acpi_bus_detach_private_data(handle);
450 kfree(data);
451 return -ENOMEM;
452 }
453
40e7fcb1 454 acpi_walk_dep_device_list(handle);
17f4a5c4
WS		 455 return 0;
456}
457
458static void acpi_i2c_remove_space_handler(struct i2c_adapter *adapter)
459{
0aef44e8 460 acpi_handle handle;
17f4a5c4
WS		 461 struct acpi_i2c_handler_data *data;
462 acpi_status status;
463
0aef44e8
PH		 464 if (!adapter->dev.parent)
465 return;
466
467 handle = ACPI_HANDLE(adapter->dev.parent);
468
17f4a5c4
WS		 469 if (!handle)
470 return;
471
472 acpi_remove_address_space_handler(handle,
473 ACPI_ADR_SPACE_GSBUS,
474 &acpi_i2c_space_handler);
475
476 status = acpi_bus_get_private_data(handle, (void **)&data);
477 if (ACPI_SUCCESS(status))
478 kfree(data);
479
480 acpi_bus_detach_private_data(handle);
481}
482#else /* CONFIG_ACPI_I2C_OPREGION */
483static inline void acpi_i2c_remove_space_handler(struct i2c_adapter *adapter)
484{ }
485
486static inline int acpi_i2c_install_space_handler(struct i2c_adapter *adapter)
487{ return 0; }
488#endif /* CONFIG_ACPI_I2C_OPREGION */
489
f37dd80a
DB		 490/* ------------------------------------------------------------------------- */
491
d2653e92
JD		 492static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
493 const struct i2c_client *client)
494{
495 while (id->name[0]) {
496 if (strcmp(client->name, id->name) == 0)
497 return id;
498 id++;
499 }
500 return NULL;
501}
502
1da177e4
LT		 503static int i2c_device_match(struct device *dev, struct device_driver *drv)
504{
51298d12
JD		 505 struct i2c_client *client = i2c_verify_client(dev);
506 struct i2c_driver *driver;
507
508 if (!client)
509 return 0;
7b4fbc50 510
959e85f7
GL		 511 /* Attempt an OF style match */
512 if (of_driver_match_device(dev, drv))
513 return 1;
514
907ddf89
MW		 515 /* Then ACPI style match */
516 if (acpi_driver_match_device(dev, drv))
517 return 1;
518
51298d12 519 driver = to_i2c_driver(drv);
d2653e92
JD		 520 /* match on an id table if there is one */
521 if (driver->id_table)
522 return i2c_match_id(driver->id_table, client) != NULL;
523
eb8a7908 524 return 0;
1da177e4
LT		 525}
526
7b4fbc50
DB		 527
528/* uevent helps with hotplug: modprobe -q $(MODALIAS) */
7eff2e7a 529static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
7b4fbc50
DB		 530{
531 struct i2c_client *client = to_i2c_client(dev);
8c4ff6d0
ZR		 532 int rc;
533
534 rc = acpi_device_uevent_modalias(dev, env);
535 if (rc != -ENODEV)
536 return rc;
7b4fbc50 537
eb8a7908
JD		 538 if (add_uevent_var(env, "MODALIAS=%s%s",
539 I2C_MODULE_PREFIX, client->name))
540 return -ENOMEM;
7b4fbc50
DB		 541 dev_dbg(dev, "uevent\n");
542 return 0;
543}
544
5f9296ba
VK		 545/* i2c bus recovery routines */
546static int get_scl_gpio_value(struct i2c_adapter *adap)
547{
548 return gpio_get_value(adap->bus_recovery_info->scl_gpio);
549}
550
551static void set_scl_gpio_value(struct i2c_adapter *adap, int val)
552{
553 gpio_set_value(adap->bus_recovery_info->scl_gpio, val);
554}
555
556static int get_sda_gpio_value(struct i2c_adapter *adap)
557{
558 return gpio_get_value(adap->bus_recovery_info->sda_gpio);
559}
560
561static int i2c_get_gpios_for_recovery(struct i2c_adapter *adap)
562{
563 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
564 struct device *dev = &adap->dev;
565 int ret = 0;
566
567 ret = gpio_request_one(bri->scl_gpio, GPIOF_OPEN_DRAIN |
568 GPIOF_OUT_INIT_HIGH, "i2c-scl");
569 if (ret) {
570 dev_warn(dev, "Can't get SCL gpio: %d\n", bri->scl_gpio);
571 return ret;
572 }
573
574 if (bri->get_sda) {
575 if (gpio_request_one(bri->sda_gpio, GPIOF_IN, "i2c-sda")) {
576 /* work without SDA polling */
577 dev_warn(dev, "Can't get SDA gpio: %d. Not using SDA polling\n",
578 bri->sda_gpio);
579 bri->get_sda = NULL;
580 }
581 }
582
583 return ret;
584}
585
586static void i2c_put_gpios_for_recovery(struct i2c_adapter *adap)
587{
588 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
589
590 if (bri->get_sda)
591 gpio_free(bri->sda_gpio);
592
593 gpio_free(bri->scl_gpio);
594}
595
596/*
597 * We are generating clock pulses. ndelay() determines durating of clk pulses.
598 * We will generate clock with rate 100 KHz and so duration of both clock levels
599 * is: delay in ns = (10^6 / 100) / 2
600 */
601#define RECOVERY_NDELAY 5000
602#define RECOVERY_CLK_CNT 9
603
604static int i2c_generic_recovery(struct i2c_adapter *adap)
605{
606 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
607 int i = 0, val = 1, ret = 0;
608
609 if (bri->prepare_recovery)
2b2190a3 610 bri->prepare_recovery(adap);
5f9296ba 611
8b062608
JL		 612 bri->set_scl(adap, val);
613 ndelay(RECOVERY_NDELAY);
614
5f9296ba
VK		 615 /*
616 * By this time SCL is high, as we need to give 9 falling-rising edges
617 */
618 while (i++ < RECOVERY_CLK_CNT * 2) {
619 if (val) {
620 /* Break if SDA is high */
621 if (bri->get_sda && bri->get_sda(adap))
622 break;
623 /* SCL shouldn't be low here */
624 if (!bri->get_scl(adap)) {
625 dev_err(&adap->dev,
626 "SCL is stuck low, exit recovery\n");
627 ret = -EBUSY;
628 break;
629 }
630 }
631
632 val = !val;
633 bri->set_scl(adap, val);
634 ndelay(RECOVERY_NDELAY);
635 }
636
637 if (bri->unprepare_recovery)
2b2190a3 638 bri->unprepare_recovery(adap);
5f9296ba
VK		 639
640 return ret;
641}
642
643int i2c_generic_scl_recovery(struct i2c_adapter *adap)
644{
5f9296ba
VK		 645 return i2c_generic_recovery(adap);
646}
c1c21f4e 647EXPORT_SYMBOL_GPL(i2c_generic_scl_recovery);
5f9296ba
VK		 648
649int i2c_generic_gpio_recovery(struct i2c_adapter *adap)
650{
651 int ret;
652
653 ret = i2c_get_gpios_for_recovery(adap);
654 if (ret)
655 return ret;
656
657 ret = i2c_generic_recovery(adap);
658 i2c_put_gpios_for_recovery(adap);
659
660 return ret;
661}
c1c21f4e 662EXPORT_SYMBOL_GPL(i2c_generic_gpio_recovery);
5f9296ba
VK		 663
664int i2c_recover_bus(struct i2c_adapter *adap)
665{
666 if (!adap->bus_recovery_info)
667 return -EOPNOTSUPP;
668
669 dev_dbg(&adap->dev, "Trying i2c bus recovery\n");
670 return adap->bus_recovery_info->recover_bus(adap);
671}
c1c21f4e 672EXPORT_SYMBOL_GPL(i2c_recover_bus);
5f9296ba 673
f37dd80a 674static int i2c_device_probe(struct device *dev)
1da177e4 675{
51298d12
JD		 676 struct i2c_client *client = i2c_verify_client(dev);
677 struct i2c_driver *driver;
50c3304a 678 int status;
7b4fbc50 679
51298d12
JD		 680 if (!client)
681 return 0;
682
845c8770
MW		 683 if (!client->irq) {
684 int irq = -ENOENT;
685
3fffd128
DT		 686 if (dev->of_node) {
687 irq = of_irq_get_byname(dev->of_node, "irq");
688 if (irq == -EINVAL || irq == -ENODATA)
689 irq = of_irq_get(dev->of_node, 0);
690 } else if (ACPI_COMPANION(dev)) {
845c8770 691 irq = acpi_dev_gpio_irq_get(ACPI_COMPANION(dev), 0);
3fffd128 692 }
6f34be74 693 if (irq == -EPROBE_DEFER)
2fd36c55 694 return irq;
6f34be74
GU		 695 if (irq < 0)
696 irq = 0;
2fd36c55
LP		 697
698 client->irq = irq;
699 }
700
51298d12 701 driver = to_i2c_driver(dev->driver);
e0457442 702 if (!driver->probe || !driver->id_table)
7b4fbc50 703 return -ENODEV;
0acc2b32 704
3fffd128
DT		 705 if (client->flags & I2C_CLIENT_WAKE) {
706 int wakeirq = -ENOENT;
707
708 if (dev->of_node) {
709 wakeirq = of_irq_get_byname(dev->of_node, "wakeup");
710 if (wakeirq == -EPROBE_DEFER)
711 return wakeirq;
712 }
713
714 device_init_wakeup(&client->dev, true);
715
716 if (wakeirq > 0 && wakeirq != client->irq)
717 status = dev_pm_set_dedicated_wake_irq(dev, wakeirq);
718 else if (client->irq > 0)
c18fba23 719 status = dev_pm_set_wake_irq(dev, client->irq);
3fffd128
DT		 720 else
721 status = 0;
722
723 if (status)
724 dev_warn(&client->dev, "failed to set up wakeup irq");
725 }
726
7b4fbc50 727 dev_dbg(dev, "probe\n");
d2653e92 728
86be408b
SN		 729 status = of_clk_set_defaults(dev->of_node, false);
730 if (status < 0)
3fffd128 731 goto err_clear_wakeup_irq;
86be408b 732
e09b0d4e 733 status = dev_pm_domain_attach(&client->dev, true);
74cedd30
KB		 734 if (status == -EPROBE_DEFER)
735 goto err_clear_wakeup_irq;
736
737 status = driver->probe(client, i2c_match_id(driver->id_table, client));
738 if (status)
739 goto err_detach_pm_domain;
72fa818e 740
3fffd128
DT		 741 return 0;
742
743err_detach_pm_domain:
744 dev_pm_domain_detach(&client->dev, true);
745err_clear_wakeup_irq:
746 dev_pm_clear_wake_irq(&client->dev);
747 device_init_wakeup(&client->dev, false);
50c3304a 748 return status;
f37dd80a 749}
1da177e4 750
f37dd80a
DB		 751static int i2c_device_remove(struct device *dev)
752{
51298d12 753 struct i2c_client *client = i2c_verify_client(dev);
a1d9e6e4 754 struct i2c_driver *driver;
72fa818e 755 int status = 0;
a1d9e6e4 756
51298d12 757 if (!client || !dev->driver)
a1d9e6e4
DB		 758 return 0;
759
760 driver = to_i2c_driver(dev->driver);
761 if (driver->remove) {
762 dev_dbg(dev, "remove\n");
763 status = driver->remove(client);
a1d9e6e4 764 }
72fa818e 765
e09b0d4e 766 dev_pm_domain_detach(&client->dev, true);
3fffd128
DT		 767
768 dev_pm_clear_wake_irq(&client->dev);
769 device_init_wakeup(&client->dev, false);
770
a1d9e6e4 771 return status;
1da177e4
LT		 772}
773
f37dd80a 774static void i2c_device_shutdown(struct device *dev)
1da177e4 775{
51298d12 776 struct i2c_client *client = i2c_verify_client(dev);
f37dd80a
DB		 777 struct i2c_driver *driver;
778
51298d12 779 if (!client || !dev->driver)
f37dd80a
DB		 780 return;
781 driver = to_i2c_driver(dev->driver);
782 if (driver->shutdown)
51298d12 783 driver->shutdown(client);
1da177e4
LT		 784}
785
9c1600ed
DB		 786static void i2c_client_dev_release(struct device *dev)
787{
788 kfree(to_i2c_client(dev));
789}
790
09b8ce0a 791static ssize_t
4f8cf824 792show_name(struct device *dev, struct device_attribute *attr, char *buf)
7b4fbc50 793{
4f8cf824
JD		 794 return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
795 to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
7b4fbc50 796}
a5eb71b2 797static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
7b4fbc50 798
09b8ce0a
ZX		 799static ssize_t
800show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
7b4fbc50
DB		 801{
802 struct i2c_client *client = to_i2c_client(dev);
8c4ff6d0
ZR		 803 int len;
804
805 len = acpi_device_modalias(dev, buf, PAGE_SIZE -1);
806 if (len != -ENODEV)
807 return len;
808
eb8a7908 809 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
7b4fbc50 810}
51298d12
JD		 811static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
812
813static struct attribute *i2c_dev_attrs[] = {
814 &dev_attr_name.attr,
7b4fbc50 815 /* modalias helps coldplug: modprobe $(cat .../modalias) */
51298d12
JD		 816 &dev_attr_modalias.attr,
817 NULL
818};
a5eb71b2 819ATTRIBUTE_GROUPS(i2c_dev);
54067ee2 820
e9ca9eb9 821struct bus_type i2c_bus_type = {
f37dd80a
DB		 822 .name = "i2c",
823 .match = i2c_device_match,
824 .probe = i2c_device_probe,
825 .remove = i2c_device_remove,
826 .shutdown = i2c_device_shutdown,
b864c7d5 827};
e9ca9eb9 828EXPORT_SYMBOL_GPL(i2c_bus_type);
b864c7d5 829
51298d12 830static struct device_type i2c_client_type = {
a5eb71b2 831 .groups = i2c_dev_groups,
51298d12
JD		 832 .uevent = i2c_device_uevent,
833 .release = i2c_client_dev_release,
834};
835
9b766b81
DB		 836
837/**
838 * i2c_verify_client - return parameter as i2c_client, or NULL
839 * @dev: device, probably from some driver model iterator
840 *
841 * When traversing the driver model tree, perhaps using driver model
842 * iterators like @device_for_each_child(), you can't assume very much
843 * about the nodes you find. Use this function to avoid oopses caused
844 * by wrongly treating some non-I2C device as an i2c_client.
845 */
846struct i2c_client *i2c_verify_client(struct device *dev)
847{
51298d12 848 return (dev->type == &i2c_client_type)
9b766b81
DB		 849 ? to_i2c_client(dev)
850 : NULL;
851}
852EXPORT_SYMBOL(i2c_verify_client);
853
854
da899f55
WS		 855/* Return a unique address which takes the flags of the client into account */
856static unsigned short i2c_encode_flags_to_addr(struct i2c_client *client)
857{
858 unsigned short addr = client->addr;
859
860 /* For some client flags, add an arbitrary offset to avoid collisions */
861 if (client->flags & I2C_CLIENT_TEN)
862 addr |= I2C_ADDR_OFFSET_TEN_BIT;
863
864 if (client->flags & I2C_CLIENT_SLAVE)
865 addr |= I2C_ADDR_OFFSET_SLAVE;
866
867 return addr;
868}
869
3a89db5f 870/* This is a permissive address validity check, I2C address map constraints
25985edc 871 * are purposely not enforced, except for the general call address. */
c4019b70 872static int i2c_check_addr_validity(unsigned addr, unsigned short flags)
3a89db5f 873{
c4019b70 874 if (flags & I2C_CLIENT_TEN) {
3a89db5f 875 /* 10-bit address, all values are valid */
c4019b70 876 if (addr > 0x3ff)
3a89db5f
JD		 877 return -EINVAL;
878 } else {
879 /* 7-bit address, reject the general call address */
c4019b70 880 if (addr == 0x00 || addr > 0x7f)
3a89db5f
JD		 881 return -EINVAL;
882 }
883 return 0;
884}
885
656b8761
JD		 886/* And this is a strict address validity check, used when probing. If a
887 * device uses a reserved address, then it shouldn't be probed. 7-bit
888 * addressing is assumed, 10-bit address devices are rare and should be
889 * explicitly enumerated. */
66be6056 890static int i2c_check_7bit_addr_validity_strict(unsigned short addr)
656b8761
JD		 891{
892 /*
893 * Reserved addresses per I2C specification:
894 * 0x00 General call address / START byte
895 * 0x01 CBUS address
896 * 0x02 Reserved for different bus format
897 * 0x03 Reserved for future purposes
898 * 0x04-0x07 Hs-mode master code
899 * 0x78-0x7b 10-bit slave addressing
900 * 0x7c-0x7f Reserved for future purposes
901 */
902 if (addr < 0x08 || addr > 0x77)
903 return -EINVAL;
904 return 0;
905}
906
3b5f794b
JD		 907static int __i2c_check_addr_busy(struct device *dev, void *addrp)
908{
909 struct i2c_client *client = i2c_verify_client(dev);
910 int addr = *(int *)addrp;
911
9bccc70a 912 if (client && i2c_encode_flags_to_addr(client) == addr)
3b5f794b
JD		 913 return -EBUSY;
914 return 0;
915}
916
0826374b
ML		 917/* walk up mux tree */
918static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
919{
97cc4d49 920 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
0826374b
ML		 921 int result;
922
923 result = device_for_each_child(&adapter->dev, &addr,
924 __i2c_check_addr_busy);
925
97cc4d49
JD		 926 if (!result && parent)
927 result = i2c_check_mux_parents(parent, addr);
0826374b
ML		 928
929 return result;
930}
931
932/* recurse down mux tree */
933static int i2c_check_mux_children(struct device *dev, void *addrp)
934{
935 int result;
936
937 if (dev->type == &i2c_adapter_type)
938 result = device_for_each_child(dev, addrp,
939 i2c_check_mux_children);
940 else
941 result = __i2c_check_addr_busy(dev, addrp);
942
943 return result;
944}
945
3b5f794b
JD		 946static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
947{
97cc4d49 948 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
0826374b
ML		 949 int result = 0;
950
97cc4d49
JD		 951 if (parent)
952 result = i2c_check_mux_parents(parent, addr);
0826374b
ML		 953
954 if (!result)
955 result = device_for_each_child(&adapter->dev, &addr,
956 i2c_check_mux_children);
957
958 return result;
3b5f794b
JD		 959}
960
fe61e07e
JD		 961/**
962 * i2c_lock_adapter - Get exclusive access to an I2C bus segment
963 * @adapter: Target I2C bus segment
964 */
965void i2c_lock_adapter(struct i2c_adapter *adapter)
966{
97cc4d49
JD		 967 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
968
969 if (parent)
970 i2c_lock_adapter(parent);
0826374b
ML		 971 else
972 rt_mutex_lock(&adapter->bus_lock);
fe61e07e
JD		 973}
974EXPORT_SYMBOL_GPL(i2c_lock_adapter);
975
976/**
977 * i2c_trylock_adapter - Try to get exclusive access to an I2C bus segment
978 * @adapter: Target I2C bus segment
979 */
980static int i2c_trylock_adapter(struct i2c_adapter *adapter)
981{
97cc4d49
JD		 982 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
983
984 if (parent)
985 return i2c_trylock_adapter(parent);
0826374b
ML		 986 else
987 return rt_mutex_trylock(&adapter->bus_lock);
fe61e07e
JD		 988}
989
990/**
991 * i2c_unlock_adapter - Release exclusive access to an I2C bus segment
992 * @adapter: Target I2C bus segment
993 */
994void i2c_unlock_adapter(struct i2c_adapter *adapter)
995{
97cc4d49
JD		 996 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
997
998 if (parent)
999 i2c_unlock_adapter(parent);
0826374b
ML		 1000 else
1001 rt_mutex_unlock(&adapter->bus_lock);
fe61e07e
JD		 1002}
1003EXPORT_SYMBOL_GPL(i2c_unlock_adapter);
1004
70762abb
JN		 1005static void i2c_dev_set_name(struct i2c_adapter *adap,
1006 struct i2c_client *client)
1007{
1008 struct acpi_device *adev = ACPI_COMPANION(&client->dev);
1009
1010 if (adev) {
1011 dev_set_name(&client->dev, "i2c-%s", acpi_dev_name(adev));
1012 return;
1013 }
1014
70762abb 1015 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
da899f55 1016 i2c_encode_flags_to_addr(client));
70762abb
JN		 1017}
1018
9c1600ed 1019/**
f8a227e8 1020 * i2c_new_device - instantiate an i2c device
9c1600ed
DB		 1021 * @adap: the adapter managing the device
1022 * @info: describes one I2C device; bus_num is ignored
d64f73be 1023 * Context: can sleep
9c1600ed 1024 *
f8a227e8
JD		 1025 * Create an i2c device. Binding is handled through driver model
1026 * probe()/remove() methods. A driver may be bound to this device when we
1027 * return from this function, or any later moment (e.g. maybe hotplugging will
1028 * load the driver module). This call is not appropriate for use by mainboard
1029 * initialization logic, which usually runs during an arch_initcall() long
1030 * before any i2c_adapter could exist.
9c1600ed
DB		 1031 *
1032 * This returns the new i2c client, which may be saved for later use with
1033 * i2c_unregister_device(); or NULL to indicate an error.
1034 */
1035struct i2c_client *
1036i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
1037{
1038 struct i2c_client *client;
1039 int status;
1040
1041 client = kzalloc(sizeof *client, GFP_KERNEL);
1042 if (!client)
1043 return NULL;
1044
1045 client->adapter = adap;
1046
1047 client->dev.platform_data = info->platform_data;
3bbb835d 1048
11f1f2af
AV		 1049 if (info->archdata)
1050 client->dev.archdata = *info->archdata;
1051
ee35425c 1052 client->flags = info->flags;
9c1600ed
DB		 1053 client->addr = info->addr;
1054 client->irq = info->irq;
1055
9c1600ed
DB		 1056 strlcpy(client->name, info->type, sizeof(client->name));
1057
c4019b70 1058 status = i2c_check_addr_validity(client->addr, client->flags);
3a89db5f
JD		 1059 if (status) {
1060 dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
1061 client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
1062 goto out_err_silent;
1063 }
1064
f8a227e8 1065 /* Check for address business */
9bccc70a 1066 status = i2c_check_addr_busy(adap, i2c_encode_flags_to_addr(client));
f8a227e8
JD		 1067 if (status)
1068 goto out_err;
1069
1070 client->dev.parent = &client->adapter->dev;
1071 client->dev.bus = &i2c_bus_type;
51298d12 1072 client->dev.type = &i2c_client_type;
d12d42f7 1073 client->dev.of_node = info->of_node;
ce793486 1074 client->dev.fwnode = info->fwnode;
f8a227e8 1075
70762abb 1076 i2c_dev_set_name(adap, client);
f8a227e8
JD		 1077 status = device_register(&client->dev);
1078 if (status)
1079 goto out_err;
1080
f8a227e8
JD		 1081 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
1082 client->name, dev_name(&client->dev));
1083
9c1600ed 1084 return client;
f8a227e8
JD		 1085
1086out_err:
1087 dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
1088 "(%d)\n", client->name, client->addr, status);
3a89db5f 1089out_err_silent:
f8a227e8
JD		 1090 kfree(client);
1091 return NULL;
9c1600ed
DB		 1092}
1093EXPORT_SYMBOL_GPL(i2c_new_device);
1094
1095
1096/**
1097 * i2c_unregister_device - reverse effect of i2c_new_device()
1098 * @client: value returned from i2c_new_device()
d64f73be 1099 * Context: can sleep
9c1600ed
DB		 1100 */
1101void i2c_unregister_device(struct i2c_client *client)
a1d9e6e4 1102{
4f001fd3
PA		 1103 if (client->dev.of_node)
1104 of_node_clear_flag(client->dev.of_node, OF_POPULATED);
a1d9e6e4
DB		 1105 device_unregister(&client->dev);
1106}
9c1600ed 1107EXPORT_SYMBOL_GPL(i2c_unregister_device);
a1d9e6e4
DB		 1108
1109
60b129d7
JD		 1110static const struct i2c_device_id dummy_id[] = {
1111 { "dummy", 0 },
1112 { },
1113};
1114
d2653e92
JD		 1115static int dummy_probe(struct i2c_client *client,
1116 const struct i2c_device_id *id)
1117{
1118 return 0;
1119}
1120
1121static int dummy_remove(struct i2c_client *client)
e9f1373b
DB		 1122{
1123 return 0;
1124}
1125
1126static struct i2c_driver dummy_driver = {
1127 .driver.name = "dummy",
d2653e92
JD		 1128 .probe = dummy_probe,
1129 .remove = dummy_remove,
60b129d7 1130 .id_table = dummy_id,
e9f1373b
DB		 1131};
1132
1133/**
1134 * i2c_new_dummy - return a new i2c device bound to a dummy driver
1135 * @adapter: the adapter managing the device
1136 * @address: seven bit address to be used
e9f1373b
DB		 1137 * Context: can sleep
1138 *
1139 * This returns an I2C client bound to the "dummy" driver, intended for use
1140 * with devices that consume multiple addresses. Examples of such chips
1141 * include various EEPROMS (like 24c04 and 24c08 models).
1142 *
1143 * These dummy devices have two main uses. First, most I2C and SMBus calls
1144 * except i2c_transfer() need a client handle; the dummy will be that handle.
1145 * And second, this prevents the specified address from being bound to a
1146 * different driver.
1147 *
1148 * This returns the new i2c client, which should be saved for later use with
1149 * i2c_unregister_device(); or NULL to indicate an error.
1150 */
09b8ce0a 1151struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
e9f1373b
DB		 1152{
1153 struct i2c_board_info info = {
60b129d7 1154 I2C_BOARD_INFO("dummy", address),
e9f1373b
DB		 1155 };
1156
e9f1373b
DB		 1157 return i2c_new_device(adapter, &info);
1158}
1159EXPORT_SYMBOL_GPL(i2c_new_dummy);
1160
f37dd80a
DB		 1161/* ------------------------------------------------------------------------- */
1162
16ffadfc
DB		 1163/* I2C bus adapters -- one roots each I2C or SMBUS segment */
1164
83eaaed0 1165static void i2c_adapter_dev_release(struct device *dev)
1da177e4 1166{
ef2c8321 1167 struct i2c_adapter *adap = to_i2c_adapter(dev);
1da177e4
LT		 1168 complete(&adap->dev_released);
1169}
1170
390946b1
JD		 1171/*
1172 * This function is only needed for mutex_lock_nested, so it is never
1173 * called unless locking correctness checking is enabled. Thus we
1174 * make it inline to avoid a compiler warning. That's what gcc ends up
1175 * doing anyway.
1176 */
1177static inline unsigned int i2c_adapter_depth(struct i2c_adapter *adapter)
1178{
1179 unsigned int depth = 0;
1180
1181 while ((adapter = i2c_parent_is_i2c_adapter(adapter)))
1182 depth++;
1183
1184 return depth;
1185}
1186
99cd8e25
JD		 1187/*
1188 * Let users instantiate I2C devices through sysfs. This can be used when
1189 * platform initialization code doesn't contain the proper data for
1190 * whatever reason. Also useful for drivers that do device detection and
1191 * detection fails, either because the device uses an unexpected address,
1192 * or this is a compatible device with different ID register values.
1193 *
1194 * Parameter checking may look overzealous, but we really don't want
1195 * the user to provide incorrect parameters.
1196 */
1197static ssize_t
1198i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
1199 const char *buf, size_t count)
1200{
1201 struct i2c_adapter *adap = to_i2c_adapter(dev);
1202 struct i2c_board_info info;
1203 struct i2c_client *client;
1204 char *blank, end;
1205 int res;
1206
99cd8e25
JD		 1207 memset(&info, 0, sizeof(struct i2c_board_info));
1208
1209 blank = strchr(buf, ' ');
1210 if (!blank) {
1211 dev_err(dev, "%s: Missing parameters\n", "new_device");
1212 return -EINVAL;
1213 }
1214 if (blank - buf > I2C_NAME_SIZE - 1) {
1215 dev_err(dev, "%s: Invalid device name\n", "new_device");
1216 return -EINVAL;
1217 }
1218 memcpy(info.type, buf, blank - buf);
1219
1220 /* Parse remaining parameters, reject extra parameters */
1221 res = sscanf(++blank, "%hi%c", &info.addr, &end);
1222 if (res < 1) {
1223 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
1224 return -EINVAL;
1225 }
1226 if (res > 1 && end != '\n') {
1227 dev_err(dev, "%s: Extra parameters\n", "new_device");
1228 return -EINVAL;
1229 }
1230
cfa0327b
WS		 1231 if ((info.addr & I2C_ADDR_OFFSET_TEN_BIT) == I2C_ADDR_OFFSET_TEN_BIT) {
1232 info.addr &= ~I2C_ADDR_OFFSET_TEN_BIT;
1233 info.flags |= I2C_CLIENT_TEN;
1234 }
1235
1236 if (info.addr & I2C_ADDR_OFFSET_SLAVE) {
1237 info.addr &= ~I2C_ADDR_OFFSET_SLAVE;
1238 info.flags |= I2C_CLIENT_SLAVE;
1239 }
1240
99cd8e25
JD		 1241 client = i2c_new_device(adap, &info);
1242 if (!client)
3a89db5f 1243 return -EINVAL;
99cd8e25
JD		 1244
1245 /* Keep track of the added device */
dafc50d1 1246 mutex_lock(&adap->userspace_clients_lock);
6629dcff 1247 list_add_tail(&client->detected, &adap->userspace_clients);
dafc50d1 1248 mutex_unlock(&adap->userspace_clients_lock);
99cd8e25
JD		 1249 dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
1250 info.type, info.addr);
1251
1252 return count;
1253}
a5eb71b2 1254static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
99cd8e25
JD		 1255
1256/*
1257 * And of course let the users delete the devices they instantiated, if
1258 * they got it wrong. This interface can only be used to delete devices
1259 * instantiated by i2c_sysfs_new_device above. This guarantees that we
1260 * don't delete devices to which some kernel code still has references.
1261 *
1262 * Parameter checking may look overzealous, but we really don't want
1263 * the user to delete the wrong device.
1264 */
1265static ssize_t
1266i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
1267 const char *buf, size_t count)
1268{
1269 struct i2c_adapter *adap = to_i2c_adapter(dev);
1270 struct i2c_client *client, *next;
1271 unsigned short addr;
1272 char end;
1273 int res;
1274
1275 /* Parse parameters, reject extra parameters */
1276 res = sscanf(buf, "%hi%c", &addr, &end);
1277 if (res < 1) {
1278 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
1279 return -EINVAL;
1280 }
1281 if (res > 1 && end != '\n') {
1282 dev_err(dev, "%s: Extra parameters\n", "delete_device");
1283 return -EINVAL;
1284 }
1285
1286 /* Make sure the device was added through sysfs */
1287 res = -ENOENT;
390946b1
JD		 1288 mutex_lock_nested(&adap->userspace_clients_lock,
1289 i2c_adapter_depth(adap));
6629dcff
JD		 1290 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1291 detected) {
cfa0327b 1292 if (i2c_encode_flags_to_addr(client) == addr) {
99cd8e25
JD		 1293 dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
1294 "delete_device", client->name, client->addr);
1295
1296 list_del(&client->detected);
1297 i2c_unregister_device(client);
1298 res = count;
1299 break;
1300 }
1301 }
dafc50d1 1302 mutex_unlock(&adap->userspace_clients_lock);
99cd8e25
JD		 1303
1304 if (res < 0)
1305 dev_err(dev, "%s: Can't find device in list\n",
1306 "delete_device");
1307 return res;
1308}
e9b526fe
AS		 1309static DEVICE_ATTR_IGNORE_LOCKDEP(delete_device, S_IWUSR, NULL,
1310 i2c_sysfs_delete_device);
4f8cf824
JD		 1311
1312static struct attribute *i2c_adapter_attrs[] = {
1313 &dev_attr_name.attr,
1314 &dev_attr_new_device.attr,
1315 &dev_attr_delete_device.attr,
1316 NULL
1317};
a5eb71b2 1318ATTRIBUTE_GROUPS(i2c_adapter);
b119dc3f 1319
0826374b 1320struct device_type i2c_adapter_type = {
a5eb71b2 1321 .groups = i2c_adapter_groups,
4f8cf824 1322 .release = i2c_adapter_dev_release,
1da177e4 1323};
0826374b 1324EXPORT_SYMBOL_GPL(i2c_adapter_type);
1da177e4 1325
643dd09e
SW		 1326/**
1327 * i2c_verify_adapter - return parameter as i2c_adapter or NULL
1328 * @dev: device, probably from some driver model iterator
1329 *
1330 * When traversing the driver model tree, perhaps using driver model
1331 * iterators like @device_for_each_child(), you can't assume very much
1332 * about the nodes you find. Use this function to avoid oopses caused
1333 * by wrongly treating some non-I2C device as an i2c_adapter.
1334 */
1335struct i2c_adapter *i2c_verify_adapter(struct device *dev)
1336{
1337 return (dev->type == &i2c_adapter_type)
1338 ? to_i2c_adapter(dev)
1339 : NULL;
1340}
1341EXPORT_SYMBOL(i2c_verify_adapter);
1342
2bb5095a
JD		 1343#ifdef CONFIG_I2C_COMPAT
1344static struct class_compat *i2c_adapter_compat_class;
1345#endif
1346
9c1600ed
DB		 1347static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
1348{
1349 struct i2c_devinfo *devinfo;
1350
f18c41da 1351 down_read(&__i2c_board_lock);
9c1600ed
DB		 1352 list_for_each_entry(devinfo, &__i2c_board_list, list) {
1353 if (devinfo->busnum == adapter->nr
1354 && !i2c_new_device(adapter,
1355 &devinfo->board_info))
09b8ce0a
ZX		 1356 dev_err(&adapter->dev,
1357 "Can't create device at 0x%02x\n",
9c1600ed
DB		 1358 devinfo->board_info.addr);
1359 }
f18c41da 1360 up_read(&__i2c_board_lock);
9c1600ed
DB		 1361}
1362
687b81d0
WS		 1363/* OF support code */
1364
1365#if IS_ENABLED(CONFIG_OF)
a430a345
PA		 1366static struct i2c_client *of_i2c_register_device(struct i2c_adapter *adap,
1367 struct device_node *node)
687b81d0 1368{
a430a345
PA		 1369 struct i2c_client *result;
1370 struct i2c_board_info info = {};
1371 struct dev_archdata dev_ad = {};
b4e2f6ac
WS		 1372 const __be32 *addr_be;
1373 u32 addr;
a430a345 1374 int len;
687b81d0 1375
a430a345 1376 dev_dbg(&adap->dev, "of_i2c: register %s\n", node->full_name);
687b81d0 1377
a430a345
PA		 1378 if (of_modalias_node(node, info.type, sizeof(info.type)) < 0) {
1379 dev_err(&adap->dev, "of_i2c: modalias failure on %s\n",
1380 node->full_name);
1381 return ERR_PTR(-EINVAL);
1382 }
687b81d0 1383
b4e2f6ac
WS		 1384 addr_be = of_get_property(node, "reg", &len);
1385 if (!addr_be || (len < sizeof(*addr_be))) {
a430a345
PA		 1386 dev_err(&adap->dev, "of_i2c: invalid reg on %s\n",
1387 node->full_name);
1388 return ERR_PTR(-EINVAL);
1389 }
687b81d0 1390
b4e2f6ac
WS		 1391 addr = be32_to_cpup(addr_be);
1392 if (addr & I2C_TEN_BIT_ADDRESS) {
1393 addr &= ~I2C_TEN_BIT_ADDRESS;
1394 info.flags |= I2C_CLIENT_TEN;
1395 }
1396
1397 if (addr & I2C_OWN_SLAVE_ADDRESS) {
1398 addr &= ~I2C_OWN_SLAVE_ADDRESS;
1399 info.flags |= I2C_CLIENT_SLAVE;
1400 }
1401
1402 if (i2c_check_addr_validity(addr, info.flags)) {
a430a345
PA		 1403 dev_err(&adap->dev, "of_i2c: invalid addr=%x on %s\n",
1404 info.addr, node->full_name);
1405 return ERR_PTR(-EINVAL);
1406 }
687b81d0 1407
b4e2f6ac 1408 info.addr = addr;
a430a345
PA		 1409 info.of_node = of_node_get(node);
1410 info.archdata = &dev_ad;
687b81d0 1411
a430a345
PA		 1412 if (of_get_property(node, "wakeup-source", NULL))
1413 info.flags |= I2C_CLIENT_WAKE;
687b81d0 1414
a430a345
PA		 1415 result = i2c_new_device(adap, &info);
1416 if (result == NULL) {
1417 dev_err(&adap->dev, "of_i2c: Failure registering %s\n",
1418 node->full_name);
1419 of_node_put(node);
a430a345
PA		 1420 return ERR_PTR(-EINVAL);
1421 }
1422 return result;
1423}
687b81d0 1424
a430a345
PA		 1425static void of_i2c_register_devices(struct i2c_adapter *adap)
1426{
1427 struct device_node *node;
687b81d0 1428
a430a345
PA		 1429 /* Only register child devices if the adapter has a node pointer set */
1430 if (!adap->dev.of_node)
1431 return;
687b81d0 1432
a430a345
PA		 1433 dev_dbg(&adap->dev, "of_i2c: walking child nodes\n");
1434
4f001fd3
PA		 1435 for_each_available_child_of_node(adap->dev.of_node, node) {
1436 if (of_node_test_and_set_flag(node, OF_POPULATED))
1437 continue;
a430a345 1438 of_i2c_register_device(adap, node);
4f001fd3 1439 }
687b81d0
WS		 1440}
1441
1442static int of_dev_node_match(struct device *dev, void *data)
1443{
1444 return dev->of_node == data;
1445}
1446
1447/* must call put_device() when done with returned i2c_client device */
1448struct i2c_client *of_find_i2c_device_by_node(struct device_node *node)
1449{
1450 struct device *dev;
e3311469 1451 struct i2c_client *client;
687b81d0 1452
e3311469 1453 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
687b81d0
WS		 1454 if (!dev)
1455 return NULL;
1456
e3311469
VZ		 1457 client = i2c_verify_client(dev);
1458 if (!client)
1459 put_device(dev);
1460
1461 return client;
687b81d0
WS		 1462}
1463EXPORT_SYMBOL(of_find_i2c_device_by_node);
1464
1465/* must call put_device() when done with returned i2c_adapter device */
1466struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node)
1467{
1468 struct device *dev;
e3311469 1469 struct i2c_adapter *adapter;
687b81d0 1470
e3311469 1471 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
687b81d0
WS		 1472 if (!dev)
1473 return NULL;
1474
e3311469
VZ		 1475 adapter = i2c_verify_adapter(dev);
1476 if (!adapter)
1477 put_device(dev);
1478
1479 return adapter;
687b81d0
WS		 1480}
1481EXPORT_SYMBOL(of_find_i2c_adapter_by_node);
48e9743d
VZ		 1482
1483/* must call i2c_put_adapter() when done with returned i2c_adapter device */
1484struct i2c_adapter *of_get_i2c_adapter_by_node(struct device_node *node)
1485{
1486 struct i2c_adapter *adapter;
1487
1488 adapter = of_find_i2c_adapter_by_node(node);
1489 if (!adapter)
1490 return NULL;
1491
1492 if (!try_module_get(adapter->owner)) {
1493 put_device(&adapter->dev);
1494 adapter = NULL;
1495 }
1496
1497 return adapter;
1498}
1499EXPORT_SYMBOL(of_get_i2c_adapter_by_node);
687b81d0
WS		 1500#else
1501static void of_i2c_register_devices(struct i2c_adapter *adap) { }
1502#endif /* CONFIG_OF */
1503
69b0089a
JD		 1504static int i2c_do_add_adapter(struct i2c_driver *driver,
1505 struct i2c_adapter *adap)
026526f5 1506{
4735c98f
JD		 1507 /* Detect supported devices on that bus, and instantiate them */
1508 i2c_detect(adap, driver);
1509
1510 /* Let legacy drivers scan this bus for matching devices */
026526f5 1511 if (driver->attach_adapter) {
a920ff41
JD		 1512 dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
1513 driver->driver.name);
fe6fc258
JD		 1514 dev_warn(&adap->dev, "Please use another way to instantiate "
1515 "your i2c_client\n");
026526f5
JD		 1516 /* We ignore the return code; if it fails, too bad */
1517 driver->attach_adapter(adap);
1518 }
1519 return 0;
1520}
1521
69b0089a
JD		 1522static int __process_new_adapter(struct device_driver *d, void *data)
1523{
1524 return i2c_do_add_adapter(to_i2c_driver(d), data);
1525}
1526
6e13e641 1527static int i2c_register_adapter(struct i2c_adapter *adap)
1da177e4 1528{
d6703281 1529 int res = 0;
1da177e4 1530
1d0b19c9 1531 /* Can't register until after driver model init */
35fc37f8
JD		 1532 if (unlikely(WARN_ON(!i2c_bus_type.p))) {
1533 res = -EAGAIN;
1534 goto out_list;
1535 }
1d0b19c9 1536
2236baa7
JD		 1537 /* Sanity checks */
1538 if (unlikely(adap->name[0] == '\0')) {
1539 pr_err("i2c-core: Attempt to register an adapter with "
1540 "no name!\n");
1541 return -EINVAL;
1542 }
1543 if (unlikely(!adap->algo)) {
1544 pr_err("i2c-core: Attempt to register adapter '%s' with "
1545 "no algo!\n", adap->name);
1546 return -EINVAL;
1547 }
1548
194684e5 1549 rt_mutex_init(&adap->bus_lock);
dafc50d1 1550 mutex_init(&adap->userspace_clients_lock);
6629dcff 1551 INIT_LIST_HEAD(&adap->userspace_clients);
1da177e4 1552
8fcfef6e
JD		 1553 /* Set default timeout to 1 second if not already set */
1554 if (adap->timeout == 0)
1555 adap->timeout = HZ;
1556
27d9c183 1557 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
4f8cf824
JD		 1558 adap->dev.bus = &i2c_bus_type;
1559 adap->dev.type = &i2c_adapter_type;
b119c6c9
JD		 1560 res = device_register(&adap->dev);
1561 if (res)
1562 goto out_list;
1da177e4 1563
b6d7b3d1
JD		 1564 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
1565
6ada5c1e 1566 pm_runtime_no_callbacks(&adap->dev);
9f924169 1567 pm_runtime_enable(&adap->dev);
6ada5c1e 1568
2bb5095a
JD		 1569#ifdef CONFIG_I2C_COMPAT
1570 res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
1571 adap->dev.parent);
1572 if (res)
1573 dev_warn(&adap->dev,
1574 "Failed to create compatibility class link\n");
1575#endif
1576
5f9296ba
VK		 1577 /* bus recovery specific initialization */
1578 if (adap->bus_recovery_info) {
1579 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
1580
1581 if (!bri->recover_bus) {
1582 dev_err(&adap->dev, "No recover_bus() found, not using recovery\n");
1583 adap->bus_recovery_info = NULL;
1584 goto exit_recovery;
1585 }
1586
1587 /* Generic GPIO recovery */
1588 if (bri->recover_bus == i2c_generic_gpio_recovery) {
1589 if (!gpio_is_valid(bri->scl_gpio)) {
1590 dev_err(&adap->dev, "Invalid SCL gpio, not using recovery\n");
1591 adap->bus_recovery_info = NULL;
1592 goto exit_recovery;
1593 }
1594
1595 if (gpio_is_valid(bri->sda_gpio))
1596 bri->get_sda = get_sda_gpio_value;
1597 else
1598 bri->get_sda = NULL;
1599
1600 bri->get_scl = get_scl_gpio_value;
1601 bri->set_scl = set_scl_gpio_value;
1602 } else if (!bri->set_scl || !bri->get_scl) {
1603 /* Generic SCL recovery */
1604 dev_err(&adap->dev, "No {get|set}_gpio() found, not using recovery\n");
1605 adap->bus_recovery_info = NULL;
1606 }
1607 }
1608
1609exit_recovery:
729d6dd5 1610 /* create pre-declared device nodes */
687b81d0 1611 of_i2c_register_devices(adap);
55e71edb 1612 acpi_i2c_register_devices(adap);
5d98e61d 1613 acpi_i2c_install_space_handler(adap);
687b81d0 1614
6e13e641
DB		 1615 if (adap->nr < __i2c_first_dynamic_bus_num)
1616 i2c_scan_static_board_info(adap);
1617
4735c98f 1618 /* Notify drivers */
35fc37f8 1619 mutex_lock(&core_lock);
d6703281 1620 bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
caada32a 1621 mutex_unlock(&core_lock);
35fc37f8
JD		 1622
1623 return 0;
b119c6c9 1624
b119c6c9 1625out_list:
35fc37f8 1626 mutex_lock(&core_lock);
b119c6c9 1627 idr_remove(&i2c_adapter_idr, adap->nr);
35fc37f8
JD		 1628 mutex_unlock(&core_lock);
1629 return res;
1da177e4
LT		 1630}
1631
ee5c2744
DA		 1632/**
1633 * __i2c_add_numbered_adapter - i2c_add_numbered_adapter where nr is never -1
1634 * @adap: the adapter to register (with adap->nr initialized)
1635 * Context: can sleep
1636 *
1637 * See i2c_add_numbered_adapter() for details.
1638 */
1639static int __i2c_add_numbered_adapter(struct i2c_adapter *adap)
1640{
1641 int id;
1642
1643 mutex_lock(&core_lock);
1644 id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1,
1645 GFP_KERNEL);
1646 mutex_unlock(&core_lock);
1647 if (id < 0)
1648 return id == -ENOSPC ? -EBUSY : id;
1649
1650 return i2c_register_adapter(adap);
1651}
1652
6e13e641
DB		 1653/**
1654 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
1655 * @adapter: the adapter to add
d64f73be 1656 * Context: can sleep
6e13e641
DB		 1657 *
1658 * This routine is used to declare an I2C adapter when its bus number
ee5c2744
DA		 1659 * doesn't matter or when its bus number is specified by an dt alias.
1660 * Examples of bases when the bus number doesn't matter: I2C adapters
1661 * dynamically added by USB links or PCI plugin cards.
6e13e641
DB		 1662 *
1663 * When this returns zero, a new bus number was allocated and stored
1664 * in adap->nr, and the specified adapter became available for clients.
1665 * Otherwise, a negative errno value is returned.
1666 */
1667int i2c_add_adapter(struct i2c_adapter *adapter)
1668{
ee5c2744 1669 struct device *dev = &adapter->dev;
4ae42b0f 1670 int id;
6e13e641 1671
ee5c2744
DA		 1672 if (dev->of_node) {
1673 id = of_alias_get_id(dev->of_node, "i2c");
1674 if (id >= 0) {
1675 adapter->nr = id;
1676 return __i2c_add_numbered_adapter(adapter);
1677 }
1678 }
1679
caada32a 1680 mutex_lock(&core_lock);
4ae42b0f
TH		 1681 id = idr_alloc(&i2c_adapter_idr, adapter,
1682 __i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
caada32a 1683 mutex_unlock(&core_lock);
4ae42b0f
TH		 1684 if (id < 0)
1685 return id;
6e13e641
DB		 1686
1687 adapter->nr = id;
4ae42b0f 1688
6e13e641
DB		 1689 return i2c_register_adapter(adapter);
1690}
1691EXPORT_SYMBOL(i2c_add_adapter);
1692
1693/**
1694 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
1695 * @adap: the adapter to register (with adap->nr initialized)
d64f73be 1696 * Context: can sleep
6e13e641
DB		 1697 *
1698 * This routine is used to declare an I2C adapter when its bus number
8c07e46f
RD		 1699 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
1700 * or otherwise built in to the system's mainboard, and where i2c_board_info
6e13e641
DB		 1701 * is used to properly configure I2C devices.
1702 *
488bf314
GL		 1703 * If the requested bus number is set to -1, then this function will behave
1704 * identically to i2c_add_adapter, and will dynamically assign a bus number.
1705 *
6e13e641
DB		 1706 * If no devices have pre-been declared for this bus, then be sure to
1707 * register the adapter before any dynamically allocated ones. Otherwise
1708 * the required bus ID may not be available.
1709 *
1710 * When this returns zero, the specified adapter became available for
1711 * clients using the bus number provided in adap->nr. Also, the table
1712 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
1713 * and the appropriate driver model device nodes are created. Otherwise, a
1714 * negative errno value is returned.
1715 */
1716int i2c_add_numbered_adapter(struct i2c_adapter *adap)
1717{
488bf314
GL		 1718 if (adap->nr == -1) /* -1 means dynamically assign bus id */
1719 return i2c_add_adapter(adap);
6e13e641 1720
ee5c2744 1721 return __i2c_add_numbered_adapter(adap);
6e13e641
DB		 1722}
1723EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
1724
19baba4c 1725static void i2c_do_del_adapter(struct i2c_driver *driver,
69b0089a 1726 struct i2c_adapter *adapter)
026526f5 1727{
4735c98f 1728 struct i2c_client *client, *_n;
026526f5 1729
acec211c
JD		 1730 /* Remove the devices we created ourselves as the result of hardware
1731 * probing (using a driver's detect method) */
4735c98f
JD		 1732 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
1733 if (client->adapter == adapter) {
1734 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
1735 client->name, client->addr);
1736 list_del(&client->detected);
1737 i2c_unregister_device(client);
1738 }
1739 }
026526f5
JD		 1740}
1741
e549c2b5 1742static int __unregister_client(struct device *dev, void *dummy)
5219bf88
JD		 1743{
1744 struct i2c_client *client = i2c_verify_client(dev);
1745 if (client && strcmp(client->name, "dummy"))
1746 i2c_unregister_device(client);
1747 return 0;
1748}
1749
1750static int __unregister_dummy(struct device *dev, void *dummy)
e549c2b5
JD		 1751{
1752 struct i2c_client *client = i2c_verify_client(dev);
1753 if (client)
1754 i2c_unregister_device(client);
1755 return 0;
1756}
1757
69b0089a
JD		 1758static int __process_removed_adapter(struct device_driver *d, void *data)
1759{
19baba4c
LPC		 1760 i2c_do_del_adapter(to_i2c_driver(d), data);
1761 return 0;
69b0089a
JD		 1762}
1763
d64f73be
DB		 1764/**
1765 * i2c_del_adapter - unregister I2C adapter
1766 * @adap: the adapter being unregistered
1767 * Context: can sleep
1768 *
1769 * This unregisters an I2C adapter which was previously registered
1770 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
1771 */
71546300 1772void i2c_del_adapter(struct i2c_adapter *adap)
1da177e4 1773{
35fc37f8 1774 struct i2c_adapter *found;
bbd2d9c9 1775 struct i2c_client *client, *next;
1da177e4
LT		 1776
1777 /* First make sure that this adapter was ever added */
35fc37f8
JD		 1778 mutex_lock(&core_lock);
1779 found = idr_find(&i2c_adapter_idr, adap->nr);
1780 mutex_unlock(&core_lock);
1781 if (found != adap) {
b6d7b3d1
JD		 1782 pr_debug("i2c-core: attempting to delete unregistered "
1783 "adapter [%s]\n", adap->name);
71546300 1784 return;
1da177e4
LT		 1785 }
1786
5d98e61d 1787 acpi_i2c_remove_space_handler(adap);
026526f5 1788 /* Tell drivers about this removal */
35fc37f8 1789 mutex_lock(&core_lock);
19baba4c 1790 bus_for_each_drv(&i2c_bus_type, NULL, adap,
69b0089a 1791 __process_removed_adapter);
35fc37f8 1792 mutex_unlock(&core_lock);
1da177e4 1793
bbd2d9c9 1794 /* Remove devices instantiated from sysfs */
390946b1
JD		 1795 mutex_lock_nested(&adap->userspace_clients_lock,
1796 i2c_adapter_depth(adap));
6629dcff
JD		 1797 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1798 detected) {
1799 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
1800 client->addr);
1801 list_del(&client->detected);
1802 i2c_unregister_device(client);
bbd2d9c9 1803 }
dafc50d1 1804 mutex_unlock(&adap->userspace_clients_lock);
bbd2d9c9 1805
e549c2b5 1806 /* Detach any active clients. This can't fail, thus we do not
5219bf88
JD		 1807 * check the returned value. This is a two-pass process, because
1808 * we can't remove the dummy devices during the first pass: they
1809 * could have been instantiated by real devices wishing to clean
1810 * them up properly, so we give them a chance to do that first. */
19baba4c
LPC		 1811 device_for_each_child(&adap->dev, NULL, __unregister_client);
1812 device_for_each_child(&adap->dev, NULL, __unregister_dummy);
1da177e4 1813
2bb5095a
JD		 1814#ifdef CONFIG_I2C_COMPAT
1815 class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
1816 adap->dev.parent);
1817#endif
1818
c5567521
TLSC		 1819 /* device name is gone after device_unregister */
1820 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
1821
9f924169
WS		 1822 pm_runtime_disable(&adap->dev);
1823
26680ee2
WS		 1824 /* wait until all references to the device are gone
1825 *
1826 * FIXME: This is old code and should ideally be replaced by an
1827 * alternative which results in decoupling the lifetime of the struct
1828 * device from the i2c_adapter, like spi or netdev do. Any solution
95cc1e3d 1829 * should be thoroughly tested with DEBUG_KOBJECT_RELEASE enabled!
26680ee2 1830 */
1da177e4 1831 init_completion(&adap->dev_released);
1da177e4 1832 device_unregister(&adap->dev);
1da177e4 1833 wait_for_completion(&adap->dev_released);
1da177e4 1834
6e13e641 1835 /* free bus id */
35fc37f8 1836 mutex_lock(&core_lock);
1da177e4 1837 idr_remove(&i2c_adapter_idr, adap->nr);
35fc37f8 1838 mutex_unlock(&core_lock);
1da177e4 1839
bd4bc3db
JD		 1840 /* Clear the device structure in case this adapter is ever going to be
1841 added again */
1842 memset(&adap->dev, 0, sizeof(adap->dev));
1da177e4 1843}
c0564606 1844EXPORT_SYMBOL(i2c_del_adapter);
1da177e4 1845
54177ccf
WS		 1846/**
1847 * i2c_parse_fw_timings - get I2C related timing parameters from firmware
1848 * @dev: The device to scan for I2C timing properties
1849 * @t: the i2c_timings struct to be filled with values
1850 * @use_defaults: bool to use sane defaults derived from the I2C specification
1851 * when properties are not found, otherwise use 0
1852 *
1853 * Scan the device for the generic I2C properties describing timing parameters
1854 * for the signal and fill the given struct with the results. If a property was
1855 * not found and use_defaults was true, then maximum timings are assumed which
1856 * are derived from the I2C specification. If use_defaults is not used, the
1857 * results will be 0, so drivers can apply their own defaults later. The latter
1858 * is mainly intended for avoiding regressions of existing drivers which want
1859 * to switch to this function. New drivers almost always should use the defaults.
1860 */
1861
1862void i2c_parse_fw_timings(struct device *dev, struct i2c_timings *t, bool use_defaults)
1863{
1864 int ret;
1865
1866 memset(t, 0, sizeof(*t));
1867
1868 ret = device_property_read_u32(dev, "clock-frequency", &t->bus_freq_hz);
1869 if (ret && use_defaults)
1870 t->bus_freq_hz = 100000;
1871
1872 ret = device_property_read_u32(dev, "i2c-scl-rising-time-ns", &t->scl_rise_ns);
1873 if (ret && use_defaults) {
1874 if (t->bus_freq_hz <= 100000)
1875 t->scl_rise_ns = 1000;
1876 else if (t->bus_freq_hz <= 400000)
1877 t->scl_rise_ns = 300;
1878 else
1879 t->scl_rise_ns = 120;
1880 }
1881
1882 ret = device_property_read_u32(dev, "i2c-scl-falling-time-ns", &t->scl_fall_ns);
1883 if (ret && use_defaults) {
1884 if (t->bus_freq_hz <= 400000)
1885 t->scl_fall_ns = 300;
1886 else
1887 t->scl_fall_ns = 120;
1888 }
1889
1890 device_property_read_u32(dev, "i2c-scl-internal-delay-ns", &t->scl_int_delay_ns);
1891
1892 ret = device_property_read_u32(dev, "i2c-sda-falling-time-ns", &t->sda_fall_ns);
1893 if (ret && use_defaults)
1894 t->sda_fall_ns = t->scl_fall_ns;
1895}
1896EXPORT_SYMBOL_GPL(i2c_parse_fw_timings);
1897
7b4fbc50
DB		 1898/* ------------------------------------------------------------------------- */
1899
7ae31482
JD		 1900int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
1901{
1902 int res;
1903
1904 mutex_lock(&core_lock);
1905 res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
1906 mutex_unlock(&core_lock);
1907
1908 return res;
1909}
1910EXPORT_SYMBOL_GPL(i2c_for_each_dev);
1911
69b0089a 1912static int __process_new_driver(struct device *dev, void *data)
7f101a97 1913{
4f8cf824
JD		 1914 if (dev->type != &i2c_adapter_type)
1915 return 0;
69b0089a 1916 return i2c_do_add_adapter(data, to_i2c_adapter(dev));
7f101a97
DY		 1917}
1918
7b4fbc50
DB		 1919/*
1920 * An i2c_driver is used with one or more i2c_client (device) nodes to access
729d6dd5 1921 * i2c slave chips, on a bus instance associated with some i2c_adapter.
1da177e4
LT		 1922 */
1923
de59cf9e 1924int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
1da177e4 1925{
7eebcb7c 1926 int res;
1da177e4 1927
1d0b19c9
DB		 1928 /* Can't register until after driver model init */
1929 if (unlikely(WARN_ON(!i2c_bus_type.p)))
1930 return -EAGAIN;
1931
1da177e4 1932 /* add the driver to the list of i2c drivers in the driver core */
de59cf9e 1933 driver->driver.owner = owner;
1da177e4 1934 driver->driver.bus = &i2c_bus_type;
1da177e4 1935
729d6dd5 1936 /* When registration returns, the driver core
6e13e641
DB		 1937 * will have called probe() for all matching-but-unbound devices.
1938 */
1da177e4
LT		 1939 res = driver_register(&driver->driver);
1940 if (res)
7eebcb7c 1941 return res;
438d6c2c 1942
35d8b2e6 1943 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
1da177e4 1944
4735c98f
JD		 1945 INIT_LIST_HEAD(&driver->clients);
1946 /* Walk the adapters that are already present */
7ae31482 1947 i2c_for_each_dev(driver, __process_new_driver);
35fc37f8 1948
7f101a97
DY		 1949 return 0;
1950}
1951EXPORT_SYMBOL(i2c_register_driver);
1952
69b0089a 1953static int __process_removed_driver(struct device *dev, void *data)
7f101a97 1954{
19baba4c
LPC		 1955 if (dev->type == &i2c_adapter_type)
1956 i2c_do_del_adapter(data, to_i2c_adapter(dev));
1957 return 0;
1da177e4
LT		 1958}
1959
a1d9e6e4
DB		 1960/**
1961 * i2c_del_driver - unregister I2C driver
1962 * @driver: the driver being unregistered
d64f73be 1963 * Context: can sleep
a1d9e6e4 1964 */
b3e82096 1965void i2c_del_driver(struct i2c_driver *driver)
1da177e4 1966{
7ae31482 1967 i2c_for_each_dev(driver, __process_removed_driver);
1da177e4
LT		 1968
1969 driver_unregister(&driver->driver);
35d8b2e6 1970 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
1da177e4 1971}
c0564606 1972EXPORT_SYMBOL(i2c_del_driver);
1da177e4 1973
7b4fbc50
DB		 1974/* ------------------------------------------------------------------------- */
1975
e48d3319
JD		 1976/**
1977 * i2c_use_client - increments the reference count of the i2c client structure
1978 * @client: the client being referenced
1979 *
1980 * Each live reference to a client should be refcounted. The driver model does
1981 * that automatically as part of driver binding, so that most drivers don't
1982 * need to do this explicitly: they hold a reference until they're unbound
1983 * from the device.
1984 *
1985 * A pointer to the client with the incremented reference counter is returned.
1986 */
1987struct i2c_client *i2c_use_client(struct i2c_client *client)
1da177e4 1988{
6ea438ec
DB		 1989 if (client && get_device(&client->dev))
1990 return client;
1991 return NULL;
1da177e4 1992}
c0564606 1993EXPORT_SYMBOL(i2c_use_client);
1da177e4 1994
e48d3319
JD		 1995/**
1996 * i2c_release_client - release a use of the i2c client structure
1997 * @client: the client being no longer referenced
1998 *
1999 * Must be called when a user of a client is finished with it.
2000 */
2001void i2c_release_client(struct i2c_client *client)
1da177e4 2002{
6ea438ec
DB		 2003 if (client)
2004 put_device(&client->dev);
1da177e4 2005}
c0564606 2006EXPORT_SYMBOL(i2c_release_client);
1da177e4 2007
9b766b81
DB		 2008struct i2c_cmd_arg {
2009 unsigned cmd;
2010 void *arg;
2011};
2012
2013static int i2c_cmd(struct device *dev, void *_arg)
2014{
2015 struct i2c_client *client = i2c_verify_client(dev);
2016 struct i2c_cmd_arg *arg = _arg;
0acc2b32
LPC		 2017 struct i2c_driver *driver;
2018
2019 if (!client || !client->dev.driver)
2020 return 0;
9b766b81 2021
0acc2b32
LPC		 2022 driver = to_i2c_driver(client->dev.driver);
2023 if (driver->command)
2024 driver->command(client, arg->cmd, arg->arg);
9b766b81
DB		 2025 return 0;
2026}
2027
1da177e4
LT		 2028void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
2029{
9b766b81 2030 struct i2c_cmd_arg cmd_arg;
1da177e4 2031
9b766b81
DB		 2032 cmd_arg.cmd = cmd;
2033 cmd_arg.arg = arg;
2034 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
1da177e4 2035}
c0564606 2036EXPORT_SYMBOL(i2c_clients_command);
1da177e4 2037
ea7513bb
PA		 2038#if IS_ENABLED(CONFIG_OF_DYNAMIC)
2039static int of_i2c_notify(struct notifier_block *nb, unsigned long action,
2040 void *arg)
2041{
2042 struct of_reconfig_data *rd = arg;
2043 struct i2c_adapter *adap;
2044 struct i2c_client *client;
2045
2046 switch (of_reconfig_get_state_change(action, rd)) {
2047 case OF_RECONFIG_CHANGE_ADD:
2048 adap = of_find_i2c_adapter_by_node(rd->dn->parent);
2049 if (adap == NULL)
2050 return NOTIFY_OK; /* not for us */
2051
4f001fd3
PA		 2052 if (of_node_test_and_set_flag(rd->dn, OF_POPULATED)) {
2053 put_device(&adap->dev);
2054 return NOTIFY_OK;
2055 }
2056
ea7513bb
PA		 2057 client = of_i2c_register_device(adap, rd->dn);
2058 put_device(&adap->dev);
2059
2060 if (IS_ERR(client)) {
2061 pr_err("%s: failed to create for '%s'\n",
2062 __func__, rd->dn->full_name);
2063 return notifier_from_errno(PTR_ERR(client));
2064 }
2065 break;
2066 case OF_RECONFIG_CHANGE_REMOVE:
4f001fd3
PA		 2067 /* already depopulated? */
2068 if (!of_node_check_flag(rd->dn, OF_POPULATED))
2069 return NOTIFY_OK;
2070
ea7513bb
PA		 2071 /* find our device by node */
2072 client = of_find_i2c_device_by_node(rd->dn);
2073 if (client == NULL)
2074 return NOTIFY_OK; /* no? not meant for us */
2075
2076 /* unregister takes one ref away */
2077 i2c_unregister_device(client);
2078
2079 /* and put the reference of the find */
2080 put_device(&client->dev);
2081 break;
2082 }
2083
2084 return NOTIFY_OK;
2085}
2086static struct notifier_block i2c_of_notifier = {
2087 .notifier_call = of_i2c_notify,
2088};
2089#else
2090extern struct notifier_block i2c_of_notifier;
2091#endif /* CONFIG_OF_DYNAMIC */
2092
1da177e4
LT		 2093static int __init i2c_init(void)
2094{
2095 int retval;
2096
03bde7c3
WS		 2097 retval = of_alias_get_highest_id("i2c");
2098
2099 down_write(&__i2c_board_lock);
2100 if (retval >= __i2c_first_dynamic_bus_num)
2101 __i2c_first_dynamic_bus_num = retval + 1;
2102 up_write(&__i2c_board_lock);
2103
1da177e4 2104 retval = bus_register(&i2c_bus_type);
1da177e4
LT		 2105 if (retval)
2106 return retval;
2bb5095a
JD		 2107#ifdef CONFIG_I2C_COMPAT
2108 i2c_adapter_compat_class = class_compat_register("i2c-adapter");
2109 if (!i2c_adapter_compat_class) {
2110 retval = -ENOMEM;
2111 goto bus_err;
2112 }
2113#endif
e9f1373b
DB		 2114 retval = i2c_add_driver(&dummy_driver);
2115 if (retval)
2bb5095a 2116 goto class_err;
ea7513bb
PA		 2117
2118 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2119 WARN_ON(of_reconfig_notifier_register(&i2c_of_notifier));
2120
e9f1373b
DB		 2121 return 0;
2122
2bb5095a
JD		 2123class_err:
2124#ifdef CONFIG_I2C_COMPAT
2125 class_compat_unregister(i2c_adapter_compat_class);
e9f1373b 2126bus_err:
2bb5095a 2127#endif
e9f1373b
DB		 2128 bus_unregister(&i2c_bus_type);
2129 return retval;
1da177e4
LT		 2130}
2131
2132static void __exit i2c_exit(void)
2133{
ea7513bb
PA		 2134 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2135 WARN_ON(of_reconfig_notifier_unregister(&i2c_of_notifier));
e9f1373b 2136 i2c_del_driver(&dummy_driver);
2bb5095a
JD		 2137#ifdef CONFIG_I2C_COMPAT
2138 class_compat_unregister(i2c_adapter_compat_class);
2139#endif
1da177e4 2140 bus_unregister(&i2c_bus_type);
d9a83d62 2141 tracepoint_synchronize_unregister();
1da177e4
LT		 2142}
2143
a10f9e7c
DB		 2144/* We must initialize early, because some subsystems register i2c drivers
2145 * in subsys_initcall() code, but are linked (and initialized) before i2c.
2146 */
2147postcore_initcall(i2c_init);
1da177e4
LT		 2148module_exit(i2c_exit);
2149
2150/* ----------------------------------------------------
2151 * the functional interface to the i2c busses.
2152 * ----------------------------------------------------
2153 */
2154
b7f62584
WS		 2155/* Check if val is exceeding the quirk IFF quirk is non 0 */
2156#define i2c_quirk_exceeded(val, quirk) ((quirk) && ((val) > (quirk)))
2157
2158static int i2c_quirk_error(struct i2c_adapter *adap, struct i2c_msg *msg, char *err_msg)
2159{
2160 dev_err_ratelimited(&adap->dev, "adapter quirk: %s (addr 0x%04x, size %u, %s)\n",
2161 err_msg, msg->addr, msg->len,
2162 msg->flags & I2C_M_RD ? "read" : "write");
2163 return -EOPNOTSUPP;
2164}
2165
2166static int i2c_check_for_quirks(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2167{
2168 const struct i2c_adapter_quirks *q = adap->quirks;
2169 int max_num = q->max_num_msgs, i;
2170 bool do_len_check = true;
2171
2172 if (q->flags & I2C_AQ_COMB) {
2173 max_num = 2;
2174
2175 /* special checks for combined messages */
2176 if (num == 2) {
2177 if (q->flags & I2C_AQ_COMB_WRITE_FIRST && msgs[0].flags & I2C_M_RD)
2178 return i2c_quirk_error(adap, &msgs[0], "1st comb msg must be write");
2179
2180 if (q->flags & I2C_AQ_COMB_READ_SECOND && !(msgs[1].flags & I2C_M_RD))
2181 return i2c_quirk_error(adap, &msgs[1], "2nd comb msg must be read");
2182
2183 if (q->flags & I2C_AQ_COMB_SAME_ADDR && msgs[0].addr != msgs[1].addr)
2184 return i2c_quirk_error(adap, &msgs[0], "comb msg only to same addr");
2185
2186 if (i2c_quirk_exceeded(msgs[0].len, q->max_comb_1st_msg_len))
2187 return i2c_quirk_error(adap, &msgs[0], "msg too long");
2188
2189 if (i2c_quirk_exceeded(msgs[1].len, q->max_comb_2nd_msg_len))
2190 return i2c_quirk_error(adap, &msgs[1], "msg too long");
2191
2192 do_len_check = false;
2193 }
2194 }
2195
2196 if (i2c_quirk_exceeded(num, max_num))
2197 return i2c_quirk_error(adap, &msgs[0], "too many messages");
2198
2199 for (i = 0; i < num; i++) {
2200 u16 len = msgs[i].len;
2201
2202 if (msgs[i].flags & I2C_M_RD) {
2203 if (do_len_check && i2c_quirk_exceeded(len, q->max_read_len))
2204 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2205 } else {
2206 if (do_len_check && i2c_quirk_exceeded(len, q->max_write_len))
2207 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2208 }
2209 }
2210
2211 return 0;
2212}
2213
b37d2a3a
JD		 2214/**
2215 * __i2c_transfer - unlocked flavor of i2c_transfer
2216 * @adap: Handle to I2C bus
2217 * @msgs: One or more messages to execute before STOP is issued to
2218 * terminate the operation; each message begins with a START.
2219 * @num: Number of messages to be executed.
2220 *
2221 * Returns negative errno, else the number of messages executed.
2222 *
2223 * Adapter lock must be held when calling this function. No debug logging
2224 * takes place. adap->algo->master_xfer existence isn't checked.
2225 */
2226int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2227{
2228 unsigned long orig_jiffies;
2229 int ret, try;
2230
b7f62584
WS		 2231 if (adap->quirks && i2c_check_for_quirks(adap, msgs, num))
2232 return -EOPNOTSUPP;
2233
d9a83d62
DH		 2234 /* i2c_trace_msg gets enabled when tracepoint i2c_transfer gets
2235 * enabled. This is an efficient way of keeping the for-loop from
2236 * being executed when not needed.
2237 */
2238 if (static_key_false(&i2c_trace_msg)) {
2239 int i;
2240 for (i = 0; i < num; i++)
2241 if (msgs[i].flags & I2C_M_RD)
2242 trace_i2c_read(adap, &msgs[i], i);
2243 else
2244 trace_i2c_write(adap, &msgs[i], i);
2245 }
2246
b37d2a3a
JD		 2247 /* Retry automatically on arbitration loss */
2248 orig_jiffies = jiffies;
2249 for (ret = 0, try = 0; try <= adap->retries; try++) {
2250 ret = adap->algo->master_xfer(adap, msgs, num);
2251 if (ret != -EAGAIN)
2252 break;
2253 if (time_after(jiffies, orig_jiffies + adap->timeout))
2254 break;
2255 }
2256
d9a83d62
DH		 2257 if (static_key_false(&i2c_trace_msg)) {
2258 int i;
2259 for (i = 0; i < ret; i++)
2260 if (msgs[i].flags & I2C_M_RD)
2261 trace_i2c_reply(adap, &msgs[i], i);
2262 trace_i2c_result(adap, i, ret);
2263 }
2264
b37d2a3a
JD		 2265 return ret;
2266}
2267EXPORT_SYMBOL(__i2c_transfer);
2268
a1cdedac
DB		 2269/**
2270 * i2c_transfer - execute a single or combined I2C message
2271 * @adap: Handle to I2C bus
2272 * @msgs: One or more messages to execute before STOP is issued to
2273 * terminate the operation; each message begins with a START.
2274 * @num: Number of messages to be executed.
2275 *
2276 * Returns negative errno, else the number of messages executed.
2277 *
2278 * Note that there is no requirement that each message be sent to
2279 * the same slave address, although that is the most common model.
2280 */
09b8ce0a 2281int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
1da177e4 2282{
b37d2a3a 2283 int ret;
1da177e4 2284
a1cdedac
DB		 2285 /* REVISIT the fault reporting model here is weak:
2286 *
2287 * - When we get an error after receiving N bytes from a slave,
2288 * there is no way to report "N".
2289 *
2290 * - When we get a NAK after transmitting N bytes to a slave,
2291 * there is no way to report "N" ... or to let the master
2292 * continue executing the rest of this combined message, if
2293 * that's the appropriate response.
2294 *
2295 * - When for example "num" is two and we successfully complete
2296 * the first message but get an error part way through the
2297 * second, it's unclear whether that should be reported as
2298 * one (discarding status on the second message) or errno
2299 * (discarding status on the first one).
2300 */
2301
1da177e4
LT		 2302 if (adap->algo->master_xfer) {
2303#ifdef DEBUG
2304 for (ret = 0; ret < num; ret++) {
2305 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
209d27c3
JD		 2306 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
2307 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
2308 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
1da177e4
LT		 2309 }
2310#endif
2311
cea443a8 2312 if (in_atomic() || irqs_disabled()) {
fe61e07e 2313 ret = i2c_trylock_adapter(adap);
cea443a8
MR		 2314 if (!ret)
2315 /* I2C activity is ongoing. */
2316 return -EAGAIN;
2317 } else {
fe61e07e 2318 i2c_lock_adapter(adap);
cea443a8
MR		 2319 }
2320
b37d2a3a 2321 ret = __i2c_transfer(adap, msgs, num);
fe61e07e 2322 i2c_unlock_adapter(adap);
1da177e4
LT		 2323
2324 return ret;
2325 } else {
2326 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
24a5bb7b 2327 return -EOPNOTSUPP;
1da177e4
LT		 2328 }
2329}
c0564606 2330EXPORT_SYMBOL(i2c_transfer);
1da177e4 2331
a1cdedac
DB		 2332/**
2333 * i2c_master_send - issue a single I2C message in master transmit mode
2334 * @client: Handle to slave device
2335 * @buf: Data that will be written to the slave
0c43ea54 2336 * @count: How many bytes to write, must be less than 64k since msg.len is u16
a1cdedac
DB		 2337 *
2338 * Returns negative errno, or else the number of bytes written.
2339 */
0cc43a18 2340int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
1da177e4
LT		 2341{
2342 int ret;
7225acf4 2343 struct i2c_adapter *adap = client->adapter;
1da177e4
LT		 2344 struct i2c_msg msg;
2345
815f55f2
JD		 2346 msg.addr = client->addr;
2347 msg.flags = client->flags & I2C_M_TEN;
2348 msg.len = count;
2349 msg.buf = (char *)buf;
438d6c2c 2350
815f55f2 2351 ret = i2c_transfer(adap, &msg, 1);
1da177e4 2352
834aa6f3
WS		 2353 /*
2354 * If everything went ok (i.e. 1 msg transmitted), return #bytes
2355 * transmitted, else error code.
2356 */
815f55f2 2357 return (ret == 1) ? count : ret;
1da177e4 2358}
c0564606 2359EXPORT_SYMBOL(i2c_master_send);
1da177e4 2360
a1cdedac
DB		 2361/**
2362 * i2c_master_recv - issue a single I2C message in master receive mode
2363 * @client: Handle to slave device
2364 * @buf: Where to store data read from slave
0c43ea54 2365 * @count: How many bytes to read, must be less than 64k since msg.len is u16
a1cdedac
DB		 2366 *
2367 * Returns negative errno, or else the number of bytes read.
2368 */
0cc43a18 2369int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
1da177e4 2370{
7225acf4 2371 struct i2c_adapter *adap = client->adapter;
1da177e4
LT		 2372 struct i2c_msg msg;
2373 int ret;
815f55f2
JD		 2374
2375 msg.addr = client->addr;
2376 msg.flags = client->flags & I2C_M_TEN;
2377 msg.flags |= I2C_M_RD;
2378 msg.len = count;
2379 msg.buf = buf;
2380
2381 ret = i2c_transfer(adap, &msg, 1);
2382
834aa6f3
WS		 2383 /*
2384 * If everything went ok (i.e. 1 msg received), return #bytes received,
2385 * else error code.
2386 */
815f55f2 2387 return (ret == 1) ? count : ret;
1da177e4 2388}
c0564606 2389EXPORT_SYMBOL(i2c_master_recv);
1da177e4 2390
1da177e4
LT		 2391/* ----------------------------------------------------
2392 * the i2c address scanning function
2393 * Will not work for 10-bit addresses!
2394 * ----------------------------------------------------
2395 */
1da177e4 2396
63e4e802
JD		 2397/*
2398 * Legacy default probe function, mostly relevant for SMBus. The default
2399 * probe method is a quick write, but it is known to corrupt the 24RF08
2400 * EEPROMs due to a state machine bug, and could also irreversibly
2401 * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
2402 * we use a short byte read instead. Also, some bus drivers don't implement
2403 * quick write, so we fallback to a byte read in that case too.
2404 * On x86, there is another special case for FSC hardware monitoring chips,
2405 * which want regular byte reads (address 0x73.) Fortunately, these are the
2406 * only known chips using this I2C address on PC hardware.
2407 * Returns 1 if probe succeeded, 0 if not.
2408 */
2409static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
2410{
2411 int err;
2412 union i2c_smbus_data dummy;
2413
2414#ifdef CONFIG_X86
2415 if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
2416 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
2417 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2418 I2C_SMBUS_BYTE_DATA, &dummy);
2419 else
2420#endif
8031d79b
JD		 2421 if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
2422 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
63e4e802
JD		 2423 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
2424 I2C_SMBUS_QUICK, NULL);
8031d79b
JD		 2425 else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
2426 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2427 I2C_SMBUS_BYTE, &dummy);
2428 else {
d63a9e85
AL		 2429 dev_warn(&adap->dev, "No suitable probing method supported for address 0x%02X\n",
2430 addr);
8031d79b
JD		 2431 err = -EOPNOTSUPP;
2432 }
63e4e802
JD		 2433
2434 return err >= 0;
2435}
2436
ccfbbd08 2437static int i2c_detect_address(struct i2c_client *temp_client,
4735c98f
JD		 2438 struct i2c_driver *driver)
2439{
2440 struct i2c_board_info info;
2441 struct i2c_adapter *adapter = temp_client->adapter;
2442 int addr = temp_client->addr;
2443 int err;
2444
2445 /* Make sure the address is valid */
66be6056 2446 err = i2c_check_7bit_addr_validity_strict(addr);
656b8761 2447 if (err) {
4735c98f
JD		 2448 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
2449 addr);
656b8761 2450 return err;
4735c98f
JD		 2451 }
2452
9bccc70a 2453 /* Skip if already in use (7 bit, no need to encode flags) */
3b5f794b 2454 if (i2c_check_addr_busy(adapter, addr))
4735c98f
JD		 2455 return 0;
2456
ccfbbd08 2457 /* Make sure there is something at this address */
63e4e802
JD		 2458 if (!i2c_default_probe(adapter, addr))
2459 return 0;
4735c98f
JD		 2460
2461 /* Finally call the custom detection function */
2462 memset(&info, 0, sizeof(struct i2c_board_info));
2463 info.addr = addr;
310ec792 2464 err = driver->detect(temp_client, &info);
4735c98f
JD		 2465 if (err) {
2466 /* -ENODEV is returned if the detection fails. We catch it
2467 here as this isn't an error. */
2468 return err == -ENODEV ? 0 : err;
2469 }
2470
2471 /* Consistency check */
2472 if (info.type[0] == '\0') {
2473 dev_err(&adapter->dev, "%s detection function provided "
2474 "no name for 0x%x\n", driver->driver.name,
2475 addr);
2476 } else {
2477 struct i2c_client *client;
2478
2479 /* Detection succeeded, instantiate the device */
0c176170
WS		 2480 if (adapter->class & I2C_CLASS_DEPRECATED)
2481 dev_warn(&adapter->dev,
2482 "This adapter will soon drop class based instantiation of devices. "
2483 "Please make sure client 0x%02x gets instantiated by other means. "
2484 "Check 'Documentation/i2c/instantiating-devices' for details.\n",
2485 info.addr);
2486
4735c98f
JD		 2487 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
2488 info.type, info.addr);
2489 client = i2c_new_device(adapter, &info);
2490 if (client)
2491 list_add_tail(&client->detected, &driver->clients);
2492 else
2493 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
2494 info.type, info.addr);
2495 }
2496 return 0;
2497}
2498
2499static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
2500{
c3813d6a 2501 const unsigned short *address_list;
4735c98f
JD		 2502 struct i2c_client *temp_client;
2503 int i, err = 0;
2504 int adap_id = i2c_adapter_id(adapter);
2505
c3813d6a
JD		 2506 address_list = driver->address_list;
2507 if (!driver->detect || !address_list)
4735c98f
JD		 2508 return 0;
2509
45552272
WS		 2510 /* Warn that the adapter lost class based instantiation */
2511 if (adapter->class == I2C_CLASS_DEPRECATED) {
2512 dev_dbg(&adapter->dev,
2513 "This adapter dropped support for I2C classes and "
2514 "won't auto-detect %s devices anymore. If you need it, check "
2515 "'Documentation/i2c/instantiating-devices' for alternatives.\n",
2516 driver->driver.name);
2517 return 0;
2518 }
2519
51b54ba9
JD		 2520 /* Stop here if the classes do not match */
2521 if (!(adapter->class & driver->class))
2522 return 0;
2523
4735c98f
JD		 2524 /* Set up a temporary client to help detect callback */
2525 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
2526 if (!temp_client)
2527 return -ENOMEM;
2528 temp_client->adapter = adapter;
2529
c3813d6a 2530 for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
4735c98f 2531 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
c3813d6a
JD		 2532 "addr 0x%02x\n", adap_id, address_list[i]);
2533 temp_client->addr = address_list[i];
ccfbbd08 2534 err = i2c_detect_address(temp_client, driver);
51b54ba9
JD		 2535 if (unlikely(err))
2536 break;
4735c98f
JD		 2537 }
2538
4735c98f
JD		 2539 kfree(temp_client);
2540 return err;
2541}
2542
d44f19d5
JD		 2543int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
2544{
2545 return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2546 I2C_SMBUS_QUICK, NULL) >= 0;
2547}
2548EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
2549
12b5053a
JD		 2550struct i2c_client *
2551i2c_new_probed_device(struct i2c_adapter *adap,
2552 struct i2c_board_info *info,
9a94241a
JD		 2553 unsigned short const *addr_list,
2554 int (*probe)(struct i2c_adapter *, unsigned short addr))
12b5053a
JD		 2555{
2556 int i;
2557
8031d79b 2558 if (!probe)
9a94241a 2559 probe = i2c_default_probe;
12b5053a 2560
12b5053a
JD		 2561 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
2562 /* Check address validity */
66be6056 2563 if (i2c_check_7bit_addr_validity_strict(addr_list[i]) < 0) {
12b5053a
JD		 2564 dev_warn(&adap->dev, "Invalid 7-bit address "
2565 "0x%02x\n", addr_list[i]);
2566 continue;
2567 }
2568
9bccc70a 2569 /* Check address availability (7 bit, no need to encode flags) */
3b5f794b 2570 if (i2c_check_addr_busy(adap, addr_list[i])) {
12b5053a
JD		 2571 dev_dbg(&adap->dev, "Address 0x%02x already in "
2572 "use, not probing\n", addr_list[i]);
2573 continue;
2574 }
2575
63e4e802 2576 /* Test address responsiveness */
9a94241a 2577 if (probe(adap, addr_list[i]))
63e4e802 2578 break;
12b5053a 2579 }
12b5053a
JD		 2580
2581 if (addr_list[i] == I2C_CLIENT_END) {
2582 dev_dbg(&adap->dev, "Probing failed, no device found\n");
2583 return NULL;
2584 }
2585
2586 info->addr = addr_list[i];
2587 return i2c_new_device(adap, info);
2588}
2589EXPORT_SYMBOL_GPL(i2c_new_probed_device);
2590
d735b34d 2591struct i2c_adapter *i2c_get_adapter(int nr)
1da177e4 2592{
1da177e4 2593 struct i2c_adapter *adapter;
438d6c2c 2594
caada32a 2595 mutex_lock(&core_lock);
d735b34d 2596 adapter = idr_find(&i2c_adapter_idr, nr);
611e12ea
VZ		 2597 if (!adapter)
2598 goto exit;
2599
2600 if (try_module_get(adapter->owner))
2601 get_device(&adapter->dev);
2602 else
a0920e10
MH		 2603 adapter = NULL;
2604
611e12ea 2605 exit:
caada32a 2606 mutex_unlock(&core_lock);
a0920e10 2607 return adapter;
1da177e4 2608}
c0564606 2609EXPORT_SYMBOL(i2c_get_adapter);
1da177e4
LT		 2610
2611void i2c_put_adapter(struct i2c_adapter *adap)
2612{
611e12ea
VZ		 2613 if (!adap)
2614 return;
2615
2616 put_device(&adap->dev);
2617 module_put(adap->owner);
1da177e4 2618}
c0564606 2619EXPORT_SYMBOL(i2c_put_adapter);
1da177e4
LT		 2620
2621/* The SMBus parts */
2622
438d6c2c 2623#define POLY (0x1070U << 3)
09b8ce0a 2624static u8 crc8(u16 data)
1da177e4
LT		 2625{
2626 int i;
438d6c2c 2627
7225acf4 2628 for (i = 0; i < 8; i++) {
438d6c2c 2629 if (data & 0x8000)
1da177e4
LT		 2630 data = data ^ POLY;
2631 data = data << 1;
2632 }
2633 return (u8)(data >> 8);
2634}
2635
421ef47b
JD		 2636/* Incremental CRC8 over count bytes in the array pointed to by p */
2637static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
1da177e4
LT		 2638{
2639 int i;
2640
7225acf4 2641 for (i = 0; i < count; i++)
421ef47b 2642 crc = crc8((crc ^ p[i]) << 8);
1da177e4
LT		 2643 return crc;
2644}
2645
421ef47b
JD		 2646/* Assume a 7-bit address, which is reasonable for SMBus */
2647static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
1da177e4 2648{
421ef47b
JD		 2649 /* The address will be sent first */
2650 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
2651 pec = i2c_smbus_pec(pec, &addr, 1);
2652
2653 /* The data buffer follows */
2654 return i2c_smbus_pec(pec, msg->buf, msg->len);
1da177e4
LT		 2655}
2656
421ef47b
JD		 2657/* Used for write only transactions */
2658static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
1da177e4 2659{
421ef47b
JD		 2660 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
2661 msg->len++;
1da177e4
LT		 2662}
2663
421ef47b
JD		 2664/* Return <0 on CRC error
2665 If there was a write before this read (most cases) we need to take the
2666 partial CRC from the write part into account.
2667 Note that this function does modify the message (we need to decrease the
2668 message length to hide the CRC byte from the caller). */
2669static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
1da177e4 2670{
421ef47b
JD		 2671 u8 rpec = msg->buf[--msg->len];
2672 cpec = i2c_smbus_msg_pec(cpec, msg);
1da177e4 2673
1da177e4
LT		 2674 if (rpec != cpec) {
2675 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
2676 rpec, cpec);
24a5bb7b 2677 return -EBADMSG;
1da177e4 2678 }
438d6c2c 2679 return 0;
1da177e4
LT		 2680}
2681
a1cdedac
DB		 2682/**
2683 * i2c_smbus_read_byte - SMBus "receive byte" protocol
2684 * @client: Handle to slave device
2685 *
2686 * This executes the SMBus "receive byte" protocol, returning negative errno
2687 * else the byte received from the device.
2688 */
0cc43a18 2689s32 i2c_smbus_read_byte(const struct i2c_client *client)
1da177e4
LT		 2690{
2691 union i2c_smbus_data data;
24a5bb7b
DB		 2692 int status;
2693
2694 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2695 I2C_SMBUS_READ, 0,
2696 I2C_SMBUS_BYTE, &data);
2697 return (status < 0) ? status : data.byte;
1da177e4 2698}
c0564606 2699EXPORT_SYMBOL(i2c_smbus_read_byte);
1da177e4 2700
a1cdedac
DB		 2701/**
2702 * i2c_smbus_write_byte - SMBus "send byte" protocol
2703 * @client: Handle to slave device
2704 * @value: Byte to be sent
2705 *
2706 * This executes the SMBus "send byte" protocol, returning negative errno
2707 * else zero on success.
2708 */
0cc43a18 2709s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
1da177e4 2710{
7225acf4 2711 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
421ef47b 2712 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
1da177e4 2713}
c0564606 2714EXPORT_SYMBOL(i2c_smbus_write_byte);
1da177e4 2715
a1cdedac
DB		 2716/**
2717 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
2718 * @client: Handle to slave device
2719 * @command: Byte interpreted by slave
2720 *
2721 * This executes the SMBus "read byte" protocol, returning negative errno
2722 * else a data byte received from the device.
2723 */
0cc43a18 2724s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
1da177e4
LT		 2725{
2726 union i2c_smbus_data data;
24a5bb7b
DB		 2727 int status;
2728
2729 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2730 I2C_SMBUS_READ, command,
2731 I2C_SMBUS_BYTE_DATA, &data);
2732 return (status < 0) ? status : data.byte;
1da177e4 2733}
c0564606 2734EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1da177e4 2735
a1cdedac
DB		 2736/**
2737 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
2738 * @client: Handle to slave device
2739 * @command: Byte interpreted by slave
2740 * @value: Byte being written
2741 *
2742 * This executes the SMBus "write byte" protocol, returning negative errno
2743 * else zero on success.
2744 */
0cc43a18
JD		 2745s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
2746 u8 value)
1da177e4
LT		 2747{
2748 union i2c_smbus_data data;
2749 data.byte = value;
7225acf4
FH		 2750 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2751 I2C_SMBUS_WRITE, command,
2752 I2C_SMBUS_BYTE_DATA, &data);
1da177e4 2753}
c0564606 2754EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1da177e4 2755
a1cdedac
DB		 2756/**
2757 * i2c_smbus_read_word_data - SMBus "read word" protocol
2758 * @client: Handle to slave device
2759 * @command: Byte interpreted by slave
2760 *
2761 * This executes the SMBus "read word" protocol, returning negative errno
2762 * else a 16-bit unsigned "word" received from the device.
2763 */
0cc43a18 2764s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
1da177e4
LT		 2765{
2766 union i2c_smbus_data data;
24a5bb7b
DB		 2767 int status;
2768
2769 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2770 I2C_SMBUS_READ, command,
2771 I2C_SMBUS_WORD_DATA, &data);
2772 return (status < 0) ? status : data.word;
1da177e4 2773}
c0564606 2774EXPORT_SYMBOL(i2c_smbus_read_word_data);
1da177e4 2775
a1cdedac
DB		 2776/**
2777 * i2c_smbus_write_word_data - SMBus "write word" protocol
2778 * @client: Handle to slave device
2779 * @command: Byte interpreted by slave
2780 * @value: 16-bit "word" being written
2781 *
2782 * This executes the SMBus "write word" protocol, returning negative errno
2783 * else zero on success.
2784 */
0cc43a18
JD		 2785s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
2786 u16 value)
1da177e4
LT		 2787{
2788 union i2c_smbus_data data;
2789 data.word = value;
7225acf4
FH		 2790 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2791 I2C_SMBUS_WRITE, command,
2792 I2C_SMBUS_WORD_DATA, &data);
1da177e4 2793}
c0564606 2794EXPORT_SYMBOL(i2c_smbus_write_word_data);
1da177e4 2795
a64ec07d 2796/**
a1cdedac 2797 * i2c_smbus_read_block_data - SMBus "block read" protocol
a64ec07d 2798 * @client: Handle to slave device
a1cdedac 2799 * @command: Byte interpreted by slave
a64ec07d
DB		 2800 * @values: Byte array into which data will be read; big enough to hold
2801 * the data returned by the slave. SMBus allows at most 32 bytes.
2802 *
a1cdedac
DB		 2803 * This executes the SMBus "block read" protocol, returning negative errno
2804 * else the number of data bytes in the slave's response.
a64ec07d
DB		 2805 *
2806 * Note that using this function requires that the client's adapter support
2807 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
2808 * support this; its emulation through I2C messaging relies on a specific
2809 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
2810 */
0cc43a18 2811s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
b86a1bc8
JD		 2812 u8 *values)
2813{
2814 union i2c_smbus_data data;
24a5bb7b 2815 int status;
b86a1bc8 2816
24a5bb7b
DB		 2817 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2818 I2C_SMBUS_READ, command,
2819 I2C_SMBUS_BLOCK_DATA, &data);
2820 if (status)
2821 return status;
b86a1bc8
JD		 2822
2823 memcpy(values, &data.block[1], data.block[0]);
2824 return data.block[0];
2825}
2826EXPORT_SYMBOL(i2c_smbus_read_block_data);
2827
a1cdedac
DB		 2828/**
2829 * i2c_smbus_write_block_data - SMBus "block write" protocol
2830 * @client: Handle to slave device
2831 * @command: Byte interpreted by slave
2832 * @length: Size of data block; SMBus allows at most 32 bytes
2833 * @values: Byte array which will be written.
2834 *
2835 * This executes the SMBus "block write" protocol, returning negative errno
2836 * else zero on success.
2837 */
0cc43a18 2838s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
46f5ed75 2839 u8 length, const u8 *values)
1da177e4
LT		 2840{
2841 union i2c_smbus_data data;
7656032b 2842
1da177e4
LT		 2843 if (length > I2C_SMBUS_BLOCK_MAX)
2844 length = I2C_SMBUS_BLOCK_MAX;
1da177e4 2845 data.block[0] = length;
7656032b 2846 memcpy(&data.block[1], values, length);
7225acf4
FH		 2847 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2848 I2C_SMBUS_WRITE, command,
2849 I2C_SMBUS_BLOCK_DATA, &data);
1da177e4 2850}
c0564606 2851EXPORT_SYMBOL(i2c_smbus_write_block_data);
1da177e4
LT		 2852
2853/* Returns the number of read bytes */
0cc43a18 2854s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
4b2643d7 2855 u8 length, u8 *values)
1da177e4
LT		 2856{
2857 union i2c_smbus_data data;
24a5bb7b 2858 int status;
7656032b 2859
4b2643d7
JD		 2860 if (length > I2C_SMBUS_BLOCK_MAX)
2861 length = I2C_SMBUS_BLOCK_MAX;
2862 data.block[0] = length;
24a5bb7b
DB		 2863 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2864 I2C_SMBUS_READ, command,
2865 I2C_SMBUS_I2C_BLOCK_DATA, &data);
2866 if (status < 0)
2867 return status;
7656032b
JD		 2868
2869 memcpy(values, &data.block[1], data.block[0]);
2870 return data.block[0];
1da177e4 2871}
c0564606 2872EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1da177e4 2873
0cc43a18 2874s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
46f5ed75 2875 u8 length, const u8 *values)
21bbd691
JD		 2876{
2877 union i2c_smbus_data data;
2878
2879 if (length > I2C_SMBUS_BLOCK_MAX)
2880 length = I2C_SMBUS_BLOCK_MAX;
2881 data.block[0] = length;
2882 memcpy(data.block + 1, values, length);
2883 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2884 I2C_SMBUS_WRITE, command,
2885 I2C_SMBUS_I2C_BLOCK_DATA, &data);
2886}
c0564606 2887EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
21bbd691 2888
438d6c2c 2889/* Simulate a SMBus command using the i2c protocol
1da177e4 2890 No checking of parameters is done! */
7225acf4
FH		 2891static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
2892 unsigned short flags,
2893 char read_write, u8 command, int size,
2894 union i2c_smbus_data *data)
1da177e4
LT		 2895{
2896 /* So we need to generate a series of msgs. In the case of writing, we
2897 need to use only one message; when reading, we need two. We initialize
2898 most things with sane defaults, to keep the code below somewhat
2899 simpler. */
5c50d188
HI		 2900 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
2901 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
7225acf4 2902 int num = read_write == I2C_SMBUS_READ ? 2 : 1;
1da177e4 2903 int i;
421ef47b 2904 u8 partial_pec = 0;
24a5bb7b 2905 int status;
230da094
S		 2906 struct i2c_msg msg[2] = {
2907 {
2908 .addr = addr,
2909 .flags = flags,
2910 .len = 1,
2911 .buf = msgbuf0,
2912 }, {
2913 .addr = addr,
2914 .flags = flags | I2C_M_RD,
2915 .len = 0,
2916 .buf = msgbuf1,
2917 },
2918 };
1da177e4
LT		 2919
2920 msgbuf0[0] = command;
7225acf4 2921 switch (size) {
1da177e4
LT		 2922 case I2C_SMBUS_QUICK:
2923 msg[0].len = 0;
2924 /* Special case: The read/write field is used as data */
f29d2e02
RK		 2925 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
2926 I2C_M_RD : 0);
1da177e4
LT		 2927 num = 1;
2928 break;
2929 case I2C_SMBUS_BYTE:
2930 if (read_write == I2C_SMBUS_READ) {
2931 /* Special case: only a read! */
2932 msg[0].flags = I2C_M_RD | flags;
2933 num = 1;
2934 }
2935 break;
2936 case I2C_SMBUS_BYTE_DATA:
2937 if (read_write == I2C_SMBUS_READ)
2938 msg[1].len = 1;
2939 else {
2940 msg[0].len = 2;
2941 msgbuf0[1] = data->byte;
2942 }
2943 break;
2944 case I2C_SMBUS_WORD_DATA:
2945 if (read_write == I2C_SMBUS_READ)
2946 msg[1].len = 2;
2947 else {
7225acf4 2948 msg[0].len = 3;
1da177e4 2949 msgbuf0[1] = data->word & 0xff;
7eff82c8 2950 msgbuf0[2] = data->word >> 8;
1da177e4
LT		 2951 }
2952 break;
2953 case I2C_SMBUS_PROC_CALL:
2954 num = 2; /* Special case */
2955 read_write = I2C_SMBUS_READ;
2956 msg[0].len = 3;
2957 msg[1].len = 2;
2958 msgbuf0[1] = data->word & 0xff;
7eff82c8 2959 msgbuf0[2] = data->word >> 8;
1da177e4
LT		 2960 break;
2961 case I2C_SMBUS_BLOCK_DATA:
1da177e4 2962 if (read_write == I2C_SMBUS_READ) {
209d27c3
JD		 2963 msg[1].flags |= I2C_M_RECV_LEN;
2964 msg[1].len = 1; /* block length will be added by
2965 the underlying bus driver */
1da177e4
LT		 2966 } else {
2967 msg[0].len = data->block[0] + 2;
2968 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
24a5bb7b
DB		 2969 dev_err(&adapter->dev,
2970 "Invalid block write size %d\n",
2971 data->block[0]);
2972 return -EINVAL;
1da177e4 2973 }
5c50d188 2974 for (i = 1; i < msg[0].len; i++)
1da177e4
LT		 2975 msgbuf0[i] = data->block[i-1];
2976 }
2977 break;
2978 case I2C_SMBUS_BLOCK_PROC_CALL:
209d27c3
JD		 2979 num = 2; /* Another special case */
2980 read_write = I2C_SMBUS_READ;
2981 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
24a5bb7b
DB		 2982 dev_err(&adapter->dev,
2983 "Invalid block write size %d\n",
209d27c3 2984 data->block[0]);
24a5bb7b 2985 return -EINVAL;
209d27c3
JD		 2986 }
2987 msg[0].len = data->block[0] + 2;
2988 for (i = 1; i < msg[0].len; i++)
2989 msgbuf0[i] = data->block[i-1];
2990 msg[1].flags |= I2C_M_RECV_LEN;
2991 msg[1].len = 1; /* block length will be added by
2992 the underlying bus driver */
2993 break;
1da177e4
LT		 2994 case I2C_SMBUS_I2C_BLOCK_DATA:
2995 if (read_write == I2C_SMBUS_READ) {
4b2643d7 2996 msg[1].len = data->block[0];
1da177e4
LT		 2997 } else {
2998 msg[0].len = data->block[0] + 1;
30dac746 2999 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
24a5bb7b
DB		 3000 dev_err(&adapter->dev,
3001 "Invalid block write size %d\n",
3002 data->block[0]);
3003 return -EINVAL;
1da177e4
LT		 3004 }
3005 for (i = 1; i <= data->block[0]; i++)
3006 msgbuf0[i] = data->block[i];
3007 }
3008 break;
3009 default:
24a5bb7b
DB		 3010 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
3011 return -EOPNOTSUPP;
1da177e4
LT		 3012 }
3013
421ef47b
JD		 3014 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
3015 && size != I2C_SMBUS_I2C_BLOCK_DATA);
3016 if (i) {
3017 /* Compute PEC if first message is a write */
3018 if (!(msg[0].flags & I2C_M_RD)) {
438d6c2c 3019 if (num == 1) /* Write only */
421ef47b
JD		 3020 i2c_smbus_add_pec(&msg[0]);
3021 else /* Write followed by read */
3022 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
3023 }
3024 /* Ask for PEC if last message is a read */
3025 if (msg[num-1].flags & I2C_M_RD)
438d6c2c 3026 msg[num-1].len++;
421ef47b
JD		 3027 }
3028
24a5bb7b
DB		 3029 status = i2c_transfer(adapter, msg, num);
3030 if (status < 0)
3031 return status;
1da177e4 3032
421ef47b
JD		 3033 /* Check PEC if last message is a read */
3034 if (i && (msg[num-1].flags & I2C_M_RD)) {
24a5bb7b
DB		 3035 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
3036 if (status < 0)
3037 return status;
421ef47b
JD		 3038 }
3039
1da177e4 3040 if (read_write == I2C_SMBUS_READ)
7225acf4
FH		 3041 switch (size) {
3042 case I2C_SMBUS_BYTE:
3043 data->byte = msgbuf0[0];
3044 break;
3045 case I2C_SMBUS_BYTE_DATA:
3046 data->byte = msgbuf1[0];
3047 break;
3048 case I2C_SMBUS_WORD_DATA:
3049 case I2C_SMBUS_PROC_CALL:
3050 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
3051 break;
3052 case I2C_SMBUS_I2C_BLOCK_DATA:
3053 for (i = 0; i < data->block[0]; i++)
3054 data->block[i+1] = msgbuf1[i];
3055 break;
3056 case I2C_SMBUS_BLOCK_DATA:
3057 case I2C_SMBUS_BLOCK_PROC_CALL:
3058 for (i = 0; i < msgbuf1[0] + 1; i++)
3059 data->block[i] = msgbuf1[i];
3060 break;
1da177e4
LT		 3061 }
3062 return 0;
3063}
3064
a1cdedac
DB		 3065/**
3066 * i2c_smbus_xfer - execute SMBus protocol operations
3067 * @adapter: Handle to I2C bus
3068 * @addr: Address of SMBus slave on that bus
3069 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
3070 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
3071 * @command: Byte interpreted by slave, for protocols which use such bytes
3072 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
3073 * @data: Data to be read or written
3074 *
3075 * This executes an SMBus protocol operation, and returns a negative
3076 * errno code else zero on success.
3077 */
09b8ce0a 3078s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
a1cdedac 3079 char read_write, u8 command, int protocol,
09b8ce0a 3080 union i2c_smbus_data *data)
1da177e4 3081{
66b650f0
CW		 3082 unsigned long orig_jiffies;
3083 int try;
1da177e4 3084 s32 res;
1da177e4 3085
8a325997
DH		 3086 /* If enabled, the following two tracepoints are conditional on
3087 * read_write and protocol.
3088 */
3089 trace_smbus_write(adapter, addr, flags, read_write,
3090 command, protocol, data);
3091 trace_smbus_read(adapter, addr, flags, read_write,
3092 command, protocol);
3093
d47726c5 3094 flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
1da177e4
LT		 3095
3096 if (adapter->algo->smbus_xfer) {
fe61e07e 3097 i2c_lock_adapter(adapter);
66b650f0
CW		 3098
3099 /* Retry automatically on arbitration loss */
3100 orig_jiffies = jiffies;
3101 for (res = 0, try = 0; try <= adapter->retries; try++) {
3102 res = adapter->algo->smbus_xfer(adapter, addr, flags,
3103 read_write, command,
3104 protocol, data);
3105 if (res != -EAGAIN)
3106 break;
3107 if (time_after(jiffies,
3108 orig_jiffies + adapter->timeout))
3109 break;
3110 }
fe61e07e 3111 i2c_unlock_adapter(adapter);
1da177e4 3112
72fc2c7f 3113 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
8a325997 3114 goto trace;
72fc2c7f
LP		 3115 /*
3116 * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
3117 * implement native support for the SMBus operation.
3118 */
3119 }
3120
8a325997
DH		 3121 res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
3122 command, protocol, data);
3123
3124trace:
3125 /* If enabled, the reply tracepoint is conditional on read_write. */
3126 trace_smbus_reply(adapter, addr, flags, read_write,
3127 command, protocol, data);
3128 trace_smbus_result(adapter, addr, flags, read_write,
3129 command, protocol, res);
3130
3131 return res;
1da177e4 3132}
1da177e4 3133EXPORT_SYMBOL(i2c_smbus_xfer);
1da177e4 3134
01eef96e
IT		 3135/**
3136 * i2c_smbus_read_i2c_block_data_or_emulated - read block or emulate
3137 * @client: Handle to slave device
3138 * @command: Byte interpreted by slave
3139 * @length: Size of data block; SMBus allows at most I2C_SMBUS_BLOCK_MAX bytes
3140 * @values: Byte array into which data will be read; big enough to hold
3141 * the data returned by the slave. SMBus allows at most
3142 * I2C_SMBUS_BLOCK_MAX bytes.
3143 *
3144 * This executes the SMBus "block read" protocol if supported by the adapter.
3145 * If block read is not supported, it emulates it using either word or byte
3146 * read protocols depending on availability.
3147 *
3148 * The addresses of the I2C slave device that are accessed with this function
3149 * must be mapped to a linear region, so that a block read will have the same
3150 * effect as a byte read. Before using this function you must double-check
3151 * if the I2C slave does support exchanging a block transfer with a byte
3152 * transfer.
3153 */
3154s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
3155 u8 command, u8 length, u8 *values)
3156{
3157 u8 i = 0;
3158 int status;
3159
3160 if (length > I2C_SMBUS_BLOCK_MAX)
3161 length = I2C_SMBUS_BLOCK_MAX;
3162
3163 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK))
3164 return i2c_smbus_read_i2c_block_data(client, command, length, values);
3165
3166 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA))
3167 return -EOPNOTSUPP;
3168
3169 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_WORD_DATA)) {
3170 while ((i + 2) <= length) {
3171 status = i2c_smbus_read_word_data(client, command + i);
3172 if (status < 0)
3173 return status;
3174 values[i] = status & 0xff;
3175 values[i + 1] = status >> 8;
3176 i += 2;
3177 }
3178 }
3179
3180 while (i < length) {
3181 status = i2c_smbus_read_byte_data(client, command + i);
3182 if (status < 0)
3183 return status;
3184 values[i] = status;
3185 i++;
3186 }
3187
3188 return i;
3189}
3190EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data_or_emulated);
3191
d5fd120e 3192#if IS_ENABLED(CONFIG_I2C_SLAVE)
4b1acc43
WS		 3193int i2c_slave_register(struct i2c_client *client, i2c_slave_cb_t slave_cb)
3194{
3195 int ret;
3196
0c7cab96
WS		 3197 if (!client || !slave_cb) {
3198 WARN(1, "insufficent data\n");
4b1acc43 3199 return -EINVAL;
0c7cab96 3200 }
4b1acc43 3201
c6909d6f
WS		 3202 if (!(client->flags & I2C_CLIENT_SLAVE))
3203 dev_warn(&client->dev, "%s: client slave flag not set. You might see address collisions\n",
3204 __func__);
3205
4b1acc43
WS		 3206 if (!(client->flags & I2C_CLIENT_TEN)) {
3207 /* Enforce stricter address checking */
66be6056 3208 ret = i2c_check_7bit_addr_validity_strict(client->addr);
0c7cab96
WS		 3209 if (ret) {
3210 dev_err(&client->dev, "%s: invalid address\n", __func__);
4b1acc43 3211 return ret;
0c7cab96 3212 }
4b1acc43
WS		 3213 }
3214
0c7cab96
WS		 3215 if (!client->adapter->algo->reg_slave) {
3216 dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
4b1acc43 3217 return -EOPNOTSUPP;
0c7cab96 3218 }
4b1acc43
WS		 3219
3220 client->slave_cb = slave_cb;
3221
3222 i2c_lock_adapter(client->adapter);
3223 ret = client->adapter->algo->reg_slave(client);
3224 i2c_unlock_adapter(client->adapter);
3225
0c7cab96 3226 if (ret) {
4b1acc43 3227 client->slave_cb = NULL;
0c7cab96
WS		 3228 dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
3229 }
4b1acc43
WS		 3230
3231 return ret;
3232}
3233EXPORT_SYMBOL_GPL(i2c_slave_register);
3234
3235int i2c_slave_unregister(struct i2c_client *client)
3236{
3237 int ret;
3238
0c7cab96
WS		 3239 if (!client->adapter->algo->unreg_slave) {
3240 dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
4b1acc43 3241 return -EOPNOTSUPP;
0c7cab96 3242 }
4b1acc43
WS		 3243
3244 i2c_lock_adapter(client->adapter);
3245 ret = client->adapter->algo->unreg_slave(client);
3246 i2c_unlock_adapter(client->adapter);
3247
3248 if (ret == 0)
3249 client->slave_cb = NULL;
0c7cab96
WS		 3250 else
3251 dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
4b1acc43
WS		 3252
3253 return ret;
3254}
3255EXPORT_SYMBOL_GPL(i2c_slave_unregister);
d5fd120e 3256#endif
4b1acc43 3257
1da177e4
LT		 3258MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
3259MODULE_DESCRIPTION("I2C-Bus main module");
3260MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 1.08974 seconds and 5 git commands to generate.