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

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * I2C multiplexer using GPIO API
   4  *
   5  * Peter Korsgaard <peter.korsgaard@barco.com>
   6  */
   7
   8 #include <linux/i2c.h>
   9 #include <linux/i2c-mux.h>
  10 #include <linux/platform_data/i2c-mux-gpio.h>
  11 #include <linux/platform_device.h>
  12 #include <linux/module.h>
  13 #include <linux/slab.h>
  14 #include <linux/gpio.h>
  15 #include "../../gpio/gpiolib.h"
  16 #include <linux/of_gpio.h>
  17
  18 struct gpiomux {
  19         struct i2c_mux_gpio_platform_data data;
  20         unsigned gpio_base;
  21         struct gpio_desc **gpios;
  22 };
  23
  24 static void i2c_mux_gpio_set(const struct gpiomux *mux, unsigned val)
  25 {
  26         DECLARE_BITMAP(values, BITS_PER_TYPE(val));
  27
  28         values[0] = val;
  29
  30         gpiod_set_array_value_cansleep(mux->data.n_gpios, mux->gpios, NULL,
  31                                        values);
  32 }
  33
  34 static int i2c_mux_gpio_select(struct i2c_mux_core *muxc, u32 chan)
  35 {
  36         struct gpiomux *mux = i2c_mux_priv(muxc);
  37
  38         i2c_mux_gpio_set(mux, chan);
  39
  40         return 0;
  41 }
  42
  43 static int i2c_mux_gpio_deselect(struct i2c_mux_core *muxc, u32 chan)
  44 {
  45         struct gpiomux *mux = i2c_mux_priv(muxc);
  46
  47         i2c_mux_gpio_set(mux, mux->data.idle);
  48
  49         return 0;
  50 }
  51
  52 static int match_gpio_chip_by_label(struct gpio_chip *chip,
  53                                               void *data)
  54 {
  55         return !strcmp(chip->label, data);
  56 }
  57
  58 #ifdef CONFIG_OF
  59 static int i2c_mux_gpio_probe_dt(struct gpiomux *mux,
  60                                         struct platform_device *pdev)
  61 {
  62         struct device_node *np = pdev->dev.of_node;
  63         struct device_node *adapter_np, *child;
  64         struct i2c_adapter *adapter;
  65         unsigned *values, *gpios;
  66         int i = 0, ret;
  67
  68         if (!np)
  69                 return -ENODEV;
  70
  71         adapter_np = of_parse_phandle(np, "i2c-parent", 0);
  72         if (!adapter_np) {
  73                 dev_err(&pdev->dev, "Cannot parse i2c-parent\n");
  74                 return -ENODEV;
  75         }
  76         adapter = of_find_i2c_adapter_by_node(adapter_np);
  77         of_node_put(adapter_np);
  78         if (!adapter)
  79                 return -EPROBE_DEFER;
  80
  81         mux->data.parent = i2c_adapter_id(adapter);
  82         put_device(&adapter->dev);
  83
  84         mux->data.n_values = of_get_child_count(np);
  85
  86         values = devm_kcalloc(&pdev->dev,
  87                               mux->data.n_values, sizeof(*mux->data.values),
  88                               GFP_KERNEL);
  89         if (!values) {
  90                 dev_err(&pdev->dev, "Cannot allocate values array");
  91                 return -ENOMEM;
  92         }
  93
  94         for_each_child_of_node(np, child) {
  95                 of_property_read_u32(child, "reg", values + i);
  96                 i++;
  97         }
  98         mux->data.values = values;
  99
 100         if (of_property_read_u32(np, "idle-state", &mux->data.idle))
 101                 mux->data.idle = I2C_MUX_GPIO_NO_IDLE;
 102
 103         mux->data.n_gpios = of_gpio_named_count(np, "mux-gpios");
 104         if (mux->data.n_gpios < 0) {
 105                 dev_err(&pdev->dev, "Missing mux-gpios property in the DT.\n");
 106                 return -EINVAL;
 107         }
 108
 109         gpios = devm_kcalloc(&pdev->dev,
 110                              mux->data.n_gpios, sizeof(*mux->data.gpios),
 111                              GFP_KERNEL);
 112         if (!gpios) {
 113                 dev_err(&pdev->dev, "Cannot allocate gpios array");
 114                 return -ENOMEM;
 115         }
 116
 117         for (i = 0; i < mux->data.n_gpios; i++) {
 118                 ret = of_get_named_gpio(np, "mux-gpios", i);
 119                 if (ret < 0)
 120                         return ret;
 121                 gpios[i] = ret;
 122         }
 123
 124         mux->data.gpios = gpios;
 125
 126         return 0;
 127 }
 128 #else
 129 static int i2c_mux_gpio_probe_dt(struct gpiomux *mux,
 130                                         struct platform_device *pdev)
 131 {
 132         return 0;
 133 }
 134 #endif
 135
 136 static int i2c_mux_gpio_probe(struct platform_device *pdev)
 137 {
 138         struct i2c_mux_core *muxc;
 139         struct gpiomux *mux;
 140         struct i2c_adapter *parent;
 141         struct i2c_adapter *root;
 142         unsigned initial_state, gpio_base;
 143         int i, ret;
 144
 145         mux = devm_kzalloc(&pdev->dev, sizeof(*mux), GFP_KERNEL);
 146         if (!mux)
 147                 return -ENOMEM;
 148
 149         if (!dev_get_platdata(&pdev->dev)) {
 150                 ret = i2c_mux_gpio_probe_dt(mux, pdev);
 151                 if (ret < 0)
 152                         return ret;
 153         } else {
 154                 memcpy(&mux->data, dev_get_platdata(&pdev->dev),
 155                         sizeof(mux->data));
 156         }
 157
 158         /*
 159          * If a GPIO chip name is provided, the GPIO pin numbers provided are
 160          * relative to its base GPIO number. Otherwise they are absolute.
 161          */
 162         if (mux->data.gpio_chip) {
 163                 struct gpio_chip *gpio;
 164
 165                 gpio = gpiochip_find(mux->data.gpio_chip,
 166                                      match_gpio_chip_by_label);
 167                 if (!gpio)
 168                         return -EPROBE_DEFER;
 169
 170                 gpio_base = gpio->base;
 171         } else {
 172                 gpio_base = 0;
 173         }
 174
 175         parent = i2c_get_adapter(mux->data.parent);
 176         if (!parent)
 177                 return -EPROBE_DEFER;
 178
 179         muxc = i2c_mux_alloc(parent, &pdev->dev, mux->data.n_values,
 180                              mux->data.n_gpios * sizeof(*mux->gpios), 0,
 181                              i2c_mux_gpio_select, NULL);
 182         if (!muxc) {
 183                 ret = -ENOMEM;
 184                 goto alloc_failed;
 185         }
 186         mux->gpios = muxc->priv;
 187         muxc->priv = mux;
 188
 189         platform_set_drvdata(pdev, muxc);
 190
 191         root = i2c_root_adapter(&parent->dev);
 192
 193         muxc->mux_locked = true;
 194         mux->gpio_base = gpio_base;
 195
 196         if (mux->data.idle != I2C_MUX_GPIO_NO_IDLE) {
 197                 initial_state = mux->data.idle;
 198                 muxc->deselect = i2c_mux_gpio_deselect;
 199         } else {
 200                 initial_state = mux->data.values[0];
 201         }
 202
 203         for (i = 0; i < mux->data.n_gpios; i++) {
 204                 struct device *gpio_dev;
 205                 struct gpio_desc *gpio_desc;
 206
 207                 ret = gpio_request(gpio_base + mux->data.gpios[i], "i2c-mux-gpio");
 208                 if (ret) {
 209                         dev_err(&pdev->dev, "Failed to request GPIO %d\n",
 210                                 mux->data.gpios[i]);
 211                         goto err_request_gpio;
 212                 }
 213
 214                 ret = gpio_direction_output(gpio_base + mux->data.gpios[i],
 215                                             initial_state & (1 << i));
 216                 if (ret) {
 217                         dev_err(&pdev->dev,
 218                                 "Failed to set direction of GPIO %d to output\n",
 219                                 mux->data.gpios[i]);
 220                         i++;    /* gpio_request above succeeded, so must free */
 221                         goto err_request_gpio;
 222                 }
 223
 224                 gpio_desc = gpio_to_desc(gpio_base + mux->data.gpios[i]);
 225                 mux->gpios[i] = gpio_desc;
 226
 227                 if (!muxc->mux_locked)
 228                         continue;
 229
 230                 gpio_dev = &gpio_desc->gdev->dev;
 231                 muxc->mux_locked = i2c_root_adapter(gpio_dev) == root;
 232         }
 233
 234         if (muxc->mux_locked)
 235                 dev_info(&pdev->dev, "mux-locked i2c mux\n");
 236
 237         for (i = 0; i < mux->data.n_values; i++) {
 238                 u32 nr = mux->data.base_nr ? (mux->data.base_nr + i) : 0;
 239                 unsigned int class = mux->data.classes ? mux->data.classes[i] : 0;
 240
 241                 ret = i2c_mux_add_adapter(muxc, nr, mux->data.values[i], class);
 242                 if (ret)
 243                         goto add_adapter_failed;
 244         }
 245
 246         dev_info(&pdev->dev, "%d port mux on %s adapter\n",
 247                  mux->data.n_values, parent->name);
 248
 249         return 0;
 250
 251 add_adapter_failed:
 252         i2c_mux_del_adapters(muxc);
 253         i = mux->data.n_gpios;
 254 err_request_gpio:
 255         for (; i > 0; i--)
 256                 gpio_free(gpio_base + mux->data.gpios[i - 1]);
 257 alloc_failed:
 258         i2c_put_adapter(parent);
 259
 260         return ret;
 261 }
 262
 263 static int i2c_mux_gpio_remove(struct platform_device *pdev)
 264 {
 265         struct i2c_mux_core *muxc = platform_get_drvdata(pdev);
 266         struct gpiomux *mux = i2c_mux_priv(muxc);
 267         int i;
 268
 269         i2c_mux_del_adapters(muxc);
 270
 271         for (i = 0; i < mux->data.n_gpios; i++)
 272                 gpio_free(mux->gpio_base + mux->data.gpios[i]);
 273
 274         i2c_put_adapter(muxc->parent);
 275
 276         return 0;
 277 }
 278
 279 static const struct of_device_id i2c_mux_gpio_of_match[] = {
 280         { .compatible = "i2c-mux-gpio", },
 281         {},
 282 };
 283 MODULE_DEVICE_TABLE(of, i2c_mux_gpio_of_match);
 284
 285 static struct platform_driver i2c_mux_gpio_driver = {
 286         .probe  = i2c_mux_gpio_probe,
 287         .remove = i2c_mux_gpio_remove,
 288         .driver = {
 289                 .name   = "i2c-mux-gpio",
 290                 .of_match_table = i2c_mux_gpio_of_match,
 291         },
 292 };
 293
 294 module_platform_driver(i2c_mux_gpio_driver);
 295
 296 MODULE_DESCRIPTION("GPIO-based I2C multiplexer driver");
 297 MODULE_AUTHOR("Peter Korsgaard <peter.korsgaard@barco.com>");
 298 MODULE_LICENSE("GPL");
 299 MODULE_ALIAS("platform:i2c-mux-gpio");