drivers/i2c/muxes/i2c-mux-pinctrl.c

   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/module.h>
  22 #include <linux/pinctrl/consumer.h>
  23 #include <linux/i2c-mux-pinctrl.h>
  24 #include <linux/platform_device.h>
  25 #include <linux/slab.h>
  26 #include <linux/of.h>
  27
  28 struct i2c_mux_pinctrl {
  29         struct device *dev;
  30         struct i2c_mux_pinctrl_platform_data *pdata;
  31         struct pinctrl *pinctrl;
  32         struct pinctrl_state **states;
  33         struct pinctrl_state *state_idle;
  34         struct i2c_adapter *parent;
  35         struct i2c_adapter **busses;
  36 };
  37
  38 static int i2c_mux_pinctrl_select(struct i2c_adapter *adap, void *data,
  39                                   u32 chan)
  40 {
  41         struct i2c_mux_pinctrl *mux = data;
  42
  43         return pinctrl_select_state(mux->pinctrl, mux->states[chan]);
  44 }
  45
  46 static int i2c_mux_pinctrl_deselect(struct i2c_adapter *adap, void *data,
  47                                     u32 chan)
  48 {
  49         struct i2c_mux_pinctrl *mux = data;
  50
  51         return pinctrl_select_state(mux->pinctrl, mux->state_idle);
  52 }
  53
  54 #ifdef CONFIG_OF
  55 static int i2c_mux_pinctrl_parse_dt(struct i2c_mux_pinctrl *mux,
  56                                 struct platform_device *pdev)
  57 {
  58         struct device_node *np = pdev->dev.of_node;
  59         int num_names, i, ret;
  60         struct device_node *adapter_np;
  61         struct i2c_adapter *adapter;
  62
  63         if (!np)
  64                 return 0;
  65
  66         mux->pdata = devm_kzalloc(&pdev->dev, sizeof(*mux->pdata), GFP_KERNEL);
  67         if (!mux->pdata) {
  68                 dev_err(mux->dev,
  69                         "Cannot allocate i2c_mux_pinctrl_platform_data\n");
  70                 return -ENOMEM;
  71         }
  72
  73         num_names = of_property_count_strings(np, "pinctrl-names");
  74         if (num_names < 0) {
  75                 dev_err(mux->dev, "Cannot parse pinctrl-names: %d\n",
  76                         num_names);
  77                 return num_names;
  78         }
  79
  80         mux->pdata->pinctrl_states = devm_kzalloc(&pdev->dev,
  81                 sizeof(*mux->pdata->pinctrl_states) * num_names,
  82                 GFP_KERNEL);
  83         if (!mux->pdata->pinctrl_states) {
  84                 dev_err(mux->dev, "Cannot allocate pinctrl_states\n");
  85                 return -ENOMEM;
  86         }
  87
  88         for (i = 0; i < num_names; i++) {
  89                 ret = of_property_read_string_index(np, "pinctrl-names", i,
  90                         &mux->pdata->pinctrl_states[mux->pdata->bus_count]);
  91                 if (ret < 0) {
  92                         dev_err(mux->dev, "Cannot parse pinctrl-names: %d\n",
  93                                 ret);
  94                         return ret;
  95                 }
  96                 if (!strcmp(mux->pdata->pinctrl_states[mux->pdata->bus_count],
  97                             "idle")) {
  98                         if (i != num_names - 1) {
  99                                 dev_err(mux->dev, "idle state must be last\n");
 100                                 return -EINVAL;
 101                         }
 102                         mux->pdata->pinctrl_state_idle = "idle";
 103                 } else {
 104                         mux->pdata->bus_count++;
 105                 }
 106         }
 107
 108         adapter_np = of_parse_phandle(np, "i2c-parent", 0);
 109         if (!adapter_np) {
 110                 dev_err(mux->dev, "Cannot parse i2c-parent\n");
 111                 return -ENODEV;
 112         }
 113         adapter = of_find_i2c_adapter_by_node(adapter_np);
 114         of_node_put(adapter_np);
 115         if (!adapter) {
 116                 dev_err(mux->dev, "Cannot find parent bus\n");
 117                 return -EPROBE_DEFER;
 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
 132 static int i2c_mux_pinctrl_probe(struct platform_device *pdev)
 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 = dev_get_platdata(&pdev->dev);
 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,
 170                                    sizeof(*mux->busses) * mux->pdata->bus_count,
 171                                    GFP_KERNEL);
 172         if (!mux->busses) {
 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 = -EPROBE_DEFER;
 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,
 224                                                      mux, bus, i, 0,
 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
 244 static int i2c_mux_pinctrl_remove(struct platform_device *pdev)
 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
 258 static const struct of_device_id i2c_mux_pinctrl_of_match[] = {
 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                 .of_match_table = of_match_ptr(i2c_mux_pinctrl_of_match),
 269         },
 270         .probe  = i2c_mux_pinctrl_probe,
 271         .remove = i2c_mux_pinctrl_remove,
 272 };
 273 module_platform_driver(i2c_mux_pinctrl_driver);
 274
 275 MODULE_DESCRIPTION("pinctrl-based I2C multiplexer driver");
 276 MODULE_AUTHOR("Stephen Warren <swarren@nvidia.com>");
 277 MODULE_LICENSE("GPL v2");
 278 MODULE_ALIAS("platform:i2c-mux-pinctrl");