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