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"); 300