1 /* 2 * I2C multiplexer using pinctrl API 3 * 4 * Copyright (c) 2012, NVIDIA CORPORATION. All rights reserved. 5 * 6 * This program is free software; you can redistribute it and/or modify it 7 * under the terms and conditions of the GNU General Public License, 8 * version 2, as published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 13 * more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program. If not, see <http://www.gnu.org/licenses/>. 17 */ 18 19 #include <linux/i2c.h> 20 #include <linux/i2c-mux.h> 21 #include <linux/init.h> 22 #include <linux/module.h> 23 #include <linux/pinctrl/consumer.h> 24 #include <linux/i2c-mux-pinctrl.h> 25 #include <linux/platform_device.h> 26 #include <linux/slab.h> 27 #include <linux/of.h> 28 29 struct i2c_mux_pinctrl { 30 struct device *dev; 31 struct i2c_mux_pinctrl_platform_data *pdata; 32 struct pinctrl *pinctrl; 33 struct pinctrl_state **states; 34 struct pinctrl_state *state_idle; 35 struct i2c_adapter *parent; 36 struct i2c_adapter **busses; 37 }; 38 39 static int i2c_mux_pinctrl_select(struct i2c_adapter *adap, void *data, 40 u32 chan) 41 { 42 struct i2c_mux_pinctrl *mux = data; 43 44 return pinctrl_select_state(mux->pinctrl, mux->states[chan]); 45 } 46 47 static int i2c_mux_pinctrl_deselect(struct i2c_adapter *adap, void *data, 48 u32 chan) 49 { 50 struct i2c_mux_pinctrl *mux = data; 51 52 return pinctrl_select_state(mux->pinctrl, mux->state_idle); 53 } 54 55 #ifdef CONFIG_OF 56 static int i2c_mux_pinctrl_parse_dt(struct i2c_mux_pinctrl *mux, 57 struct platform_device *pdev) 58 { 59 struct device_node *np = pdev->dev.of_node; 60 int num_names, i, ret; 61 struct device_node *adapter_np; 62 struct i2c_adapter *adapter; 63 64 if (!np) 65 return 0; 66 67 mux->pdata = devm_kzalloc(&pdev->dev, sizeof(*mux->pdata), GFP_KERNEL); 68 if (!mux->pdata) { 69 dev_err(mux->dev, 70 "Cannot allocate i2c_mux_pinctrl_platform_data\n"); 71 return -ENOMEM; 72 } 73 74 num_names = of_property_count_strings(np, "pinctrl-names"); 75 if (num_names < 0) { 76 dev_err(mux->dev, "Cannot parse pinctrl-names: %d\n", 77 num_names); 78 return num_names; 79 } 80 81 mux->pdata->pinctrl_states = devm_kzalloc(&pdev->dev, 82 sizeof(*mux->pdata->pinctrl_states) * num_names, 83 GFP_KERNEL); 84 if (!mux->pdata->pinctrl_states) { 85 dev_err(mux->dev, "Cannot allocate pinctrl_states\n"); 86 return -ENOMEM; 87 } 88 89 for (i = 0; i < num_names; i++) { 90 ret = of_property_read_string_index(np, "pinctrl-names", i, 91 &mux->pdata->pinctrl_states[mux->pdata->bus_count]); 92 if (ret < 0) { 93 dev_err(mux->dev, "Cannot parse pinctrl-names: %d\n", 94 ret); 95 return ret; 96 } 97 if (!strcmp(mux->pdata->pinctrl_states[mux->pdata->bus_count], 98 "idle")) { 99 if (i != num_names - 1) { 100 dev_err(mux->dev, "idle state must be last\n"); 101 return -EINVAL; 102 } 103 mux->pdata->pinctrl_state_idle = "idle"; 104 } else { 105 mux->pdata->bus_count++; 106 } 107 } 108 109 adapter_np = of_parse_phandle(np, "i2c-parent", 0); 110 if (!adapter_np) { 111 dev_err(mux->dev, "Cannot parse i2c-parent\n"); 112 return -ENODEV; 113 } 114 adapter = of_find_i2c_adapter_by_node(adapter_np); 115 if (!adapter) { 116 dev_err(mux->dev, "Cannot find parent bus\n"); 117 return -EPROBE_DEFER; 118 } 119 mux->pdata->parent_bus_num = i2c_adapter_id(adapter); 120 put_device(&adapter->dev); 121 122 return 0; 123 } 124 #else 125 static inline int i2c_mux_pinctrl_parse_dt(struct i2c_mux_pinctrl *mux, 126 struct platform_device *pdev) 127 { 128 return 0; 129 } 130 #endif 131 132 static int i2c_mux_pinctrl_probe(struct platform_device *pdev) 133 { 134 struct i2c_mux_pinctrl *mux; 135 int (*deselect)(struct i2c_adapter *, void *, u32); 136 int i, ret; 137 138 mux = devm_kzalloc(&pdev->dev, sizeof(*mux), GFP_KERNEL); 139 if (!mux) { 140 dev_err(&pdev->dev, "Cannot allocate i2c_mux_pinctrl\n"); 141 ret = -ENOMEM; 142 goto err; 143 } 144 platform_set_drvdata(pdev, mux); 145 146 mux->dev = &pdev->dev; 147 148 mux->pdata = dev_get_platdata(&pdev->dev); 149 if (!mux->pdata) { 150 ret = i2c_mux_pinctrl_parse_dt(mux, pdev); 151 if (ret < 0) 152 goto err; 153 } 154 if (!mux->pdata) { 155 dev_err(&pdev->dev, "Missing platform data\n"); 156 ret = -ENODEV; 157 goto err; 158 } 159 160 mux->states = devm_kzalloc(&pdev->dev, 161 sizeof(*mux->states) * mux->pdata->bus_count, 162 GFP_KERNEL); 163 if (!mux->states) { 164 dev_err(&pdev->dev, "Cannot allocate states\n"); 165 ret = -ENOMEM; 166 goto err; 167 } 168 169 mux->busses = devm_kzalloc(&pdev->dev, 170 sizeof(*mux->busses) * mux->pdata->bus_count, 171 GFP_KERNEL); 172 if (!mux->busses) { 173 dev_err(&pdev->dev, "Cannot allocate busses\n"); 174 ret = -ENOMEM; 175 goto err; 176 } 177 178 mux->pinctrl = devm_pinctrl_get(&pdev->dev); 179 if (IS_ERR(mux->pinctrl)) { 180 ret = PTR_ERR(mux->pinctrl); 181 dev_err(&pdev->dev, "Cannot get pinctrl: %d\n", ret); 182 goto err; 183 } 184 for (i = 0; i < mux->pdata->bus_count; i++) { 185 mux->states[i] = pinctrl_lookup_state(mux->pinctrl, 186 mux->pdata->pinctrl_states[i]); 187 if (IS_ERR(mux->states[i])) { 188 ret = PTR_ERR(mux->states[i]); 189 dev_err(&pdev->dev, 190 "Cannot look up pinctrl state %s: %d\n", 191 mux->pdata->pinctrl_states[i], ret); 192 goto err; 193 } 194 } 195 if (mux->pdata->pinctrl_state_idle) { 196 mux->state_idle = pinctrl_lookup_state(mux->pinctrl, 197 mux->pdata->pinctrl_state_idle); 198 if (IS_ERR(mux->state_idle)) { 199 ret = PTR_ERR(mux->state_idle); 200 dev_err(&pdev->dev, 201 "Cannot look up pinctrl state %s: %d\n", 202 mux->pdata->pinctrl_state_idle, ret); 203 goto err; 204 } 205 206 deselect = i2c_mux_pinctrl_deselect; 207 } else { 208 deselect = NULL; 209 } 210 211 mux->parent = i2c_get_adapter(mux->pdata->parent_bus_num); 212 if (!mux->parent) { 213 dev_err(&pdev->dev, "Parent adapter (%d) not found\n", 214 mux->pdata->parent_bus_num); 215 ret = -EPROBE_DEFER; 216 goto err; 217 } 218 219 for (i = 0; i < mux->pdata->bus_count; i++) { 220 u32 bus = mux->pdata->base_bus_num ? 221 (mux->pdata->base_bus_num + i) : 0; 222 223 mux->busses[i] = i2c_add_mux_adapter(mux->parent, &pdev->dev, 224 mux, bus, i, 0, 225 i2c_mux_pinctrl_select, 226 deselect); 227 if (!mux->busses[i]) { 228 ret = -ENODEV; 229 dev_err(&pdev->dev, "Failed to add adapter %d\n", i); 230 goto err_del_adapter; 231 } 232 } 233 234 return 0; 235 236 err_del_adapter: 237 for (; i > 0; i--) 238 i2c_del_mux_adapter(mux->busses[i - 1]); 239 i2c_put_adapter(mux->parent); 240 err: 241 return ret; 242 } 243 244 static int i2c_mux_pinctrl_remove(struct platform_device *pdev) 245 { 246 struct i2c_mux_pinctrl *mux = platform_get_drvdata(pdev); 247 int i; 248 249 for (i = 0; i < mux->pdata->bus_count; i++) 250 i2c_del_mux_adapter(mux->busses[i]); 251 252 i2c_put_adapter(mux->parent); 253 254 return 0; 255 } 256 257 #ifdef CONFIG_OF 258 static const struct of_device_id i2c_mux_pinctrl_of_match[] = { 259 { .compatible = "i2c-mux-pinctrl", }, 260 {}, 261 }; 262 MODULE_DEVICE_TABLE(of, i2c_mux_pinctrl_of_match); 263 #endif 264 265 static struct platform_driver i2c_mux_pinctrl_driver = { 266 .driver = { 267 .name = "i2c-mux-pinctrl", 268 .owner = THIS_MODULE, 269 .of_match_table = of_match_ptr(i2c_mux_pinctrl_of_match), 270 }, 271 .probe = i2c_mux_pinctrl_probe, 272 .remove = i2c_mux_pinctrl_remove, 273 }; 274 module_platform_driver(i2c_mux_pinctrl_driver); 275 276 MODULE_DESCRIPTION("pinctrl-based I2C multiplexer driver"); 277 MODULE_AUTHOR("Stephen Warren <swarren@nvidia.com>"); 278 MODULE_LICENSE("GPL v2"); 279 MODULE_ALIAS("platform:i2c-mux-pinctrl"); 280