[linux.git] / drivers / i2c / i2c-core-slave.c

/*
 * Linux I2C core slave support code
 *
 * Copyright (C) 2014 by Wolfram Sang <[email protected]>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 */

#include <dt-bindings/i2c/i2c.h>
#include <linux/acpi.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/i2c.h>
#include <linux/of.h>

#include "i2c-core.h"

int i2c_slave_register(struct i2c_client *client, i2c_slave_cb_t slave_cb)
{
	int ret;

	if (!client || !slave_cb) {
		WARN(1, "insufficient data\n");
		return -EINVAL;
	}

	if (!(client->flags & I2C_CLIENT_SLAVE))
		dev_warn(&client->dev, "%s: client slave flag not set. You might see address collisions\n",
			 __func__);

	if (!(client->flags & I2C_CLIENT_TEN)) {
		/* Enforce stricter address checking */
		ret = i2c_check_7bit_addr_validity_strict(client->addr);
		if (ret) {
			dev_err(&client->dev, "%s: invalid address\n", __func__);
			return ret;
		}
	}

	if (!client->adapter->algo->reg_slave) {
		dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
		return -EOPNOTSUPP;
	}

	client->slave_cb = slave_cb;

	i2c_lock_bus(client->adapter, I2C_LOCK_ROOT_ADAPTER);
	ret = client->adapter->algo->reg_slave(client);
	i2c_unlock_bus(client->adapter, I2C_LOCK_ROOT_ADAPTER);

	if (ret) {
		client->slave_cb = NULL;
		dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
	}

	return ret;
}
EXPORT_SYMBOL_GPL(i2c_slave_register);

int i2c_slave_unregister(struct i2c_client *client)
{
	int ret;

	if (!client->adapter->algo->unreg_slave) {
		dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
		return -EOPNOTSUPP;
	}

	i2c_lock_bus(client->adapter, I2C_LOCK_ROOT_ADAPTER);
	ret = client->adapter->algo->unreg_slave(client);
	i2c_unlock_bus(client->adapter, I2C_LOCK_ROOT_ADAPTER);

	if (ret == 0)
		client->slave_cb = NULL;
	else
		dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);

	return ret;
}
EXPORT_SYMBOL_GPL(i2c_slave_unregister);

/**
 * i2c_detect_slave_mode - detect operation mode
 * @dev: The device owning the bus
 *
 * This checks the device nodes for an I2C slave by checking the address
 * used in the reg property. If the address match the I2C_OWN_SLAVE_ADDRESS
 * flag this means the device is configured to act as a I2C slave and it will
 * be listening at that address.
 *
 * Returns true if an I2C own slave address is detected, otherwise returns
 * false.
 */
bool i2c_detect_slave_mode(struct device *dev)
{
	if (IS_BUILTIN(CONFIG_OF) && dev->of_node) {
		struct device_node *child;
		u32 reg;

		for_each_child_of_node(dev->of_node, child) {
			of_property_read_u32(child, "reg", &reg);
			if (reg & I2C_OWN_SLAVE_ADDRESS) {
				of_node_put(child);
				return true;
			}
		}
	} else if (IS_BUILTIN(CONFIG_ACPI) && ACPI_HANDLE(dev)) {
		dev_dbg(dev, "ACPI slave is not supported yet\n");
	}
	return false;
}
EXPORT_SYMBOL_GPL(i2c_detect_slave_mode);
Commit	Line	Data
e4991ecd WS	1	/*
	2	* Linux I2C core slave support code
	3	*
	4	* Copyright (C) 2014 by Wolfram Sang <[email protected]>
	5	*
	6	* This program is free software; you can redistribute it and/or modify it
	7	* under the terms of the GNU General Public License as published by the Free
	8	* Software Foundation; either version 2 of the License, or (at your option)
	9	* any later version.
	10	*/
	11
	12	#include <dt-bindings/i2c/i2c.h>
	13	#include <linux/acpi.h>
	14	#include <linux/device.h>
	15	#include <linux/err.h>
	16	#include <linux/i2c.h>
	17	#include <linux/of.h>
	18
	19	#include "i2c-core.h"
	20
	21	int i2c_slave_register(struct i2c_client *client, i2c_slave_cb_t slave_cb)
	22	{
	23	int ret;
	24
	25	if (!client \|\| !slave_cb) {
	26	WARN(1, "insufficient data\n");
	27	return -EINVAL;
	28	}
	29
	30	if (!(client->flags & I2C_CLIENT_SLAVE))
	31	dev_warn(&client->dev, "%s: client slave flag not set. You might see address collisions\n",
	32	__func__);
	33
	34	if (!(client->flags & I2C_CLIENT_TEN)) {
	35	/* Enforce stricter address checking */
	36	ret = i2c_check_7bit_addr_validity_strict(client->addr);
	37	if (ret) {
	38	dev_err(&client->dev, "%s: invalid address\n", __func__);
	39	return ret;
	40	}
	41	}
	42
	43	if (!client->adapter->algo->reg_slave) {
	44	dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
	45	return -EOPNOTSUPP;
	46	}
	47
	48	client->slave_cb = slave_cb;
	49
3f3a89e1	50	i2c_lock_bus(client->adapter, I2C_LOCK_ROOT_ADAPTER);
e4991ecd	51	ret = client->adapter->algo->reg_slave(client);
3f3a89e1	52	i2c_unlock_bus(client->adapter, I2C_LOCK_ROOT_ADAPTER);
e4991ecd WS	53
	54	if (ret) {
	55	client->slave_cb = NULL;
	56	dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
	57	}
	58
	59	return ret;
	60	}
	61	EXPORT_SYMBOL_GPL(i2c_slave_register);
	62
	63	int i2c_slave_unregister(struct i2c_client *client)
	64	{
	65	int ret;
	66
	67	if (!client->adapter->algo->unreg_slave) {
	68	dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
	69	return -EOPNOTSUPP;
	70	}
	71
3f3a89e1	72	i2c_lock_bus(client->adapter, I2C_LOCK_ROOT_ADAPTER);
e4991ecd	73	ret = client->adapter->algo->unreg_slave(client);
3f3a89e1	74	i2c_unlock_bus(client->adapter, I2C_LOCK_ROOT_ADAPTER);
e4991ecd WS	75
	76	if (ret == 0)
	77	client->slave_cb = NULL;
	78	else
	79	dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
	80
	81	return ret;
	82	}
	83	EXPORT_SYMBOL_GPL(i2c_slave_unregister);
	84
	85	/**
	86	* i2c_detect_slave_mode - detect operation mode
	87	* @dev: The device owning the bus
	88	*
	89	* This checks the device nodes for an I2C slave by checking the address
	90	* used in the reg property. If the address match the I2C_OWN_SLAVE_ADDRESS
	91	* flag this means the device is configured to act as a I2C slave and it will
	92	* be listening at that address.
	93	*
	94	* Returns true if an I2C own slave address is detected, otherwise returns
	95	* false.
	96	*/
	97	bool i2c_detect_slave_mode(struct device *dev)
	98	{
	99	if (IS_BUILTIN(CONFIG_OF) && dev->of_node) {
	100	struct device_node *child;
	101	u32 reg;
	102
	103	for_each_child_of_node(dev->of_node, child) {
	104	of_property_read_u32(child, "reg", &reg);
	105	if (reg & I2C_OWN_SLAVE_ADDRESS) {
	106	of_node_put(child);
	107	return true;
	108	}
	109	}
	110	} else if (IS_BUILTIN(CONFIG_ACPI) && ACPI_HANDLE(dev)) {
	111	dev_dbg(dev, "ACPI slave is not supported yet\n");
	112	}
	113	return false;
	114	}
	115	EXPORT_SYMBOL_GPL(i2c_detect_slave_mode);