[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / i2c / muxes / i2c-mux-pinctrl.c

/*
 * I2C multiplexer using pinctrl API
 *
 * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <linux/i2c.h>
#include <linux/i2c-mux.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/of_i2c.h>
#include <linux/pinctrl/consumer.h>
#include <linux/i2c-mux-pinctrl.h>
#include <linux/platform_device.h>
#include <linux/slab.h>

struct i2c_mux_pinctrl {
	struct device *dev;
	struct i2c_mux_pinctrl_platform_data *pdata;
	struct pinctrl *pinctrl;
	struct pinctrl_state **states;
	struct pinctrl_state *state_idle;
	struct i2c_adapter *parent;
	struct i2c_adapter **busses;
};

static int i2c_mux_pinctrl_select(struct i2c_adapter *adap, void *data,
				  u32 chan)
{
	struct i2c_mux_pinctrl *mux = data;

	return pinctrl_select_state(mux->pinctrl, mux->states[chan]);
}

static int i2c_mux_pinctrl_deselect(struct i2c_adapter *adap, void *data,
				    u32 chan)
{
	struct i2c_mux_pinctrl *mux = data;

	return pinctrl_select_state(mux->pinctrl, mux->state_idle);
}

#ifdef CONFIG_OF
static int i2c_mux_pinctrl_parse_dt(struct i2c_mux_pinctrl *mux,
				struct platform_device *pdev)
{
	struct device_node *np = pdev->dev.of_node;
	int num_names, i, ret;
	struct device_node *adapter_np;
	struct i2c_adapter *adapter;

	if (!np)
		return 0;

	mux->pdata = devm_kzalloc(&pdev->dev, sizeof(*mux->pdata), GFP_KERNEL);
	if (!mux->pdata) {
		dev_err(mux->dev,
			"Cannot allocate i2c_mux_pinctrl_platform_data\n");
		return -ENOMEM;
	}

	num_names = of_property_count_strings(np, "pinctrl-names");
	if (num_names < 0) {
		dev_err(mux->dev, "Cannot parse pinctrl-names: %d\n",
			num_names);
		return num_names;
	}

	mux->pdata->pinctrl_states = devm_kzalloc(&pdev->dev,
		sizeof(*mux->pdata->pinctrl_states) * num_names,
		GFP_KERNEL);
	if (!mux->pdata->pinctrl_states) {
		dev_err(mux->dev, "Cannot allocate pinctrl_states\n");
		return -ENOMEM;
	}

	for (i = 0; i < num_names; i++) {
		ret = of_property_read_string_index(np, "pinctrl-names", i,
			&mux->pdata->pinctrl_states[mux->pdata->bus_count]);
		if (ret < 0) {
			dev_err(mux->dev, "Cannot parse pinctrl-names: %d\n",
				ret);
			return ret;
		}
		if (!strcmp(mux->pdata->pinctrl_states[mux->pdata->bus_count],
			    "idle")) {
			if (i != num_names - 1) {
				dev_err(mux->dev, "idle state must be last\n");
				return -EINVAL;
			}
			mux->pdata->pinctrl_state_idle = "idle";
		} else {
			mux->pdata->bus_count++;
		}
	}

	adapter_np = of_parse_phandle(np, "i2c-parent", 0);
	if (!adapter_np) {
		dev_err(mux->dev, "Cannot parse i2c-parent\n");
		return -ENODEV;
	}
	adapter = of_find_i2c_adapter_by_node(adapter_np);
	if (!adapter) {
		dev_err(mux->dev, "Cannot find parent bus\n");
		return -ENODEV;
	}
	mux->pdata->parent_bus_num = i2c_adapter_id(adapter);
	put_device(&adapter->dev);

	return 0;
}
#else
static inline int i2c_mux_pinctrl_parse_dt(struct i2c_mux_pinctrl *mux,
					   struct platform_device *pdev)
{
	return 0;
}
#endif

static int i2c_mux_pinctrl_probe(struct platform_device *pdev)
{
	struct i2c_mux_pinctrl *mux;
	int (*deselect)(struct i2c_adapter *, void *, u32);
	int i, ret;

	mux = devm_kzalloc(&pdev->dev, sizeof(*mux), GFP_KERNEL);
	if (!mux) {
		dev_err(&pdev->dev, "Cannot allocate i2c_mux_pinctrl\n");
		ret = -ENOMEM;
		goto err;
	}
	platform_set_drvdata(pdev, mux);

	mux->dev = &pdev->dev;

	mux->pdata = pdev->dev.platform_data;
	if (!mux->pdata) {
		ret = i2c_mux_pinctrl_parse_dt(mux, pdev);
		if (ret < 0)
			goto err;
	}
	if (!mux->pdata) {
		dev_err(&pdev->dev, "Missing platform data\n");
		ret = -ENODEV;
		goto err;
	}

	mux->states = devm_kzalloc(&pdev->dev,
				   sizeof(*mux->states) * mux->pdata->bus_count,
				   GFP_KERNEL);
	if (!mux->states) {
		dev_err(&pdev->dev, "Cannot allocate states\n");
		ret = -ENOMEM;
		goto err;
	}

	mux->busses = devm_kzalloc(&pdev->dev,
				   sizeof(*mux->busses) * mux->pdata->bus_count,
				   GFP_KERNEL);
	if (!mux->busses) {
		dev_err(&pdev->dev, "Cannot allocate busses\n");
		ret = -ENOMEM;
		goto err;
	}

	mux->pinctrl = devm_pinctrl_get(&pdev->dev);
	if (IS_ERR(mux->pinctrl)) {
		ret = PTR_ERR(mux->pinctrl);
		dev_err(&pdev->dev, "Cannot get pinctrl: %d\n", ret);
		goto err;
	}
	for (i = 0; i < mux->pdata->bus_count; i++) {
		mux->states[i] = pinctrl_lookup_state(mux->pinctrl,
						mux->pdata->pinctrl_states[i]);
			if (IS_ERR(mux->states[i])) {
				ret = PTR_ERR(mux->states[i]);
				dev_err(&pdev->dev,
					"Cannot look up pinctrl state %s: %d\n",
					mux->pdata->pinctrl_states[i], ret);
				goto err;
			}
	}
	if (mux->pdata->pinctrl_state_idle) {
		mux->state_idle = pinctrl_lookup_state(mux->pinctrl,
						mux->pdata->pinctrl_state_idle);
		if (IS_ERR(mux->state_idle)) {
			ret = PTR_ERR(mux->state_idle);
			dev_err(&pdev->dev,
				"Cannot look up pinctrl state %s: %d\n",
				mux->pdata->pinctrl_state_idle, ret);
			goto err;
		}

		deselect = i2c_mux_pinctrl_deselect;
	} else {
		deselect = NULL;
	}

	mux->parent = i2c_get_adapter(mux->pdata->parent_bus_num);
	if (!mux->parent) {
		dev_err(&pdev->dev, "Parent adapter (%d) not found\n",
			mux->pdata->parent_bus_num);
		ret = -ENODEV;
		goto err;
	}

	for (i = 0; i < mux->pdata->bus_count; i++) {
		u32 bus = mux->pdata->base_bus_num ?
				(mux->pdata->base_bus_num + i) : 0;

		mux->busses[i] = i2c_add_mux_adapter(mux->parent, &pdev->dev,
						     mux, bus, i, 0,
						     i2c_mux_pinctrl_select,
						     deselect);
		if (!mux->busses[i]) {
			ret = -ENODEV;
			dev_err(&pdev->dev, "Failed to add adapter %d\n", i);
			goto err_del_adapter;
		}
	}

	return 0;

err_del_adapter:
	for (; i > 0; i--)
		i2c_del_mux_adapter(mux->busses[i - 1]);
	i2c_put_adapter(mux->parent);
err:
	return ret;
}

static int i2c_mux_pinctrl_remove(struct platform_device *pdev)
{
	struct i2c_mux_pinctrl *mux = platform_get_drvdata(pdev);
	int i;

	for (i = 0; i < mux->pdata->bus_count; i++)
		i2c_del_mux_adapter(mux->busses[i]);

	i2c_put_adapter(mux->parent);

	return 0;
}

#ifdef CONFIG_OF
static const struct of_device_id i2c_mux_pinctrl_of_match[] = {
	{ .compatible = "i2c-mux-pinctrl", },
	{},
};
MODULE_DEVICE_TABLE(of, i2c_mux_pinctrl_of_match);
#endif

static struct platform_driver i2c_mux_pinctrl_driver = {
	.driver	= {
		.name	= "i2c-mux-pinctrl",
		.owner	= THIS_MODULE,
		.of_match_table = of_match_ptr(i2c_mux_pinctrl_of_match),
	},
	.probe	= i2c_mux_pinctrl_probe,
	.remove	= i2c_mux_pinctrl_remove,
};
module_platform_driver(i2c_mux_pinctrl_driver);

MODULE_DESCRIPTION("pinctrl-based I2C multiplexer driver");
MODULE_AUTHOR("Stephen Warren <swarren@nvidia.com>");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:i2c-mux-pinctrl");
Commit	Line	Data
ae58d1e4 SW	1	/*
	2	* I2C multiplexer using pinctrl API
	3	*
	4	* Copyright (c) 2012, NVIDIA CORPORATION. All rights reserved.
	5	*
	6	* This program is free software; you can redistribute it and/or modify it
	7	* under the terms and conditions of the GNU General Public License,
	8	* version 2, as published by the Free Software Foundation.
	9	*
	10	* This program is distributed in the hope it will be useful, but WITHOUT
	11	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	12	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	13	* more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	17	*/
	18
	19	#include <linux/i2c.h>
	20	#include <linux/i2c-mux.h>
	21	#include <linux/init.h>
	22	#include <linux/module.h>
	23	#include <linux/of_i2c.h>
	24	#include <linux/pinctrl/consumer.h>
	25	#include <linux/i2c-mux-pinctrl.h>
	26	#include <linux/platform_device.h>
	27	#include <linux/slab.h>
	28
	29	struct i2c_mux_pinctrl {
	30	struct device *dev;
	31	struct i2c_mux_pinctrl_platform_data *pdata;
	32	struct pinctrl *pinctrl;
	33	struct pinctrl_state **states;
	34	struct pinctrl_state *state_idle;
	35	struct i2c_adapter *parent;
	36	struct i2c_adapter **busses;
	37	};
	38
	39	static int i2c_mux_pinctrl_select(struct i2c_adapter adap, void data,
	40	u32 chan)
	41	{
	42	struct i2c_mux_pinctrl *mux = data;
	43
	44	return pinctrl_select_state(mux->pinctrl, mux->states[chan]);
	45	}
	46
	47	static int i2c_mux_pinctrl_deselect(struct i2c_adapter adap, void data,
	48	u32 chan)
	49	{
	50	struct i2c_mux_pinctrl *mux = data;
	51
	52	return pinctrl_select_state(mux->pinctrl, mux->state_idle);
	53	}
	54
	55	#ifdef CONFIG_OF
	56	static int i2c_mux_pinctrl_parse_dt(struct i2c_mux_pinctrl *mux,
	57	struct platform_device *pdev)
	58	{
	59	struct device_node *np = pdev->dev.of_node;
	60	int num_names, i, ret;
	61	struct device_node *adapter_np;
	62	struct i2c_adapter *adapter;
	63
	64	if (!np)
65	return 0;
66
67	mux->pdata = devm_kzalloc(&pdev->dev, sizeof(*mux->pdata), GFP_KERNEL);
68	if (!mux->pdata) {
69	dev_err(mux->dev,
70	"Cannot allocate i2c_mux_pinctrl_platform_data\n");
71	return -ENOMEM;
72	}
73
74	num_names = of_property_count_strings(np, "pinctrl-names");
75	if (num_names < 0) {
76	dev_err(mux->dev, "Cannot parse pinctrl-names: %d\n",
77	num_names);
78	return num_names;
79	}
80
81	mux->pdata->pinctrl_states = devm_kzalloc(&pdev->dev,
82	sizeof(mux->pdata->pinctrl_states) num_names,
83	GFP_KERNEL);
84	if (!mux->pdata->pinctrl_states) {
85	dev_err(mux->dev, "Cannot allocate pinctrl_states\n");
86	return -ENOMEM;
87	}
88
89	for (i = 0; i < num_names; i++) {
90	ret = of_property_read_string_index(np, "pinctrl-names", i,
91	&mux->pdata->pinctrl_states[mux->pdata->bus_count]);
92	if (ret < 0) {
93	dev_err(mux->dev, "Cannot parse pinctrl-names: %d\n",
94	ret);
95	return ret;
96	}
97	if (!strcmp(mux->pdata->pinctrl_states[mux->pdata->bus_count],
98	"idle")) {
99	if (i != num_names - 1) {
100	dev_err(mux->dev, "idle state must be last\n");
101	return -EINVAL;
102	}
103	mux->pdata->pinctrl_state_idle = "idle";
104	} else {
105	mux->pdata->bus_count++;
106	}
107	}
108
109	adapter_np = of_parse_phandle(np, "i2c-parent", 0);
110	if (!adapter_np) {
111	dev_err(mux->dev, "Cannot parse i2c-parent\n");
112	return -ENODEV;
113	}
114	adapter = of_find_i2c_adapter_by_node(adapter_np);
115	if (!adapter) {
116	dev_err(mux->dev, "Cannot find parent bus\n");
117	return -ENODEV;
118	}
119	mux->pdata->parent_bus_num = i2c_adapter_id(adapter);
120	put_device(&adapter->dev);
121
122	return 0;
123	}
124	#else
125	static inline int i2c_mux_pinctrl_parse_dt(struct i2c_mux_pinctrl *mux,
126	struct platform_device *pdev)
127	{
128	return 0;
129	}
130	#endif
131
0b255e92	132	static int i2c_mux_pinctrl_probe(struct platform_device *pdev)
ae58d1e4 SW	133	{
	134	struct i2c_mux_pinctrl *mux;
	135	int (deselect)(struct i2c_adapter , void *, u32);
	136	int i, ret;
	137
	138	mux = devm_kzalloc(&pdev->dev, sizeof(*mux), GFP_KERNEL);
	139	if (!mux) {
	140	dev_err(&pdev->dev, "Cannot allocate i2c_mux_pinctrl\n");
	141	ret = -ENOMEM;
	142	goto err;
	143	}
	144	platform_set_drvdata(pdev, mux);
	145
	146	mux->dev = &pdev->dev;
	147
	148	mux->pdata = pdev->dev.platform_data;
	149	if (!mux->pdata) {
	150	ret = i2c_mux_pinctrl_parse_dt(mux, pdev);
	151	if (ret < 0)
	152	goto err;
	153	}
	154	if (!mux->pdata) {
	155	dev_err(&pdev->dev, "Missing platform data\n");
	156	ret = -ENODEV;
	157	goto err;
	158	}
	159
	160	mux->states = devm_kzalloc(&pdev->dev,
	161	sizeof(mux->states) mux->pdata->bus_count,
	162	GFP_KERNEL);
	163	if (!mux->states) {
	164	dev_err(&pdev->dev, "Cannot allocate states\n");
	165	ret = -ENOMEM;
	166	goto err;
	167	}
	168
	169	mux->busses = devm_kzalloc(&pdev->dev,
43a2bd42	170	sizeof(mux->busses) mux->pdata->bus_count,
ae58d1e4	171	GFP_KERNEL);
aa1e3e81	172	if (!mux->busses) {
ae58d1e4 SW	173	dev_err(&pdev->dev, "Cannot allocate busses\n");
	174	ret = -ENOMEM;
	175	goto err;
	176	}
	177
	178	mux->pinctrl = devm_pinctrl_get(&pdev->dev);
	179	if (IS_ERR(mux->pinctrl)) {
	180	ret = PTR_ERR(mux->pinctrl);
	181	dev_err(&pdev->dev, "Cannot get pinctrl: %d\n", ret);
	182	goto err;
	183	}
	184	for (i = 0; i < mux->pdata->bus_count; i++) {
	185	mux->states[i] = pinctrl_lookup_state(mux->pinctrl,
	186	mux->pdata->pinctrl_states[i]);
	187	if (IS_ERR(mux->states[i])) {
	188	ret = PTR_ERR(mux->states[i]);
	189	dev_err(&pdev->dev,
	190	"Cannot look up pinctrl state %s: %d\n",
	191	mux->pdata->pinctrl_states[i], ret);
	192	goto err;
	193	}
	194	}
	195	if (mux->pdata->pinctrl_state_idle) {
	196	mux->state_idle = pinctrl_lookup_state(mux->pinctrl,
	197	mux->pdata->pinctrl_state_idle);
	198	if (IS_ERR(mux->state_idle)) {
	199	ret = PTR_ERR(mux->state_idle);
	200	dev_err(&pdev->dev,
	201	"Cannot look up pinctrl state %s: %d\n",
	202	mux->pdata->pinctrl_state_idle, ret);
	203	goto err;
	204	}
	205
	206	deselect = i2c_mux_pinctrl_deselect;
	207	} else {
	208	deselect = NULL;
	209	}
	210
	211	mux->parent = i2c_get_adapter(mux->pdata->parent_bus_num);
	212	if (!mux->parent) {
	213	dev_err(&pdev->dev, "Parent adapter (%d) not found\n",
	214	mux->pdata->parent_bus_num);
	215	ret = -ENODEV;
	216	goto err;
	217	}
	218
	219	for (i = 0; i < mux->pdata->bus_count; i++) {
	220	u32 bus = mux->pdata->base_bus_num ?
	221	(mux->pdata->base_bus_num + i) : 0;
	222
	223	mux->busses[i] = i2c_add_mux_adapter(mux->parent, &pdev->dev,
eee543e8	224	mux, bus, i, 0,
ae58d1e4 SW	225	i2c_mux_pinctrl_select,
	226	deselect);
	227	if (!mux->busses[i]) {
	228	ret = -ENODEV;
	229	dev_err(&pdev->dev, "Failed to add adapter %d\n", i);
	230	goto err_del_adapter;
	231	}
	232	}
	233
	234	return 0;
	235
	236	err_del_adapter:
	237	for (; i > 0; i--)
	238	i2c_del_mux_adapter(mux->busses[i - 1]);
	239	i2c_put_adapter(mux->parent);
	240	err:
	241	return ret;
	242	}
	243
0b255e92	244	static int i2c_mux_pinctrl_remove(struct platform_device *pdev)
ae58d1e4 SW	245	{
	246	struct i2c_mux_pinctrl *mux = platform_get_drvdata(pdev);
	247	int i;
	248
	249	for (i = 0; i < mux->pdata->bus_count; i++)
	250	i2c_del_mux_adapter(mux->busses[i]);
	251
	252	i2c_put_adapter(mux->parent);
	253
	254	return 0;
	255	}
	256
	257	#ifdef CONFIG_OF
0b255e92	258	static const struct of_device_id i2c_mux_pinctrl_of_match[] = {
ae58d1e4 SW	259	{ .compatible = "i2c-mux-pinctrl", },
	260	{},
	261	};
	262	MODULE_DEVICE_TABLE(of, i2c_mux_pinctrl_of_match);
	263	#endif
	264
	265	static struct platform_driver i2c_mux_pinctrl_driver = {
	266	.driver = {
	267	.name = "i2c-mux-pinctrl",
	268	.owner = THIS_MODULE,
	269	.of_match_table = of_match_ptr(i2c_mux_pinctrl_of_match),
	270	},
	271	.probe = i2c_mux_pinctrl_probe,
0b255e92	272	.remove = i2c_mux_pinctrl_remove,
ae58d1e4 SW	273	};
	274	module_platform_driver(i2c_mux_pinctrl_driver);
	275
	276	MODULE_DESCRIPTION("pinctrl-based I2C multiplexer driver");
	277	MODULE_AUTHOR("Stephen Warren <swarren@nvidia.com>");
	278	MODULE_LICENSE("GPL v2");
	279	MODULE_ALIAS("platform:i2c-mux-pinctrl");