![Thomas Gleixner](/assets/img/avatar_default.png)
Based on 1 normalized pattern(s): 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 extracted by the scancode license scanner the SPDX license identifier GPL-2.0-or-later has been chosen to replace the boilerplate/reference in 3029 file(s). Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Reviewed-by: Allison Randal <allison@lohutok.net> Cc: linux-spdx@vger.kernel.org Link: https://lkml.kernel.org/r/20190527070032.746973796@linutronix.de Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
272 lines
6.3 KiB
C
272 lines
6.3 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* I2C multiplexer using a single register
|
|
*
|
|
* Copyright 2015 Freescale Semiconductor
|
|
* York Sun <yorksun@freescale.com>
|
|
*/
|
|
|
|
#include <linux/i2c.h>
|
|
#include <linux/i2c-mux.h>
|
|
#include <linux/init.h>
|
|
#include <linux/io.h>
|
|
#include <linux/module.h>
|
|
#include <linux/of_address.h>
|
|
#include <linux/platform_data/i2c-mux-reg.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/slab.h>
|
|
|
|
struct regmux {
|
|
struct i2c_mux_reg_platform_data data;
|
|
};
|
|
|
|
static int i2c_mux_reg_set(const struct regmux *mux, unsigned int chan_id)
|
|
{
|
|
if (!mux->data.reg)
|
|
return -EINVAL;
|
|
|
|
/*
|
|
* Write to the register, followed by a read to ensure the write is
|
|
* completed on a "posted" bus, for example PCI or write buffers.
|
|
* The endianness of reading doesn't matter and the return data
|
|
* is not used.
|
|
*/
|
|
switch (mux->data.reg_size) {
|
|
case 4:
|
|
if (mux->data.little_endian)
|
|
iowrite32(chan_id, mux->data.reg);
|
|
else
|
|
iowrite32be(chan_id, mux->data.reg);
|
|
if (!mux->data.write_only)
|
|
ioread32(mux->data.reg);
|
|
break;
|
|
case 2:
|
|
if (mux->data.little_endian)
|
|
iowrite16(chan_id, mux->data.reg);
|
|
else
|
|
iowrite16be(chan_id, mux->data.reg);
|
|
if (!mux->data.write_only)
|
|
ioread16(mux->data.reg);
|
|
break;
|
|
case 1:
|
|
iowrite8(chan_id, mux->data.reg);
|
|
if (!mux->data.write_only)
|
|
ioread8(mux->data.reg);
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int i2c_mux_reg_select(struct i2c_mux_core *muxc, u32 chan)
|
|
{
|
|
struct regmux *mux = i2c_mux_priv(muxc);
|
|
|
|
return i2c_mux_reg_set(mux, chan);
|
|
}
|
|
|
|
static int i2c_mux_reg_deselect(struct i2c_mux_core *muxc, u32 chan)
|
|
{
|
|
struct regmux *mux = i2c_mux_priv(muxc);
|
|
|
|
if (mux->data.idle_in_use)
|
|
return i2c_mux_reg_set(mux, mux->data.idle);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_OF
|
|
static int i2c_mux_reg_probe_dt(struct regmux *mux,
|
|
struct platform_device *pdev)
|
|
{
|
|
struct device_node *np = pdev->dev.of_node;
|
|
struct device_node *adapter_np, *child;
|
|
struct i2c_adapter *adapter;
|
|
struct resource res;
|
|
unsigned *values;
|
|
int i = 0;
|
|
|
|
if (!np)
|
|
return -ENODEV;
|
|
|
|
adapter_np = of_parse_phandle(np, "i2c-parent", 0);
|
|
if (!adapter_np) {
|
|
dev_err(&pdev->dev, "Cannot parse i2c-parent\n");
|
|
return -ENODEV;
|
|
}
|
|
adapter = of_find_i2c_adapter_by_node(adapter_np);
|
|
of_node_put(adapter_np);
|
|
if (!adapter)
|
|
return -EPROBE_DEFER;
|
|
|
|
mux->data.parent = i2c_adapter_id(adapter);
|
|
put_device(&adapter->dev);
|
|
|
|
mux->data.n_values = of_get_child_count(np);
|
|
if (of_property_read_bool(np, "little-endian")) {
|
|
mux->data.little_endian = true;
|
|
} else if (of_property_read_bool(np, "big-endian")) {
|
|
mux->data.little_endian = false;
|
|
} else {
|
|
#if defined(__BYTE_ORDER) ? __BYTE_ORDER == __LITTLE_ENDIAN : \
|
|
defined(__LITTLE_ENDIAN)
|
|
mux->data.little_endian = true;
|
|
#elif defined(__BYTE_ORDER) ? __BYTE_ORDER == __BIG_ENDIAN : \
|
|
defined(__BIG_ENDIAN)
|
|
mux->data.little_endian = false;
|
|
#else
|
|
#error Endianness not defined?
|
|
#endif
|
|
}
|
|
mux->data.write_only = of_property_read_bool(np, "write-only");
|
|
|
|
values = devm_kcalloc(&pdev->dev,
|
|
mux->data.n_values, sizeof(*mux->data.values),
|
|
GFP_KERNEL);
|
|
if (!values)
|
|
return -ENOMEM;
|
|
|
|
for_each_child_of_node(np, child) {
|
|
of_property_read_u32(child, "reg", values + i);
|
|
i++;
|
|
}
|
|
mux->data.values = values;
|
|
|
|
if (!of_property_read_u32(np, "idle-state", &mux->data.idle))
|
|
mux->data.idle_in_use = true;
|
|
|
|
/* map address from "reg" if exists */
|
|
if (of_address_to_resource(np, 0, &res) == 0) {
|
|
mux->data.reg_size = resource_size(&res);
|
|
mux->data.reg = devm_ioremap_resource(&pdev->dev, &res);
|
|
if (IS_ERR(mux->data.reg))
|
|
return PTR_ERR(mux->data.reg);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#else
|
|
static int i2c_mux_reg_probe_dt(struct regmux *mux,
|
|
struct platform_device *pdev)
|
|
{
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
static int i2c_mux_reg_probe(struct platform_device *pdev)
|
|
{
|
|
struct i2c_mux_core *muxc;
|
|
struct regmux *mux;
|
|
struct i2c_adapter *parent;
|
|
struct resource *res;
|
|
unsigned int class;
|
|
int i, ret, nr;
|
|
|
|
mux = devm_kzalloc(&pdev->dev, sizeof(*mux), GFP_KERNEL);
|
|
if (!mux)
|
|
return -ENOMEM;
|
|
|
|
if (dev_get_platdata(&pdev->dev)) {
|
|
memcpy(&mux->data, dev_get_platdata(&pdev->dev),
|
|
sizeof(mux->data));
|
|
} else {
|
|
ret = i2c_mux_reg_probe_dt(mux, pdev);
|
|
if (ret == -EPROBE_DEFER)
|
|
return ret;
|
|
|
|
if (ret < 0) {
|
|
dev_err(&pdev->dev, "Error parsing device tree");
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
parent = i2c_get_adapter(mux->data.parent);
|
|
if (!parent)
|
|
return -EPROBE_DEFER;
|
|
|
|
if (!mux->data.reg) {
|
|
dev_info(&pdev->dev,
|
|
"Register not set, using platform resource\n");
|
|
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
|
mux->data.reg_size = resource_size(res);
|
|
mux->data.reg = devm_ioremap_resource(&pdev->dev, res);
|
|
if (IS_ERR(mux->data.reg)) {
|
|
ret = PTR_ERR(mux->data.reg);
|
|
goto err_put_parent;
|
|
}
|
|
}
|
|
|
|
if (mux->data.reg_size != 4 && mux->data.reg_size != 2 &&
|
|
mux->data.reg_size != 1) {
|
|
dev_err(&pdev->dev, "Invalid register size\n");
|
|
ret = -EINVAL;
|
|
goto err_put_parent;
|
|
}
|
|
|
|
muxc = i2c_mux_alloc(parent, &pdev->dev, mux->data.n_values, 0, 0,
|
|
i2c_mux_reg_select, NULL);
|
|
if (!muxc) {
|
|
ret = -ENOMEM;
|
|
goto err_put_parent;
|
|
}
|
|
muxc->priv = mux;
|
|
|
|
platform_set_drvdata(pdev, muxc);
|
|
|
|
if (mux->data.idle_in_use)
|
|
muxc->deselect = i2c_mux_reg_deselect;
|
|
|
|
for (i = 0; i < mux->data.n_values; i++) {
|
|
nr = mux->data.base_nr ? (mux->data.base_nr + i) : 0;
|
|
class = mux->data.classes ? mux->data.classes[i] : 0;
|
|
|
|
ret = i2c_mux_add_adapter(muxc, nr, mux->data.values[i], class);
|
|
if (ret)
|
|
goto err_del_mux_adapters;
|
|
}
|
|
|
|
dev_dbg(&pdev->dev, "%d port mux on %s adapter\n",
|
|
mux->data.n_values, muxc->parent->name);
|
|
|
|
return 0;
|
|
|
|
err_del_mux_adapters:
|
|
i2c_mux_del_adapters(muxc);
|
|
err_put_parent:
|
|
i2c_put_adapter(parent);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int i2c_mux_reg_remove(struct platform_device *pdev)
|
|
{
|
|
struct i2c_mux_core *muxc = platform_get_drvdata(pdev);
|
|
|
|
i2c_mux_del_adapters(muxc);
|
|
i2c_put_adapter(muxc->parent);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct of_device_id i2c_mux_reg_of_match[] = {
|
|
{ .compatible = "i2c-mux-reg", },
|
|
{},
|
|
};
|
|
MODULE_DEVICE_TABLE(of, i2c_mux_reg_of_match);
|
|
|
|
static struct platform_driver i2c_mux_reg_driver = {
|
|
.probe = i2c_mux_reg_probe,
|
|
.remove = i2c_mux_reg_remove,
|
|
.driver = {
|
|
.name = "i2c-mux-reg",
|
|
.of_match_table = of_match_ptr(i2c_mux_reg_of_match),
|
|
},
|
|
};
|
|
|
|
module_platform_driver(i2c_mux_reg_driver);
|
|
|
|
MODULE_DESCRIPTION("Register-based I2C multiplexer driver");
|
|
MODULE_AUTHOR("York Sun <yorksun@freescale.com>");
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_ALIAS("platform:i2c-mux-reg");
|