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