1 /* 2 * gpio-regulator.c 3 * 4 * Copyright 2011 Heiko Stuebner <heiko@sntech.de> 5 * 6 * based on fixed.c 7 * 8 * Copyright 2008 Wolfson Microelectronics PLC. 9 * 10 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com> 11 * 12 * Copyright (c) 2009 Nokia Corporation 13 * Roger Quadros <ext-roger.quadros@nokia.com> 14 * 15 * This program is free software; you can redistribute it and/or 16 * modify it under the terms of the GNU General Public License as 17 * published by the Free Software Foundation; either version 2 of the 18 * License, or (at your option) any later version. 19 * 20 * This is useful for systems with mixed controllable and 21 * non-controllable regulators, as well as for allowing testing on 22 * systems with no controllable regulators. 23 */ 24 25 #include <linux/err.h> 26 #include <linux/mutex.h> 27 #include <linux/module.h> 28 #include <linux/platform_device.h> 29 #include <linux/regulator/driver.h> 30 #include <linux/regulator/machine.h> 31 #include <linux/regulator/of_regulator.h> 32 #include <linux/regulator/gpio-regulator.h> 33 #include <linux/gpio/consumer.h> 34 #include <linux/slab.h> 35 #include <linux/of.h> 36 37 struct gpio_regulator_data { 38 struct regulator_desc desc; 39 40 struct gpio_desc **gpiods; 41 int nr_gpios; 42 43 struct gpio_regulator_state *states; 44 int nr_states; 45 46 int state; 47 }; 48 49 static int gpio_regulator_get_value(struct regulator_dev *dev) 50 { 51 struct gpio_regulator_data *data = rdev_get_drvdata(dev); 52 int ptr; 53 54 for (ptr = 0; ptr < data->nr_states; ptr++) 55 if (data->states[ptr].gpios == data->state) 56 return data->states[ptr].value; 57 58 return -EINVAL; 59 } 60 61 static int gpio_regulator_set_voltage(struct regulator_dev *dev, 62 int min_uV, int max_uV, 63 unsigned *selector) 64 { 65 struct gpio_regulator_data *data = rdev_get_drvdata(dev); 66 int ptr, target = 0, state, best_val = INT_MAX; 67 68 for (ptr = 0; ptr < data->nr_states; ptr++) 69 if (data->states[ptr].value < best_val && 70 data->states[ptr].value >= min_uV && 71 data->states[ptr].value <= max_uV) { 72 target = data->states[ptr].gpios; 73 best_val = data->states[ptr].value; 74 if (selector) 75 *selector = ptr; 76 } 77 78 if (best_val == INT_MAX) 79 return -EINVAL; 80 81 for (ptr = 0; ptr < data->nr_gpios; ptr++) { 82 state = (target & (1 << ptr)) >> ptr; 83 gpiod_set_value_cansleep(data->gpiods[ptr], state); 84 } 85 data->state = target; 86 87 return 0; 88 } 89 90 static int gpio_regulator_list_voltage(struct regulator_dev *dev, 91 unsigned selector) 92 { 93 struct gpio_regulator_data *data = rdev_get_drvdata(dev); 94 95 if (selector >= data->nr_states) 96 return -EINVAL; 97 98 return data->states[selector].value; 99 } 100 101 static int gpio_regulator_set_current_limit(struct regulator_dev *dev, 102 int min_uA, int max_uA) 103 { 104 struct gpio_regulator_data *data = rdev_get_drvdata(dev); 105 int ptr, target = 0, state, best_val = 0; 106 107 for (ptr = 0; ptr < data->nr_states; ptr++) 108 if (data->states[ptr].value > best_val && 109 data->states[ptr].value >= min_uA && 110 data->states[ptr].value <= max_uA) { 111 target = data->states[ptr].gpios; 112 best_val = data->states[ptr].value; 113 } 114 115 if (best_val == 0) 116 return -EINVAL; 117 118 for (ptr = 0; ptr < data->nr_gpios; ptr++) { 119 state = (target & (1 << ptr)) >> ptr; 120 gpiod_set_value_cansleep(data->gpiods[ptr], state); 121 } 122 data->state = target; 123 124 return 0; 125 } 126 127 static const struct regulator_ops gpio_regulator_voltage_ops = { 128 .get_voltage = gpio_regulator_get_value, 129 .set_voltage = gpio_regulator_set_voltage, 130 .list_voltage = gpio_regulator_list_voltage, 131 }; 132 133 static struct gpio_regulator_config * 134 of_get_gpio_regulator_config(struct device *dev, struct device_node *np, 135 const struct regulator_desc *desc) 136 { 137 struct gpio_regulator_config *config; 138 const char *regtype; 139 int proplen, i; 140 int ngpios; 141 int ret; 142 143 config = devm_kzalloc(dev, 144 sizeof(struct gpio_regulator_config), 145 GFP_KERNEL); 146 if (!config) 147 return ERR_PTR(-ENOMEM); 148 149 config->init_data = of_get_regulator_init_data(dev, np, desc); 150 if (!config->init_data) 151 return ERR_PTR(-EINVAL); 152 153 config->supply_name = config->init_data->constraints.name; 154 155 if (of_property_read_bool(np, "enable-at-boot")) 156 config->enabled_at_boot = true; 157 158 of_property_read_u32(np, "startup-delay-us", &config->startup_delay); 159 160 /* Fetch GPIO init levels */ 161 ngpios = gpiod_count(dev, NULL); 162 if (ngpios > 0) { 163 config->gflags = devm_kzalloc(dev, 164 sizeof(enum gpiod_flags) 165 * ngpios, 166 GFP_KERNEL); 167 if (!config->gflags) 168 return ERR_PTR(-ENOMEM); 169 170 for (i = 0; i < ngpios; i++) { 171 u32 val; 172 173 ret = of_property_read_u32_index(np, "gpios-states", i, 174 &val); 175 176 /* Default to high per specification */ 177 if (ret) 178 config->gflags[i] = GPIOD_OUT_HIGH; 179 else 180 config->gflags[i] = 181 val ? GPIOD_OUT_HIGH : GPIOD_OUT_LOW; 182 } 183 } 184 config->ngpios = ngpios; 185 186 /* Fetch states. */ 187 proplen = of_property_count_u32_elems(np, "states"); 188 if (proplen < 0) { 189 dev_err(dev, "No 'states' property found\n"); 190 return ERR_PTR(-EINVAL); 191 } 192 193 config->states = devm_kcalloc(dev, 194 proplen / 2, 195 sizeof(struct gpio_regulator_state), 196 GFP_KERNEL); 197 if (!config->states) 198 return ERR_PTR(-ENOMEM); 199 200 for (i = 0; i < proplen / 2; i++) { 201 of_property_read_u32_index(np, "states", i * 2, 202 &config->states[i].value); 203 of_property_read_u32_index(np, "states", i * 2 + 1, 204 &config->states[i].gpios); 205 } 206 config->nr_states = i; 207 208 config->type = REGULATOR_VOLTAGE; 209 ret = of_property_read_string(np, "regulator-type", ®type); 210 if (ret >= 0) { 211 if (!strncmp("voltage", regtype, 7)) 212 config->type = REGULATOR_VOLTAGE; 213 else if (!strncmp("current", regtype, 7)) 214 config->type = REGULATOR_CURRENT; 215 else 216 dev_warn(dev, "Unknown regulator-type '%s'\n", 217 regtype); 218 } 219 220 return config; 221 } 222 223 static const struct regulator_ops gpio_regulator_current_ops = { 224 .get_current_limit = gpio_regulator_get_value, 225 .set_current_limit = gpio_regulator_set_current_limit, 226 }; 227 228 static int gpio_regulator_probe(struct platform_device *pdev) 229 { 230 struct device *dev = &pdev->dev; 231 struct gpio_regulator_config *config = dev_get_platdata(dev); 232 struct device_node *np = dev->of_node; 233 struct gpio_regulator_data *drvdata; 234 struct regulator_config cfg = { }; 235 struct regulator_dev *rdev; 236 enum gpiod_flags gflags; 237 int ptr, ret, state, i; 238 239 drvdata = devm_kzalloc(dev, sizeof(struct gpio_regulator_data), 240 GFP_KERNEL); 241 if (drvdata == NULL) 242 return -ENOMEM; 243 244 if (np) { 245 config = of_get_gpio_regulator_config(dev, np, 246 &drvdata->desc); 247 if (IS_ERR(config)) 248 return PTR_ERR(config); 249 } 250 251 drvdata->desc.name = devm_kstrdup(dev, config->supply_name, GFP_KERNEL); 252 if (drvdata->desc.name == NULL) { 253 dev_err(dev, "Failed to allocate supply name\n"); 254 return -ENOMEM; 255 } 256 257 drvdata->gpiods = devm_kzalloc(dev, sizeof(struct gpio_desc *), 258 GFP_KERNEL); 259 if (!drvdata->gpiods) 260 return -ENOMEM; 261 for (i = 0; i < config->ngpios; i++) { 262 drvdata->gpiods[i] = devm_gpiod_get_index(dev, 263 NULL, 264 i, 265 config->gflags[i]); 266 if (IS_ERR(drvdata->gpiods[i])) 267 return PTR_ERR(drvdata->gpiods[i]); 268 /* This is good to know */ 269 gpiod_set_consumer_name(drvdata->gpiods[i], drvdata->desc.name); 270 } 271 drvdata->nr_gpios = config->ngpios; 272 273 drvdata->states = devm_kmemdup(dev, 274 config->states, 275 config->nr_states * 276 sizeof(struct gpio_regulator_state), 277 GFP_KERNEL); 278 if (drvdata->states == NULL) { 279 dev_err(dev, "Failed to allocate state data\n"); 280 return -ENOMEM; 281 } 282 drvdata->nr_states = config->nr_states; 283 284 drvdata->desc.owner = THIS_MODULE; 285 drvdata->desc.enable_time = config->startup_delay; 286 287 /* handle regulator type*/ 288 switch (config->type) { 289 case REGULATOR_VOLTAGE: 290 drvdata->desc.type = REGULATOR_VOLTAGE; 291 drvdata->desc.ops = &gpio_regulator_voltage_ops; 292 drvdata->desc.n_voltages = config->nr_states; 293 break; 294 case REGULATOR_CURRENT: 295 drvdata->desc.type = REGULATOR_CURRENT; 296 drvdata->desc.ops = &gpio_regulator_current_ops; 297 break; 298 default: 299 dev_err(dev, "No regulator type set\n"); 300 return -EINVAL; 301 } 302 303 /* build initial state from gpio init data. */ 304 state = 0; 305 for (ptr = 0; ptr < drvdata->nr_gpios; ptr++) { 306 if (config->gflags[ptr] == GPIOD_OUT_HIGH) 307 state |= (1 << ptr); 308 } 309 drvdata->state = state; 310 311 cfg.dev = dev; 312 cfg.init_data = config->init_data; 313 cfg.driver_data = drvdata; 314 cfg.of_node = np; 315 316 /* 317 * The signal will be inverted by the GPIO core if flagged so in the 318 * decriptor. 319 */ 320 if (config->enabled_at_boot) 321 gflags = GPIOD_OUT_HIGH | GPIOD_FLAGS_BIT_NONEXCLUSIVE; 322 else 323 gflags = GPIOD_OUT_LOW | GPIOD_FLAGS_BIT_NONEXCLUSIVE; 324 325 cfg.ena_gpiod = gpiod_get_optional(dev, "enable", gflags); 326 if (IS_ERR(cfg.ena_gpiod)) 327 return PTR_ERR(cfg.ena_gpiod); 328 329 rdev = devm_regulator_register(dev, &drvdata->desc, &cfg); 330 if (IS_ERR(rdev)) { 331 ret = PTR_ERR(rdev); 332 dev_err(dev, "Failed to register regulator: %d\n", ret); 333 return ret; 334 } 335 336 platform_set_drvdata(pdev, drvdata); 337 338 return 0; 339 } 340 341 #if defined(CONFIG_OF) 342 static const struct of_device_id regulator_gpio_of_match[] = { 343 { .compatible = "regulator-gpio", }, 344 {}, 345 }; 346 MODULE_DEVICE_TABLE(of, regulator_gpio_of_match); 347 #endif 348 349 static struct platform_driver gpio_regulator_driver = { 350 .probe = gpio_regulator_probe, 351 .driver = { 352 .name = "gpio-regulator", 353 .of_match_table = of_match_ptr(regulator_gpio_of_match), 354 }, 355 }; 356 357 static int __init gpio_regulator_init(void) 358 { 359 return platform_driver_register(&gpio_regulator_driver); 360 } 361 subsys_initcall(gpio_regulator_init); 362 363 static void __exit gpio_regulator_exit(void) 364 { 365 platform_driver_unregister(&gpio_regulator_driver); 366 } 367 module_exit(gpio_regulator_exit); 368 369 MODULE_AUTHOR("Heiko Stuebner <heiko@sntech.de>"); 370 MODULE_DESCRIPTION("gpio voltage regulator"); 371 MODULE_LICENSE("GPL"); 372 MODULE_ALIAS("platform:gpio-regulator"); 373