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