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