From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1756649AbbFRT55 (ORCPT ); Thu, 18 Jun 2015 15:57:57 -0400 Received: from mail-bl2on0108.outbound.protection.outlook.com ([65.55.169.108]:16920 "EHLO na01-bl2-obe.outbound.protection.outlook.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1752532AbbFRT5u (ORCPT ); Thu, 18 Jun 2015 15:57:50 -0400 Authentication-Results: spf=fail (sender IP is 192.88.158.2) smtp.mailfrom=freescale.com; nokia.com; dkim=none (message not signed) header.d=none; From: York Sun To: CC: , , York Sun , Paul Bolle , Peter Korsgaard , Alexander Sverdlin Subject: [Patch v3] driver/i2c/mux: Add register-based mux i2c-mux-reg Date: Thu, 18 Jun 2015 12:57:38 -0700 Message-ID: <1434657458-16553-1-git-send-email-yorksun@freescale.com> X-Mailer: git-send-email 1.7.9.5 X-EOPAttributedMessage: 0 X-Microsoft-Exchange-Diagnostics: 1;BN1AFFO11FD042;1:ohyAKI7cTwtEo8IrqavyKbTrsKsqKUQvplvXtJiklTl2MTY+aqgLl2rsma8AfrEf+5mxgihYPifN39RkC/nLQkVIVzXSpT0FpzaDHI0cHL50ZIr0Z0HInOzsfefpc7rerhgyxotZ7bXIaFdIfJrHrsoMPIc4+nq9qeNCHyPLu69ORVoY0bMGn3mkgfb69SqR27Kbbmhohwo0ddZ4BFImWWWbAlQJ14aM/xFUIqLjQFS8e1XnMHrgDrfAdztE30+15uXG3ROpJSCpPilz6OYv43hBEzkTjN9wInrtLCay3FzkRHGUt9C/aYoqWLRxBON/C7DjjN5I/XgaA7pzWrrQncskM7/H93W3tNiDfJsOwZ8= X-Forefront-Antispam-Report: CIP:192.88.158.2;CTRY:US;IPV:NLI;EFV:NLI;SFV:NSPM;SFS:(10019020)(6009001)(2980300002)(339900001)(189002)(54534003)(199003)(479174004)(62966003)(105606002)(77156002)(2351001)(229853001)(36756003)(104016003)(33646002)(230783001)(189998001)(106466001)(92566002)(5001960100002)(85426001)(110136002)(86362001)(575784001)(50466002)(6806004)(77096005)(48376002)(47776003)(19580395003)(50226001)(46102003)(50986999)(87936001)(19580405001)(2004002);DIR:OUT;SFP:1102;SCL:1;SRVR:BN1PR03MB154;H:az84smr01.freescale.net;FPR:;SPF:Fail;MLV:ovrnspm;PTR:InfoDomainNonexistent;MX:1;A:1;LANG:en; MIME-Version: 1.0 Content-Type: text/plain X-Microsoft-Exchange-Diagnostics: 1;BN1PR03MB154;2:J+hPzkx+nmigA2W7252kwpwvyxMbWb9SoYHVo6Tsrp9IIW4sTKLTnbOjnRgG080D;2:TtNM8jEngafY0ODEQKMbd2IS44zhe8okYhIoanFZZoZbRTAPlwZ6UMNsbvd1xOWNTP4fiFU97nuHgBEgMnfo19UjlinCqQMmz9ir+O59cl6B9sVlacX+5ZSKQKwARlrET7sJIAIVR5PT9662NuQ54ZRdnrah1p1vUkYHly3/hLLt+Xtu1airPjx6qEBqUzc7vXrg8tlcJYKdiVl+jHwuhMPEGwL7Jf9cZDaH4O3jW60=;6:H4V9kdHONzqt5N7q4LXjG52lkoXArzC+SryXOpvSSD19VM7xWTzOucRfs0ZRY37ChElpOWqG6b8Q6b3ZRZfJIvJVixr15ExHD6OTU0QrwV/jf2zanQfEtxZ8YAAeB62O/7w06Q7ITkmdtMsT3tNvkBj1tYt9ZVAI1dURbWLtF//YXf28PnRDwJxv0RDCFBIrwebd7BG4pmZDfhmU+/Hki+aLAEuoiKEPqQxwFwSdIBR6b88zaMdXpxMpVDh3PGR/GoImPcgCzlpQ3o005Rt9UY3nymYjcklXWPSoXbtqzoS0Ykb/b+r4NMqNm1H6YuKqaevf79Wa6sdKUHrc8NnUJw==;3:p+AWU+nON1SIKGw1pFDiU/pHAZmDGwAAY6lBf5Np2/jTAanV9/hvd2gpBDUHNBE72xNp9WtsPtkcJnN/lUih2WmtMR5meeeTWMs4Av5Ej5RajAxw5RSvvFFzY10Wx4TDHptz3ABwl3YyjfKaFe1lI2HOG6Ma2aWO+gdL7VSAvR+Jfvg8q3CY0htDXN1TDrTW9OS4JkmN3RZD+yDy+Og1vWQanRl9q1LRDG+GPXF4q3cRJaDbDXhHD+ME8mVifcBWFHr7xOGouHw4xuPqfOjEs26cu4me0vRPUZ2UWvM5YKUNCAjaclCG7nd9UAxxGayA X-Microsoft-Antispam: UriScan:;BCL:0;PCL:0;RULEID:;SRVR:BN1PR03MB154; X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:; X-Exchange-Antispam-Report-CFA-Test: BCL:0;PCL:0;RULEID:(601004)(5005006)(520003)(3002001);SRVR:BN1PR03MB154;BCL:0;PCL:0;RULEID:;SRVR:BN1PR03MB154; X-Forefront-PRVS: 0611A21987 X-Microsoft-Exchange-Diagnostics: 1;BN1PR03MB154;9:/d6BaJRrnznFxxQdgNrQii+VDSypvy9Hh2bLyCdShpxlARymh9u5EkYmw+dkayLljf1Jv76eOhFMmqtzEIeCbr6K6txagOB34bnu7TyaJ+SGTrF74UToriwUodyQK+3vCItcaNSKjdtwN818f+MDz5RCm+0eeSKbRZs3kHJGCj50V8AAzcoxBaVEd+0VlBUAI7FeBpM67Zttb4tPF8PRf4Ll0ClII5Hj9G1zkWEXHzkxEJGyAzJoPFUK4GONL4jv1HB/fGRayCo+8b4dhkDdjOrqxjqwF/C3lFSLyxEpYaTaragxJ9umQLkZon21Nn1YLFWKP6QA485ERwDtzI4Ps8v7CqEg0+Z4r/V1SQEp53OaHhRpDJwYzkFPKYsNqIZxXtbLqn7dZ6jNf7FF2vFhP3wHvUE0+/fn5j4jtgopi57VJTdVkwBQzEP41xw3le/KiJViYTKfiUi3lqDj86cSpew1tTH++lIGY0xFWiiBi+rWX72PH6Z6acn1CiRSReeP3YwmO3uBYp6YsK779CLBo9ILhrFBGtty9GUkyjY9n+BvyUvoobVtToEmtZt8MisaRhhhjtT0bziDcSdpLkmBEjYmNmNvx/jRkTnZM60aEIuyLX6lJO7w+MJfNPaqW0kauhj4QZhYz5t4Xr9A+OExeA5AJ5wTTfADvL8Q3uGSBwCPKim1hYfq0j3Ls5MljvblaGY0DHfAKPG1H/ZEdNxrq7dwAKHTRrzLWwxi7zQFSgxYyE1uVUfiYJ+O8CgCu5AvfqRyapeyuRCBGiVUkGSX6N2jkD5DY8G6hqnwmpRlsceNGtjpx6zVYxez5xqixSmiWv4alfE920UJpBspzlb54LIOeWO3zT8lu+2aaW8t1Ry/9itBwI9dByv42MHBS8uzZhLoEFkCRbC6LMObQC9HXVSIux9rLoEWNJv3xG1+uITue1VxqUrXa2X/vNDSDI9l X-Microsoft-Exchange-Diagnostics: 1;BN1PR03MB154;3:98Yu4MEPL8MgqoyjKJZmothiIsxKyZQlnKbxk/Oqu19ZVHOJ14eTAmb+e+ngYHqx8gQkmvEqyK9hFQQE15lvoghO8SSpGlV5z1EJ/fkc+bq6lIeho2sHry15o2cN3HifD/9TDRzBQkAZd2kTg7VJ+Q==;10:ASDuyxX2uJOJxFu/O1rh5l5ebofRVoozm1c9ibzaF6/aEvTTFixd2adXVa6DwUA+Cq76UYWZ3tsuu+rBtCJ/8Z4B7fqsWJ9BOy5ES8wktMs=;6:5It9e5OZpLjxd8rNr31On8yAa2SLdxbjTrCpYPc7XE83TuzwCRlKuZ9siKJH0JOT X-OriginatorOrg: freescale.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 18 Jun 2015 19:57:46.7757 (UTC) X-MS-Exchange-CrossTenant-Id: 710a03f5-10f6-4d38-9ff4-a80b81da590d X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=710a03f5-10f6-4d38-9ff4-a80b81da590d;Ip=[192.88.158.2];Helo=[az84smr01.freescale.net] X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: BN1PR03MB154 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Based on i2c-mux-gpio driver, similarly the register-based mux switch from one bus to another by setting a single register. The register can be on PCIe bus, local bus, or any memory-mapped address. The endianness of such register can be specified in device tree if used, or in platform data. Signed-off-by: York Sun CC: Wolfram Sang CC: Paul Bolle CC: Peter Korsgaard CC: Alexander Sverdlin --- According to Alexander's feedback, readback is added. Different sizes are supported. I stick with iowrite but adding an option to use iowrite big endian in in case needed. Both big- and little-endian are tested. Comments are updated. Change log: v3: Add support of both big- and little-endian register Add readback after writing to register Add no-read option. By default, readback is alowed. Fix using chan_id transferred back from i2c-mux. It was mistakenly used as an index. It is actually the data to be written. v2: Update to GPLv2+ licence header Use iowrite instead of direct dereference the pointer to write register Add support of difference register size of 1/2/4 bytes Remove i2c_put_adapter(parent) in probe fucntion Replace multiple dev_info() with dev_dbg() Add idle_in_use variable to gate using idle value Add __iomem for register pointer Move platform data header file to include/linux/platform_data/ .../devicetree/bindings/i2c/i2c-mux-reg.txt | 75 +++++ drivers/i2c/muxes/Kconfig | 11 + drivers/i2c/muxes/Makefile | 1 + drivers/i2c/muxes/i2c-mux-reg.c | 299 ++++++++++++++++++++ include/linux/platform_data/i2c-mux-reg.h | 44 +++ 5 files changed, 430 insertions(+) create mode 100644 Documentation/devicetree/bindings/i2c/i2c-mux-reg.txt create mode 100644 drivers/i2c/muxes/i2c-mux-reg.c create mode 100644 include/linux/platform_data/i2c-mux-reg.h diff --git a/Documentation/devicetree/bindings/i2c/i2c-mux-reg.txt b/Documentation/devicetree/bindings/i2c/i2c-mux-reg.txt new file mode 100644 index 0000000..6e3197f --- /dev/null +++ b/Documentation/devicetree/bindings/i2c/i2c-mux-reg.txt @@ -0,0 +1,75 @@ +Register-based I2C Bus Mux + +This binding describes an I2C bus multiplexer that uses a single register +to route the I2C signals. + +Required properties: +- compatible: i2c-mux-reg +- i2c-parent: The phandle of the I2C bus that this multiplexer's master-side + port is connected to. +* Standard I2C mux properties. See mux.txt in this directory. +* I2C child bus nodes. See mux.txt in this directory. + +Optional properties: +- reg: this pair of specifies the register to control the mux. + The depends on its parent node. It can be any memory-mapped + address. The size must be either 1, 2, or 4 bytes. If reg is omitted, the + resource of this device will be used. +- little-endian: The existence indicates the register is in little endian. + If omitted, the endianness of the host will be used. +- no-read: The existence indicates reading the register is not allowed. +- idle-state: value to set the muxer to when idle. When no value is + given, it defaults to the last value used. + +For each i2c child node, an I2C child bus will be created. They will +be numbered based on their order in the device tree. + +Whenever an access is made to a device on a child bus, the value set +in the revelant node's reg property will be output to the register. + +If an idle state is defined, using the idle-state (optional) property, +whenever an access is not being made to a device on a child bus, the +register will be set according to the idle value. + +If an idle state is not defined, the most recently used value will be +left programmed into the register. + +Example of a mux on PCIe card, the host is a powerpc SoC (big endian): + + i2c-mux { + /* the depends on the address translation + * of the parent device. If omitted, device resource + * will be used instead. The size is to determine + * whether iowrite32, iowrite16, or iowrite8 will be used. + */ + reg = <0x6028 0x4>; + little-endian; /* little endian register on PCIe */ + compatible = "i2c-mux-reg"; + #address-cells = <1>; + #size-cells = <0>; + i2c-parent = <&i2c1>; + i2c@0 { + reg = <0>; + #address-cells = <1>; + #size-cells = <0>; + + si5338: clock-generator@70 { + compatible = "silabs,si5338"; + reg = <0x70>; + /* other stuff */ + }; + }; + + i2c@1 { + /* data is written using iowrite32 */ + reg = <1>; + #address-cells = <1>; + #size-cells = <0>; + + si5338: clock-generator@70 { + compatible = "silabs,si5338"; + reg = <0x70>; + /* other stuff */ + }; + }; + }; diff --git a/drivers/i2c/muxes/Kconfig b/drivers/i2c/muxes/Kconfig index f6d313e..77c1257 100644 --- a/drivers/i2c/muxes/Kconfig +++ b/drivers/i2c/muxes/Kconfig @@ -29,6 +29,17 @@ config I2C_MUX_GPIO This driver can also be built as a module. If so, the module will be called i2c-mux-gpio. +config I2C_MUX_REG + tristate "Register-based I2C multiplexer" + help + If you say yes to this option, support will be included for a + register based I2C multiplexer. This driver provides access to + I2C busses connected through a MUX, which is controlled + by a sinple register. + + This driver can also be built as a module. If so, the module + will be called i2c-mux-reg. + config I2C_MUX_PCA9541 tristate "NXP PCA9541 I2C Master Selector" help diff --git a/drivers/i2c/muxes/Makefile b/drivers/i2c/muxes/Makefile index 465778b..bc517bb 100644 --- a/drivers/i2c/muxes/Makefile +++ b/drivers/i2c/muxes/Makefile @@ -4,6 +4,7 @@ obj-$(CONFIG_I2C_ARB_GPIO_CHALLENGE) += i2c-arb-gpio-challenge.o obj-$(CONFIG_I2C_MUX_GPIO) += i2c-mux-gpio.o +obj-$(CONFIG_I2C_MUX_REG) += i2c-mux-reg.o obj-$(CONFIG_I2C_MUX_PCA9541) += i2c-mux-pca9541.o obj-$(CONFIG_I2C_MUX_PCA954x) += i2c-mux-pca954x.o obj-$(CONFIG_I2C_MUX_PINCTRL) += i2c-mux-pinctrl.o diff --git a/drivers/i2c/muxes/i2c-mux-reg.c b/drivers/i2c/muxes/i2c-mux-reg.c new file mode 100644 index 0000000..1692aec --- /dev/null +++ b/drivers/i2c/muxes/i2c-mux-reg.c @@ -0,0 +1,299 @@ +/* + * I2C multiplexer using a single register + * + * Copyright 2015 Freescale Semiconductor + * York Sun + * + * 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 +#include +#include +#include +#include +#include +#include +#include +#include + +struct regmux { + struct i2c_adapter *parent; + struct i2c_adapter **adap; /* child busses */ + 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; + + switch (mux->data.reg_size) { + case 4: + if (mux->data.little_endian) { + iowrite32(chan_id, mux->data.reg); + if (!mux->data.no_read) + ioread32(mux->data.reg); + } else { + iowrite32be(chan_id, mux->data.reg); + if (!mux->data.no_read) + ioread32(mux->data.reg); + } + break; + case 2: + if (mux->data.little_endian) { + iowrite16(chan_id, mux->data.reg); + if (!mux->data.no_read) + ioread16(mux->data.reg); + } else { + iowrite16be(chan_id, mux->data.reg); + if (!mux->data.no_read) + ioread16be(mux->data.reg); + } + break; + case 1: + iowrite8(chan_id, mux->data.reg); + if (!mux->data.no_read) + ioread8(mux->data.reg); + break; + default: + pr_err("Invalid register size\n"); + return -EINVAL; + } + + return 0; +} + +static int i2c_mux_reg_select(struct i2c_adapter *adap, void *data, + unsigned int chan) +{ + struct regmux *mux = data; + + return i2c_mux_reg_set(mux, chan); +} + +static int i2c_mux_reg_deselect(struct i2c_adapter *adap, void *data, + unsigned int chan) +{ + struct regmux *mux = data; + + 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); + if (!adapter) { + dev_err(&pdev->dev, "Cannot find parent bus\n"); + return -EPROBE_DEFER; + } + mux->parent = adapter; + mux->data.parent = i2c_adapter_id(adapter); + put_device(&adapter->dev); + + mux->data.n_values = of_get_child_count(np); + if (of_find_property(np, "little-endian", NULL)) { + mux->data.little_endian = true; + } else { +#ifdef __LITTLE_ENDIAN__ + mux->data.little_endian = true; +#elif defined(__BIG_ENDIAN__) + mux->data.little_endian = false; +#else +#error Endianness not defined? +#endif + } + if (of_find_property(np, "no-read", NULL)) + mux->data.no_read = true; + else + mux->data.no_read = false; + + values = devm_kzalloc(&pdev->dev, + sizeof(*mux->data.values) * mux->data.n_values, + GFP_KERNEL); + if (!values) { + dev_err(&pdev->dev, "Cannot allocate values array"); + 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)) { + mux->data.reg_size = resource_size(&res); + if (mux->data.reg_size > 4) { + dev_err(&pdev->dev, "Invalid address size\n"); + return -EINVAL; + } + 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 gpiomux *mux, + struct platform_device *pdev) +{ + return 0; +} +#endif + +static int i2c_mux_reg_probe(struct platform_device *pdev) +{ + struct regmux *mux; + struct i2c_adapter *parent; + struct resource *res; + int (*deselect)(struct i2c_adapter *, void *, u32); + unsigned int initial_state, class; + int i, ret, nr; + + mux = devm_kzalloc(&pdev->dev, sizeof(*mux), GFP_KERNEL); + if (!mux) + return -ENOMEM; + + platform_set_drvdata(pdev, mux); + + if (dev_get_platdata(&pdev->dev)) { + memcpy(&mux->data, dev_get_platdata(&pdev->dev), + sizeof(mux->data)); + + parent = i2c_get_adapter(mux->data.parent); + if (!parent) { + dev_err(&pdev->dev, "Parent adapter (%d) not found\n", + mux->data.parent); + return -EPROBE_DEFER; + } + mux->parent = parent; + } else { + ret = i2c_mux_reg_probe_dt(mux, pdev); + if (ret < 0) { + dev_err(&pdev->dev, "Error parsing device tree"); + return ret; + } + } + + 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); + if (mux->data.reg_size > 4) { + dev_err(&pdev->dev, "Invalid resource size\n"); + return -EINVAL; + } + mux->data.reg = devm_ioremap_resource(&pdev->dev, res); + if (IS_ERR(mux->data.reg)) + return PTR_ERR(mux->data.reg); + } + + mux->adap = devm_kzalloc(&pdev->dev, + sizeof(*mux->adap) * mux->data.n_values, + GFP_KERNEL); + if (!mux->adap) { + dev_err(&pdev->dev, "Cannot allocate i2c_adapter structure"); + return -ENOMEM; + } + + if (mux->data.idle_in_use) { + initial_state = mux->data.idle; + deselect = i2c_mux_reg_deselect; + } else { + initial_state = mux->data.values[0]; + deselect = NULL; + } + + 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; + + mux->adap[i] = i2c_add_mux_adapter(mux->parent, &pdev->dev, mux, + nr, mux->data.values[i], + class, i2c_mux_reg_select, + deselect); + if (!mux->adap[i]) { + ret = -ENODEV; + dev_err(&pdev->dev, "Failed to add adapter %d\n", i); + goto add_adapter_failed; + } + } + + dev_dbg(&pdev->dev, "%d port mux on %s adapter\n", + mux->data.n_values, mux->parent->name); + + return 0; + +add_adapter_failed: + for (; i > 0; i--) + i2c_del_mux_adapter(mux->adap[i - 1]); + + return ret; +} + +static int i2c_mux_reg_remove(struct platform_device *pdev) +{ + struct regmux *mux = platform_get_drvdata(pdev); + int i; + + for (i = 0; i < mux->data.n_values; i++) + i2c_del_mux_adapter(mux->adap[i]); + + i2c_put_adapter(mux->parent); + + dev_dbg(&pdev->dev, "Removed\n"); + + 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 = { + .owner = THIS_MODULE, + .name = "i2c-mux-reg", + }, +}; + +module_platform_driver(i2c_mux_reg_driver); + +MODULE_DESCRIPTION("Register-based I2C multiplexer driver"); +MODULE_AUTHOR("York Sun "); +MODULE_LICENSE("GPL"); +MODULE_ALIAS("platform:i2c-mux-reg"); diff --git a/include/linux/platform_data/i2c-mux-reg.h b/include/linux/platform_data/i2c-mux-reg.h new file mode 100644 index 0000000..cf0cc1e --- /dev/null +++ b/include/linux/platform_data/i2c-mux-reg.h @@ -0,0 +1,44 @@ +/* + * I2C multiplexer using a single register + * + * Copyright 2015 Freescale Semiconductor + * York Sun + * + * 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. + */ + +#ifndef __LINUX_PLATFORM_DATA_I2C_MUX_REG_H +#define __LINUX_PLATFORM_DATA_I2C_MUX_REG_H + +/** + * struct i2c_mux_reg_platform_data - Platform-dependent data for i2c-mux-reg + * @parent: Parent I2C bus adapter number + * @base_nr: Base I2C bus number to number adapters from or zero for dynamic + * @values: Array of value for each channel + * @n_values: Number of multiplexer channels + * @little_endian: Indicating if the register is in little endian + * @no_read: Reading the register is not allowed by hardware + * @classes: Optional I2C auto-detection classes + * @idle: Value to write to mux when idle + * @idle_in_use: indicate if idle value is in use + * @reg: Virtual address of the register to switch channel + * @reg_size: register size in bytes + */ +struct i2c_mux_reg_platform_data { + int parent; + int base_nr; + const unsigned int *values; + int n_values; + bool little_endian; + bool no_read; + const unsigned int *classes; + u32 idle; + bool idle_in_use; + void __iomem *reg; + resource_size_t reg_size; +}; + +#endif /* __LINUX_PLATFORM_DATA_I2C_MUX_REG_H */ -- 1.7.9.5