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