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