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