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 28 struct i2c_mux_pinctrl { 29 struct device *dev; 30 struct i2c_mux_pinctrl_platform_data *pdata; 31 struct pinctrl *pinctrl; 32 struct pinctrl_state **states; 33 struct pinctrl_state *state_idle; 34 struct i2c_adapter *parent; 35 struct i2c_adapter **busses; 36 }; 37 38 static int i2c_mux_pinctrl_select(struct i2c_adapter *adap, void *data, 39 u32 chan) 40 { 41 struct i2c_mux_pinctrl *mux = data; 42 43 return pinctrl_select_state(mux->pinctrl, mux->states[chan]); 44 } 45 46 static int i2c_mux_pinctrl_deselect(struct i2c_adapter *adap, void *data, 47 u32 chan) 48 { 49 struct i2c_mux_pinctrl *mux = data; 50 51 return pinctrl_select_state(mux->pinctrl, mux->state_idle); 52 } 53 54 #ifdef CONFIG_OF 55 static int i2c_mux_pinctrl_parse_dt(struct i2c_mux_pinctrl *mux, 56 struct platform_device *pdev) 57 { 58 struct device_node *np = pdev->dev.of_node; 59 int num_names, i, ret; 60 struct device_node *adapter_np; 61 struct i2c_adapter *adapter; 62 63 if (!np) 64 return 0; 65 66 mux->pdata = devm_kzalloc(&pdev->dev, sizeof(*mux->pdata), GFP_KERNEL); 67 if (!mux->pdata) { 68 dev_err(mux->dev, 69 "Cannot allocate i2c_mux_pinctrl_platform_data\n"); 70 return -ENOMEM; 71 } 72 73 num_names = of_property_count_strings(np, "pinctrl-names"); 74 if (num_names < 0) { 75 dev_err(mux->dev, "Cannot parse pinctrl-names: %d\n", 76 num_names); 77 return num_names; 78 } 79 80 mux->pdata->pinctrl_states = devm_kzalloc(&pdev->dev, 81 sizeof(*mux->pdata->pinctrl_states) * num_names, 82 GFP_KERNEL); 83 if (!mux->pdata->pinctrl_states) { 84 dev_err(mux->dev, "Cannot allocate pinctrl_states\n"); 85 return -ENOMEM; 86 } 87 88 for (i = 0; i < num_names; i++) { 89 ret = of_property_read_string_index(np, "pinctrl-names", i, 90 &mux->pdata->pinctrl_states[mux->pdata->bus_count]); 91 if (ret < 0) { 92 dev_err(mux->dev, "Cannot parse pinctrl-names: %d\n", 93 ret); 94 return ret; 95 } 96 if (!strcmp(mux->pdata->pinctrl_states[mux->pdata->bus_count], 97 "idle")) { 98 if (i != num_names - 1) { 99 dev_err(mux->dev, "idle state must be last\n"); 100 return -EINVAL; 101 } 102 mux->pdata->pinctrl_state_idle = "idle"; 103 } else { 104 mux->pdata->bus_count++; 105 } 106 } 107 108 adapter_np = of_parse_phandle(np, "i2c-parent", 0); 109 if (!adapter_np) { 110 dev_err(mux->dev, "Cannot parse i2c-parent\n"); 111 return -ENODEV; 112 } 113 adapter = of_find_i2c_adapter_by_node(adapter_np); 114 if (!adapter) { 115 dev_err(mux->dev, "Cannot find parent bus\n"); 116 return -EPROBE_DEFER; 117 } 118 mux->pdata->parent_bus_num = i2c_adapter_id(adapter); 119 put_device(&adapter->dev); 120 121 return 0; 122 } 123 #else 124 static inline int i2c_mux_pinctrl_parse_dt(struct i2c_mux_pinctrl *mux, 125 struct platform_device *pdev) 126 { 127 return 0; 128 } 129 #endif 130 131 static int i2c_mux_pinctrl_probe(struct platform_device *pdev) 132 { 133 struct i2c_mux_pinctrl *mux; 134 int (*deselect)(struct i2c_adapter *, void *, u32); 135 int i, ret; 136 137 mux = devm_kzalloc(&pdev->dev, sizeof(*mux), GFP_KERNEL); 138 if (!mux) { 139 dev_err(&pdev->dev, "Cannot allocate i2c_mux_pinctrl\n"); 140 ret = -ENOMEM; 141 goto err; 142 } 143 platform_set_drvdata(pdev, mux); 144 145 mux->dev = &pdev->dev; 146 147 mux->pdata = dev_get_platdata(&pdev->dev); 148 if (!mux->pdata) { 149 ret = i2c_mux_pinctrl_parse_dt(mux, pdev); 150 if (ret < 0) 151 goto err; 152 } 153 if (!mux->pdata) { 154 dev_err(&pdev->dev, "Missing platform data\n"); 155 ret = -ENODEV; 156 goto err; 157 } 158 159 mux->states = devm_kzalloc(&pdev->dev, 160 sizeof(*mux->states) * mux->pdata->bus_count, 161 GFP_KERNEL); 162 if (!mux->states) { 163 dev_err(&pdev->dev, "Cannot allocate states\n"); 164 ret = -ENOMEM; 165 goto err; 166 } 167 168 mux->busses = devm_kzalloc(&pdev->dev, 169 sizeof(*mux->busses) * mux->pdata->bus_count, 170 GFP_KERNEL); 171 if (!mux->busses) { 172 dev_err(&pdev->dev, "Cannot allocate busses\n"); 173 ret = -ENOMEM; 174 goto err; 175 } 176 177 mux->pinctrl = devm_pinctrl_get(&pdev->dev); 178 if (IS_ERR(mux->pinctrl)) { 179 ret = PTR_ERR(mux->pinctrl); 180 dev_err(&pdev->dev, "Cannot get pinctrl: %d\n", ret); 181 goto err; 182 } 183 for (i = 0; i < mux->pdata->bus_count; i++) { 184 mux->states[i] = pinctrl_lookup_state(mux->pinctrl, 185 mux->pdata->pinctrl_states[i]); 186 if (IS_ERR(mux->states[i])) { 187 ret = PTR_ERR(mux->states[i]); 188 dev_err(&pdev->dev, 189 "Cannot look up pinctrl state %s: %d\n", 190 mux->pdata->pinctrl_states[i], ret); 191 goto err; 192 } 193 } 194 if (mux->pdata->pinctrl_state_idle) { 195 mux->state_idle = pinctrl_lookup_state(mux->pinctrl, 196 mux->pdata->pinctrl_state_idle); 197 if (IS_ERR(mux->state_idle)) { 198 ret = PTR_ERR(mux->state_idle); 199 dev_err(&pdev->dev, 200 "Cannot look up pinctrl state %s: %d\n", 201 mux->pdata->pinctrl_state_idle, ret); 202 goto err; 203 } 204 205 deselect = i2c_mux_pinctrl_deselect; 206 } else { 207 deselect = NULL; 208 } 209 210 mux->parent = i2c_get_adapter(mux->pdata->parent_bus_num); 211 if (!mux->parent) { 212 dev_err(&pdev->dev, "Parent adapter (%d) not found\n", 213 mux->pdata->parent_bus_num); 214 ret = -EPROBE_DEFER; 215 goto err; 216 } 217 218 for (i = 0; i < mux->pdata->bus_count; i++) { 219 u32 bus = mux->pdata->base_bus_num ? 220 (mux->pdata->base_bus_num + i) : 0; 221 222 mux->busses[i] = i2c_add_mux_adapter(mux->parent, &pdev->dev, 223 mux, bus, i, 0, 224 i2c_mux_pinctrl_select, 225 deselect); 226 if (!mux->busses[i]) { 227 ret = -ENODEV; 228 dev_err(&pdev->dev, "Failed to add adapter %d\n", i); 229 goto err_del_adapter; 230 } 231 } 232 233 return 0; 234 235 err_del_adapter: 236 for (; i > 0; i--) 237 i2c_del_mux_adapter(mux->busses[i - 1]); 238 i2c_put_adapter(mux->parent); 239 err: 240 return ret; 241 } 242 243 static int i2c_mux_pinctrl_remove(struct platform_device *pdev) 244 { 245 struct i2c_mux_pinctrl *mux = platform_get_drvdata(pdev); 246 int i; 247 248 for (i = 0; i < mux->pdata->bus_count; i++) 249 i2c_del_mux_adapter(mux->busses[i]); 250 251 i2c_put_adapter(mux->parent); 252 253 return 0; 254 } 255 256 #ifdef CONFIG_OF 257 static const struct of_device_id i2c_mux_pinctrl_of_match[] = { 258 { .compatible = "i2c-mux-pinctrl", }, 259 {}, 260 }; 261 MODULE_DEVICE_TABLE(of, i2c_mux_pinctrl_of_match); 262 #endif 263 264 static struct platform_driver i2c_mux_pinctrl_driver = { 265 .driver = { 266 .name = "i2c-mux-pinctrl", 267 .owner = THIS_MODULE, 268 .of_match_table = of_match_ptr(i2c_mux_pinctrl_of_match), 269 }, 270 .probe = i2c_mux_pinctrl_probe, 271 .remove = i2c_mux_pinctrl_remove, 272 }; 273 module_platform_driver(i2c_mux_pinctrl_driver); 274 275 MODULE_DESCRIPTION("pinctrl-based I2C multiplexer driver"); 276 MODULE_AUTHOR("Stephen Warren <swarren@nvidia.com>"); 277 MODULE_LICENSE("GPL v2"); 278 MODULE_ALIAS("platform:i2c-mux-pinctrl"); 279