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

   1 /*
   2  * I2C multiplexer using GPIO API
   3  *
   4  * Peter Korsgaard <peter.korsgaard@barco.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  */
  10
  11 #include <linux/i2c.h>
  12 #include <linux/i2c-mux.h>
  13 #include <linux/i2c-mux-gpio.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/init.h>
  16 #include <linux/module.h>
  17 #include <linux/slab.h>
  18 #include <linux/gpio.h>
  19 #include <linux/of_i2c.h>
  20 #include <linux/of_gpio.h>
  21
  22 struct gpiomux {
  23         struct i2c_adapter *parent;
  24         struct i2c_adapter **adap; /* child busses */
  25         struct i2c_mux_gpio_platform_data data;
  26         unsigned gpio_base;
  27 };
  28
  29 static void i2c_mux_gpio_set(const struct gpiomux *mux, unsigned val)
  30 {
  31         int i;
  32
  33         for (i = 0; i < mux->data.n_gpios; i++)
  34                 gpio_set_value(mux->gpio_base + mux->data.gpios[i],
  35                                val & (1 << i));
  36 }
  37
  38 static int i2c_mux_gpio_select(struct i2c_adapter *adap, void *data, u32 chan)
  39 {
  40         struct gpiomux *mux = data;
  41
  42         i2c_mux_gpio_set(mux, mux->data.values[chan]);
  43
  44         return 0;
  45 }
  46
  47 static int i2c_mux_gpio_deselect(struct i2c_adapter *adap, void *data, u32 chan)
  48 {
  49         struct gpiomux *mux = data;
  50
  51         i2c_mux_gpio_set(mux, mux->data.idle);
  52
  53         return 0;
  54 }
  55
  56 static int __devinit match_gpio_chip_by_label(struct gpio_chip *chip,
  57                                               void *data)
  58 {
  59         return !strcmp(chip->label, data);
  60 }
  61
  62 #ifdef CONFIG_OF
  63 static int __devinit i2c_mux_gpio_probe_dt(struct gpiomux *mux,
  64                                         struct platform_device *pdev)
  65 {
  66         struct device_node *np = pdev->dev.of_node;
  67         struct device_node *adapter_np, *child;
  68         struct i2c_adapter *adapter;
  69         unsigned *values, *gpios;
  70         int i = 0;
  71
  72         if (!np)
  73                 return -ENODEV;
  74
  75         adapter_np = of_parse_phandle(np, "i2c-parent", 0);
  76         if (!adapter_np) {
  77                 dev_err(&pdev->dev, "Cannot parse i2c-parent\n");
  78                 return -ENODEV;
  79         }
  80         adapter = of_find_i2c_adapter_by_node(adapter_np);
  81         if (!adapter) {
  82                 dev_err(&pdev->dev, "Cannot find parent bus\n");
  83                 return -ENODEV;
  84         }
  85         mux->data.parent = i2c_adapter_id(adapter);
  86         put_device(&adapter->dev);
  87
  88         mux->data.n_values = of_get_child_count(np);
  89
  90         values = devm_kzalloc(&pdev->dev,
  91                               sizeof(*mux->data.values) * mux->data.n_values,
  92                               GFP_KERNEL);
  93         if (!values) {
  94                 dev_err(&pdev->dev, "Cannot allocate values array");
  95                 return -ENOMEM;
  96         }
  97
  98         for_each_child_of_node(np, child) {
  99                 of_property_read_u32(child, "reg", values + i);
 100                 i++;
 101         }
 102         mux->data.values = values;
 103
 104         if (of_property_read_u32(np, "idle-state", &mux->data.idle))
 105                 mux->data.idle = I2C_MUX_GPIO_NO_IDLE;
 106
 107         mux->data.n_gpios = of_gpio_named_count(np, "mux-gpios");
 108         if (mux->data.n_gpios < 0) {
 109                 dev_err(&pdev->dev, "Missing mux-gpios property in the DT.\n");
 110                 return -EINVAL;
 111         }
 112
 113         gpios = devm_kzalloc(&pdev->dev,
 114                              sizeof(*mux->data.gpios) * mux->data.n_gpios, GFP_KERNEL);
 115         if (!gpios) {
 116                 dev_err(&pdev->dev, "Cannot allocate gpios array");
 117                 return -ENOMEM;
 118         }
 119
 120         for (i = 0; i < mux->data.n_gpios; i++)
 121                 gpios[i] = of_get_named_gpio(np, "mux-gpios", i);
 122
 123         mux->data.gpios = gpios;
 124
 125         return 0;
 126 }
 127 #else
 128 static int __devinit i2c_mux_gpio_probe_dt(struct gpiomux *mux,
 129                                         struct platform_device *pdev)
 130 {
 131         return 0;
 132 }
 133 #endif
 134
 135 static int __devinit i2c_mux_gpio_probe(struct platform_device *pdev)
 136 {
 137         struct gpiomux *mux;
 138         struct i2c_adapter *parent;
 139         int (*deselect) (struct i2c_adapter *, void *, u32);
 140         unsigned initial_state, gpio_base;
 141         int i, ret;
 142
 143         mux = devm_kzalloc(&pdev->dev, sizeof(*mux), GFP_KERNEL);
 144         if (!mux) {
 145                 dev_err(&pdev->dev, "Cannot allocate gpiomux structure");
 146                 return -ENOMEM;
 147         }
 148
 149         platform_set_drvdata(pdev, mux);
 150
 151         if (!pdev->dev.platform_data) {
 152                 ret = i2c_mux_gpio_probe_dt(mux, pdev);
 153                 if (ret < 0)
 154                         return ret;
 155         } else
 156                 memcpy(&mux->data, pdev->dev.platform_data, sizeof(mux->data));
 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                 dev_err(&pdev->dev, "Parent adapter (%d) not found\n",
 178                         mux->data.parent);
 179                 return -ENODEV;
 180         }
 181
 182         mux->parent = parent;
 183         mux->gpio_base = gpio_base;
 184
 185         mux->adap = devm_kzalloc(&pdev->dev,
 186                                  sizeof(*mux->adap) * mux->data.n_values,
 187                                  GFP_KERNEL);
 188         if (!mux->adap) {
 189                 dev_err(&pdev->dev, "Cannot allocate i2c_adapter structure");
 190                 ret = -ENOMEM;
 191                 goto alloc_failed;
 192         }
 193
 194         if (mux->data.idle != I2C_MUX_GPIO_NO_IDLE) {
 195                 initial_state = mux->data.idle;
 196                 deselect = i2c_mux_gpio_deselect;
 197         } else {
 198                 initial_state = mux->data.values[0];
 199                 deselect = NULL;
 200         }
 201
 202         for (i = 0; i < mux->data.n_gpios; i++) {
 203                 ret = gpio_request(gpio_base + mux->data.gpios[i], "i2c-mux-gpio");
 204                 if (ret)
 205                         goto err_request_gpio;
 206                 gpio_direction_output(gpio_base + mux->data.gpios[i],
 207                                       initial_state & (1 << i));
 208         }
 209
 210         for (i = 0; i < mux->data.n_values; i++) {
 211                 u32 nr = mux->data.base_nr ? (mux->data.base_nr + i) : 0;
 212                 unsigned int class = mux->data.classes ? mux->data.classes[i] : 0;
 213
 214                 mux->adap[i] = i2c_add_mux_adapter(parent, &pdev->dev, mux, nr,
 215                                                    i, class,
 216                                                    i2c_mux_gpio_select, deselect);
 217                 if (!mux->adap[i]) {
 218                         ret = -ENODEV;
 219                         dev_err(&pdev->dev, "Failed to add adapter %d\n", i);
 220                         goto add_adapter_failed;
 221                 }
 222         }
 223
 224         dev_info(&pdev->dev, "%d port mux on %s adapter\n",
 225                  mux->data.n_values, parent->name);
 226
 227         return 0;
 228
 229 add_adapter_failed:
 230         for (; i > 0; i--)
 231                 i2c_del_mux_adapter(mux->adap[i - 1]);
 232         i = mux->data.n_gpios;
 233 err_request_gpio:
 234         for (; i > 0; i--)
 235                 gpio_free(gpio_base + mux->data.gpios[i - 1]);
 236 alloc_failed:
 237         i2c_put_adapter(parent);
 238
 239         return ret;
 240 }
 241
 242 static int __devexit i2c_mux_gpio_remove(struct platform_device *pdev)
 243 {
 244         struct gpiomux *mux = platform_get_drvdata(pdev);
 245         int i;
 246
 247         for (i = 0; i < mux->data.n_values; i++)
 248                 i2c_del_mux_adapter(mux->adap[i]);
 249
 250         for (i = 0; i < mux->data.n_gpios; i++)
 251                 gpio_free(mux->gpio_base + mux->data.gpios[i]);
 252
 253         platform_set_drvdata(pdev, NULL);
 254         i2c_put_adapter(mux->parent);
 255
 256         return 0;
 257 }
 258
 259 static const struct of_device_id i2c_mux_gpio_of_match[] __devinitconst = {
 260         { .compatible = "i2c-mux-gpio", },
 261         {},
 262 };
 263 MODULE_DEVICE_TABLE(of, i2c_mux_gpio_of_match);
 264
 265 static struct platform_driver i2c_mux_gpio_driver = {
 266         .probe  = i2c_mux_gpio_probe,
 267         .remove = __devexit_p(i2c_mux_gpio_remove),
 268         .driver = {
 269                 .owner  = THIS_MODULE,
 270                 .name   = "i2c-mux-gpio",
 271                 .of_match_table = of_match_ptr(i2c_mux_gpio_of_match),
 272         },
 273 };
 274
 275 module_platform_driver(i2c_mux_gpio_driver);
 276
 277 MODULE_DESCRIPTION("GPIO-based I2C multiplexer driver");
 278 MODULE_AUTHOR("Peter Korsgaard <peter.korsgaard@barco.com>");
 279 MODULE_LICENSE("GPL");
 280 MODULE_ALIAS("platform:i2c-mux-gpio");