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