2019-05-27 00:55:06 -06:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2017-05-23 11:23:11 -06:00
|
|
|
/*
|
|
|
|
* Linux I2C core
|
|
|
|
*
|
|
|
|
* Copyright (C) 1995-99 Simon G. Vogl
|
|
|
|
* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi>
|
|
|
|
* Mux support by Rodolfo Giometti <giometti@enneenne.com> and
|
|
|
|
* Michael Lawnick <michael.lawnick.ext@nsn.com>
|
|
|
|
*
|
|
|
|
* Copyright (C) 2013-2017 Wolfram Sang <wsa@the-dreams.de>
|
2013-07-11 05:56:15 -06:00
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-07-08 22:35:04 -06:00
|
|
|
#define pr_fmt(fmt) "i2c-core: " fmt
|
|
|
|
|
2015-05-19 13:04:40 -06:00
|
|
|
#include <dt-bindings/i2c/i2c.h>
|
2016-02-20 15:33:38 -07:00
|
|
|
#include <linux/acpi.h>
|
|
|
|
#include <linux/clk/clk-conf.h>
|
|
|
|
#include <linux/completion.h>
|
2012-02-28 05:56:31 -07:00
|
|
|
#include <linux/delay.h>
|
2016-02-20 15:33:38 -07:00
|
|
|
#include <linux/err.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/errno.h>
|
2017-11-27 20:09:10 -07:00
|
|
|
#include <linux/gpio/consumer.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/i2c.h>
|
2017-08-24 03:31:04 -06:00
|
|
|
#include <linux/i2c-smbus.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/idr.h>
|
2016-02-20 15:33:38 -07:00
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/irqflags.h>
|
|
|
|
#include <linux/jump_label.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
2006-01-11 02:50:26 -07:00
|
|
|
#include <linux/mutex.h>
|
2010-06-08 07:48:19 -06:00
|
|
|
#include <linux/of_device.h>
|
2016-02-20 15:33:38 -07:00
|
|
|
#include <linux/of.h>
|
2013-07-11 05:56:15 -06:00
|
|
|
#include <linux/of_irq.h>
|
2014-09-29 05:58:47 -06:00
|
|
|
#include <linux/pm_domain.h>
|
2016-02-20 15:33:38 -07:00
|
|
|
#include <linux/pm_runtime.h>
|
2015-08-18 00:52:51 -06:00
|
|
|
#include <linux/pm_wakeirq.h>
|
2015-12-08 02:37:46 -07:00
|
|
|
#include <linux/property.h>
|
2016-02-20 15:33:38 -07:00
|
|
|
#include <linux/rwsem.h>
|
|
|
|
#include <linux/slab.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
#include "i2c-core.h"
|
|
|
|
|
2014-03-06 06:35:59 -07:00
|
|
|
#define CREATE_TRACE_POINTS
|
|
|
|
#include <trace/events/i2c.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2015-05-18 13:09:12 -06:00
|
|
|
#define I2C_ADDR_OFFSET_TEN_BIT 0xa000
|
|
|
|
#define I2C_ADDR_OFFSET_SLAVE 0x1000
|
|
|
|
|
2016-10-13 06:10:40 -06:00
|
|
|
#define I2C_ADDR_7BITS_MAX 0x77
|
|
|
|
#define I2C_ADDR_7BITS_COUNT (I2C_ADDR_7BITS_MAX + 1)
|
|
|
|
|
2018-01-22 00:32:01 -07:00
|
|
|
#define I2C_ADDR_DEVICE_ID 0x7c
|
|
|
|
|
2017-05-23 11:23:11 -06:00
|
|
|
/*
|
|
|
|
* core_lock protects i2c_adapter_idr, and guarantees that device detection,
|
2018-08-21 09:02:40 -06:00
|
|
|
* deletion of detected devices are serialized
|
2017-05-23 11:23:11 -06:00
|
|
|
*/
|
2008-01-27 10:14:49 -07:00
|
|
|
static DEFINE_MUTEX(core_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
static DEFINE_IDR(i2c_adapter_idr);
|
|
|
|
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-14 14:38:36 -06:00
|
|
|
static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
|
2007-02-13 14:09:00 -07:00
|
|
|
|
2018-03-26 15:09:24 -06:00
|
|
|
static DEFINE_STATIC_KEY_FALSE(i2c_trace_msg_key);
|
2016-03-07 04:49:17 -07:00
|
|
|
static bool is_registered;
|
2014-03-06 06:35:59 -07:00
|
|
|
|
2016-11-28 11:03:21 -07:00
|
|
|
int i2c_transfer_trace_reg(void)
|
2014-03-06 06:35:59 -07:00
|
|
|
{
|
2018-03-26 15:09:24 -06:00
|
|
|
static_branch_inc(&i2c_trace_msg_key);
|
2016-11-28 11:03:21 -07:00
|
|
|
return 0;
|
2014-03-06 06:35:59 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void i2c_transfer_trace_unreg(void)
|
|
|
|
{
|
2018-03-26 15:09:24 -06:00
|
|
|
static_branch_dec(&i2c_trace_msg_key);
|
2014-03-06 06:35:59 -07:00
|
|
|
}
|
|
|
|
|
2016-11-07 05:47:40 -07:00
|
|
|
const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
|
2008-04-29 15:11:39 -06:00
|
|
|
const struct i2c_client *client)
|
|
|
|
{
|
2016-11-07 05:47:36 -07:00
|
|
|
if (!(id && client))
|
|
|
|
return NULL;
|
|
|
|
|
2008-04-29 15:11:39 -06:00
|
|
|
while (id->name[0]) {
|
|
|
|
if (strcmp(client->name, id->name) == 0)
|
|
|
|
return id;
|
|
|
|
id++;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
2016-11-07 05:47:40 -07:00
|
|
|
EXPORT_SYMBOL_GPL(i2c_match_id);
|
2008-04-29 15:11:39 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static int i2c_device_match(struct device *dev, struct device_driver *drv)
|
|
|
|
{
|
2009-09-18 14:45:45 -06:00
|
|
|
struct i2c_client *client = i2c_verify_client(dev);
|
|
|
|
struct i2c_driver *driver;
|
|
|
|
|
2007-05-01 15:26:30 -06:00
|
|
|
|
2010-06-08 07:48:19 -06:00
|
|
|
/* Attempt an OF style match */
|
2016-11-07 05:47:39 -07:00
|
|
|
if (i2c_of_match_device(drv->of_match_table, client))
|
2010-06-08 07:48:19 -06:00
|
|
|
return 1;
|
|
|
|
|
2012-11-23 04:23:40 -07:00
|
|
|
/* Then ACPI style match */
|
|
|
|
if (acpi_driver_match_device(dev, drv))
|
|
|
|
return 1;
|
|
|
|
|
2009-09-18 14:45:45 -06:00
|
|
|
driver = to_i2c_driver(drv);
|
2016-11-07 05:47:36 -07:00
|
|
|
|
|
|
|
/* Finally an I2C match */
|
|
|
|
if (i2c_match_id(driver->id_table, client))
|
|
|
|
return 1;
|
2008-04-29 15:11:39 -06:00
|
|
|
|
2008-05-18 12:49:41 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-08-14 07:15:12 -06:00
|
|
|
static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
|
2007-05-01 15:26:30 -06:00
|
|
|
{
|
2016-03-23 13:47:02 -06:00
|
|
|
struct i2c_client *client = to_i2c_client(dev);
|
ACPI: fix module autoloading for ACPI enumerated devices
ACPI enumerated devices has ACPI style _HID and _CID strings,
all of these strings can be used for both driver loading and matching.
Currently, in Platform, I2C and SPI bus, the ACPI style driver matching
is supported by invoking acpi_driver_match_device() in bus .match() callback.
But, the module autoloading is still broken.
For example, there is any ACPI device with _HID "INTABCD" that is
enumerated to platform bus, and we have a driver that can probe it.
The driver exports its module_alias as "acpi:INTABCD" use the following code
static const struct acpi_device_id xxx_acpi_match[] = {
{ "INTABCD", 0 },
{ }
};
MODULE_DEVICE_TABLE(acpi, xxx_acpi_match);
But, unfortunately, the device' modalias is shown as "platform:INTABCD:00",
please refer to modalias_show() and platform_uevent() in
drivers/base/platform.c.
This results in that the driver will not be loaded automatically when the
device node is created, because their modalias do not match.
This also applies to I2C and SPI bus.
With this patch, the device' modalias will be shown as "acpi:INTABCD" as well.
Signed-off-by: Zhang Rui <rui.zhang@intel.com>
Acked-by: Mark Brown <broonie@linaro.org>
Acked-by: Wolfram Sang <wsa@the-dreams.de>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-01-14 01:46:37 -07:00
|
|
|
int rc;
|
|
|
|
|
2017-12-03 14:40:50 -07:00
|
|
|
rc = of_device_uevent_modalias(dev, env);
|
|
|
|
if (rc != -ENODEV)
|
|
|
|
return rc;
|
|
|
|
|
ACPI: fix module autoloading for ACPI enumerated devices
ACPI enumerated devices has ACPI style _HID and _CID strings,
all of these strings can be used for both driver loading and matching.
Currently, in Platform, I2C and SPI bus, the ACPI style driver matching
is supported by invoking acpi_driver_match_device() in bus .match() callback.
But, the module autoloading is still broken.
For example, there is any ACPI device with _HID "INTABCD" that is
enumerated to platform bus, and we have a driver that can probe it.
The driver exports its module_alias as "acpi:INTABCD" use the following code
static const struct acpi_device_id xxx_acpi_match[] = {
{ "INTABCD", 0 },
{ }
};
MODULE_DEVICE_TABLE(acpi, xxx_acpi_match);
But, unfortunately, the device' modalias is shown as "platform:INTABCD:00",
please refer to modalias_show() and platform_uevent() in
drivers/base/platform.c.
This results in that the driver will not be loaded automatically when the
device node is created, because their modalias do not match.
This also applies to I2C and SPI bus.
With this patch, the device' modalias will be shown as "acpi:INTABCD" as well.
Signed-off-by: Zhang Rui <rui.zhang@intel.com>
Acked-by: Mark Brown <broonie@linaro.org>
Acked-by: Wolfram Sang <wsa@the-dreams.de>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-01-14 01:46:37 -07:00
|
|
|
rc = acpi_device_uevent_modalias(dev, env);
|
|
|
|
if (rc != -ENODEV)
|
|
|
|
return rc;
|
2007-05-01 15:26:30 -06:00
|
|
|
|
2016-03-23 13:47:02 -06:00
|
|
|
return add_uevent_var(env, "MODALIAS=%s%s", I2C_MODULE_PREFIX, client->name);
|
2007-05-01 15:26:30 -06:00
|
|
|
}
|
|
|
|
|
2012-02-28 05:56:31 -07:00
|
|
|
/* i2c bus recovery routines */
|
|
|
|
static int get_scl_gpio_value(struct i2c_adapter *adap)
|
|
|
|
{
|
2017-11-01 20:40:24 -06:00
|
|
|
return gpiod_get_value_cansleep(adap->bus_recovery_info->scl_gpiod);
|
2012-02-28 05:56:31 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void set_scl_gpio_value(struct i2c_adapter *adap, int val)
|
|
|
|
{
|
2017-11-01 20:40:24 -06:00
|
|
|
gpiod_set_value_cansleep(adap->bus_recovery_info->scl_gpiod, val);
|
2012-02-28 05:56:31 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int get_sda_gpio_value(struct i2c_adapter *adap)
|
|
|
|
{
|
2017-11-01 20:40:24 -06:00
|
|
|
return gpiod_get_value_cansleep(adap->bus_recovery_info->sda_gpiod);
|
2012-02-28 05:56:31 -07:00
|
|
|
}
|
|
|
|
|
2018-01-09 06:58:56 -07:00
|
|
|
static void set_sda_gpio_value(struct i2c_adapter *adap, int val)
|
2012-02-28 05:56:31 -07:00
|
|
|
{
|
2018-01-09 06:58:56 -07:00
|
|
|
gpiod_set_value_cansleep(adap->bus_recovery_info->sda_gpiod, val);
|
2012-02-28 05:56:31 -07:00
|
|
|
}
|
|
|
|
|
2018-07-10 16:24:22 -06:00
|
|
|
static int i2c_generic_bus_free(struct i2c_adapter *adap)
|
|
|
|
{
|
|
|
|
struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
|
|
|
|
int ret = -EOPNOTSUPP;
|
|
|
|
|
|
|
|
if (bri->get_bus_free)
|
|
|
|
ret = bri->get_bus_free(adap);
|
|
|
|
else if (bri->get_sda)
|
|
|
|
ret = bri->get_sda(adap);
|
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return ret ? 0 : -EBUSY;
|
|
|
|
}
|
|
|
|
|
2012-02-28 05:56:31 -07:00
|
|
|
/*
|
|
|
|
* We are generating clock pulses. ndelay() determines durating of clk pulses.
|
|
|
|
* We will generate clock with rate 100 KHz and so duration of both clock levels
|
|
|
|
* is: delay in ns = (10^6 / 100) / 2
|
|
|
|
*/
|
|
|
|
#define RECOVERY_NDELAY 5000
|
|
|
|
#define RECOVERY_CLK_CNT 9
|
|
|
|
|
2017-11-01 20:40:30 -06:00
|
|
|
int i2c_generic_scl_recovery(struct i2c_adapter *adap)
|
2012-02-28 05:56:31 -07:00
|
|
|
{
|
|
|
|
struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
|
2019-05-01 12:07:40 -06:00
|
|
|
int i = 0, scl = 1, ret = 0;
|
2012-02-28 05:56:31 -07:00
|
|
|
|
|
|
|
if (bri->prepare_recovery)
|
2015-04-06 06:38:39 -06:00
|
|
|
bri->prepare_recovery(adap);
|
2012-02-28 05:56:31 -07:00
|
|
|
|
2018-07-17 03:00:05 -06:00
|
|
|
/*
|
|
|
|
* If we can set SDA, we will always create a STOP to ensure additional
|
|
|
|
* pulses will do no harm. This is achieved by letting SDA follow SCL
|
|
|
|
* half a cycle later. Check the 'incomplete_write_byte' fault injector
|
2019-12-15 09:39:05 -07:00
|
|
|
* for details. Note that we must honour tsu:sto, 4us, but lets use 5us
|
|
|
|
* here for simplicity.
|
2018-07-17 03:00:05 -06:00
|
|
|
*/
|
2018-07-10 16:27:22 -06:00
|
|
|
bri->set_scl(adap, scl);
|
2019-12-15 09:39:05 -07:00
|
|
|
ndelay(RECOVERY_NDELAY);
|
2018-01-09 06:58:57 -07:00
|
|
|
if (bri->set_sda)
|
2018-07-17 03:00:05 -06:00
|
|
|
bri->set_sda(adap, scl);
|
|
|
|
ndelay(RECOVERY_NDELAY / 2);
|
2015-07-08 08:35:06 -06:00
|
|
|
|
2012-02-28 05:56:31 -07:00
|
|
|
/*
|
|
|
|
* By this time SCL is high, as we need to give 9 falling-rising edges
|
|
|
|
*/
|
|
|
|
while (i++ < RECOVERY_CLK_CNT * 2) {
|
2018-07-10 16:27:22 -06:00
|
|
|
if (scl) {
|
2012-02-28 05:56:31 -07:00
|
|
|
/* SCL shouldn't be low here */
|
|
|
|
if (!bri->get_scl(adap)) {
|
|
|
|
dev_err(&adap->dev,
|
|
|
|
"SCL is stuck low, exit recovery\n");
|
|
|
|
ret = -EBUSY;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-10 16:27:22 -06:00
|
|
|
scl = !scl;
|
|
|
|
bri->set_scl(adap, scl);
|
2018-07-17 03:00:05 -06:00
|
|
|
/* Creating STOP again, see above */
|
2019-12-15 09:39:05 -07:00
|
|
|
if (scl) {
|
|
|
|
/* Honour minimum tsu:sto */
|
|
|
|
ndelay(RECOVERY_NDELAY);
|
|
|
|
} else {
|
|
|
|
/* Honour minimum tf and thd:dat */
|
|
|
|
ndelay(RECOVERY_NDELAY / 2);
|
|
|
|
}
|
2018-07-10 15:42:15 -06:00
|
|
|
if (bri->set_sda)
|
2018-07-10 16:27:22 -06:00
|
|
|
bri->set_sda(adap, scl);
|
2018-07-10 15:42:15 -06:00
|
|
|
ndelay(RECOVERY_NDELAY / 2);
|
2017-10-05 06:44:14 -06:00
|
|
|
|
2018-07-10 16:27:22 -06:00
|
|
|
if (scl) {
|
2018-07-10 16:24:22 -06:00
|
|
|
ret = i2c_generic_bus_free(adap);
|
2018-07-10 15:42:17 -06:00
|
|
|
if (ret == 0)
|
|
|
|
break;
|
|
|
|
}
|
2018-01-09 06:58:58 -07:00
|
|
|
}
|
|
|
|
|
2018-07-10 16:24:22 -06:00
|
|
|
/* If we can't check bus status, assume recovery worked */
|
|
|
|
if (ret == -EOPNOTSUPP)
|
|
|
|
ret = 0;
|
|
|
|
|
2012-02-28 05:56:31 -07:00
|
|
|
if (bri->unprepare_recovery)
|
2015-04-06 06:38:39 -06:00
|
|
|
bri->unprepare_recovery(adap);
|
2012-02-28 05:56:31 -07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2015-04-15 12:18:39 -06:00
|
|
|
EXPORT_SYMBOL_GPL(i2c_generic_scl_recovery);
|
2012-02-28 05:56:31 -07:00
|
|
|
|
|
|
|
int i2c_recover_bus(struct i2c_adapter *adap)
|
|
|
|
{
|
|
|
|
if (!adap->bus_recovery_info)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
dev_dbg(&adap->dev, "Trying i2c bus recovery\n");
|
|
|
|
return adap->bus_recovery_info->recover_bus(adap);
|
|
|
|
}
|
2015-04-15 12:18:39 -06:00
|
|
|
EXPORT_SYMBOL_GPL(i2c_recover_bus);
|
2012-02-28 05:56:31 -07:00
|
|
|
|
2016-07-08 22:34:59 -06:00
|
|
|
static void i2c_init_recovery(struct i2c_adapter *adap)
|
|
|
|
{
|
|
|
|
struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
|
|
|
|
char *err_str;
|
|
|
|
|
|
|
|
if (!bri)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!bri->recover_bus) {
|
|
|
|
err_str = "no recover_bus() found";
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
2017-11-01 20:40:24 -06:00
|
|
|
if (bri->scl_gpiod && bri->recover_bus == i2c_generic_scl_recovery) {
|
2016-07-08 22:34:59 -06:00
|
|
|
bri->get_scl = get_scl_gpio_value;
|
|
|
|
bri->set_scl = set_scl_gpio_value;
|
2018-01-09 06:58:56 -07:00
|
|
|
if (bri->sda_gpiod) {
|
2017-11-01 20:40:24 -06:00
|
|
|
bri->get_sda = get_sda_gpio_value;
|
2018-01-09 06:58:56 -07:00
|
|
|
/* FIXME: add proper flag instead of '0' once available */
|
|
|
|
if (gpiod_get_direction(bri->sda_gpiod) == 0)
|
|
|
|
bri->set_sda = set_sda_gpio_value;
|
|
|
|
}
|
2017-11-01 20:40:24 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-11-01 20:40:30 -06:00
|
|
|
if (bri->recover_bus == i2c_generic_scl_recovery) {
|
2016-07-08 22:34:59 -06:00
|
|
|
/* Generic SCL recovery */
|
|
|
|
if (!bri->set_scl || !bri->get_scl) {
|
|
|
|
err_str = "no {get|set}_scl() found";
|
|
|
|
goto err;
|
|
|
|
}
|
2018-07-10 15:42:16 -06:00
|
|
|
if (!bri->set_sda && !bri->get_sda) {
|
|
|
|
err_str = "either get_sda() or set_sda() needed";
|
|
|
|
goto err;
|
|
|
|
}
|
2016-07-08 22:34:59 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
err:
|
|
|
|
dev_err(&adap->dev, "Not using recovery: %s\n", err_str);
|
|
|
|
adap->bus_recovery_info = NULL;
|
|
|
|
}
|
|
|
|
|
2016-10-13 06:10:40 -06:00
|
|
|
static int i2c_smbus_host_notify_to_irq(const struct i2c_client *client)
|
|
|
|
{
|
|
|
|
struct i2c_adapter *adap = client->adapter;
|
|
|
|
unsigned int irq;
|
|
|
|
|
|
|
|
if (!adap->host_notify_domain)
|
|
|
|
return -ENXIO;
|
|
|
|
|
|
|
|
if (client->flags & I2C_CLIENT_TEN)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2018-10-19 02:59:57 -06:00
|
|
|
irq = irq_create_mapping(adap->host_notify_domain, client->addr);
|
2016-10-13 06:10:40 -06:00
|
|
|
|
|
|
|
return irq > 0 ? irq : -ENXIO;
|
|
|
|
}
|
|
|
|
|
2007-02-13 14:09:00 -07:00
|
|
|
static int i2c_device_probe(struct device *dev)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-09-18 14:45:45 -06:00
|
|
|
struct i2c_client *client = i2c_verify_client(dev);
|
|
|
|
struct i2c_driver *driver;
|
2008-03-12 07:15:00 -06:00
|
|
|
int status;
|
2007-05-01 15:26:30 -06:00
|
|
|
|
2009-09-18 14:45:45 -06:00
|
|
|
if (!client)
|
|
|
|
return 0;
|
|
|
|
|
2017-04-04 16:03:34 -06:00
|
|
|
driver = to_i2c_driver(dev->driver);
|
|
|
|
|
2019-06-27 03:24:11 -06:00
|
|
|
client->irq = client->init_irq;
|
|
|
|
|
2017-04-04 16:03:34 -06:00
|
|
|
if (!client->irq && !driver->disable_i2c_core_irq_mapping) {
|
2015-05-06 04:29:08 -06:00
|
|
|
int irq = -ENOENT;
|
|
|
|
|
2017-01-04 21:57:22 -07:00
|
|
|
if (client->flags & I2C_CLIENT_HOST_NOTIFY) {
|
|
|
|
dev_dbg(dev, "Using Host Notify IRQ\n");
|
2019-04-30 08:23:22 -06:00
|
|
|
/* Keep adapter active when Host Notify is required */
|
|
|
|
pm_runtime_get_sync(&client->adapter->dev);
|
2017-01-04 21:57:22 -07:00
|
|
|
irq = i2c_smbus_host_notify_to_irq(client);
|
|
|
|
} else if (dev->of_node) {
|
2015-08-18 00:52:51 -06:00
|
|
|
irq = of_irq_get_byname(dev->of_node, "irq");
|
|
|
|
if (irq == -EINVAL || irq == -ENODATA)
|
|
|
|
irq = of_irq_get(dev->of_node, 0);
|
|
|
|
} else if (ACPI_COMPANION(dev)) {
|
2019-06-27 03:24:09 -06:00
|
|
|
irq = i2c_acpi_get_irq(client);
|
2015-08-18 00:52:51 -06:00
|
|
|
}
|
2014-11-17 04:43:00 -07:00
|
|
|
if (irq == -EPROBE_DEFER)
|
2014-10-30 07:59:38 -06:00
|
|
|
return irq;
|
2017-01-04 21:57:22 -07:00
|
|
|
|
2014-11-17 04:43:00 -07:00
|
|
|
if (irq < 0)
|
|
|
|
irq = 0;
|
2014-10-30 07:59:38 -06:00
|
|
|
|
|
|
|
client->irq = irq;
|
|
|
|
}
|
|
|
|
|
2016-11-07 05:47:39 -07:00
|
|
|
/*
|
2017-08-09 03:21:28 -06:00
|
|
|
* An I2C ID table is not mandatory, if and only if, a suitable OF
|
|
|
|
* or ACPI ID table is supplied for the probing device.
|
2016-11-07 05:47:39 -07:00
|
|
|
*/
|
|
|
|
if (!driver->id_table &&
|
2017-07-17 08:13:28 -06:00
|
|
|
!i2c_acpi_match_device(dev->driver->acpi_match_table, client) &&
|
2016-11-07 05:47:39 -07:00
|
|
|
!i2c_of_match_device(dev->driver->of_match_table, client))
|
2007-05-01 15:26:30 -06:00
|
|
|
return -ENODEV;
|
2013-09-29 02:51:06 -06:00
|
|
|
|
2015-08-18 00:52:51 -06:00
|
|
|
if (client->flags & I2C_CLIENT_WAKE) {
|
2019-07-26 07:14:21 -06:00
|
|
|
int wakeirq;
|
2015-08-18 00:52:51 -06:00
|
|
|
|
2019-07-26 07:14:21 -06:00
|
|
|
wakeirq = of_irq_get_byname(dev->of_node, "wakeup");
|
|
|
|
if (wakeirq == -EPROBE_DEFER)
|
|
|
|
return wakeirq;
|
2015-08-18 00:52:51 -06:00
|
|
|
|
|
|
|
device_init_wakeup(&client->dev, true);
|
|
|
|
|
|
|
|
if (wakeirq > 0 && wakeirq != client->irq)
|
|
|
|
status = dev_pm_set_dedicated_wake_irq(dev, wakeirq);
|
|
|
|
else if (client->irq > 0)
|
2015-11-12 06:42:26 -07:00
|
|
|
status = dev_pm_set_wake_irq(dev, client->irq);
|
2015-08-18 00:52:51 -06:00
|
|
|
else
|
|
|
|
status = 0;
|
|
|
|
|
|
|
|
if (status)
|
2016-08-25 08:42:10 -06:00
|
|
|
dev_warn(&client->dev, "failed to set up wakeup irq\n");
|
2015-08-18 00:52:51 -06:00
|
|
|
}
|
|
|
|
|
2007-05-01 15:26:30 -06:00
|
|
|
dev_dbg(dev, "probe\n");
|
2008-04-29 15:11:39 -06:00
|
|
|
|
2014-06-18 09:29:32 -06:00
|
|
|
status = of_clk_set_defaults(dev->of_node, false);
|
|
|
|
if (status < 0)
|
2015-08-18 00:52:51 -06:00
|
|
|
goto err_clear_wakeup_irq;
|
2014-06-18 09:29:32 -06:00
|
|
|
|
2014-09-19 12:27:39 -06:00
|
|
|
status = dev_pm_domain_attach(&client->dev, true);
|
2018-04-26 02:53:07 -06:00
|
|
|
if (status)
|
2015-10-12 14:54:43 -06:00
|
|
|
goto err_clear_wakeup_irq;
|
|
|
|
|
2016-11-07 05:47:41 -07:00
|
|
|
/*
|
|
|
|
* When there are no more users of probe(),
|
|
|
|
* rename probe_new to probe.
|
|
|
|
*/
|
|
|
|
if (driver->probe_new)
|
|
|
|
status = driver->probe_new(client);
|
|
|
|
else if (driver->probe)
|
|
|
|
status = driver->probe(client,
|
|
|
|
i2c_match_id(driver->id_table, client));
|
|
|
|
else
|
|
|
|
status = -EINVAL;
|
|
|
|
|
2015-10-12 14:54:43 -06:00
|
|
|
if (status)
|
|
|
|
goto err_detach_pm_domain;
|
2014-01-21 09:48:34 -07:00
|
|
|
|
2015-08-18 00:52:51 -06:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_detach_pm_domain:
|
|
|
|
dev_pm_domain_detach(&client->dev, true);
|
|
|
|
err_clear_wakeup_irq:
|
|
|
|
dev_pm_clear_wake_irq(&client->dev);
|
|
|
|
device_init_wakeup(&client->dev, false);
|
2008-03-12 07:15:00 -06:00
|
|
|
return status;
|
2007-02-13 14:09:00 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-13 14:09:00 -07:00
|
|
|
static int i2c_device_remove(struct device *dev)
|
|
|
|
{
|
2009-09-18 14:45:45 -06:00
|
|
|
struct i2c_client *client = i2c_verify_client(dev);
|
2007-05-01 15:26:30 -06:00
|
|
|
struct i2c_driver *driver;
|
2014-01-21 09:48:34 -07:00
|
|
|
int status = 0;
|
2007-05-01 15:26:30 -06:00
|
|
|
|
2009-09-18 14:45:45 -06:00
|
|
|
if (!client || !dev->driver)
|
2007-05-01 15:26:30 -06:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
driver = to_i2c_driver(dev->driver);
|
|
|
|
if (driver->remove) {
|
|
|
|
dev_dbg(dev, "remove\n");
|
|
|
|
status = driver->remove(client);
|
|
|
|
}
|
2014-01-21 09:48:34 -07:00
|
|
|
|
2014-09-19 12:27:39 -06:00
|
|
|
dev_pm_domain_detach(&client->dev, true);
|
2015-08-18 00:52:51 -06:00
|
|
|
|
|
|
|
dev_pm_clear_wake_irq(&client->dev);
|
|
|
|
device_init_wakeup(&client->dev, false);
|
|
|
|
|
2019-06-27 03:24:11 -06:00
|
|
|
client->irq = 0;
|
2019-04-30 08:23:22 -06:00
|
|
|
if (client->flags & I2C_CLIENT_HOST_NOTIFY)
|
|
|
|
pm_runtime_put(&client->adapter->dev);
|
2018-10-19 02:59:58 -06:00
|
|
|
|
2007-05-01 15:26:30 -06:00
|
|
|
return status;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-02-13 14:09:00 -07:00
|
|
|
static void i2c_device_shutdown(struct device *dev)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-09-18 14:45:45 -06:00
|
|
|
struct i2c_client *client = i2c_verify_client(dev);
|
2007-02-13 14:09:00 -07:00
|
|
|
struct i2c_driver *driver;
|
|
|
|
|
2009-09-18 14:45:45 -06:00
|
|
|
if (!client || !dev->driver)
|
2007-02-13 14:09:00 -07:00
|
|
|
return;
|
|
|
|
driver = to_i2c_driver(dev->driver);
|
|
|
|
if (driver->shutdown)
|
2009-09-18 14:45:45 -06:00
|
|
|
driver->shutdown(client);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
static void i2c_client_dev_release(struct device *dev)
|
|
|
|
{
|
|
|
|
kfree(to_i2c_client(dev));
|
|
|
|
}
|
|
|
|
|
2009-03-28 14:34:46 -06:00
|
|
|
static ssize_t
|
2019-11-13 08:23:06 -07:00
|
|
|
name_show(struct device *dev, struct device_attribute *attr, char *buf)
|
2007-05-01 15:26:30 -06:00
|
|
|
{
|
2009-09-18 14:45:46 -06:00
|
|
|
return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
|
|
|
|
to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
|
2007-05-01 15:26:30 -06:00
|
|
|
}
|
2019-11-13 08:23:06 -07:00
|
|
|
static DEVICE_ATTR_RO(name);
|
2007-05-01 15:26:30 -06:00
|
|
|
|
2009-03-28 14:34:46 -06:00
|
|
|
static ssize_t
|
2019-11-13 08:23:06 -07:00
|
|
|
modalias_show(struct device *dev, struct device_attribute *attr, char *buf)
|
2007-05-01 15:26:30 -06:00
|
|
|
{
|
|
|
|
struct i2c_client *client = to_i2c_client(dev);
|
ACPI: fix module autoloading for ACPI enumerated devices
ACPI enumerated devices has ACPI style _HID and _CID strings,
all of these strings can be used for both driver loading and matching.
Currently, in Platform, I2C and SPI bus, the ACPI style driver matching
is supported by invoking acpi_driver_match_device() in bus .match() callback.
But, the module autoloading is still broken.
For example, there is any ACPI device with _HID "INTABCD" that is
enumerated to platform bus, and we have a driver that can probe it.
The driver exports its module_alias as "acpi:INTABCD" use the following code
static const struct acpi_device_id xxx_acpi_match[] = {
{ "INTABCD", 0 },
{ }
};
MODULE_DEVICE_TABLE(acpi, xxx_acpi_match);
But, unfortunately, the device' modalias is shown as "platform:INTABCD:00",
please refer to modalias_show() and platform_uevent() in
drivers/base/platform.c.
This results in that the driver will not be loaded automatically when the
device node is created, because their modalias do not match.
This also applies to I2C and SPI bus.
With this patch, the device' modalias will be shown as "acpi:INTABCD" as well.
Signed-off-by: Zhang Rui <rui.zhang@intel.com>
Acked-by: Mark Brown <broonie@linaro.org>
Acked-by: Wolfram Sang <wsa@the-dreams.de>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-01-14 01:46:37 -07:00
|
|
|
int len;
|
|
|
|
|
2017-12-03 14:40:50 -07:00
|
|
|
len = of_device_modalias(dev, buf, PAGE_SIZE);
|
|
|
|
if (len != -ENODEV)
|
|
|
|
return len;
|
|
|
|
|
ACPI: fix module autoloading for ACPI enumerated devices
ACPI enumerated devices has ACPI style _HID and _CID strings,
all of these strings can be used for both driver loading and matching.
Currently, in Platform, I2C and SPI bus, the ACPI style driver matching
is supported by invoking acpi_driver_match_device() in bus .match() callback.
But, the module autoloading is still broken.
For example, there is any ACPI device with _HID "INTABCD" that is
enumerated to platform bus, and we have a driver that can probe it.
The driver exports its module_alias as "acpi:INTABCD" use the following code
static const struct acpi_device_id xxx_acpi_match[] = {
{ "INTABCD", 0 },
{ }
};
MODULE_DEVICE_TABLE(acpi, xxx_acpi_match);
But, unfortunately, the device' modalias is shown as "platform:INTABCD:00",
please refer to modalias_show() and platform_uevent() in
drivers/base/platform.c.
This results in that the driver will not be loaded automatically when the
device node is created, because their modalias do not match.
This also applies to I2C and SPI bus.
With this patch, the device' modalias will be shown as "acpi:INTABCD" as well.
Signed-off-by: Zhang Rui <rui.zhang@intel.com>
Acked-by: Mark Brown <broonie@linaro.org>
Acked-by: Wolfram Sang <wsa@the-dreams.de>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-01-14 01:46:37 -07:00
|
|
|
len = acpi_device_modalias(dev, buf, PAGE_SIZE -1);
|
|
|
|
if (len != -ENODEV)
|
|
|
|
return len;
|
|
|
|
|
2008-05-18 12:49:41 -06:00
|
|
|
return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
|
2007-05-01 15:26:30 -06:00
|
|
|
}
|
2019-11-13 08:23:06 -07:00
|
|
|
static DEVICE_ATTR_RO(modalias);
|
2009-09-18 14:45:45 -06:00
|
|
|
|
|
|
|
static struct attribute *i2c_dev_attrs[] = {
|
|
|
|
&dev_attr_name.attr,
|
2007-05-01 15:26:30 -06:00
|
|
|
/* modalias helps coldplug: modprobe $(cat .../modalias) */
|
2009-09-18 14:45:45 -06:00
|
|
|
&dev_attr_modalias.attr,
|
|
|
|
NULL
|
|
|
|
};
|
2015-01-19 12:12:24 -07:00
|
|
|
ATTRIBUTE_GROUPS(i2c_dev);
|
2009-12-14 13:17:30 -07:00
|
|
|
|
2008-07-14 14:38:35 -06:00
|
|
|
struct bus_type i2c_bus_type = {
|
2007-02-13 14:09:00 -07:00
|
|
|
.name = "i2c",
|
|
|
|
.match = i2c_device_match,
|
|
|
|
.probe = i2c_device_probe,
|
|
|
|
.remove = i2c_device_remove,
|
|
|
|
.shutdown = i2c_device_shutdown,
|
2006-01-05 07:37:50 -07:00
|
|
|
};
|
2008-07-14 14:38:35 -06:00
|
|
|
EXPORT_SYMBOL_GPL(i2c_bus_type);
|
2006-01-05 07:37:50 -07:00
|
|
|
|
2017-03-04 12:29:34 -07:00
|
|
|
struct device_type i2c_client_type = {
|
2015-01-19 12:12:24 -07:00
|
|
|
.groups = i2c_dev_groups,
|
2009-09-18 14:45:45 -06:00
|
|
|
.uevent = i2c_device_uevent,
|
|
|
|
.release = i2c_client_dev_release,
|
|
|
|
};
|
2017-03-04 12:29:34 -07:00
|
|
|
EXPORT_SYMBOL_GPL(i2c_client_type);
|
2009-09-18 14:45:45 -06:00
|
|
|
|
2008-01-27 10:14:51 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* i2c_verify_client - return parameter as i2c_client, or NULL
|
|
|
|
* @dev: device, probably from some driver model iterator
|
|
|
|
*
|
|
|
|
* When traversing the driver model tree, perhaps using driver model
|
|
|
|
* iterators like @device_for_each_child(), you can't assume very much
|
|
|
|
* about the nodes you find. Use this function to avoid oopses caused
|
|
|
|
* by wrongly treating some non-I2C device as an i2c_client.
|
|
|
|
*/
|
|
|
|
struct i2c_client *i2c_verify_client(struct device *dev)
|
|
|
|
{
|
2009-09-18 14:45:45 -06:00
|
|
|
return (dev->type == &i2c_client_type)
|
2008-01-27 10:14:51 -07:00
|
|
|
? to_i2c_client(dev)
|
|
|
|
: NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(i2c_verify_client);
|
|
|
|
|
|
|
|
|
2015-05-18 13:09:12 -06:00
|
|
|
/* Return a unique address which takes the flags of the client into account */
|
|
|
|
static unsigned short i2c_encode_flags_to_addr(struct i2c_client *client)
|
|
|
|
{
|
|
|
|
unsigned short addr = client->addr;
|
|
|
|
|
|
|
|
/* For some client flags, add an arbitrary offset to avoid collisions */
|
|
|
|
if (client->flags & I2C_CLIENT_TEN)
|
|
|
|
addr |= I2C_ADDR_OFFSET_TEN_BIT;
|
|
|
|
|
|
|
|
if (client->flags & I2C_CLIENT_SLAVE)
|
|
|
|
addr |= I2C_ADDR_OFFSET_SLAVE;
|
|
|
|
|
|
|
|
return addr;
|
|
|
|
}
|
|
|
|
|
2010-06-03 03:33:52 -06:00
|
|
|
/* This is a permissive address validity check, I2C address map constraints
|
2011-03-30 19:57:33 -06:00
|
|
|
* are purposely not enforced, except for the general call address. */
|
2018-03-20 14:54:38 -06:00
|
|
|
static int i2c_check_addr_validity(unsigned int addr, unsigned short flags)
|
2010-06-03 03:33:52 -06:00
|
|
|
{
|
2015-07-17 04:50:06 -06:00
|
|
|
if (flags & I2C_CLIENT_TEN) {
|
2010-06-03 03:33:52 -06:00
|
|
|
/* 10-bit address, all values are valid */
|
2015-07-17 04:50:06 -06:00
|
|
|
if (addr > 0x3ff)
|
2010-06-03 03:33:52 -06:00
|
|
|
return -EINVAL;
|
|
|
|
} else {
|
|
|
|
/* 7-bit address, reject the general call address */
|
2015-07-17 04:50:06 -06:00
|
|
|
if (addr == 0x00 || addr > 0x7f)
|
2010-06-03 03:33:52 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-06-03 03:33:53 -06:00
|
|
|
/* And this is a strict address validity check, used when probing. If a
|
|
|
|
* device uses a reserved address, then it shouldn't be probed. 7-bit
|
|
|
|
* addressing is assumed, 10-bit address devices are rare and should be
|
|
|
|
* explicitly enumerated. */
|
2017-05-23 03:14:17 -06:00
|
|
|
int i2c_check_7bit_addr_validity_strict(unsigned short addr)
|
2010-06-03 03:33:53 -06:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Reserved addresses per I2C specification:
|
|
|
|
* 0x00 General call address / START byte
|
|
|
|
* 0x01 CBUS address
|
|
|
|
* 0x02 Reserved for different bus format
|
|
|
|
* 0x03 Reserved for future purposes
|
|
|
|
* 0x04-0x07 Hs-mode master code
|
|
|
|
* 0x78-0x7b 10-bit slave addressing
|
|
|
|
* 0x7c-0x7f Reserved for future purposes
|
|
|
|
*/
|
|
|
|
if (addr < 0x08 || addr > 0x77)
|
|
|
|
return -EINVAL;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-06-03 03:33:55 -06:00
|
|
|
static int __i2c_check_addr_busy(struct device *dev, void *addrp)
|
|
|
|
{
|
|
|
|
struct i2c_client *client = i2c_verify_client(dev);
|
|
|
|
int addr = *(int *)addrp;
|
|
|
|
|
2015-07-17 06:48:56 -06:00
|
|
|
if (client && i2c_encode_flags_to_addr(client) == addr)
|
2010-06-03 03:33:55 -06:00
|
|
|
return -EBUSY;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-08-11 10:21:02 -06:00
|
|
|
/* walk up mux tree */
|
|
|
|
static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
|
|
|
|
{
|
2010-10-24 10:16:57 -06:00
|
|
|
struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
|
2010-08-11 10:21:02 -06:00
|
|
|
int result;
|
|
|
|
|
|
|
|
result = device_for_each_child(&adapter->dev, &addr,
|
|
|
|
__i2c_check_addr_busy);
|
|
|
|
|
2010-10-24 10:16:57 -06:00
|
|
|
if (!result && parent)
|
|
|
|
result = i2c_check_mux_parents(parent, addr);
|
2010-08-11 10:21:02 -06:00
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* recurse down mux tree */
|
|
|
|
static int i2c_check_mux_children(struct device *dev, void *addrp)
|
|
|
|
{
|
|
|
|
int result;
|
|
|
|
|
|
|
|
if (dev->type == &i2c_adapter_type)
|
|
|
|
result = device_for_each_child(dev, addrp,
|
|
|
|
i2c_check_mux_children);
|
|
|
|
else
|
|
|
|
result = __i2c_check_addr_busy(dev, addrp);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2010-06-03 03:33:55 -06:00
|
|
|
static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
|
|
|
|
{
|
2010-10-24 10:16:57 -06:00
|
|
|
struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
|
2010-08-11 10:21:02 -06:00
|
|
|
int result = 0;
|
|
|
|
|
2010-10-24 10:16:57 -06:00
|
|
|
if (parent)
|
|
|
|
result = i2c_check_mux_parents(parent, addr);
|
2010-08-11 10:21:02 -06:00
|
|
|
|
|
|
|
if (!result)
|
|
|
|
result = device_for_each_child(&adapter->dev, &addr,
|
|
|
|
i2c_check_mux_children);
|
|
|
|
|
|
|
|
return result;
|
2010-06-03 03:33:55 -06:00
|
|
|
}
|
|
|
|
|
2010-08-11 10:20:58 -06:00
|
|
|
/**
|
i2c: allow adapter drivers to override the adapter locking
Add i2c_lock_bus() and i2c_unlock_bus(), which call the new lock_bus and
unlock_bus ops in the adapter. These funcs/ops take an additional flags
argument that indicates for what purpose the adapter is locked.
There are two flags, I2C_LOCK_ROOT_ADAPTER and I2C_LOCK_SEGMENT, but they
are both implemented the same. For now. Locking the root adapter means
that the whole bus is locked, locking the segment means that only the
current bus segment is locked (i.e. i2c traffic on the parent side of
a mux is still allowed even if the child side of the mux is locked).
Also support a trylock_bus op (but no function to call it, as it is not
expected to be needed outside of the i2c core).
Implement i2c_lock_adapter/i2c_unlock_adapter in terms of the new locking
scheme (i.e. lock with the I2C_LOCK_ROOT_ADAPTER flag).
Locking the root adapter and locking the segment is the same thing for
all root adapters (e.g. in the normal case of a simple topology with no
i2c muxes). The two locking variants are also the same for traditional
muxes (aka parent-locked muxes). These muxes traverse the tree, locking
each level as they go until they reach the root. This patch is preparatory
for a later patch in the series introducing mux-locked muxes, which behave
differently depending on the requested locking. Since all current users
are using i2c_lock_adapter, which is a wrapper for I2C_LOCK_ROOT_ADAPTER,
we only need to annotate the calls that will not need to lock the root
adapter for mux-locked muxes. I.e. the instances that needs to use
I2C_LOCK_SEGMENT instead of i2c_lock_adapter/I2C_LOCK_ROOT_ADAPTER. Those
instances are in the i2c_transfer and i2c_smbus_xfer functions, so that
mux-locked muxes can single out normal i2c accesses to its slave side
and adjust the locking for those accesses.
Signed-off-by: Peter Rosin <peda@axentia.se>
Signed-off-by: Wolfram Sang <wsa@the-dreams.de>
2016-05-04 14:15:27 -06:00
|
|
|
* i2c_adapter_lock_bus - Get exclusive access to an I2C bus segment
|
2010-08-11 10:20:58 -06:00
|
|
|
* @adapter: Target I2C bus segment
|
i2c: allow adapter drivers to override the adapter locking
Add i2c_lock_bus() and i2c_unlock_bus(), which call the new lock_bus and
unlock_bus ops in the adapter. These funcs/ops take an additional flags
argument that indicates for what purpose the adapter is locked.
There are two flags, I2C_LOCK_ROOT_ADAPTER and I2C_LOCK_SEGMENT, but they
are both implemented the same. For now. Locking the root adapter means
that the whole bus is locked, locking the segment means that only the
current bus segment is locked (i.e. i2c traffic on the parent side of
a mux is still allowed even if the child side of the mux is locked).
Also support a trylock_bus op (but no function to call it, as it is not
expected to be needed outside of the i2c core).
Implement i2c_lock_adapter/i2c_unlock_adapter in terms of the new locking
scheme (i.e. lock with the I2C_LOCK_ROOT_ADAPTER flag).
Locking the root adapter and locking the segment is the same thing for
all root adapters (e.g. in the normal case of a simple topology with no
i2c muxes). The two locking variants are also the same for traditional
muxes (aka parent-locked muxes). These muxes traverse the tree, locking
each level as they go until they reach the root. This patch is preparatory
for a later patch in the series introducing mux-locked muxes, which behave
differently depending on the requested locking. Since all current users
are using i2c_lock_adapter, which is a wrapper for I2C_LOCK_ROOT_ADAPTER,
we only need to annotate the calls that will not need to lock the root
adapter for mux-locked muxes. I.e. the instances that needs to use
I2C_LOCK_SEGMENT instead of i2c_lock_adapter/I2C_LOCK_ROOT_ADAPTER. Those
instances are in the i2c_transfer and i2c_smbus_xfer functions, so that
mux-locked muxes can single out normal i2c accesses to its slave side
and adjust the locking for those accesses.
Signed-off-by: Peter Rosin <peda@axentia.se>
Signed-off-by: Wolfram Sang <wsa@the-dreams.de>
2016-05-04 14:15:27 -06:00
|
|
|
* @flags: I2C_LOCK_ROOT_ADAPTER locks the root i2c adapter, I2C_LOCK_SEGMENT
|
|
|
|
* locks only this branch in the adapter tree
|
2010-08-11 10:20:58 -06:00
|
|
|
*/
|
i2c: allow adapter drivers to override the adapter locking
Add i2c_lock_bus() and i2c_unlock_bus(), which call the new lock_bus and
unlock_bus ops in the adapter. These funcs/ops take an additional flags
argument that indicates for what purpose the adapter is locked.
There are two flags, I2C_LOCK_ROOT_ADAPTER and I2C_LOCK_SEGMENT, but they
are both implemented the same. For now. Locking the root adapter means
that the whole bus is locked, locking the segment means that only the
current bus segment is locked (i.e. i2c traffic on the parent side of
a mux is still allowed even if the child side of the mux is locked).
Also support a trylock_bus op (but no function to call it, as it is not
expected to be needed outside of the i2c core).
Implement i2c_lock_adapter/i2c_unlock_adapter in terms of the new locking
scheme (i.e. lock with the I2C_LOCK_ROOT_ADAPTER flag).
Locking the root adapter and locking the segment is the same thing for
all root adapters (e.g. in the normal case of a simple topology with no
i2c muxes). The two locking variants are also the same for traditional
muxes (aka parent-locked muxes). These muxes traverse the tree, locking
each level as they go until they reach the root. This patch is preparatory
for a later patch in the series introducing mux-locked muxes, which behave
differently depending on the requested locking. Since all current users
are using i2c_lock_adapter, which is a wrapper for I2C_LOCK_ROOT_ADAPTER,
we only need to annotate the calls that will not need to lock the root
adapter for mux-locked muxes. I.e. the instances that needs to use
I2C_LOCK_SEGMENT instead of i2c_lock_adapter/I2C_LOCK_ROOT_ADAPTER. Those
instances are in the i2c_transfer and i2c_smbus_xfer functions, so that
mux-locked muxes can single out normal i2c accesses to its slave side
and adjust the locking for those accesses.
Signed-off-by: Peter Rosin <peda@axentia.se>
Signed-off-by: Wolfram Sang <wsa@the-dreams.de>
2016-05-04 14:15:27 -06:00
|
|
|
static void i2c_adapter_lock_bus(struct i2c_adapter *adapter,
|
|
|
|
unsigned int flags)
|
2010-08-11 10:20:58 -06:00
|
|
|
{
|
2018-07-20 02:39:14 -06:00
|
|
|
rt_mutex_lock_nested(&adapter->bus_lock, i2c_adapter_depth(adapter));
|
2010-08-11 10:20:58 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
i2c: allow adapter drivers to override the adapter locking
Add i2c_lock_bus() and i2c_unlock_bus(), which call the new lock_bus and
unlock_bus ops in the adapter. These funcs/ops take an additional flags
argument that indicates for what purpose the adapter is locked.
There are two flags, I2C_LOCK_ROOT_ADAPTER and I2C_LOCK_SEGMENT, but they
are both implemented the same. For now. Locking the root adapter means
that the whole bus is locked, locking the segment means that only the
current bus segment is locked (i.e. i2c traffic on the parent side of
a mux is still allowed even if the child side of the mux is locked).
Also support a trylock_bus op (but no function to call it, as it is not
expected to be needed outside of the i2c core).
Implement i2c_lock_adapter/i2c_unlock_adapter in terms of the new locking
scheme (i.e. lock with the I2C_LOCK_ROOT_ADAPTER flag).
Locking the root adapter and locking the segment is the same thing for
all root adapters (e.g. in the normal case of a simple topology with no
i2c muxes). The two locking variants are also the same for traditional
muxes (aka parent-locked muxes). These muxes traverse the tree, locking
each level as they go until they reach the root. This patch is preparatory
for a later patch in the series introducing mux-locked muxes, which behave
differently depending on the requested locking. Since all current users
are using i2c_lock_adapter, which is a wrapper for I2C_LOCK_ROOT_ADAPTER,
we only need to annotate the calls that will not need to lock the root
adapter for mux-locked muxes. I.e. the instances that needs to use
I2C_LOCK_SEGMENT instead of i2c_lock_adapter/I2C_LOCK_ROOT_ADAPTER. Those
instances are in the i2c_transfer and i2c_smbus_xfer functions, so that
mux-locked muxes can single out normal i2c accesses to its slave side
and adjust the locking for those accesses.
Signed-off-by: Peter Rosin <peda@axentia.se>
Signed-off-by: Wolfram Sang <wsa@the-dreams.de>
2016-05-04 14:15:27 -06:00
|
|
|
* i2c_adapter_trylock_bus - Try to get exclusive access to an I2C bus segment
|
2010-08-11 10:20:58 -06:00
|
|
|
* @adapter: Target I2C bus segment
|
i2c: allow adapter drivers to override the adapter locking
Add i2c_lock_bus() and i2c_unlock_bus(), which call the new lock_bus and
unlock_bus ops in the adapter. These funcs/ops take an additional flags
argument that indicates for what purpose the adapter is locked.
There are two flags, I2C_LOCK_ROOT_ADAPTER and I2C_LOCK_SEGMENT, but they
are both implemented the same. For now. Locking the root adapter means
that the whole bus is locked, locking the segment means that only the
current bus segment is locked (i.e. i2c traffic on the parent side of
a mux is still allowed even if the child side of the mux is locked).
Also support a trylock_bus op (but no function to call it, as it is not
expected to be needed outside of the i2c core).
Implement i2c_lock_adapter/i2c_unlock_adapter in terms of the new locking
scheme (i.e. lock with the I2C_LOCK_ROOT_ADAPTER flag).
Locking the root adapter and locking the segment is the same thing for
all root adapters (e.g. in the normal case of a simple topology with no
i2c muxes). The two locking variants are also the same for traditional
muxes (aka parent-locked muxes). These muxes traverse the tree, locking
each level as they go until they reach the root. This patch is preparatory
for a later patch in the series introducing mux-locked muxes, which behave
differently depending on the requested locking. Since all current users
are using i2c_lock_adapter, which is a wrapper for I2C_LOCK_ROOT_ADAPTER,
we only need to annotate the calls that will not need to lock the root
adapter for mux-locked muxes. I.e. the instances that needs to use
I2C_LOCK_SEGMENT instead of i2c_lock_adapter/I2C_LOCK_ROOT_ADAPTER. Those
instances are in the i2c_transfer and i2c_smbus_xfer functions, so that
mux-locked muxes can single out normal i2c accesses to its slave side
and adjust the locking for those accesses.
Signed-off-by: Peter Rosin <peda@axentia.se>
Signed-off-by: Wolfram Sang <wsa@the-dreams.de>
2016-05-04 14:15:27 -06:00
|
|
|
* @flags: I2C_LOCK_ROOT_ADAPTER trylocks the root i2c adapter, I2C_LOCK_SEGMENT
|
|
|
|
* trylocks only this branch in the adapter tree
|
2010-08-11 10:20:58 -06:00
|
|
|
*/
|
i2c: allow adapter drivers to override the adapter locking
Add i2c_lock_bus() and i2c_unlock_bus(), which call the new lock_bus and
unlock_bus ops in the adapter. These funcs/ops take an additional flags
argument that indicates for what purpose the adapter is locked.
There are two flags, I2C_LOCK_ROOT_ADAPTER and I2C_LOCK_SEGMENT, but they
are both implemented the same. For now. Locking the root adapter means
that the whole bus is locked, locking the segment means that only the
current bus segment is locked (i.e. i2c traffic on the parent side of
a mux is still allowed even if the child side of the mux is locked).
Also support a trylock_bus op (but no function to call it, as it is not
expected to be needed outside of the i2c core).
Implement i2c_lock_adapter/i2c_unlock_adapter in terms of the new locking
scheme (i.e. lock with the I2C_LOCK_ROOT_ADAPTER flag).
Locking the root adapter and locking the segment is the same thing for
all root adapters (e.g. in the normal case of a simple topology with no
i2c muxes). The two locking variants are also the same for traditional
muxes (aka parent-locked muxes). These muxes traverse the tree, locking
each level as they go until they reach the root. This patch is preparatory
for a later patch in the series introducing mux-locked muxes, which behave
differently depending on the requested locking. Since all current users
are using i2c_lock_adapter, which is a wrapper for I2C_LOCK_ROOT_ADAPTER,
we only need to annotate the calls that will not need to lock the root
adapter for mux-locked muxes. I.e. the instances that needs to use
I2C_LOCK_SEGMENT instead of i2c_lock_adapter/I2C_LOCK_ROOT_ADAPTER. Those
instances are in the i2c_transfer and i2c_smbus_xfer functions, so that
mux-locked muxes can single out normal i2c accesses to its slave side
and adjust the locking for those accesses.
Signed-off-by: Peter Rosin <peda@axentia.se>
Signed-off-by: Wolfram Sang <wsa@the-dreams.de>
2016-05-04 14:15:27 -06:00
|
|
|
static int i2c_adapter_trylock_bus(struct i2c_adapter *adapter,
|
|
|
|
unsigned int flags)
|
2010-08-11 10:20:58 -06:00
|
|
|
{
|
2016-05-04 14:15:28 -06:00
|
|
|
return rt_mutex_trylock(&adapter->bus_lock);
|
2010-08-11 10:20:58 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
i2c: allow adapter drivers to override the adapter locking
Add i2c_lock_bus() and i2c_unlock_bus(), which call the new lock_bus and
unlock_bus ops in the adapter. These funcs/ops take an additional flags
argument that indicates for what purpose the adapter is locked.
There are two flags, I2C_LOCK_ROOT_ADAPTER and I2C_LOCK_SEGMENT, but they
are both implemented the same. For now. Locking the root adapter means
that the whole bus is locked, locking the segment means that only the
current bus segment is locked (i.e. i2c traffic on the parent side of
a mux is still allowed even if the child side of the mux is locked).
Also support a trylock_bus op (but no function to call it, as it is not
expected to be needed outside of the i2c core).
Implement i2c_lock_adapter/i2c_unlock_adapter in terms of the new locking
scheme (i.e. lock with the I2C_LOCK_ROOT_ADAPTER flag).
Locking the root adapter and locking the segment is the same thing for
all root adapters (e.g. in the normal case of a simple topology with no
i2c muxes). The two locking variants are also the same for traditional
muxes (aka parent-locked muxes). These muxes traverse the tree, locking
each level as they go until they reach the root. This patch is preparatory
for a later patch in the series introducing mux-locked muxes, which behave
differently depending on the requested locking. Since all current users
are using i2c_lock_adapter, which is a wrapper for I2C_LOCK_ROOT_ADAPTER,
we only need to annotate the calls that will not need to lock the root
adapter for mux-locked muxes. I.e. the instances that needs to use
I2C_LOCK_SEGMENT instead of i2c_lock_adapter/I2C_LOCK_ROOT_ADAPTER. Those
instances are in the i2c_transfer and i2c_smbus_xfer functions, so that
mux-locked muxes can single out normal i2c accesses to its slave side
and adjust the locking for those accesses.
Signed-off-by: Peter Rosin <peda@axentia.se>
Signed-off-by: Wolfram Sang <wsa@the-dreams.de>
2016-05-04 14:15:27 -06:00
|
|
|
* i2c_adapter_unlock_bus - Release exclusive access to an I2C bus segment
|
2010-08-11 10:20:58 -06:00
|
|
|
* @adapter: Target I2C bus segment
|
i2c: allow adapter drivers to override the adapter locking
Add i2c_lock_bus() and i2c_unlock_bus(), which call the new lock_bus and
unlock_bus ops in the adapter. These funcs/ops take an additional flags
argument that indicates for what purpose the adapter is locked.
There are two flags, I2C_LOCK_ROOT_ADAPTER and I2C_LOCK_SEGMENT, but they
are both implemented the same. For now. Locking the root adapter means
that the whole bus is locked, locking the segment means that only the
current bus segment is locked (i.e. i2c traffic on the parent side of
a mux is still allowed even if the child side of the mux is locked).
Also support a trylock_bus op (but no function to call it, as it is not
expected to be needed outside of the i2c core).
Implement i2c_lock_adapter/i2c_unlock_adapter in terms of the new locking
scheme (i.e. lock with the I2C_LOCK_ROOT_ADAPTER flag).
Locking the root adapter and locking the segment is the same thing for
all root adapters (e.g. in the normal case of a simple topology with no
i2c muxes). The two locking variants are also the same for traditional
muxes (aka parent-locked muxes). These muxes traverse the tree, locking
each level as they go until they reach the root. This patch is preparatory
for a later patch in the series introducing mux-locked muxes, which behave
differently depending on the requested locking. Since all current users
are using i2c_lock_adapter, which is a wrapper for I2C_LOCK_ROOT_ADAPTER,
we only need to annotate the calls that will not need to lock the root
adapter for mux-locked muxes. I.e. the instances that needs to use
I2C_LOCK_SEGMENT instead of i2c_lock_adapter/I2C_LOCK_ROOT_ADAPTER. Those
instances are in the i2c_transfer and i2c_smbus_xfer functions, so that
mux-locked muxes can single out normal i2c accesses to its slave side
and adjust the locking for those accesses.
Signed-off-by: Peter Rosin <peda@axentia.se>
Signed-off-by: Wolfram Sang <wsa@the-dreams.de>
2016-05-04 14:15:27 -06:00
|
|
|
* @flags: I2C_LOCK_ROOT_ADAPTER unlocks the root i2c adapter, I2C_LOCK_SEGMENT
|
|
|
|
* unlocks only this branch in the adapter tree
|
2010-08-11 10:20:58 -06:00
|
|
|
*/
|
i2c: allow adapter drivers to override the adapter locking
Add i2c_lock_bus() and i2c_unlock_bus(), which call the new lock_bus and
unlock_bus ops in the adapter. These funcs/ops take an additional flags
argument that indicates for what purpose the adapter is locked.
There are two flags, I2C_LOCK_ROOT_ADAPTER and I2C_LOCK_SEGMENT, but they
are both implemented the same. For now. Locking the root adapter means
that the whole bus is locked, locking the segment means that only the
current bus segment is locked (i.e. i2c traffic on the parent side of
a mux is still allowed even if the child side of the mux is locked).
Also support a trylock_bus op (but no function to call it, as it is not
expected to be needed outside of the i2c core).
Implement i2c_lock_adapter/i2c_unlock_adapter in terms of the new locking
scheme (i.e. lock with the I2C_LOCK_ROOT_ADAPTER flag).
Locking the root adapter and locking the segment is the same thing for
all root adapters (e.g. in the normal case of a simple topology with no
i2c muxes). The two locking variants are also the same for traditional
muxes (aka parent-locked muxes). These muxes traverse the tree, locking
each level as they go until they reach the root. This patch is preparatory
for a later patch in the series introducing mux-locked muxes, which behave
differently depending on the requested locking. Since all current users
are using i2c_lock_adapter, which is a wrapper for I2C_LOCK_ROOT_ADAPTER,
we only need to annotate the calls that will not need to lock the root
adapter for mux-locked muxes. I.e. the instances that needs to use
I2C_LOCK_SEGMENT instead of i2c_lock_adapter/I2C_LOCK_ROOT_ADAPTER. Those
instances are in the i2c_transfer and i2c_smbus_xfer functions, so that
mux-locked muxes can single out normal i2c accesses to its slave side
and adjust the locking for those accesses.
Signed-off-by: Peter Rosin <peda@axentia.se>
Signed-off-by: Wolfram Sang <wsa@the-dreams.de>
2016-05-04 14:15:27 -06:00
|
|
|
static void i2c_adapter_unlock_bus(struct i2c_adapter *adapter,
|
|
|
|
unsigned int flags)
|
2010-08-11 10:20:58 -06:00
|
|
|
{
|
2016-05-04 14:15:28 -06:00
|
|
|
rt_mutex_unlock(&adapter->bus_lock);
|
2010-08-11 10:20:58 -06:00
|
|
|
}
|
|
|
|
|
2013-11-14 05:03:52 -07:00
|
|
|
static void i2c_dev_set_name(struct i2c_adapter *adap,
|
2017-10-11 03:41:19 -06:00
|
|
|
struct i2c_client *client,
|
|
|
|
struct i2c_board_info const *info)
|
2013-11-14 05:03:52 -07:00
|
|
|
{
|
|
|
|
struct acpi_device *adev = ACPI_COMPANION(&client->dev);
|
|
|
|
|
2017-10-11 03:41:19 -06:00
|
|
|
if (info && info->dev_name) {
|
|
|
|
dev_set_name(&client->dev, "i2c-%s", info->dev_name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-11-14 05:03:52 -07:00
|
|
|
if (adev) {
|
|
|
|
dev_set_name(&client->dev, "i2c-%s", acpi_dev_name(adev));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
|
2015-05-18 13:09:12 -06:00
|
|
|
i2c_encode_flags_to_addr(client));
|
2013-11-14 05:03:52 -07:00
|
|
|
}
|
|
|
|
|
2019-06-27 03:24:06 -06:00
|
|
|
int i2c_dev_irq_from_resources(const struct resource *resources,
|
|
|
|
unsigned int num_resources)
|
2017-03-01 12:45:51 -07:00
|
|
|
{
|
|
|
|
struct irq_data *irqd;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < num_resources; i++) {
|
|
|
|
const struct resource *r = &resources[i];
|
|
|
|
|
|
|
|
if (resource_type(r) != IORESOURCE_IRQ)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (r->flags & IORESOURCE_BITS) {
|
|
|
|
irqd = irq_get_irq_data(r->start);
|
|
|
|
if (!irqd)
|
|
|
|
break;
|
|
|
|
|
|
|
|
irqd_set_trigger_type(irqd, r->flags & IORESOURCE_BITS);
|
|
|
|
}
|
|
|
|
|
|
|
|
return r->start;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
/**
|
2019-05-16 15:13:08 -06:00
|
|
|
* i2c_new_client_device - instantiate an i2c device
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
* @adap: the adapter managing the device
|
|
|
|
* @info: describes one I2C device; bus_num is ignored
|
2007-07-12 06:12:28 -06:00
|
|
|
* Context: can sleep
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
*
|
2009-06-19 08:58:18 -06:00
|
|
|
* Create an i2c device. Binding is handled through driver model
|
|
|
|
* probe()/remove() methods. A driver may be bound to this device when we
|
|
|
|
* return from this function, or any later moment (e.g. maybe hotplugging will
|
|
|
|
* load the driver module). This call is not appropriate for use by mainboard
|
|
|
|
* initialization logic, which usually runs during an arch_initcall() long
|
|
|
|
* before any i2c_adapter could exist.
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
*
|
|
|
|
* This returns the new i2c client, which may be saved for later use with
|
2019-05-16 15:13:08 -06:00
|
|
|
* i2c_unregister_device(); or an ERR_PTR to describe the error.
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
*/
|
2019-06-24 11:04:02 -06:00
|
|
|
struct i2c_client *
|
2019-05-16 15:13:08 -06:00
|
|
|
i2c_new_client_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
{
|
|
|
|
struct i2c_client *client;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
client = kzalloc(sizeof *client, GFP_KERNEL);
|
|
|
|
if (!client)
|
2019-05-16 15:13:08 -06:00
|
|
|
return ERR_PTR(-ENOMEM);
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
|
|
|
|
client->adapter = adap;
|
|
|
|
|
|
|
|
client->dev.platform_data = info->platform_data;
|
2008-08-28 00:33:22 -06:00
|
|
|
client->flags = info->flags;
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
client->addr = info->addr;
|
2017-03-01 12:45:51 -07:00
|
|
|
|
2019-02-19 12:30:27 -07:00
|
|
|
client->init_irq = info->irq;
|
|
|
|
if (!client->init_irq)
|
|
|
|
client->init_irq = i2c_dev_irq_from_resources(info->resources,
|
2017-03-01 12:45:51 -07:00
|
|
|
info->num_resources);
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
|
|
|
|
strlcpy(client->name, info->type, sizeof(client->name));
|
|
|
|
|
2015-07-17 04:50:06 -06:00
|
|
|
status = i2c_check_addr_validity(client->addr, client->flags);
|
2010-06-03 03:33:52 -06:00
|
|
|
if (status) {
|
|
|
|
dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
|
|
|
|
client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
|
|
|
|
goto out_err_silent;
|
|
|
|
}
|
|
|
|
|
2009-06-19 08:58:18 -06:00
|
|
|
/* Check for address business */
|
2015-07-17 06:48:56 -06:00
|
|
|
status = i2c_check_addr_busy(adap, i2c_encode_flags_to_addr(client));
|
2009-06-19 08:58:18 -06:00
|
|
|
if (status)
|
|
|
|
goto out_err;
|
|
|
|
|
|
|
|
client->dev.parent = &client->adapter->dev;
|
|
|
|
client->dev.bus = &i2c_bus_type;
|
2009-09-18 14:45:45 -06:00
|
|
|
client->dev.type = &i2c_client_type;
|
2018-03-25 06:49:02 -06:00
|
|
|
client->dev.of_node = of_node_get(info->of_node);
|
2015-03-16 16:49:03 -06:00
|
|
|
client->dev.fwnode = info->fwnode;
|
2009-06-19 08:58:18 -06:00
|
|
|
|
2017-10-11 03:41:19 -06:00
|
|
|
i2c_dev_set_name(adap, client, info);
|
2017-02-02 18:41:28 -07:00
|
|
|
|
|
|
|
if (info->properties) {
|
|
|
|
status = device_add_properties(&client->dev, info->properties);
|
|
|
|
if (status) {
|
|
|
|
dev_err(&adap->dev,
|
|
|
|
"Failed to add properties to client %s: %d\n",
|
|
|
|
client->name, status);
|
2018-03-25 06:49:02 -06:00
|
|
|
goto out_err_put_of_node;
|
2017-02-02 18:41:28 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-19 08:58:18 -06:00
|
|
|
status = device_register(&client->dev);
|
|
|
|
if (status)
|
2017-02-02 18:41:28 -07:00
|
|
|
goto out_free_props;
|
2009-06-19 08:58:18 -06:00
|
|
|
|
|
|
|
dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
|
|
|
|
client->name, dev_name(&client->dev));
|
|
|
|
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
return client;
|
2009-06-19 08:58:18 -06:00
|
|
|
|
2017-02-02 18:41:28 -07:00
|
|
|
out_free_props:
|
|
|
|
if (info->properties)
|
|
|
|
device_remove_properties(&client->dev);
|
2018-03-25 06:49:02 -06:00
|
|
|
out_err_put_of_node:
|
|
|
|
of_node_put(info->of_node);
|
2009-06-19 08:58:18 -06:00
|
|
|
out_err:
|
2016-08-25 08:42:10 -06:00
|
|
|
dev_err(&adap->dev,
|
|
|
|
"Failed to register i2c client %s at 0x%02x (%d)\n",
|
|
|
|
client->name, client->addr, status);
|
2010-06-03 03:33:52 -06:00
|
|
|
out_err_silent:
|
2009-06-19 08:58:18 -06:00
|
|
|
kfree(client);
|
2019-05-16 15:13:08 -06:00
|
|
|
return ERR_PTR(status);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(i2c_new_client_device);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* i2c_new_device - instantiate an i2c device
|
|
|
|
* @adap: the adapter managing the device
|
|
|
|
* @info: describes one I2C device; bus_num is ignored
|
|
|
|
* Context: can sleep
|
|
|
|
*
|
|
|
|
* This deprecated function has the same functionality as
|
|
|
|
* @i2c_new_client_device, it just returns NULL instead of an ERR_PTR in case of
|
|
|
|
* an error for compatibility with current I2C API. It will be removed once all
|
|
|
|
* users are converted.
|
|
|
|
*
|
|
|
|
* This returns the new i2c client, which may be saved for later use with
|
|
|
|
* i2c_unregister_device(); or NULL to indicate an error.
|
|
|
|
*/
|
|
|
|
struct i2c_client *
|
|
|
|
i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
|
|
|
|
{
|
|
|
|
struct i2c_client *ret;
|
|
|
|
|
|
|
|
ret = i2c_new_client_device(adap, info);
|
|
|
|
return IS_ERR(ret) ? NULL : ret;
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(i2c_new_device);
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
2020-01-07 10:47:43 -07:00
|
|
|
* i2c_unregister_device - reverse effect of i2c_new_*_device()
|
|
|
|
* @client: value returned from i2c_new_*_device()
|
2007-07-12 06:12:28 -06:00
|
|
|
* Context: can sleep
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
*/
|
|
|
|
void i2c_unregister_device(struct i2c_client *client)
|
2007-05-01 15:26:30 -06:00
|
|
|
{
|
2019-08-19 14:48:25 -06:00
|
|
|
if (IS_ERR_OR_NULL(client))
|
2017-10-31 08:21:35 -06:00
|
|
|
return;
|
2017-11-27 00:06:55 -07:00
|
|
|
|
|
|
|
if (client->dev.of_node) {
|
2015-01-24 00:16:29 -07:00
|
|
|
of_node_clear_flag(client->dev.of_node, OF_POPULATED);
|
2017-11-27 00:06:55 -07:00
|
|
|
of_node_put(client->dev.of_node);
|
|
|
|
}
|
|
|
|
|
2016-07-08 10:13:10 -06:00
|
|
|
if (ACPI_COMPANION(&client->dev))
|
|
|
|
acpi_device_clear_enumerated(ACPI_COMPANION(&client->dev));
|
2007-05-01 15:26:30 -06:00
|
|
|
device_unregister(&client->dev);
|
|
|
|
}
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
EXPORT_SYMBOL_GPL(i2c_unregister_device);
|
2007-05-01 15:26:30 -06:00
|
|
|
|
|
|
|
|
2008-05-11 12:37:06 -06:00
|
|
|
static const struct i2c_device_id dummy_id[] = {
|
|
|
|
{ "dummy", 0 },
|
|
|
|
{ },
|
|
|
|
};
|
|
|
|
|
2008-04-29 15:11:39 -06:00
|
|
|
static int dummy_probe(struct i2c_client *client,
|
|
|
|
const struct i2c_device_id *id)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dummy_remove(struct i2c_client *client)
|
2008-01-27 10:14:52 -07:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct i2c_driver dummy_driver = {
|
|
|
|
.driver.name = "dummy",
|
2008-04-29 15:11:39 -06:00
|
|
|
.probe = dummy_probe,
|
|
|
|
.remove = dummy_remove,
|
2008-05-11 12:37:06 -06:00
|
|
|
.id_table = dummy_id,
|
2008-01-27 10:14:52 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
2019-05-16 15:13:08 -06:00
|
|
|
* i2c_new_dummy_device - return a new i2c device bound to a dummy driver
|
2008-01-27 10:14:52 -07:00
|
|
|
* @adapter: the adapter managing the device
|
|
|
|
* @address: seven bit address to be used
|
|
|
|
* Context: can sleep
|
|
|
|
*
|
|
|
|
* This returns an I2C client bound to the "dummy" driver, intended for use
|
|
|
|
* with devices that consume multiple addresses. Examples of such chips
|
|
|
|
* include various EEPROMS (like 24c04 and 24c08 models).
|
|
|
|
*
|
|
|
|
* These dummy devices have two main uses. First, most I2C and SMBus calls
|
|
|
|
* except i2c_transfer() need a client handle; the dummy will be that handle.
|
|
|
|
* And second, this prevents the specified address from being bound to a
|
|
|
|
* different driver.
|
|
|
|
*
|
|
|
|
* This returns the new i2c client, which should be saved for later use with
|
2019-05-16 15:13:08 -06:00
|
|
|
* i2c_unregister_device(); or an ERR_PTR to describe the error.
|
2008-01-27 10:14:52 -07:00
|
|
|
*/
|
2019-06-24 11:04:02 -06:00
|
|
|
struct i2c_client *i2c_new_dummy_device(struct i2c_adapter *adapter, u16 address)
|
2008-01-27 10:14:52 -07:00
|
|
|
{
|
|
|
|
struct i2c_board_info info = {
|
2008-05-11 12:37:06 -06:00
|
|
|
I2C_BOARD_INFO("dummy", address),
|
2008-01-27 10:14:52 -07:00
|
|
|
};
|
|
|
|
|
2019-05-16 15:13:08 -06:00
|
|
|
return i2c_new_client_device(adapter, &info);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(i2c_new_dummy_device);
|
|
|
|
|
2019-05-16 15:13:09 -06:00
|
|
|
struct i2c_dummy_devres {
|
|
|
|
struct i2c_client *client;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void devm_i2c_release_dummy(struct device *dev, void *res)
|
|
|
|
{
|
|
|
|
struct i2c_dummy_devres *this = res;
|
|
|
|
|
|
|
|
i2c_unregister_device(this->client);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* devm_i2c_new_dummy_device - return a new i2c device bound to a dummy driver
|
|
|
|
* @dev: device the managed resource is bound to
|
|
|
|
* @adapter: the adapter managing the device
|
|
|
|
* @address: seven bit address to be used
|
|
|
|
* Context: can sleep
|
|
|
|
*
|
|
|
|
* This is the device-managed version of @i2c_new_dummy_device. It returns the
|
|
|
|
* new i2c client or an ERR_PTR in case of an error.
|
|
|
|
*/
|
|
|
|
struct i2c_client *devm_i2c_new_dummy_device(struct device *dev,
|
|
|
|
struct i2c_adapter *adapter,
|
|
|
|
u16 address)
|
|
|
|
{
|
|
|
|
struct i2c_dummy_devres *dr;
|
|
|
|
struct i2c_client *client;
|
|
|
|
|
|
|
|
dr = devres_alloc(devm_i2c_release_dummy, sizeof(*dr), GFP_KERNEL);
|
|
|
|
if (!dr)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
client = i2c_new_dummy_device(adapter, address);
|
|
|
|
if (IS_ERR(client)) {
|
|
|
|
devres_free(dr);
|
|
|
|
} else {
|
|
|
|
dr->client = client;
|
|
|
|
devres_add(dev, dr);
|
|
|
|
}
|
|
|
|
|
|
|
|
return client;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(devm_i2c_new_dummy_device);
|
|
|
|
|
2016-01-31 08:33:00 -07:00
|
|
|
/**
|
2019-08-09 09:40:47 -06:00
|
|
|
* i2c_new_ancillary_device - Helper to get the instantiated secondary address
|
2016-01-31 08:33:00 -07:00
|
|
|
* and create the associated device
|
|
|
|
* @client: Handle to the primary client
|
|
|
|
* @name: Handle to specify which secondary address to get
|
|
|
|
* @default_addr: Used as a fallback if no secondary address was specified
|
|
|
|
* Context: can sleep
|
|
|
|
*
|
|
|
|
* I2C clients can be composed of multiple I2C slaves bound together in a single
|
|
|
|
* component. The I2C client driver then binds to the master I2C slave and needs
|
|
|
|
* to create I2C dummy clients to communicate with all the other slaves.
|
|
|
|
*
|
|
|
|
* This function creates and returns an I2C dummy client whose I2C address is
|
|
|
|
* retrieved from the platform firmware based on the given slave name. If no
|
|
|
|
* address is specified by the firmware default_addr is used.
|
|
|
|
*
|
|
|
|
* On DT-based platforms the address is retrieved from the "reg" property entry
|
|
|
|
* cell whose "reg-names" value matches the slave name.
|
|
|
|
*
|
|
|
|
* This returns the new i2c client, which should be saved for later use with
|
2019-08-09 09:40:47 -06:00
|
|
|
* i2c_unregister_device(); or an ERR_PTR to describe the error.
|
2016-01-31 08:33:00 -07:00
|
|
|
*/
|
2019-08-09 09:40:47 -06:00
|
|
|
struct i2c_client *i2c_new_ancillary_device(struct i2c_client *client,
|
2016-01-31 08:33:00 -07:00
|
|
|
const char *name,
|
|
|
|
u16 default_addr)
|
|
|
|
{
|
|
|
|
struct device_node *np = client->dev.of_node;
|
|
|
|
u32 addr = default_addr;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (np) {
|
|
|
|
i = of_property_match_string(np, "reg-names", name);
|
|
|
|
if (i >= 0)
|
|
|
|
of_property_read_u32_index(np, "reg", i, &addr);
|
|
|
|
}
|
|
|
|
|
|
|
|
dev_dbg(&client->adapter->dev, "Address for %s : 0x%x\n", name, addr);
|
2019-08-09 09:40:47 -06:00
|
|
|
return i2c_new_dummy_device(client->adapter, addr);
|
2016-01-31 08:33:00 -07:00
|
|
|
}
|
2019-08-09 09:40:47 -06:00
|
|
|
EXPORT_SYMBOL_GPL(i2c_new_ancillary_device);
|
2016-01-31 08:33:00 -07:00
|
|
|
|
2007-02-13 14:09:00 -07:00
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
|
2007-05-01 15:26:28 -06:00
|
|
|
/* I2C bus adapters -- one roots each I2C or SMBUS segment */
|
|
|
|
|
2007-10-13 15:56:30 -06:00
|
|
|
static void i2c_adapter_dev_release(struct device *dev)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-05-01 15:26:28 -06:00
|
|
|
struct i2c_adapter *adap = to_i2c_adapter(dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
complete(&adap->dev_released);
|
|
|
|
}
|
|
|
|
|
2016-09-16 10:02:42 -06:00
|
|
|
unsigned int i2c_adapter_depth(struct i2c_adapter *adapter)
|
2012-09-10 02:14:02 -06:00
|
|
|
{
|
|
|
|
unsigned int depth = 0;
|
|
|
|
|
|
|
|
while ((adapter = i2c_parent_is_i2c_adapter(adapter)))
|
|
|
|
depth++;
|
|
|
|
|
2016-09-16 10:02:44 -06:00
|
|
|
WARN_ONCE(depth >= MAX_LOCKDEP_SUBCLASSES,
|
|
|
|
"adapter depth exceeds lockdep subclass limit\n");
|
|
|
|
|
2012-09-10 02:14:02 -06:00
|
|
|
return depth;
|
|
|
|
}
|
2016-09-16 10:02:42 -06:00
|
|
|
EXPORT_SYMBOL_GPL(i2c_adapter_depth);
|
2012-09-10 02:14:02 -06:00
|
|
|
|
2009-06-19 08:58:20 -06:00
|
|
|
/*
|
|
|
|
* Let users instantiate I2C devices through sysfs. This can be used when
|
|
|
|
* platform initialization code doesn't contain the proper data for
|
|
|
|
* whatever reason. Also useful for drivers that do device detection and
|
|
|
|
* detection fails, either because the device uses an unexpected address,
|
|
|
|
* or this is a compatible device with different ID register values.
|
|
|
|
*
|
|
|
|
* Parameter checking may look overzealous, but we really don't want
|
|
|
|
* the user to provide incorrect parameters.
|
|
|
|
*/
|
|
|
|
static ssize_t
|
2019-11-13 08:23:06 -07:00
|
|
|
new_device_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
2009-06-19 08:58:20 -06:00
|
|
|
{
|
|
|
|
struct i2c_adapter *adap = to_i2c_adapter(dev);
|
|
|
|
struct i2c_board_info info;
|
|
|
|
struct i2c_client *client;
|
|
|
|
char *blank, end;
|
|
|
|
int res;
|
|
|
|
|
|
|
|
memset(&info, 0, sizeof(struct i2c_board_info));
|
|
|
|
|
|
|
|
blank = strchr(buf, ' ');
|
|
|
|
if (!blank) {
|
|
|
|
dev_err(dev, "%s: Missing parameters\n", "new_device");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
if (blank - buf > I2C_NAME_SIZE - 1) {
|
|
|
|
dev_err(dev, "%s: Invalid device name\n", "new_device");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
memcpy(info.type, buf, blank - buf);
|
|
|
|
|
|
|
|
/* Parse remaining parameters, reject extra parameters */
|
|
|
|
res = sscanf(++blank, "%hi%c", &info.addr, &end);
|
|
|
|
if (res < 1) {
|
|
|
|
dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
if (res > 1 && end != '\n') {
|
|
|
|
dev_err(dev, "%s: Extra parameters\n", "new_device");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2015-07-27 06:03:38 -06:00
|
|
|
if ((info.addr & I2C_ADDR_OFFSET_TEN_BIT) == I2C_ADDR_OFFSET_TEN_BIT) {
|
|
|
|
info.addr &= ~I2C_ADDR_OFFSET_TEN_BIT;
|
|
|
|
info.flags |= I2C_CLIENT_TEN;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (info.addr & I2C_ADDR_OFFSET_SLAVE) {
|
|
|
|
info.addr &= ~I2C_ADDR_OFFSET_SLAVE;
|
|
|
|
info.flags |= I2C_CLIENT_SLAVE;
|
|
|
|
}
|
|
|
|
|
2019-05-16 15:13:08 -06:00
|
|
|
client = i2c_new_client_device(adap, &info);
|
|
|
|
if (IS_ERR(client))
|
|
|
|
return PTR_ERR(client);
|
2009-06-19 08:58:20 -06:00
|
|
|
|
|
|
|
/* Keep track of the added device */
|
2010-08-11 10:21:01 -06:00
|
|
|
mutex_lock(&adap->userspace_clients_lock);
|
2010-05-04 03:09:28 -06:00
|
|
|
list_add_tail(&client->detected, &adap->userspace_clients);
|
2010-08-11 10:21:01 -06:00
|
|
|
mutex_unlock(&adap->userspace_clients_lock);
|
2009-06-19 08:58:20 -06:00
|
|
|
dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
|
|
|
|
info.type, info.addr);
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
2019-11-13 08:23:06 -07:00
|
|
|
static DEVICE_ATTR_WO(new_device);
|
2009-06-19 08:58:20 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* And of course let the users delete the devices they instantiated, if
|
|
|
|
* they got it wrong. This interface can only be used to delete devices
|
|
|
|
* instantiated by i2c_sysfs_new_device above. This guarantees that we
|
|
|
|
* don't delete devices to which some kernel code still has references.
|
|
|
|
*
|
|
|
|
* Parameter checking may look overzealous, but we really don't want
|
|
|
|
* the user to delete the wrong device.
|
|
|
|
*/
|
|
|
|
static ssize_t
|
2019-11-13 08:23:06 -07:00
|
|
|
delete_device_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
2009-06-19 08:58:20 -06:00
|
|
|
{
|
|
|
|
struct i2c_adapter *adap = to_i2c_adapter(dev);
|
|
|
|
struct i2c_client *client, *next;
|
|
|
|
unsigned short addr;
|
|
|
|
char end;
|
|
|
|
int res;
|
|
|
|
|
|
|
|
/* Parse parameters, reject extra parameters */
|
|
|
|
res = sscanf(buf, "%hi%c", &addr, &end);
|
|
|
|
if (res < 1) {
|
|
|
|
dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
if (res > 1 && end != '\n') {
|
|
|
|
dev_err(dev, "%s: Extra parameters\n", "delete_device");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Make sure the device was added through sysfs */
|
|
|
|
res = -ENOENT;
|
2012-09-10 02:14:02 -06:00
|
|
|
mutex_lock_nested(&adap->userspace_clients_lock,
|
|
|
|
i2c_adapter_depth(adap));
|
2010-05-04 03:09:28 -06:00
|
|
|
list_for_each_entry_safe(client, next, &adap->userspace_clients,
|
|
|
|
detected) {
|
2015-07-27 06:03:38 -06:00
|
|
|
if (i2c_encode_flags_to_addr(client) == addr) {
|
2009-06-19 08:58:20 -06:00
|
|
|
dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
|
|
|
|
"delete_device", client->name, client->addr);
|
|
|
|
|
|
|
|
list_del(&client->detected);
|
|
|
|
i2c_unregister_device(client);
|
|
|
|
res = count;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2010-08-11 10:21:01 -06:00
|
|
|
mutex_unlock(&adap->userspace_clients_lock);
|
2009-06-19 08:58:20 -06:00
|
|
|
|
|
|
|
if (res < 0)
|
|
|
|
dev_err(dev, "%s: Can't find device in list\n",
|
|
|
|
"delete_device");
|
|
|
|
return res;
|
|
|
|
}
|
2013-05-17 06:56:35 -06:00
|
|
|
static DEVICE_ATTR_IGNORE_LOCKDEP(delete_device, S_IWUSR, NULL,
|
2019-11-13 08:23:06 -07:00
|
|
|
delete_device_store);
|
2009-09-18 14:45:46 -06:00
|
|
|
|
|
|
|
static struct attribute *i2c_adapter_attrs[] = {
|
|
|
|
&dev_attr_name.attr,
|
|
|
|
&dev_attr_new_device.attr,
|
|
|
|
&dev_attr_delete_device.attr,
|
|
|
|
NULL
|
|
|
|
};
|
2015-01-19 12:12:24 -07:00
|
|
|
ATTRIBUTE_GROUPS(i2c_adapter);
|
2007-01-04 05:07:04 -07:00
|
|
|
|
2010-08-11 10:21:02 -06:00
|
|
|
struct device_type i2c_adapter_type = {
|
2015-01-19 12:12:24 -07:00
|
|
|
.groups = i2c_adapter_groups,
|
2009-09-18 14:45:46 -06:00
|
|
|
.release = i2c_adapter_dev_release,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
2010-08-11 10:21:02 -06:00
|
|
|
EXPORT_SYMBOL_GPL(i2c_adapter_type);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-04-17 12:43:33 -06:00
|
|
|
/**
|
|
|
|
* i2c_verify_adapter - return parameter as i2c_adapter or NULL
|
|
|
|
* @dev: device, probably from some driver model iterator
|
|
|
|
*
|
|
|
|
* When traversing the driver model tree, perhaps using driver model
|
|
|
|
* iterators like @device_for_each_child(), you can't assume very much
|
|
|
|
* about the nodes you find. Use this function to avoid oopses caused
|
|
|
|
* by wrongly treating some non-I2C device as an i2c_adapter.
|
|
|
|
*/
|
|
|
|
struct i2c_adapter *i2c_verify_adapter(struct device *dev)
|
|
|
|
{
|
|
|
|
return (dev->type == &i2c_adapter_type)
|
|
|
|
? to_i2c_adapter(dev)
|
|
|
|
: NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(i2c_verify_adapter);
|
|
|
|
|
2009-09-18 14:45:46 -06:00
|
|
|
#ifdef CONFIG_I2C_COMPAT
|
|
|
|
static struct class_compat *i2c_adapter_compat_class;
|
|
|
|
#endif
|
|
|
|
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
|
|
|
|
{
|
|
|
|
struct i2c_devinfo *devinfo;
|
|
|
|
|
2009-06-19 08:58:20 -06:00
|
|
|
down_read(&__i2c_board_lock);
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
list_for_each_entry(devinfo, &__i2c_board_list, list) {
|
2020-01-07 10:47:43 -07:00
|
|
|
if (devinfo->busnum == adapter->nr &&
|
|
|
|
IS_ERR(i2c_new_client_device(adapter, &devinfo->board_info)))
|
2009-03-28 14:34:46 -06:00
|
|
|
dev_err(&adapter->dev,
|
|
|
|
"Can't create device at 0x%02x\n",
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
devinfo->board_info.addr);
|
|
|
|
}
|
2009-06-19 08:58:20 -06:00
|
|
|
up_read(&__i2c_board_lock);
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
}
|
|
|
|
|
2009-12-06 09:06:27 -07:00
|
|
|
static int i2c_do_add_adapter(struct i2c_driver *driver,
|
|
|
|
struct i2c_adapter *adap)
|
2008-01-27 10:14:49 -07:00
|
|
|
{
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-14 14:38:36 -06:00
|
|
|
/* Detect supported devices on that bus, and instantiate them */
|
|
|
|
i2c_detect(adap, driver);
|
|
|
|
|
2008-01-27 10:14:49 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-12-06 09:06:27 -07:00
|
|
|
static int __process_new_adapter(struct device_driver *d, void *data)
|
|
|
|
{
|
|
|
|
return i2c_do_add_adapter(to_i2c_driver(d), data);
|
|
|
|
}
|
|
|
|
|
2016-08-25 15:07:01 -06:00
|
|
|
static const struct i2c_lock_operations i2c_adapter_lock_ops = {
|
|
|
|
.lock_bus = i2c_adapter_lock_bus,
|
|
|
|
.trylock_bus = i2c_adapter_trylock_bus,
|
|
|
|
.unlock_bus = i2c_adapter_unlock_bus,
|
|
|
|
};
|
|
|
|
|
2016-10-13 06:10:40 -06:00
|
|
|
static void i2c_host_notify_irq_teardown(struct i2c_adapter *adap)
|
|
|
|
{
|
|
|
|
struct irq_domain *domain = adap->host_notify_domain;
|
|
|
|
irq_hw_number_t hwirq;
|
|
|
|
|
|
|
|
if (!domain)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (hwirq = 0 ; hwirq < I2C_ADDR_7BITS_COUNT ; hwirq++)
|
|
|
|
irq_dispose_mapping(irq_find_mapping(domain, hwirq));
|
|
|
|
|
|
|
|
irq_domain_remove(domain);
|
|
|
|
adap->host_notify_domain = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int i2c_host_notify_irq_map(struct irq_domain *h,
|
|
|
|
unsigned int virq,
|
|
|
|
irq_hw_number_t hw_irq_num)
|
|
|
|
{
|
|
|
|
irq_set_chip_and_handler(virq, &dummy_irq_chip, handle_simple_irq);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct irq_domain_ops i2c_host_notify_irq_ops = {
|
|
|
|
.map = i2c_host_notify_irq_map,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int i2c_setup_host_notify_irq_domain(struct i2c_adapter *adap)
|
|
|
|
{
|
|
|
|
struct irq_domain *domain;
|
|
|
|
|
|
|
|
if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_HOST_NOTIFY))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
domain = irq_domain_create_linear(adap->dev.fwnode,
|
|
|
|
I2C_ADDR_7BITS_COUNT,
|
|
|
|
&i2c_host_notify_irq_ops, adap);
|
|
|
|
if (!domain)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
adap->host_notify_domain = domain;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* i2c_handle_smbus_host_notify - Forward a Host Notify event to the correct
|
|
|
|
* I2C client.
|
|
|
|
* @adap: the adapter
|
|
|
|
* @addr: the I2C address of the notifying device
|
|
|
|
* Context: can't sleep
|
|
|
|
*
|
|
|
|
* Helper function to be called from an I2C bus driver's interrupt
|
|
|
|
* handler. It will schedule the Host Notify IRQ.
|
|
|
|
*/
|
|
|
|
int i2c_handle_smbus_host_notify(struct i2c_adapter *adap, unsigned short addr)
|
|
|
|
{
|
|
|
|
int irq;
|
|
|
|
|
|
|
|
if (!adap)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
irq = irq_find_mapping(adap->host_notify_domain, addr);
|
|
|
|
if (irq <= 0)
|
|
|
|
return -ENXIO;
|
|
|
|
|
|
|
|
generic_handle_irq(irq);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(i2c_handle_smbus_host_notify);
|
|
|
|
|
2007-05-01 15:26:31 -06:00
|
|
|
static int i2c_register_adapter(struct i2c_adapter *adap)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2016-07-08 22:34:58 -06:00
|
|
|
int res = -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-10-14 09:30:05 -06:00
|
|
|
/* Can't register until after driver model init */
|
2016-03-07 04:49:17 -07:00
|
|
|
if (WARN_ON(!is_registered)) {
|
2009-06-19 08:58:19 -06:00
|
|
|
res = -EAGAIN;
|
|
|
|
goto out_list;
|
|
|
|
}
|
2008-10-14 09:30:05 -06:00
|
|
|
|
2010-11-15 14:40:38 -07:00
|
|
|
/* Sanity checks */
|
2016-07-08 22:35:00 -06:00
|
|
|
if (WARN(!adap->name[0], "i2c adapter has no name"))
|
2016-07-08 22:34:58 -06:00
|
|
|
goto out_list;
|
2016-07-08 22:35:00 -06:00
|
|
|
|
|
|
|
if (!adap->algo) {
|
2016-07-08 22:35:04 -06:00
|
|
|
pr_err("adapter '%s': no algo supplied!\n", adap->name);
|
2016-07-08 22:34:58 -06:00
|
|
|
goto out_list;
|
2010-11-15 14:40:38 -07:00
|
|
|
}
|
|
|
|
|
2016-08-25 15:07:01 -06:00
|
|
|
if (!adap->lock_ops)
|
|
|
|
adap->lock_ops = &i2c_adapter_lock_ops;
|
i2c: allow adapter drivers to override the adapter locking
Add i2c_lock_bus() and i2c_unlock_bus(), which call the new lock_bus and
unlock_bus ops in the adapter. These funcs/ops take an additional flags
argument that indicates for what purpose the adapter is locked.
There are two flags, I2C_LOCK_ROOT_ADAPTER and I2C_LOCK_SEGMENT, but they
are both implemented the same. For now. Locking the root adapter means
that the whole bus is locked, locking the segment means that only the
current bus segment is locked (i.e. i2c traffic on the parent side of
a mux is still allowed even if the child side of the mux is locked).
Also support a trylock_bus op (but no function to call it, as it is not
expected to be needed outside of the i2c core).
Implement i2c_lock_adapter/i2c_unlock_adapter in terms of the new locking
scheme (i.e. lock with the I2C_LOCK_ROOT_ADAPTER flag).
Locking the root adapter and locking the segment is the same thing for
all root adapters (e.g. in the normal case of a simple topology with no
i2c muxes). The two locking variants are also the same for traditional
muxes (aka parent-locked muxes). These muxes traverse the tree, locking
each level as they go until they reach the root. This patch is preparatory
for a later patch in the series introducing mux-locked muxes, which behave
differently depending on the requested locking. Since all current users
are using i2c_lock_adapter, which is a wrapper for I2C_LOCK_ROOT_ADAPTER,
we only need to annotate the calls that will not need to lock the root
adapter for mux-locked muxes. I.e. the instances that needs to use
I2C_LOCK_SEGMENT instead of i2c_lock_adapter/I2C_LOCK_ROOT_ADAPTER. Those
instances are in the i2c_transfer and i2c_smbus_xfer functions, so that
mux-locked muxes can single out normal i2c accesses to its slave side
and adjust the locking for those accesses.
Signed-off-by: Peter Rosin <peda@axentia.se>
Signed-off-by: Wolfram Sang <wsa@the-dreams.de>
2016-05-04 14:15:27 -06:00
|
|
|
|
2018-12-19 09:48:17 -07:00
|
|
|
adap->locked_flags = 0;
|
2009-12-06 09:06:22 -07:00
|
|
|
rt_mutex_init(&adap->bus_lock);
|
i2c: mux: relax locking of the top i2c adapter during mux-locked muxing
With a i2c topology like the following
GPIO ---| ------ BAT1
| v /
I2C -----+----------+---- MUX
| \
EEPROM ------ BAT2
there is a locking problem with the GPIO controller since it is a client
on the same i2c bus that it muxes. Transfers to the mux clients (e.g. BAT1)
will lock the whole i2c bus prior to attempting to switch the mux to the
correct i2c segment. In the above case, the GPIO device is an I/O expander
with an i2c interface, and since the GPIO subsystem knows nothing (and
rightfully so) about the lockless needs of the i2c mux code, this results
in a deadlock when the GPIO driver issues i2c transfers to modify the
mux.
So, observing that while it is needed to have the i2c bus locked during the
actual MUX update in order to avoid random garbage on the slave side, it
is not strictly a must to have it locked over the whole sequence of a full
select-transfer-deselect mux client operation. The mux itself needs to be
locked, so transfers to clients behind the mux are serialized, and the mux
needs to be stable during all i2c traffic (otherwise individual mux slave
segments might see garbage, or worse).
Introduce this new locking concept as "mux-locked" muxes, and call the
pre-existing mux locking scheme "parent-locked".
Modify the i2c mux locking so that muxes that are "mux-locked" locks only
the muxes on the parent adapter instead of the whole i2c bus when there is
a transfer to the slave side of the mux. This lock serializes transfers to
the slave side of the muxes on the parent adapter.
Add code to i2c-mux-gpio and i2c-mux-pinctrl that checks if all involved
gpio/pinctrl devices have a parent that is an i2c adapter in the same
adapter tree that is muxed, and request a "mux-locked mux" if that is the
case.
Modify the select-transfer-deselect code for "mux-locked" muxes so
that each of the select-transfer-deselect ops locks the mux parent
adapter individually.
Signed-off-by: Peter Rosin <peda@axentia.se>
Signed-off-by: Wolfram Sang <wsa@the-dreams.de>
2016-05-04 14:15:29 -06:00
|
|
|
rt_mutex_init(&adap->mux_lock);
|
2010-08-11 10:21:01 -06:00
|
|
|
mutex_init(&adap->userspace_clients_lock);
|
2010-05-04 03:09:28 -06:00
|
|
|
INIT_LIST_HEAD(&adap->userspace_clients);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-03-28 14:34:43 -06:00
|
|
|
/* Set default timeout to 1 second if not already set */
|
|
|
|
if (adap->timeout == 0)
|
|
|
|
adap->timeout = HZ;
|
|
|
|
|
2016-10-13 06:10:40 -06:00
|
|
|
/* register soft irqs for Host Notify */
|
|
|
|
res = i2c_setup_host_notify_irq_domain(adap);
|
|
|
|
if (res) {
|
|
|
|
pr_err("adapter '%s': can't create Host Notify IRQs (%d)\n",
|
|
|
|
adap->name, res);
|
|
|
|
goto out_list;
|
|
|
|
}
|
|
|
|
|
i2c: Replace bus_id with dev_name(), dev_set_name()
This patch is part of a larger patch series which will remove
the "char bus_id[20]" name string from struct device. The device
name is managed in the kobject anyway, and without any size
limitation, and just needlessly copied into "struct device".
To set and read the device name dev_name(dev) and dev_set_name(dev)
must be used. If your code uses static kobjects, which it shouldn't
do, "const char *init_name" can be used to statically provide the
name the registered device should have. At registration time, the
init_name field is cleared, to enforce the use of dev_name(dev) to
access the device name at a later time.
We need to get rid of all occurrences of bus_id in the entire tree
to be able to enable the new interface. Please apply this patch,
and possibly convert any remaining remaining occurrences of bus_id.
We want to submit a patch to -next, which will remove bus_id from
"struct device", to find the remaining pieces to convert, and finally
switch over to the new api, which will remove the 20 bytes array
and does no longer have a size limitation.
Acked-by: Greg Kroah-Hartman <gregkh@suse.de>
Signed-off-by: Kay Sievers <kay.sievers@vrfy.org>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2009-01-07 06:29:16 -07:00
|
|
|
dev_set_name(&adap->dev, "i2c-%d", adap->nr);
|
2009-09-18 14:45:46 -06:00
|
|
|
adap->dev.bus = &i2c_bus_type;
|
|
|
|
adap->dev.type = &i2c_adapter_type;
|
2006-08-15 10:26:30 -06:00
|
|
|
res = device_register(&adap->dev);
|
2016-07-08 22:35:00 -06:00
|
|
|
if (res) {
|
2016-07-08 22:35:04 -06:00
|
|
|
pr_err("adapter '%s': can't register device (%d)\n", adap->name, res);
|
2006-08-15 10:26:30 -06:00
|
|
|
goto out_list;
|
2016-07-08 22:35:00 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2017-08-24 03:31:04 -06:00
|
|
|
res = of_i2c_setup_smbus_alert(adap);
|
|
|
|
if (res)
|
|
|
|
goto out_reg;
|
|
|
|
|
2005-07-31 11:02:53 -06:00
|
|
|
dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
|
|
|
|
|
2015-04-16 06:05:19 -06:00
|
|
|
pm_runtime_no_callbacks(&adap->dev);
|
i2c: let I2C masters ignore their children for PM
When using a certain I2C device with runtime PM enabled on
a certain I2C bus adaper the following happens:
struct amba_device *foo
\
struct i2c_adapter *bar
\
struct i2c_client *baz
The AMBA device foo has its device PM struct set to ignore
children with pm_suspend_ignore_children(&foo->dev, true).
This makes runtime PM work just fine locally in the driver:
the fact that devices on the bus are suspended or resumed
individually does not affect its operation, and the hardware
does not power up unless transferring messages.
However this child ignorance property is not inherited into
the struct i2c_adapter *bar.
On system suspend things will work fine.
On system resume the following annoying phenomenon occurs:
- In the pm_runtime_force_resume() path of
struct i2c_client *baz, pm_runtime_set_active(&baz->dev); is
eventually called.
- This becomes __pm_runtime_set_status(&baz->dev, RPM_ACTIVE);
- __pm_runtime_set_status() detects that RPM state is changed,
and checks whether the parent is:
not active (RPM_ACTIVE) and not ignoring its children
If this happens it concludes something is wrong, because
a parent that is not ignoring its children must be active
before any children activate.
- Since the struct i2c_adapter *bar does not ignore
its children, the PM core thinks that it must indeed go
online before its children, the check bails out with
-EBUSY, i.e. the i2c_client *baz thinks it can't work
because it's parent is not online, and it respects its
parent.
- In the driver the .resume() callback returns -EBUSY from
the runtime_force_resume() call as per above. This leaves
the device in a suspended state, leading to bad behaviour
later when the device is used. The following debug
print is made with an extra printg patch but illustrates
the problem:
[ 17.040832] bh1780 2-0029: parent (i2c-2) is not active
parent->power.ignore_children = 0
[ 17.040832] bh1780 2-0029: pm_runtime_force_resume:
pm_runtime_set_active() failed (-16)
[ 17.040863] dpm_run_callback():
pm_runtime_force_resume+0x0/0x88 returns -16
[ 17.040863] PM: Device 2-0029 failed to resume: error -16
Fix this by letting all struct i2c_adapter:s ignore their
children: i2c children have no business doing keeping
their parents awake: they are completely autonomous
devices that just use their parent to talk, a usecase
which must be power managed in the host on a per-message
basis.
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
Reviewed-by: Ulf Hansson <ulf.hansson@linaro.org>
Signed-off-by: Wolfram Sang <wsa@the-dreams.de>
2016-04-12 01:57:35 -06:00
|
|
|
pm_suspend_ignore_children(&adap->dev, true);
|
2015-12-23 10:19:28 -07:00
|
|
|
pm_runtime_enable(&adap->dev);
|
2015-04-16 06:05:19 -06:00
|
|
|
|
2009-09-18 14:45:46 -06:00
|
|
|
#ifdef CONFIG_I2C_COMPAT
|
|
|
|
res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
|
|
|
|
adap->dev.parent);
|
|
|
|
if (res)
|
|
|
|
dev_warn(&adap->dev,
|
|
|
|
"Failed to create compatibility class link\n");
|
|
|
|
#endif
|
|
|
|
|
2016-07-08 22:34:59 -06:00
|
|
|
i2c_init_recovery(adap);
|
2012-02-28 05:56:31 -07:00
|
|
|
|
2009-06-19 08:58:18 -06:00
|
|
|
/* create pre-declared device nodes */
|
2013-07-11 05:56:15 -06:00
|
|
|
of_i2c_register_devices(adap);
|
2016-08-12 08:02:52 -06:00
|
|
|
i2c_acpi_register_devices(adap);
|
|
|
|
i2c_acpi_install_space_handler(adap);
|
2013-07-11 05:56:15 -06:00
|
|
|
|
2007-05-01 15:26:31 -06:00
|
|
|
if (adap->nr < __i2c_first_dynamic_bus_num)
|
|
|
|
i2c_scan_static_board_info(adap);
|
|
|
|
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-14 14:38:36 -06:00
|
|
|
/* Notify drivers */
|
2009-06-19 08:58:19 -06:00
|
|
|
mutex_lock(&core_lock);
|
2010-08-11 10:20:59 -06:00
|
|
|
bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
|
2008-01-27 10:14:49 -07:00
|
|
|
mutex_unlock(&core_lock);
|
2009-06-19 08:58:19 -06:00
|
|
|
|
|
|
|
return 0;
|
2006-08-15 10:26:30 -06:00
|
|
|
|
2017-08-24 03:31:04 -06:00
|
|
|
out_reg:
|
|
|
|
init_completion(&adap->dev_released);
|
|
|
|
device_unregister(&adap->dev);
|
|
|
|
wait_for_completion(&adap->dev_released);
|
2006-08-15 10:26:30 -06:00
|
|
|
out_list:
|
2009-06-19 08:58:19 -06:00
|
|
|
mutex_lock(&core_lock);
|
2006-08-15 10:26:30 -06:00
|
|
|
idr_remove(&i2c_adapter_idr, adap->nr);
|
2009-06-19 08:58:19 -06:00
|
|
|
mutex_unlock(&core_lock);
|
|
|
|
return res;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2013-03-01 09:57:31 -07:00
|
|
|
/**
|
|
|
|
* __i2c_add_numbered_adapter - i2c_add_numbered_adapter where nr is never -1
|
|
|
|
* @adap: the adapter to register (with adap->nr initialized)
|
|
|
|
* Context: can sleep
|
|
|
|
*
|
|
|
|
* See i2c_add_numbered_adapter() for details.
|
|
|
|
*/
|
|
|
|
static int __i2c_add_numbered_adapter(struct i2c_adapter *adap)
|
|
|
|
{
|
2016-07-08 22:35:01 -06:00
|
|
|
int id;
|
2013-03-01 09:57:31 -07:00
|
|
|
|
|
|
|
mutex_lock(&core_lock);
|
2016-07-08 22:35:01 -06:00
|
|
|
id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1, GFP_KERNEL);
|
2013-03-01 09:57:31 -07:00
|
|
|
mutex_unlock(&core_lock);
|
2016-07-08 22:35:01 -06:00
|
|
|
if (WARN(id < 0, "couldn't get idr"))
|
2013-03-01 09:57:31 -07:00
|
|
|
return id == -ENOSPC ? -EBUSY : id;
|
|
|
|
|
|
|
|
return i2c_register_adapter(adap);
|
|
|
|
}
|
|
|
|
|
2007-05-01 15:26:31 -06:00
|
|
|
/**
|
|
|
|
* i2c_add_adapter - declare i2c adapter, use dynamic bus number
|
|
|
|
* @adapter: the adapter to add
|
2007-07-12 06:12:28 -06:00
|
|
|
* Context: can sleep
|
2007-05-01 15:26:31 -06:00
|
|
|
*
|
|
|
|
* This routine is used to declare an I2C adapter when its bus number
|
2013-03-01 09:57:31 -07:00
|
|
|
* doesn't matter or when its bus number is specified by an dt alias.
|
|
|
|
* Examples of bases when the bus number doesn't matter: I2C adapters
|
|
|
|
* dynamically added by USB links or PCI plugin cards.
|
2007-05-01 15:26:31 -06:00
|
|
|
*
|
|
|
|
* When this returns zero, a new bus number was allocated and stored
|
|
|
|
* in adap->nr, and the specified adapter became available for clients.
|
|
|
|
* Otherwise, a negative errno value is returned.
|
|
|
|
*/
|
|
|
|
int i2c_add_adapter(struct i2c_adapter *adapter)
|
|
|
|
{
|
2013-03-01 09:57:31 -07:00
|
|
|
struct device *dev = &adapter->dev;
|
2013-02-27 18:04:15 -07:00
|
|
|
int id;
|
2007-05-01 15:26:31 -06:00
|
|
|
|
2013-03-01 09:57:31 -07:00
|
|
|
if (dev->of_node) {
|
|
|
|
id = of_alias_get_id(dev->of_node, "i2c");
|
|
|
|
if (id >= 0) {
|
|
|
|
adapter->nr = id;
|
|
|
|
return __i2c_add_numbered_adapter(adapter);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-01-27 10:14:49 -07:00
|
|
|
mutex_lock(&core_lock);
|
2013-02-27 18:04:15 -07:00
|
|
|
id = idr_alloc(&i2c_adapter_idr, adapter,
|
|
|
|
__i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
|
2008-01-27 10:14:49 -07:00
|
|
|
mutex_unlock(&core_lock);
|
2016-07-08 22:35:01 -06:00
|
|
|
if (WARN(id < 0, "couldn't get idr"))
|
2013-02-27 18:04:15 -07:00
|
|
|
return id;
|
2007-05-01 15:26:31 -06:00
|
|
|
|
|
|
|
adapter->nr = id;
|
2013-02-27 18:04:15 -07:00
|
|
|
|
2007-05-01 15:26:31 -06:00
|
|
|
return i2c_register_adapter(adapter);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(i2c_add_adapter);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* i2c_add_numbered_adapter - declare i2c adapter, use static bus number
|
|
|
|
* @adap: the adapter to register (with adap->nr initialized)
|
2007-07-12 06:12:28 -06:00
|
|
|
* Context: can sleep
|
2007-05-01 15:26:31 -06:00
|
|
|
*
|
|
|
|
* This routine is used to declare an I2C adapter when its bus number
|
2008-03-23 13:28:20 -06:00
|
|
|
* matters. For example, use it for I2C adapters from system-on-chip CPUs,
|
|
|
|
* or otherwise built in to the system's mainboard, and where i2c_board_info
|
2007-05-01 15:26:31 -06:00
|
|
|
* is used to properly configure I2C devices.
|
|
|
|
*
|
2011-07-25 09:49:43 -06:00
|
|
|
* If the requested bus number is set to -1, then this function will behave
|
|
|
|
* identically to i2c_add_adapter, and will dynamically assign a bus number.
|
|
|
|
*
|
2007-05-01 15:26:31 -06:00
|
|
|
* If no devices have pre-been declared for this bus, then be sure to
|
|
|
|
* register the adapter before any dynamically allocated ones. Otherwise
|
|
|
|
* the required bus ID may not be available.
|
|
|
|
*
|
|
|
|
* When this returns zero, the specified adapter became available for
|
|
|
|
* clients using the bus number provided in adap->nr. Also, the table
|
|
|
|
* of I2C devices pre-declared using i2c_register_board_info() is scanned,
|
|
|
|
* and the appropriate driver model device nodes are created. Otherwise, a
|
|
|
|
* negative errno value is returned.
|
|
|
|
*/
|
|
|
|
int i2c_add_numbered_adapter(struct i2c_adapter *adap)
|
|
|
|
{
|
2011-07-25 09:49:43 -06:00
|
|
|
if (adap->nr == -1) /* -1 means dynamically assign bus id */
|
|
|
|
return i2c_add_adapter(adap);
|
2007-05-01 15:26:31 -06:00
|
|
|
|
2013-03-01 09:57:31 -07:00
|
|
|
return __i2c_add_numbered_adapter(adap);
|
2007-05-01 15:26:31 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
|
|
|
|
|
2013-03-09 01:16:44 -07:00
|
|
|
static void i2c_do_del_adapter(struct i2c_driver *driver,
|
2009-12-06 09:06:27 -07:00
|
|
|
struct i2c_adapter *adapter)
|
2008-01-27 10:14:49 -07:00
|
|
|
{
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-14 14:38:36 -06:00
|
|
|
struct i2c_client *client, *_n;
|
2008-01-27 10:14:49 -07:00
|
|
|
|
2009-03-28 14:34:40 -06:00
|
|
|
/* Remove the devices we created ourselves as the result of hardware
|
|
|
|
* probing (using a driver's detect method) */
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-14 14:38:36 -06:00
|
|
|
list_for_each_entry_safe(client, _n, &driver->clients, detected) {
|
|
|
|
if (client->adapter == adapter) {
|
|
|
|
dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
|
|
|
|
client->name, client->addr);
|
|
|
|
list_del(&client->detected);
|
|
|
|
i2c_unregister_device(client);
|
|
|
|
}
|
|
|
|
}
|
2008-01-27 10:14:49 -07:00
|
|
|
}
|
|
|
|
|
2009-06-19 08:58:19 -06:00
|
|
|
static int __unregister_client(struct device *dev, void *dummy)
|
2011-01-14 14:03:49 -07:00
|
|
|
{
|
|
|
|
struct i2c_client *client = i2c_verify_client(dev);
|
|
|
|
if (client && strcmp(client->name, "dummy"))
|
|
|
|
i2c_unregister_device(client);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __unregister_dummy(struct device *dev, void *dummy)
|
2009-06-19 08:58:19 -06:00
|
|
|
{
|
|
|
|
struct i2c_client *client = i2c_verify_client(dev);
|
2017-10-31 08:21:35 -06:00
|
|
|
i2c_unregister_device(client);
|
2009-06-19 08:58:19 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-12-06 09:06:27 -07:00
|
|
|
static int __process_removed_adapter(struct device_driver *d, void *data)
|
|
|
|
{
|
2013-03-09 01:16:44 -07:00
|
|
|
i2c_do_del_adapter(to_i2c_driver(d), data);
|
|
|
|
return 0;
|
2009-12-06 09:06:27 -07:00
|
|
|
}
|
|
|
|
|
2007-07-12 06:12:28 -06:00
|
|
|
/**
|
|
|
|
* i2c_del_adapter - unregister I2C adapter
|
|
|
|
* @adap: the adapter being unregistered
|
|
|
|
* Context: can sleep
|
|
|
|
*
|
|
|
|
* This unregisters an I2C adapter which was previously registered
|
|
|
|
* by @i2c_add_adapter or @i2c_add_numbered_adapter.
|
|
|
|
*/
|
2013-03-09 01:16:47 -07:00
|
|
|
void i2c_del_adapter(struct i2c_adapter *adap)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-06-19 08:58:19 -06:00
|
|
|
struct i2c_adapter *found;
|
2009-11-26 01:22:33 -07:00
|
|
|
struct i2c_client *client, *next;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* First make sure that this adapter was ever added */
|
2009-06-19 08:58:19 -06:00
|
|
|
mutex_lock(&core_lock);
|
|
|
|
found = idr_find(&i2c_adapter_idr, adap->nr);
|
|
|
|
mutex_unlock(&core_lock);
|
|
|
|
if (found != adap) {
|
2016-07-08 22:35:04 -06:00
|
|
|
pr_debug("attempting to delete unregistered adapter [%s]\n", adap->name);
|
2013-03-09 01:16:47 -07:00
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2016-08-12 08:02:52 -06:00
|
|
|
i2c_acpi_remove_space_handler(adap);
|
2008-01-27 10:14:49 -07:00
|
|
|
/* Tell drivers about this removal */
|
2009-06-19 08:58:19 -06:00
|
|
|
mutex_lock(&core_lock);
|
2013-03-09 01:16:44 -07:00
|
|
|
bus_for_each_drv(&i2c_bus_type, NULL, adap,
|
2009-12-06 09:06:27 -07:00
|
|
|
__process_removed_adapter);
|
2009-06-19 08:58:19 -06:00
|
|
|
mutex_unlock(&core_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-11-26 01:22:33 -07:00
|
|
|
/* Remove devices instantiated from sysfs */
|
2012-09-10 02:14:02 -06:00
|
|
|
mutex_lock_nested(&adap->userspace_clients_lock,
|
|
|
|
i2c_adapter_depth(adap));
|
2010-05-04 03:09:28 -06:00
|
|
|
list_for_each_entry_safe(client, next, &adap->userspace_clients,
|
|
|
|
detected) {
|
|
|
|
dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
|
|
|
|
client->addr);
|
|
|
|
list_del(&client->detected);
|
|
|
|
i2c_unregister_device(client);
|
2009-11-26 01:22:33 -07:00
|
|
|
}
|
2010-08-11 10:21:01 -06:00
|
|
|
mutex_unlock(&adap->userspace_clients_lock);
|
2009-11-26 01:22:33 -07:00
|
|
|
|
2009-06-19 08:58:19 -06:00
|
|
|
/* Detach any active clients. This can't fail, thus we do not
|
2011-01-14 14:03:49 -07:00
|
|
|
* check the returned value. This is a two-pass process, because
|
|
|
|
* we can't remove the dummy devices during the first pass: they
|
|
|
|
* could have been instantiated by real devices wishing to clean
|
|
|
|
* them up properly, so we give them a chance to do that first. */
|
2013-03-09 01:16:44 -07:00
|
|
|
device_for_each_child(&adap->dev, NULL, __unregister_client);
|
|
|
|
device_for_each_child(&adap->dev, NULL, __unregister_dummy);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-09-18 14:45:46 -06:00
|
|
|
#ifdef CONFIG_I2C_COMPAT
|
|
|
|
class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
|
|
|
|
adap->dev.parent);
|
|
|
|
#endif
|
|
|
|
|
2010-01-16 12:43:13 -07:00
|
|
|
/* device name is gone after device_unregister */
|
|
|
|
dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
|
|
|
|
|
2015-12-23 10:19:28 -07:00
|
|
|
pm_runtime_disable(&adap->dev);
|
|
|
|
|
2016-10-13 06:10:40 -06:00
|
|
|
i2c_host_notify_irq_teardown(adap);
|
|
|
|
|
2015-01-29 14:45:09 -07:00
|
|
|
/* wait until all references to the device are gone
|
|
|
|
*
|
|
|
|
* FIXME: This is old code and should ideally be replaced by an
|
|
|
|
* alternative which results in decoupling the lifetime of the struct
|
|
|
|
* device from the i2c_adapter, like spi or netdev do. Any solution
|
2015-05-18 10:54:01 -06:00
|
|
|
* should be thoroughly tested with DEBUG_KOBJECT_RELEASE enabled!
|
2015-01-29 14:45:09 -07:00
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
init_completion(&adap->dev_released);
|
|
|
|
device_unregister(&adap->dev);
|
|
|
|
wait_for_completion(&adap->dev_released);
|
|
|
|
|
2007-05-01 15:26:31 -06:00
|
|
|
/* free bus id */
|
2009-06-19 08:58:19 -06:00
|
|
|
mutex_lock(&core_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
idr_remove(&i2c_adapter_idr, adap->nr);
|
2009-06-19 08:58:19 -06:00
|
|
|
mutex_unlock(&core_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-07-16 11:30:05 -06:00
|
|
|
/* Clear the device structure in case this adapter is ever going to be
|
|
|
|
added again */
|
|
|
|
memset(&adap->dev, 0, sizeof(adap->dev));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
EXPORT_SYMBOL(i2c_del_adapter);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2015-12-17 05:32:36 -07:00
|
|
|
/**
|
|
|
|
* i2c_parse_fw_timings - get I2C related timing parameters from firmware
|
|
|
|
* @dev: The device to scan for I2C timing properties
|
|
|
|
* @t: the i2c_timings struct to be filled with values
|
|
|
|
* @use_defaults: bool to use sane defaults derived from the I2C specification
|
|
|
|
* when properties are not found, otherwise use 0
|
|
|
|
*
|
|
|
|
* Scan the device for the generic I2C properties describing timing parameters
|
|
|
|
* for the signal and fill the given struct with the results. If a property was
|
|
|
|
* not found and use_defaults was true, then maximum timings are assumed which
|
|
|
|
* are derived from the I2C specification. If use_defaults is not used, the
|
|
|
|
* results will be 0, so drivers can apply their own defaults later. The latter
|
|
|
|
* is mainly intended for avoiding regressions of existing drivers which want
|
|
|
|
* to switch to this function. New drivers almost always should use the defaults.
|
|
|
|
*/
|
|
|
|
|
|
|
|
void i2c_parse_fw_timings(struct device *dev, struct i2c_timings *t, bool use_defaults)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
memset(t, 0, sizeof(*t));
|
|
|
|
|
|
|
|
ret = device_property_read_u32(dev, "clock-frequency", &t->bus_freq_hz);
|
|
|
|
if (ret && use_defaults)
|
|
|
|
t->bus_freq_hz = 100000;
|
|
|
|
|
|
|
|
ret = device_property_read_u32(dev, "i2c-scl-rising-time-ns", &t->scl_rise_ns);
|
|
|
|
if (ret && use_defaults) {
|
|
|
|
if (t->bus_freq_hz <= 100000)
|
|
|
|
t->scl_rise_ns = 1000;
|
|
|
|
else if (t->bus_freq_hz <= 400000)
|
|
|
|
t->scl_rise_ns = 300;
|
|
|
|
else
|
|
|
|
t->scl_rise_ns = 120;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = device_property_read_u32(dev, "i2c-scl-falling-time-ns", &t->scl_fall_ns);
|
|
|
|
if (ret && use_defaults) {
|
|
|
|
if (t->bus_freq_hz <= 400000)
|
|
|
|
t->scl_fall_ns = 300;
|
|
|
|
else
|
|
|
|
t->scl_fall_ns = 120;
|
|
|
|
}
|
|
|
|
|
|
|
|
device_property_read_u32(dev, "i2c-scl-internal-delay-ns", &t->scl_int_delay_ns);
|
|
|
|
|
|
|
|
ret = device_property_read_u32(dev, "i2c-sda-falling-time-ns", &t->sda_fall_ns);
|
|
|
|
if (ret && use_defaults)
|
|
|
|
t->sda_fall_ns = t->scl_fall_ns;
|
2018-07-25 08:39:25 -06:00
|
|
|
|
|
|
|
device_property_read_u32(dev, "i2c-sda-hold-time-ns", &t->sda_hold_ns);
|
2019-10-23 06:40:14 -06:00
|
|
|
|
|
|
|
device_property_read_u32(dev, "i2c-digital-filter-width-ns",
|
|
|
|
&t->digital_filter_width_ns);
|
|
|
|
|
|
|
|
device_property_read_u32(dev, "i2c-analog-filter-cutoff-frequency",
|
|
|
|
&t->analog_filter_cutoff_freq_hz);
|
2015-12-17 05:32:36 -07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(i2c_parse_fw_timings);
|
|
|
|
|
2007-05-01 15:26:30 -06:00
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
|
2019-06-03 02:25:33 -06:00
|
|
|
int i2c_for_each_dev(void *data, int (*fn)(struct device *dev, void *data))
|
2011-03-20 07:50:52 -06:00
|
|
|
{
|
|
|
|
int res;
|
|
|
|
|
|
|
|
mutex_lock(&core_lock);
|
|
|
|
res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
|
|
|
|
mutex_unlock(&core_lock);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(i2c_for_each_dev);
|
|
|
|
|
2009-12-06 09:06:27 -07:00
|
|
|
static int __process_new_driver(struct device *dev, void *data)
|
2008-07-14 14:38:19 -06:00
|
|
|
{
|
2009-09-18 14:45:46 -06:00
|
|
|
if (dev->type != &i2c_adapter_type)
|
|
|
|
return 0;
|
2009-12-06 09:06:27 -07:00
|
|
|
return i2c_do_add_adapter(data, to_i2c_adapter(dev));
|
2008-07-14 14:38:19 -06:00
|
|
|
}
|
|
|
|
|
2007-05-01 15:26:30 -06:00
|
|
|
/*
|
|
|
|
* An i2c_driver is used with one or more i2c_client (device) nodes to access
|
2009-06-19 08:58:18 -06:00
|
|
|
* i2c slave chips, on a bus instance associated with some i2c_adapter.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
2005-12-06 16:33:15 -07:00
|
|
|
int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-02-05 15:28:21 -07:00
|
|
|
int res;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-10-14 09:30:05 -06:00
|
|
|
/* Can't register until after driver model init */
|
2016-03-07 04:49:17 -07:00
|
|
|
if (WARN_ON(!is_registered))
|
2008-10-14 09:30:05 -06:00
|
|
|
return -EAGAIN;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* add the driver to the list of i2c drivers in the driver core */
|
2005-12-06 16:33:15 -07:00
|
|
|
driver->driver.owner = owner;
|
2005-04-16 16:20:36 -06:00
|
|
|
driver->driver.bus = &i2c_bus_type;
|
2016-10-31 13:46:24 -06:00
|
|
|
INIT_LIST_HEAD(&driver->clients);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-06-19 08:58:18 -06:00
|
|
|
/* When registration returns, the driver core
|
2007-05-01 15:26:31 -06:00
|
|
|
* will have called probe() for all matching-but-unbound devices.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
res = driver_register(&driver->driver);
|
|
|
|
if (res)
|
2006-02-05 15:28:21 -07:00
|
|
|
return res;
|
2006-12-10 13:21:31 -07:00
|
|
|
|
2016-07-08 22:35:04 -06:00
|
|
|
pr_debug("driver [%s] registered\n", driver->driver.name);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-14 14:38:36 -06:00
|
|
|
/* Walk the adapters that are already present */
|
2011-03-20 07:50:52 -06:00
|
|
|
i2c_for_each_dev(driver, __process_new_driver);
|
2009-06-19 08:58:19 -06:00
|
|
|
|
2008-07-14 14:38:19 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(i2c_register_driver);
|
|
|
|
|
2009-12-06 09:06:27 -07:00
|
|
|
static int __process_removed_driver(struct device *dev, void *data)
|
2008-07-14 14:38:19 -06:00
|
|
|
{
|
2013-03-09 01:16:44 -07:00
|
|
|
if (dev->type == &i2c_adapter_type)
|
|
|
|
i2c_do_del_adapter(data, to_i2c_adapter(dev));
|
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-05-01 15:26:30 -06:00
|
|
|
/**
|
|
|
|
* i2c_del_driver - unregister I2C driver
|
|
|
|
* @driver: the driver being unregistered
|
2007-07-12 06:12:28 -06:00
|
|
|
* Context: can sleep
|
2007-05-01 15:26:30 -06:00
|
|
|
*/
|
2007-05-01 15:26:32 -06:00
|
|
|
void i2c_del_driver(struct i2c_driver *driver)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-03-20 07:50:52 -06:00
|
|
|
i2c_for_each_dev(driver, __process_removed_driver);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
driver_unregister(&driver->driver);
|
2016-07-08 22:35:04 -06:00
|
|
|
pr_debug("driver [%s] unregistered\n", driver->driver.name);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
EXPORT_SYMBOL(i2c_del_driver);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 15:26:30 -06:00
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
|
2008-01-27 10:14:51 -07:00
|
|
|
struct i2c_cmd_arg {
|
|
|
|
unsigned cmd;
|
|
|
|
void *arg;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int i2c_cmd(struct device *dev, void *_arg)
|
|
|
|
{
|
|
|
|
struct i2c_client *client = i2c_verify_client(dev);
|
|
|
|
struct i2c_cmd_arg *arg = _arg;
|
2013-09-29 02:51:06 -06:00
|
|
|
struct i2c_driver *driver;
|
|
|
|
|
|
|
|
if (!client || !client->dev.driver)
|
|
|
|
return 0;
|
2008-01-27 10:14:51 -07:00
|
|
|
|
2013-09-29 02:51:06 -06:00
|
|
|
driver = to_i2c_driver(client->dev.driver);
|
|
|
|
if (driver->command)
|
|
|
|
driver->command(client, arg->cmd, arg->arg);
|
2008-01-27 10:14:51 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
|
|
|
|
{
|
2008-01-27 10:14:51 -07:00
|
|
|
struct i2c_cmd_arg cmd_arg;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-01-27 10:14:51 -07:00
|
|
|
cmd_arg.cmd = cmd;
|
|
|
|
cmd_arg.arg = arg;
|
|
|
|
device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
EXPORT_SYMBOL(i2c_clients_command);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
static int __init i2c_init(void)
|
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
|
2015-03-12 10:17:59 -06:00
|
|
|
retval = of_alias_get_highest_id("i2c");
|
|
|
|
|
|
|
|
down_write(&__i2c_board_lock);
|
|
|
|
if (retval >= __i2c_first_dynamic_bus_num)
|
|
|
|
__i2c_first_dynamic_bus_num = retval + 1;
|
|
|
|
up_write(&__i2c_board_lock);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
retval = bus_register(&i2c_bus_type);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
2016-03-14 03:41:52 -06:00
|
|
|
|
|
|
|
is_registered = true;
|
|
|
|
|
2009-09-18 14:45:46 -06:00
|
|
|
#ifdef CONFIG_I2C_COMPAT
|
|
|
|
i2c_adapter_compat_class = class_compat_register("i2c-adapter");
|
|
|
|
if (!i2c_adapter_compat_class) {
|
|
|
|
retval = -ENOMEM;
|
|
|
|
goto bus_err;
|
|
|
|
}
|
|
|
|
#endif
|
2008-01-27 10:14:52 -07:00
|
|
|
retval = i2c_add_driver(&dummy_driver);
|
|
|
|
if (retval)
|
2009-09-18 14:45:46 -06:00
|
|
|
goto class_err;
|
2014-10-28 14:36:03 -06:00
|
|
|
|
|
|
|
if (IS_ENABLED(CONFIG_OF_DYNAMIC))
|
|
|
|
WARN_ON(of_reconfig_notifier_register(&i2c_of_notifier));
|
2016-07-08 10:13:10 -06:00
|
|
|
if (IS_ENABLED(CONFIG_ACPI))
|
|
|
|
WARN_ON(acpi_reconfig_notifier_register(&i2c_acpi_notifier));
|
2014-10-28 14:36:03 -06:00
|
|
|
|
2008-01-27 10:14:52 -07:00
|
|
|
return 0;
|
|
|
|
|
2009-09-18 14:45:46 -06:00
|
|
|
class_err:
|
|
|
|
#ifdef CONFIG_I2C_COMPAT
|
|
|
|
class_compat_unregister(i2c_adapter_compat_class);
|
2008-01-27 10:14:52 -07:00
|
|
|
bus_err:
|
2009-09-18 14:45:46 -06:00
|
|
|
#endif
|
2016-03-14 03:41:52 -06:00
|
|
|
is_registered = false;
|
2008-01-27 10:14:52 -07:00
|
|
|
bus_unregister(&i2c_bus_type);
|
|
|
|
return retval;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit i2c_exit(void)
|
|
|
|
{
|
2016-07-08 10:13:10 -06:00
|
|
|
if (IS_ENABLED(CONFIG_ACPI))
|
|
|
|
WARN_ON(acpi_reconfig_notifier_unregister(&i2c_acpi_notifier));
|
2014-10-28 14:36:03 -06:00
|
|
|
if (IS_ENABLED(CONFIG_OF_DYNAMIC))
|
|
|
|
WARN_ON(of_reconfig_notifier_unregister(&i2c_of_notifier));
|
2008-01-27 10:14:52 -07:00
|
|
|
i2c_del_driver(&dummy_driver);
|
2009-09-18 14:45:46 -06:00
|
|
|
#ifdef CONFIG_I2C_COMPAT
|
|
|
|
class_compat_unregister(i2c_adapter_compat_class);
|
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
bus_unregister(&i2c_bus_type);
|
2014-03-06 06:35:59 -07:00
|
|
|
tracepoint_synchronize_unregister();
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-10-14 09:30:06 -06:00
|
|
|
/* We must initialize early, because some subsystems register i2c drivers
|
|
|
|
* in subsys_initcall() code, but are linked (and initialized) before i2c.
|
|
|
|
*/
|
|
|
|
postcore_initcall(i2c_init);
|
2005-04-16 16:20:36 -06:00
|
|
|
module_exit(i2c_exit);
|
|
|
|
|
|
|
|
/* ----------------------------------------------------
|
|
|
|
* the functional interface to the i2c busses.
|
|
|
|
* ----------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
2015-01-05 15:45:59 -07:00
|
|
|
/* Check if val is exceeding the quirk IFF quirk is non 0 */
|
|
|
|
#define i2c_quirk_exceeded(val, quirk) ((quirk) && ((val) > (quirk)))
|
|
|
|
|
|
|
|
static int i2c_quirk_error(struct i2c_adapter *adap, struct i2c_msg *msg, char *err_msg)
|
|
|
|
{
|
|
|
|
dev_err_ratelimited(&adap->dev, "adapter quirk: %s (addr 0x%04x, size %u, %s)\n",
|
|
|
|
err_msg, msg->addr, msg->len,
|
|
|
|
msg->flags & I2C_M_RD ? "read" : "write");
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int i2c_check_for_quirks(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
|
|
|
|
{
|
|
|
|
const struct i2c_adapter_quirks *q = adap->quirks;
|
|
|
|
int max_num = q->max_num_msgs, i;
|
|
|
|
bool do_len_check = true;
|
|
|
|
|
|
|
|
if (q->flags & I2C_AQ_COMB) {
|
|
|
|
max_num = 2;
|
|
|
|
|
|
|
|
/* special checks for combined messages */
|
|
|
|
if (num == 2) {
|
|
|
|
if (q->flags & I2C_AQ_COMB_WRITE_FIRST && msgs[0].flags & I2C_M_RD)
|
|
|
|
return i2c_quirk_error(adap, &msgs[0], "1st comb msg must be write");
|
|
|
|
|
|
|
|
if (q->flags & I2C_AQ_COMB_READ_SECOND && !(msgs[1].flags & I2C_M_RD))
|
|
|
|
return i2c_quirk_error(adap, &msgs[1], "2nd comb msg must be read");
|
|
|
|
|
|
|
|
if (q->flags & I2C_AQ_COMB_SAME_ADDR && msgs[0].addr != msgs[1].addr)
|
|
|
|
return i2c_quirk_error(adap, &msgs[0], "comb msg only to same addr");
|
|
|
|
|
|
|
|
if (i2c_quirk_exceeded(msgs[0].len, q->max_comb_1st_msg_len))
|
|
|
|
return i2c_quirk_error(adap, &msgs[0], "msg too long");
|
|
|
|
|
|
|
|
if (i2c_quirk_exceeded(msgs[1].len, q->max_comb_2nd_msg_len))
|
|
|
|
return i2c_quirk_error(adap, &msgs[1], "msg too long");
|
|
|
|
|
|
|
|
do_len_check = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (i2c_quirk_exceeded(num, max_num))
|
|
|
|
return i2c_quirk_error(adap, &msgs[0], "too many messages");
|
|
|
|
|
|
|
|
for (i = 0; i < num; i++) {
|
|
|
|
u16 len = msgs[i].len;
|
|
|
|
|
|
|
|
if (msgs[i].flags & I2C_M_RD) {
|
|
|
|
if (do_len_check && i2c_quirk_exceeded(len, q->max_read_len))
|
|
|
|
return i2c_quirk_error(adap, &msgs[i], "msg too long");
|
2018-07-23 14:26:05 -06:00
|
|
|
|
|
|
|
if (q->flags & I2C_AQ_NO_ZERO_LEN_READ && len == 0)
|
|
|
|
return i2c_quirk_error(adap, &msgs[i], "no zero length");
|
2015-01-05 15:45:59 -07:00
|
|
|
} else {
|
|
|
|
if (do_len_check && i2c_quirk_exceeded(len, q->max_write_len))
|
|
|
|
return i2c_quirk_error(adap, &msgs[i], "msg too long");
|
2018-07-23 14:26:05 -06:00
|
|
|
|
|
|
|
if (q->flags & I2C_AQ_NO_ZERO_LEN_WRITE && len == 0)
|
|
|
|
return i2c_quirk_error(adap, &msgs[i], "no zero length");
|
2015-01-05 15:45:59 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-06-29 04:47:19 -06:00
|
|
|
/**
|
|
|
|
* __i2c_transfer - unlocked flavor of i2c_transfer
|
|
|
|
* @adap: Handle to I2C bus
|
|
|
|
* @msgs: One or more messages to execute before STOP is issued to
|
|
|
|
* terminate the operation; each message begins with a START.
|
|
|
|
* @num: Number of messages to be executed.
|
|
|
|
*
|
|
|
|
* Returns negative errno, else the number of messages executed.
|
|
|
|
*
|
|
|
|
* Adapter lock must be held when calling this function. No debug logging
|
|
|
|
* takes place. adap->algo->master_xfer existence isn't checked.
|
|
|
|
*/
|
|
|
|
int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
|
|
|
|
{
|
|
|
|
unsigned long orig_jiffies;
|
|
|
|
int ret, try;
|
|
|
|
|
2018-04-03 13:11:50 -06:00
|
|
|
if (WARN_ON(!msgs || num < 1))
|
|
|
|
return -EINVAL;
|
2019-04-25 08:19:48 -06:00
|
|
|
|
|
|
|
ret = __i2c_check_suspended(adap);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2018-04-03 13:11:50 -06:00
|
|
|
|
2015-01-05 15:45:59 -07:00
|
|
|
if (adap->quirks && i2c_check_for_quirks(adap, msgs, num))
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2018-03-26 15:09:24 -06:00
|
|
|
/*
|
|
|
|
* i2c_trace_msg_key gets enabled when tracepoint i2c_transfer gets
|
2014-03-06 06:35:59 -07:00
|
|
|
* enabled. This is an efficient way of keeping the for-loop from
|
|
|
|
* being executed when not needed.
|
|
|
|
*/
|
2018-03-26 15:09:24 -06:00
|
|
|
if (static_branch_unlikely(&i2c_trace_msg_key)) {
|
2014-03-06 06:35:59 -07:00
|
|
|
int i;
|
|
|
|
for (i = 0; i < num; i++)
|
|
|
|
if (msgs[i].flags & I2C_M_RD)
|
|
|
|
trace_i2c_read(adap, &msgs[i], i);
|
|
|
|
else
|
|
|
|
trace_i2c_write(adap, &msgs[i], i);
|
|
|
|
}
|
|
|
|
|
2012-06-29 04:47:19 -06:00
|
|
|
/* Retry automatically on arbitration loss */
|
|
|
|
orig_jiffies = jiffies;
|
|
|
|
for (ret = 0, try = 0; try <= adap->retries; try++) {
|
2019-04-03 06:40:10 -06:00
|
|
|
if (i2c_in_atomic_xfer_mode() && adap->algo->master_xfer_atomic)
|
|
|
|
ret = adap->algo->master_xfer_atomic(adap, msgs, num);
|
|
|
|
else
|
|
|
|
ret = adap->algo->master_xfer(adap, msgs, num);
|
|
|
|
|
2012-06-29 04:47:19 -06:00
|
|
|
if (ret != -EAGAIN)
|
|
|
|
break;
|
|
|
|
if (time_after(jiffies, orig_jiffies + adap->timeout))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2018-03-26 15:09:24 -06:00
|
|
|
if (static_branch_unlikely(&i2c_trace_msg_key)) {
|
2014-03-06 06:35:59 -07:00
|
|
|
int i;
|
|
|
|
for (i = 0; i < ret; i++)
|
|
|
|
if (msgs[i].flags & I2C_M_RD)
|
|
|
|
trace_i2c_reply(adap, &msgs[i], i);
|
2018-03-31 02:17:34 -06:00
|
|
|
trace_i2c_result(adap, num, ret);
|
2014-03-06 06:35:59 -07:00
|
|
|
}
|
|
|
|
|
2012-06-29 04:47:19 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(__i2c_transfer);
|
|
|
|
|
2008-07-14 14:38:24 -06:00
|
|
|
/**
|
|
|
|
* i2c_transfer - execute a single or combined I2C message
|
|
|
|
* @adap: Handle to I2C bus
|
|
|
|
* @msgs: One or more messages to execute before STOP is issued to
|
|
|
|
* terminate the operation; each message begins with a START.
|
|
|
|
* @num: Number of messages to be executed.
|
|
|
|
*
|
|
|
|
* Returns negative errno, else the number of messages executed.
|
|
|
|
*
|
|
|
|
* Note that there is no requirement that each message be sent to
|
|
|
|
* the same slave address, although that is the most common model.
|
|
|
|
*/
|
2009-03-28 14:34:46 -06:00
|
|
|
int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-06-29 04:47:19 -06:00
|
|
|
int ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2018-09-20 10:14:21 -06:00
|
|
|
if (!adap->algo->master_xfer) {
|
|
|
|
dev_dbg(&adap->dev, "I2C level transfers not supported\n");
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
|
2008-07-14 14:38:24 -06:00
|
|
|
/* REVISIT the fault reporting model here is weak:
|
|
|
|
*
|
|
|
|
* - When we get an error after receiving N bytes from a slave,
|
|
|
|
* there is no way to report "N".
|
|
|
|
*
|
|
|
|
* - When we get a NAK after transmitting N bytes to a slave,
|
|
|
|
* there is no way to report "N" ... or to let the master
|
|
|
|
* continue executing the rest of this combined message, if
|
|
|
|
* that's the appropriate response.
|
|
|
|
*
|
|
|
|
* - When for example "num" is two and we successfully complete
|
|
|
|
* the first message but get an error part way through the
|
|
|
|
* second, it's unclear whether that should be reported as
|
|
|
|
* one (discarding status on the second message) or errno
|
|
|
|
* (discarding status on the first one).
|
|
|
|
*/
|
2019-04-03 06:40:09 -06:00
|
|
|
ret = __i2c_lock_bus_helper(adap);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2018-09-20 10:14:21 -06:00
|
|
|
|
|
|
|
ret = __i2c_transfer(adap, msgs, num);
|
|
|
|
i2c_unlock_bus(adap, I2C_LOCK_SEGMENT);
|
|
|
|
|
|
|
|
return ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
EXPORT_SYMBOL(i2c_transfer);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-07-14 14:38:24 -06:00
|
|
|
/**
|
2017-11-04 14:20:04 -06:00
|
|
|
* i2c_transfer_buffer_flags - issue a single I2C message transferring data
|
|
|
|
* to/from a buffer
|
2008-07-14 14:38:24 -06:00
|
|
|
* @client: Handle to slave device
|
2017-11-04 14:20:04 -06:00
|
|
|
* @buf: Where the data is stored
|
|
|
|
* @count: How many bytes to transfer, must be less than 64k since msg.len is u16
|
|
|
|
* @flags: The flags to be used for the message, e.g. I2C_M_RD for reads
|
2008-07-14 14:38:24 -06:00
|
|
|
*
|
2017-11-04 14:20:04 -06:00
|
|
|
* Returns negative errno, or else the number of bytes transferred.
|
2008-07-14 14:38:24 -06:00
|
|
|
*/
|
2017-11-04 14:20:04 -06:00
|
|
|
int i2c_transfer_buffer_flags(const struct i2c_client *client, char *buf,
|
|
|
|
int count, u16 flags)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int ret;
|
2017-11-04 14:20:04 -06:00
|
|
|
struct i2c_msg msg = {
|
|
|
|
.addr = client->addr,
|
|
|
|
.flags = flags | (client->flags & I2C_M_TEN),
|
|
|
|
.len = count,
|
|
|
|
.buf = buf,
|
|
|
|
};
|
2005-05-07 14:58:46 -06:00
|
|
|
|
2017-11-04 14:20:04 -06:00
|
|
|
ret = i2c_transfer(client->adapter, &msg, 1);
|
2005-05-07 14:58:46 -06:00
|
|
|
|
2012-03-15 11:11:05 -06:00
|
|
|
/*
|
2017-11-04 14:20:04 -06:00
|
|
|
* If everything went ok (i.e. 1 msg transferred), return #bytes
|
|
|
|
* transferred, else error code.
|
2012-03-15 11:11:05 -06:00
|
|
|
*/
|
2005-05-07 14:58:46 -06:00
|
|
|
return (ret == 1) ? count : ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2017-11-04 14:20:04 -06:00
|
|
|
EXPORT_SYMBOL(i2c_transfer_buffer_flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2018-01-22 00:32:01 -07:00
|
|
|
/**
|
|
|
|
* i2c_get_device_id - get manufacturer, part id and die revision of a device
|
|
|
|
* @client: The device to query
|
|
|
|
* @id: The queried information
|
|
|
|
*
|
|
|
|
* Returns negative errno on error, zero on success.
|
|
|
|
*/
|
|
|
|
int i2c_get_device_id(const struct i2c_client *client,
|
|
|
|
struct i2c_device_identity *id)
|
|
|
|
{
|
|
|
|
struct i2c_adapter *adap = client->adapter;
|
|
|
|
union i2c_smbus_data raw_id;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_I2C_BLOCK))
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
raw_id.block[0] = 3;
|
|
|
|
ret = i2c_smbus_xfer(adap, I2C_ADDR_DEVICE_ID, 0,
|
|
|
|
I2C_SMBUS_READ, client->addr << 1,
|
|
|
|
I2C_SMBUS_I2C_BLOCK_DATA, &raw_id);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
id->manufacturer_id = (raw_id.block[1] << 4) | (raw_id.block[2] >> 4);
|
|
|
|
id->part_id = ((raw_id.block[2] & 0xf) << 5) | (raw_id.block[3] >> 3);
|
|
|
|
id->die_revision = raw_id.block[3] & 0x7;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(i2c_get_device_id);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* ----------------------------------------------------
|
|
|
|
* the i2c address scanning function
|
|
|
|
* Will not work for 10-bit addresses!
|
|
|
|
* ----------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
2010-06-03 03:33:51 -06:00
|
|
|
/*
|
|
|
|
* Legacy default probe function, mostly relevant for SMBus. The default
|
|
|
|
* probe method is a quick write, but it is known to corrupt the 24RF08
|
|
|
|
* EEPROMs due to a state machine bug, and could also irreversibly
|
|
|
|
* write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
|
|
|
|
* we use a short byte read instead. Also, some bus drivers don't implement
|
|
|
|
* quick write, so we fallback to a byte read in that case too.
|
|
|
|
* On x86, there is another special case for FSC hardware monitoring chips,
|
|
|
|
* which want regular byte reads (address 0x73.) Fortunately, these are the
|
|
|
|
* only known chips using this I2C address on PC hardware.
|
|
|
|
* Returns 1 if probe succeeded, 0 if not.
|
|
|
|
*/
|
|
|
|
static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
union i2c_smbus_data dummy;
|
|
|
|
|
|
|
|
#ifdef CONFIG_X86
|
|
|
|
if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
|
|
|
|
&& i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
|
|
|
|
err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
|
|
|
|
I2C_SMBUS_BYTE_DATA, &dummy);
|
|
|
|
else
|
|
|
|
#endif
|
2010-08-11 10:21:00 -06:00
|
|
|
if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
|
|
|
|
&& i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
|
2010-06-03 03:33:51 -06:00
|
|
|
err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
|
|
|
|
I2C_SMBUS_QUICK, NULL);
|
2010-08-11 10:21:00 -06:00
|
|
|
else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
|
|
|
|
err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
|
|
|
|
I2C_SMBUS_BYTE, &dummy);
|
|
|
|
else {
|
2013-07-17 14:27:59 -06:00
|
|
|
dev_warn(&adap->dev, "No suitable probing method supported for address 0x%02X\n",
|
|
|
|
addr);
|
2010-08-11 10:21:00 -06:00
|
|
|
err = -EOPNOTSUPP;
|
|
|
|
}
|
2010-06-03 03:33:51 -06:00
|
|
|
|
|
|
|
return err >= 0;
|
|
|
|
}
|
|
|
|
|
2009-12-06 09:06:25 -07:00
|
|
|
static int i2c_detect_address(struct i2c_client *temp_client,
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-14 14:38:36 -06:00
|
|
|
struct i2c_driver *driver)
|
|
|
|
{
|
|
|
|
struct i2c_board_info info;
|
|
|
|
struct i2c_adapter *adapter = temp_client->adapter;
|
|
|
|
int addr = temp_client->addr;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
/* Make sure the address is valid */
|
2015-07-17 04:43:22 -06:00
|
|
|
err = i2c_check_7bit_addr_validity_strict(addr);
|
2010-06-03 03:33:53 -06:00
|
|
|
if (err) {
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-14 14:38:36 -06:00
|
|
|
dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
|
|
|
|
addr);
|
2010-06-03 03:33:53 -06:00
|
|
|
return err;
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-14 14:38:36 -06:00
|
|
|
}
|
|
|
|
|
2015-07-17 06:48:56 -06:00
|
|
|
/* Skip if already in use (7 bit, no need to encode flags) */
|
2010-06-03 03:33:55 -06:00
|
|
|
if (i2c_check_addr_busy(adapter, addr))
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-14 14:38:36 -06:00
|
|
|
return 0;
|
|
|
|
|
2009-12-06 09:06:25 -07:00
|
|
|
/* Make sure there is something at this address */
|
2010-06-03 03:33:51 -06:00
|
|
|
if (!i2c_default_probe(adapter, addr))
|
|
|
|
return 0;
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-14 14:38:36 -06:00
|
|
|
|
|
|
|
/* Finally call the custom detection function */
|
|
|
|
memset(&info, 0, sizeof(struct i2c_board_info));
|
|
|
|
info.addr = addr;
|
2009-12-14 13:17:23 -07:00
|
|
|
err = driver->detect(temp_client, &info);
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-14 14:38:36 -06:00
|
|
|
if (err) {
|
|
|
|
/* -ENODEV is returned if the detection fails. We catch it
|
|
|
|
here as this isn't an error. */
|
|
|
|
return err == -ENODEV ? 0 : err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Consistency check */
|
|
|
|
if (info.type[0] == '\0') {
|
2016-08-25 08:42:10 -06:00
|
|
|
dev_err(&adapter->dev,
|
|
|
|
"%s detection function provided no name for 0x%x\n",
|
|
|
|
driver->driver.name, addr);
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-14 14:38:36 -06:00
|
|
|
} else {
|
|
|
|
struct i2c_client *client;
|
|
|
|
|
|
|
|
/* Detection succeeded, instantiate the device */
|
2014-02-10 03:03:56 -07:00
|
|
|
if (adapter->class & I2C_CLASS_DEPRECATED)
|
|
|
|
dev_warn(&adapter->dev,
|
|
|
|
"This adapter will soon drop class based instantiation of devices. "
|
|
|
|
"Please make sure client 0x%02x gets instantiated by other means. "
|
2019-07-26 06:51:16 -06:00
|
|
|
"Check 'Documentation/i2c/instantiating-devices.rst' for details.\n",
|
2014-02-10 03:03:56 -07:00
|
|
|
info.addr);
|
|
|
|
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-14 14:38:36 -06:00
|
|
|
dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
|
|
|
|
info.type, info.addr);
|
2020-01-07 10:47:43 -07:00
|
|
|
client = i2c_new_client_device(adapter, &info);
|
|
|
|
if (!IS_ERR(client))
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-14 14:38:36 -06:00
|
|
|
list_add_tail(&client->detected, &driver->clients);
|
|
|
|
else
|
|
|
|
dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
|
|
|
|
info.type, info.addr);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
|
|
|
|
{
|
2009-12-14 13:17:25 -07:00
|
|
|
const unsigned short *address_list;
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-14 14:38:36 -06:00
|
|
|
struct i2c_client *temp_client;
|
|
|
|
int i, err = 0;
|
|
|
|
int adap_id = i2c_adapter_id(adapter);
|
|
|
|
|
2009-12-14 13:17:25 -07:00
|
|
|
address_list = driver->address_list;
|
|
|
|
if (!driver->detect || !address_list)
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-14 14:38:36 -06:00
|
|
|
return 0;
|
|
|
|
|
2014-07-10 05:46:21 -06:00
|
|
|
/* Warn that the adapter lost class based instantiation */
|
|
|
|
if (adapter->class == I2C_CLASS_DEPRECATED) {
|
|
|
|
dev_dbg(&adapter->dev,
|
2016-08-25 08:42:10 -06:00
|
|
|
"This adapter dropped support for I2C classes and won't auto-detect %s devices anymore. "
|
2019-07-26 06:51:16 -06:00
|
|
|
"If you need it, check 'Documentation/i2c/instantiating-devices.rst' for alternatives.\n",
|
2014-07-10 05:46:21 -06:00
|
|
|
driver->driver.name);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-10-24 10:16:58 -06:00
|
|
|
/* Stop here if the classes do not match */
|
|
|
|
if (!(adapter->class & driver->class))
|
|
|
|
return 0;
|
|
|
|
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-14 14:38:36 -06:00
|
|
|
/* Set up a temporary client to help detect callback */
|
|
|
|
temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
|
|
|
|
if (!temp_client)
|
|
|
|
return -ENOMEM;
|
|
|
|
temp_client->adapter = adapter;
|
|
|
|
|
2009-12-14 13:17:25 -07:00
|
|
|
for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
|
2016-08-25 08:42:10 -06:00
|
|
|
dev_dbg(&adapter->dev,
|
|
|
|
"found normal entry for adapter %d, addr 0x%02x\n",
|
|
|
|
adap_id, address_list[i]);
|
2009-12-14 13:17:25 -07:00
|
|
|
temp_client->addr = address_list[i];
|
2009-12-06 09:06:25 -07:00
|
|
|
err = i2c_detect_address(temp_client, driver);
|
2010-10-24 10:16:58 -06:00
|
|
|
if (unlikely(err))
|
|
|
|
break;
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-14 14:38:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
kfree(temp_client);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2010-08-11 10:20:57 -06:00
|
|
|
int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
|
|
|
|
{
|
|
|
|
return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
|
|
|
|
I2C_SMBUS_QUICK, NULL) >= 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
|
|
|
|
|
2007-05-01 15:26:31 -06:00
|
|
|
struct i2c_client *
|
2019-11-06 02:50:19 -07:00
|
|
|
i2c_new_scanned_device(struct i2c_adapter *adap,
|
|
|
|
struct i2c_board_info *info,
|
|
|
|
unsigned short const *addr_list,
|
|
|
|
int (*probe)(struct i2c_adapter *adap, unsigned short addr))
|
2007-05-01 15:26:31 -06:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2010-08-11 10:21:00 -06:00
|
|
|
if (!probe)
|
2010-08-11 10:20:56 -06:00
|
|
|
probe = i2c_default_probe;
|
2007-05-01 15:26:31 -06:00
|
|
|
|
|
|
|
for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
|
|
|
|
/* Check address validity */
|
2015-07-17 04:43:22 -06:00
|
|
|
if (i2c_check_7bit_addr_validity_strict(addr_list[i]) < 0) {
|
2016-08-25 08:42:10 -06:00
|
|
|
dev_warn(&adap->dev, "Invalid 7-bit address 0x%02x\n",
|
|
|
|
addr_list[i]);
|
2007-05-01 15:26:31 -06:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2015-07-17 06:48:56 -06:00
|
|
|
/* Check address availability (7 bit, no need to encode flags) */
|
2010-06-03 03:33:55 -06:00
|
|
|
if (i2c_check_addr_busy(adap, addr_list[i])) {
|
2016-08-25 08:42:10 -06:00
|
|
|
dev_dbg(&adap->dev,
|
|
|
|
"Address 0x%02x already in use, not probing\n",
|
|
|
|
addr_list[i]);
|
2007-05-01 15:26:31 -06:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2010-06-03 03:33:51 -06:00
|
|
|
/* Test address responsiveness */
|
2010-08-11 10:20:56 -06:00
|
|
|
if (probe(adap, addr_list[i]))
|
2010-06-03 03:33:51 -06:00
|
|
|
break;
|
2007-05-01 15:26:31 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (addr_list[i] == I2C_CLIENT_END) {
|
|
|
|
dev_dbg(&adap->dev, "Probing failed, no device found\n");
|
2019-11-06 02:50:19 -07:00
|
|
|
return ERR_PTR(-ENODEV);
|
2007-05-01 15:26:31 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
info->addr = addr_list[i];
|
2019-11-06 02:50:19 -07:00
|
|
|
return i2c_new_client_device(adap, info);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(i2c_new_scanned_device);
|
|
|
|
|
|
|
|
struct i2c_client *
|
|
|
|
i2c_new_probed_device(struct i2c_adapter *adap,
|
|
|
|
struct i2c_board_info *info,
|
|
|
|
unsigned short const *addr_list,
|
|
|
|
int (*probe)(struct i2c_adapter *adap, unsigned short addr))
|
|
|
|
{
|
|
|
|
struct i2c_client *client;
|
|
|
|
|
|
|
|
client = i2c_new_scanned_device(adap, info, addr_list, probe);
|
|
|
|
return IS_ERR(client) ? NULL : client;
|
2007-05-01 15:26:31 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(i2c_new_probed_device);
|
|
|
|
|
2011-03-20 07:50:52 -06:00
|
|
|
struct i2c_adapter *i2c_get_adapter(int nr)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct i2c_adapter *adapter;
|
2006-12-10 13:21:31 -07:00
|
|
|
|
2008-01-27 10:14:49 -07:00
|
|
|
mutex_lock(&core_lock);
|
2011-03-20 07:50:52 -06:00
|
|
|
adapter = idr_find(&i2c_adapter_idr, nr);
|
2015-07-27 08:30:49 -06:00
|
|
|
if (!adapter)
|
|
|
|
goto exit;
|
|
|
|
|
|
|
|
if (try_module_get(adapter->owner))
|
|
|
|
get_device(&adapter->dev);
|
|
|
|
else
|
2005-06-27 22:21:30 -06:00
|
|
|
adapter = NULL;
|
|
|
|
|
2015-07-27 08:30:49 -06:00
|
|
|
exit:
|
2008-01-27 10:14:49 -07:00
|
|
|
mutex_unlock(&core_lock);
|
2005-06-27 22:21:30 -06:00
|
|
|
return adapter;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
EXPORT_SYMBOL(i2c_get_adapter);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
void i2c_put_adapter(struct i2c_adapter *adap)
|
|
|
|
{
|
2015-07-27 08:30:49 -06:00
|
|
|
if (!adap)
|
|
|
|
return;
|
|
|
|
|
|
|
|
put_device(&adap->dev);
|
|
|
|
module_put(adap->owner);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
EXPORT_SYMBOL(i2c_put_adapter);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2017-11-04 14:20:02 -06:00
|
|
|
/**
|
|
|
|
* i2c_get_dma_safe_msg_buf() - get a DMA safe buffer for the given i2c_msg
|
|
|
|
* @msg: the message to be checked
|
2019-03-12 06:44:42 -06:00
|
|
|
* @threshold: the minimum number of bytes for which using DMA makes sense.
|
|
|
|
* Should at least be 1.
|
2017-11-04 14:20:02 -06:00
|
|
|
*
|
|
|
|
* Return: NULL if a DMA safe buffer was not obtained. Use msg->buf with PIO.
|
|
|
|
* Or a valid pointer to be used with DMA. After use, release it by
|
2018-10-08 08:55:20 -06:00
|
|
|
* calling i2c_put_dma_safe_msg_buf().
|
2017-11-04 14:20:02 -06:00
|
|
|
*
|
|
|
|
* This function must only be called from process context!
|
|
|
|
*/
|
|
|
|
u8 *i2c_get_dma_safe_msg_buf(struct i2c_msg *msg, unsigned int threshold)
|
|
|
|
{
|
2019-03-12 06:44:42 -06:00
|
|
|
/* also skip 0-length msgs for bogus thresholds of 0 */
|
|
|
|
if (!threshold)
|
|
|
|
pr_debug("DMA buffer for addr=0x%02x with length 0 is bogus\n",
|
|
|
|
msg->addr);
|
|
|
|
if (msg->len < threshold || msg->len == 0)
|
2017-11-04 14:20:02 -06:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (msg->flags & I2C_M_DMA_SAFE)
|
|
|
|
return msg->buf;
|
|
|
|
|
|
|
|
pr_debug("using bounce buffer for addr=0x%02x, len=%d\n",
|
|
|
|
msg->addr, msg->len);
|
|
|
|
|
|
|
|
if (msg->flags & I2C_M_RD)
|
|
|
|
return kzalloc(msg->len, GFP_KERNEL);
|
|
|
|
else
|
|
|
|
return kmemdup(msg->buf, msg->len, GFP_KERNEL);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(i2c_get_dma_safe_msg_buf);
|
|
|
|
|
|
|
|
/**
|
2018-08-24 08:52:44 -06:00
|
|
|
* i2c_put_dma_safe_msg_buf - release DMA safe buffer and sync with i2c_msg
|
2017-11-04 14:20:02 -06:00
|
|
|
* @buf: the buffer obtained from i2c_get_dma_safe_msg_buf(). May be NULL.
|
2018-08-24 08:52:44 -06:00
|
|
|
* @msg: the message which the buffer corresponds to
|
|
|
|
* @xferred: bool saying if the message was transferred
|
2017-11-04 14:20:02 -06:00
|
|
|
*/
|
2018-08-24 08:52:44 -06:00
|
|
|
void i2c_put_dma_safe_msg_buf(u8 *buf, struct i2c_msg *msg, bool xferred)
|
2017-11-04 14:20:02 -06:00
|
|
|
{
|
|
|
|
if (!buf || buf == msg->buf)
|
|
|
|
return;
|
|
|
|
|
2018-08-24 08:52:44 -06:00
|
|
|
if (xferred && msg->flags & I2C_M_RD)
|
2017-11-04 14:20:02 -06:00
|
|
|
memcpy(msg->buf, buf, msg->len);
|
|
|
|
|
|
|
|
kfree(buf);
|
|
|
|
}
|
2018-08-24 08:52:44 -06:00
|
|
|
EXPORT_SYMBOL_GPL(i2c_put_dma_safe_msg_buf);
|
2017-11-04 14:20:02 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
|
|
|
|
MODULE_DESCRIPTION("I2C-Bus main module");
|
|
|
|
MODULE_LICENSE("GPL");
|