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/bits.h> 15 #include <linux/gpio/consumer.h> 16 /* FIXME: stop poking around inside gpiolib */ 17 #include "../../gpio/gpiolib.h" 18 19 struct gpiomux { 20 struct i2c_mux_gpio_platform_data data; 21 int ngpios; 22 struct gpio_desc **gpios; 23 }; 24 25 static void i2c_mux_gpio_set(const struct gpiomux *mux, unsigned val) 26 { 27 DECLARE_BITMAP(values, BITS_PER_TYPE(val)); 28 29 values[0] = val; 30 31 gpiod_set_array_value_cansleep(mux->ngpios, mux->gpios, NULL, 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 #ifdef CONFIG_ACPI 53 54 static int i2c_mux_gpio_get_acpi_adr(struct device *dev, 55 struct fwnode_handle *fwdev, 56 unsigned int *adr) 57 58 { 59 unsigned long long adr64; 60 acpi_status status; 61 62 status = acpi_evaluate_integer(ACPI_HANDLE_FWNODE(fwdev), 63 METHOD_NAME__ADR, 64 NULL, &adr64); 65 66 if (!ACPI_SUCCESS(status)) { 67 dev_err(dev, "Cannot get address\n"); 68 return -EINVAL; 69 } 70 71 *adr = adr64; 72 if (*adr != adr64) { 73 dev_err(dev, "Address out of range\n"); 74 return -ERANGE; 75 } 76 77 return 0; 78 } 79 80 #else 81 82 static int i2c_mux_gpio_get_acpi_adr(struct device *dev, 83 struct fwnode_handle *fwdev, 84 unsigned int *adr) 85 { 86 return -EINVAL; 87 } 88 89 #endif 90 91 static int i2c_mux_gpio_probe_fw(struct gpiomux *mux, 92 struct platform_device *pdev) 93 { 94 struct device *dev = &pdev->dev; 95 struct device_node *np = dev->of_node; 96 struct device_node *adapter_np; 97 struct i2c_adapter *adapter = NULL; 98 struct fwnode_handle *child; 99 unsigned *values; 100 int rc, i = 0; 101 102 if (is_of_node(dev->fwnode)) { 103 if (!np) 104 return -ENODEV; 105 106 adapter_np = of_parse_phandle(np, "i2c-parent", 0); 107 if (!adapter_np) { 108 dev_err(&pdev->dev, "Cannot parse i2c-parent\n"); 109 return -ENODEV; 110 } 111 adapter = of_find_i2c_adapter_by_node(adapter_np); 112 of_node_put(adapter_np); 113 114 } else if (is_acpi_node(dev->fwnode)) { 115 /* 116 * In ACPI land the mux should be a direct child of the i2c 117 * bus it muxes. 118 */ 119 acpi_handle dev_handle = ACPI_HANDLE(dev->parent); 120 121 adapter = i2c_acpi_find_adapter_by_handle(dev_handle); 122 } 123 124 if (!adapter) 125 return -EPROBE_DEFER; 126 127 mux->data.parent = i2c_adapter_id(adapter); 128 put_device(&adapter->dev); 129 130 mux->data.n_values = device_get_child_node_count(dev); 131 values = devm_kcalloc(dev, 132 mux->data.n_values, sizeof(*mux->data.values), 133 GFP_KERNEL); 134 if (!values) { 135 dev_err(dev, "Cannot allocate values array"); 136 return -ENOMEM; 137 } 138 139 device_for_each_child_node(dev, child) { 140 if (is_of_node(child)) { 141 fwnode_property_read_u32(child, "reg", values + i); 142 143 } else if (is_acpi_node(child)) { 144 rc = i2c_mux_gpio_get_acpi_adr(dev, child, values + i); 145 if (rc) 146 return rc; 147 } 148 149 i++; 150 } 151 mux->data.values = values; 152 153 if (fwnode_property_read_u32(dev->fwnode, "idle-state", &mux->data.idle)) 154 mux->data.idle = I2C_MUX_GPIO_NO_IDLE; 155 156 return 0; 157 } 158 159 static int i2c_mux_gpio_probe(struct platform_device *pdev) 160 { 161 struct i2c_mux_core *muxc; 162 struct gpiomux *mux; 163 struct i2c_adapter *parent; 164 struct i2c_adapter *root; 165 unsigned initial_state; 166 int i, ngpios, ret; 167 168 mux = devm_kzalloc(&pdev->dev, sizeof(*mux), GFP_KERNEL); 169 if (!mux) 170 return -ENOMEM; 171 172 if (!dev_get_platdata(&pdev->dev)) { 173 ret = i2c_mux_gpio_probe_fw(mux, pdev); 174 if (ret < 0) 175 return ret; 176 } else { 177 memcpy(&mux->data, dev_get_platdata(&pdev->dev), 178 sizeof(mux->data)); 179 } 180 181 ngpios = gpiod_count(&pdev->dev, "mux"); 182 if (ngpios <= 0) { 183 dev_err(&pdev->dev, "no valid gpios provided\n"); 184 return ngpios ?: -EINVAL; 185 } 186 mux->ngpios = ngpios; 187 188 parent = i2c_get_adapter(mux->data.parent); 189 if (!parent) 190 return -EPROBE_DEFER; 191 192 muxc = i2c_mux_alloc(parent, &pdev->dev, mux->data.n_values, 193 ngpios * sizeof(*mux->gpios), 0, 194 i2c_mux_gpio_select, NULL); 195 if (!muxc) { 196 ret = -ENOMEM; 197 goto alloc_failed; 198 } 199 mux->gpios = muxc->priv; 200 muxc->priv = mux; 201 202 platform_set_drvdata(pdev, muxc); 203 204 root = i2c_root_adapter(&parent->dev); 205 206 muxc->mux_locked = true; 207 208 if (mux->data.idle != I2C_MUX_GPIO_NO_IDLE) { 209 initial_state = mux->data.idle; 210 muxc->deselect = i2c_mux_gpio_deselect; 211 } else { 212 initial_state = mux->data.values[0]; 213 } 214 215 for (i = 0; i < ngpios; i++) { 216 struct device *gpio_dev; 217 struct gpio_desc *gpiod; 218 enum gpiod_flags flag; 219 220 if (initial_state & BIT(i)) 221 flag = GPIOD_OUT_HIGH; 222 else 223 flag = GPIOD_OUT_LOW; 224 gpiod = devm_gpiod_get_index(&pdev->dev, "mux", i, flag); 225 if (IS_ERR(gpiod)) { 226 ret = PTR_ERR(gpiod); 227 goto alloc_failed; 228 } 229 230 mux->gpios[i] = gpiod; 231 232 if (!muxc->mux_locked) 233 continue; 234 235 /* FIXME: find a proper way to access the GPIO device */ 236 gpio_dev = &gpiod->gdev->dev; 237 muxc->mux_locked = i2c_root_adapter(gpio_dev) == root; 238 } 239 240 if (muxc->mux_locked) 241 dev_info(&pdev->dev, "mux-locked i2c mux\n"); 242 243 for (i = 0; i < mux->data.n_values; i++) { 244 u32 nr = mux->data.base_nr ? (mux->data.base_nr + i) : 0; 245 unsigned int class = mux->data.classes ? mux->data.classes[i] : 0; 246 247 ret = i2c_mux_add_adapter(muxc, nr, mux->data.values[i], class); 248 if (ret) 249 goto add_adapter_failed; 250 } 251 252 dev_info(&pdev->dev, "%d port mux on %s adapter\n", 253 mux->data.n_values, parent->name); 254 255 return 0; 256 257 add_adapter_failed: 258 i2c_mux_del_adapters(muxc); 259 alloc_failed: 260 i2c_put_adapter(parent); 261 262 return ret; 263 } 264 265 static int i2c_mux_gpio_remove(struct platform_device *pdev) 266 { 267 struct i2c_mux_core *muxc = platform_get_drvdata(pdev); 268 269 i2c_mux_del_adapters(muxc); 270 i2c_put_adapter(muxc->parent); 271 272 return 0; 273 } 274 275 static const struct of_device_id i2c_mux_gpio_of_match[] = { 276 { .compatible = "i2c-mux-gpio", }, 277 {}, 278 }; 279 MODULE_DEVICE_TABLE(of, i2c_mux_gpio_of_match); 280 281 static struct platform_driver i2c_mux_gpio_driver = { 282 .probe = i2c_mux_gpio_probe, 283 .remove = i2c_mux_gpio_remove, 284 .driver = { 285 .name = "i2c-mux-gpio", 286 .of_match_table = i2c_mux_gpio_of_match, 287 }, 288 }; 289 290 module_platform_driver(i2c_mux_gpio_driver); 291 292 MODULE_DESCRIPTION("GPIO-based I2C multiplexer driver"); 293 MODULE_AUTHOR("Peter Korsgaard <peter.korsgaard@barco.com>"); 294 MODULE_LICENSE("GPL"); 295 MODULE_ALIAS("platform:i2c-mux-gpio"); 296