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.h> 34 #include <linux/slab.h> 35 #include <linux/of.h> 36 #include <linux/of_gpio.h> 37 38 struct gpio_regulator_data { 39 struct regulator_desc desc; 40 struct regulator_dev *dev; 41 42 struct gpio *gpios; 43 int nr_gpios; 44 45 struct gpio_regulator_state *states; 46 int nr_states; 47 48 int state; 49 }; 50 51 static int gpio_regulator_get_value(struct regulator_dev *dev) 52 { 53 struct gpio_regulator_data *data = rdev_get_drvdata(dev); 54 int ptr; 55 56 for (ptr = 0; ptr < data->nr_states; ptr++) 57 if (data->states[ptr].gpios == data->state) 58 return data->states[ptr].value; 59 60 return -EINVAL; 61 } 62 63 static int gpio_regulator_set_voltage(struct regulator_dev *dev, 64 int min_uV, int max_uV, 65 unsigned *selector) 66 { 67 struct gpio_regulator_data *data = rdev_get_drvdata(dev); 68 int ptr, target = 0, state, best_val = INT_MAX; 69 70 for (ptr = 0; ptr < data->nr_states; ptr++) 71 if (data->states[ptr].value < best_val && 72 data->states[ptr].value >= min_uV && 73 data->states[ptr].value <= max_uV) { 74 target = data->states[ptr].gpios; 75 best_val = data->states[ptr].value; 76 if (selector) 77 *selector = ptr; 78 } 79 80 if (best_val == INT_MAX) 81 return -EINVAL; 82 83 for (ptr = 0; ptr < data->nr_gpios; ptr++) { 84 state = (target & (1 << ptr)) >> ptr; 85 gpio_set_value_cansleep(data->gpios[ptr].gpio, state); 86 } 87 data->state = target; 88 89 return 0; 90 } 91 92 static int gpio_regulator_list_voltage(struct regulator_dev *dev, 93 unsigned selector) 94 { 95 struct gpio_regulator_data *data = rdev_get_drvdata(dev); 96 97 if (selector >= data->nr_states) 98 return -EINVAL; 99 100 return data->states[selector].value; 101 } 102 103 static int gpio_regulator_set_current_limit(struct regulator_dev *dev, 104 int min_uA, int max_uA) 105 { 106 struct gpio_regulator_data *data = rdev_get_drvdata(dev); 107 int ptr, target = 0, state, best_val = 0; 108 109 for (ptr = 0; ptr < data->nr_states; ptr++) 110 if (data->states[ptr].value > best_val && 111 data->states[ptr].value >= min_uA && 112 data->states[ptr].value <= max_uA) { 113 target = data->states[ptr].gpios; 114 best_val = data->states[ptr].value; 115 } 116 117 if (best_val == 0) 118 return -EINVAL; 119 120 for (ptr = 0; ptr < data->nr_gpios; ptr++) { 121 state = (target & (1 << ptr)) >> ptr; 122 gpio_set_value_cansleep(data->gpios[ptr].gpio, state); 123 } 124 data->state = target; 125 126 return 0; 127 } 128 129 static struct regulator_ops gpio_regulator_voltage_ops = { 130 .get_voltage = gpio_regulator_get_value, 131 .set_voltage = gpio_regulator_set_voltage, 132 .list_voltage = gpio_regulator_list_voltage, 133 }; 134 135 static struct gpio_regulator_config * 136 of_get_gpio_regulator_config(struct device *dev, struct device_node *np, 137 const struct regulator_desc *desc) 138 { 139 struct gpio_regulator_config *config; 140 const char *regtype; 141 int proplen, gpio, i; 142 int ret; 143 144 config = devm_kzalloc(dev, 145 sizeof(struct gpio_regulator_config), 146 GFP_KERNEL); 147 if (!config) 148 return ERR_PTR(-ENOMEM); 149 150 config->init_data = of_get_regulator_init_data(dev, np, desc); 151 if (!config->init_data) 152 return ERR_PTR(-EINVAL); 153 154 config->supply_name = config->init_data->constraints.name; 155 156 if (of_property_read_bool(np, "enable-active-high")) 157 config->enable_high = true; 158 159 if (of_property_read_bool(np, "enable-at-boot")) 160 config->enabled_at_boot = true; 161 162 of_property_read_u32(np, "startup-delay-us", &config->startup_delay); 163 164 config->enable_gpio = of_get_named_gpio(np, "enable-gpio", 0); 165 166 /* Fetch GPIOs. - optional property*/ 167 ret = of_gpio_count(np); 168 if ((ret < 0) && (ret != -ENOENT)) 169 return ERR_PTR(ret); 170 171 if (ret > 0) { 172 config->nr_gpios = ret; 173 config->gpios = devm_kzalloc(dev, 174 sizeof(struct gpio) * config->nr_gpios, 175 GFP_KERNEL); 176 if (!config->gpios) 177 return ERR_PTR(-ENOMEM); 178 179 proplen = of_property_count_u32_elems(np, "gpios-states"); 180 /* optional property */ 181 if (proplen < 0) 182 proplen = 0; 183 184 if (proplen > 0 && proplen != config->nr_gpios) { 185 dev_warn(dev, "gpios <-> gpios-states mismatch\n"); 186 proplen = 0; 187 } 188 189 for (i = 0; i < config->nr_gpios; i++) { 190 gpio = of_get_named_gpio(np, "gpios", i); 191 if (gpio < 0) 192 break; 193 config->gpios[i].gpio = gpio; 194 if (proplen > 0) { 195 of_property_read_u32_index(np, "gpios-states", 196 i, &ret); 197 if (ret) 198 config->gpios[i].flags = 199 GPIOF_OUT_INIT_HIGH; 200 } 201 } 202 } 203 204 /* Fetch states. */ 205 proplen = of_property_count_u32_elems(np, "states"); 206 if (proplen < 0) { 207 dev_err(dev, "No 'states' property found\n"); 208 return ERR_PTR(-EINVAL); 209 } 210 211 config->states = devm_kzalloc(dev, 212 sizeof(struct gpio_regulator_state) 213 * (proplen / 2), 214 GFP_KERNEL); 215 if (!config->states) 216 return ERR_PTR(-ENOMEM); 217 218 for (i = 0; i < proplen / 2; i++) { 219 of_property_read_u32_index(np, "states", i * 2, 220 &config->states[i].value); 221 of_property_read_u32_index(np, "states", i * 2 + 1, 222 &config->states[i].gpios); 223 } 224 config->nr_states = i; 225 226 config->type = REGULATOR_VOLTAGE; 227 ret = of_property_read_string(np, "regulator-type", ®type); 228 if (ret >= 0) { 229 if (!strncmp("voltage", regtype, 7)) 230 config->type = REGULATOR_VOLTAGE; 231 else if (!strncmp("current", regtype, 7)) 232 config->type = REGULATOR_CURRENT; 233 else 234 dev_warn(dev, "Unknown regulator-type '%s'\n", 235 regtype); 236 } 237 238 return config; 239 } 240 241 static struct regulator_ops gpio_regulator_current_ops = { 242 .get_current_limit = gpio_regulator_get_value, 243 .set_current_limit = gpio_regulator_set_current_limit, 244 }; 245 246 static int gpio_regulator_probe(struct platform_device *pdev) 247 { 248 struct gpio_regulator_config *config = dev_get_platdata(&pdev->dev); 249 struct device_node *np = pdev->dev.of_node; 250 struct gpio_regulator_data *drvdata; 251 struct regulator_config cfg = { }; 252 int ptr, ret, state; 253 254 drvdata = devm_kzalloc(&pdev->dev, sizeof(struct gpio_regulator_data), 255 GFP_KERNEL); 256 if (drvdata == NULL) 257 return -ENOMEM; 258 259 if (np) { 260 config = of_get_gpio_regulator_config(&pdev->dev, np, 261 &drvdata->desc); 262 if (IS_ERR(config)) 263 return PTR_ERR(config); 264 } 265 266 drvdata->desc.name = kstrdup(config->supply_name, GFP_KERNEL); 267 if (drvdata->desc.name == NULL) { 268 dev_err(&pdev->dev, "Failed to allocate supply name\n"); 269 ret = -ENOMEM; 270 goto err; 271 } 272 273 if (config->nr_gpios != 0) { 274 drvdata->gpios = kmemdup(config->gpios, 275 config->nr_gpios * sizeof(struct gpio), 276 GFP_KERNEL); 277 if (drvdata->gpios == NULL) { 278 dev_err(&pdev->dev, "Failed to allocate gpio data\n"); 279 ret = -ENOMEM; 280 goto err_name; 281 } 282 283 drvdata->nr_gpios = config->nr_gpios; 284 ret = gpio_request_array(drvdata->gpios, drvdata->nr_gpios); 285 if (ret) { 286 dev_err(&pdev->dev, 287 "Could not obtain regulator setting GPIOs: %d\n", ret); 288 goto err_memstate; 289 } 290 } 291 292 drvdata->states = kmemdup(config->states, 293 config->nr_states * 294 sizeof(struct gpio_regulator_state), 295 GFP_KERNEL); 296 if (drvdata->states == NULL) { 297 dev_err(&pdev->dev, "Failed to allocate state data\n"); 298 ret = -ENOMEM; 299 goto err_memgpio; 300 } 301 drvdata->nr_states = config->nr_states; 302 303 drvdata->desc.owner = THIS_MODULE; 304 drvdata->desc.enable_time = config->startup_delay; 305 306 /* handle regulator type*/ 307 switch (config->type) { 308 case REGULATOR_VOLTAGE: 309 drvdata->desc.type = REGULATOR_VOLTAGE; 310 drvdata->desc.ops = &gpio_regulator_voltage_ops; 311 drvdata->desc.n_voltages = config->nr_states; 312 break; 313 case REGULATOR_CURRENT: 314 drvdata->desc.type = REGULATOR_CURRENT; 315 drvdata->desc.ops = &gpio_regulator_current_ops; 316 break; 317 default: 318 dev_err(&pdev->dev, "No regulator type set\n"); 319 ret = -EINVAL; 320 goto err_memgpio; 321 } 322 323 /* build initial state from gpio init data. */ 324 state = 0; 325 for (ptr = 0; ptr < drvdata->nr_gpios; ptr++) { 326 if (config->gpios[ptr].flags & GPIOF_OUT_INIT_HIGH) 327 state |= (1 << ptr); 328 } 329 drvdata->state = state; 330 331 cfg.dev = &pdev->dev; 332 cfg.init_data = config->init_data; 333 cfg.driver_data = drvdata; 334 cfg.of_node = np; 335 336 if (gpio_is_valid(config->enable_gpio)) { 337 cfg.ena_gpio = config->enable_gpio; 338 cfg.ena_gpio_initialized = true; 339 } 340 cfg.ena_gpio_invert = !config->enable_high; 341 if (config->enabled_at_boot) { 342 if (config->enable_high) 343 cfg.ena_gpio_flags |= GPIOF_OUT_INIT_HIGH; 344 else 345 cfg.ena_gpio_flags |= GPIOF_OUT_INIT_LOW; 346 } else { 347 if (config->enable_high) 348 cfg.ena_gpio_flags |= GPIOF_OUT_INIT_LOW; 349 else 350 cfg.ena_gpio_flags |= GPIOF_OUT_INIT_HIGH; 351 } 352 353 drvdata->dev = regulator_register(&drvdata->desc, &cfg); 354 if (IS_ERR(drvdata->dev)) { 355 ret = PTR_ERR(drvdata->dev); 356 dev_err(&pdev->dev, "Failed to register regulator: %d\n", ret); 357 goto err_stategpio; 358 } 359 360 platform_set_drvdata(pdev, drvdata); 361 362 return 0; 363 364 err_stategpio: 365 gpio_free_array(drvdata->gpios, drvdata->nr_gpios); 366 err_memstate: 367 kfree(drvdata->states); 368 err_memgpio: 369 kfree(drvdata->gpios); 370 err_name: 371 kfree(drvdata->desc.name); 372 err: 373 return ret; 374 } 375 376 static int gpio_regulator_remove(struct platform_device *pdev) 377 { 378 struct gpio_regulator_data *drvdata = platform_get_drvdata(pdev); 379 380 regulator_unregister(drvdata->dev); 381 382 gpio_free_array(drvdata->gpios, drvdata->nr_gpios); 383 384 kfree(drvdata->states); 385 kfree(drvdata->gpios); 386 387 kfree(drvdata->desc.name); 388 389 return 0; 390 } 391 392 #if defined(CONFIG_OF) 393 static const struct of_device_id regulator_gpio_of_match[] = { 394 { .compatible = "regulator-gpio", }, 395 {}, 396 }; 397 MODULE_DEVICE_TABLE(of, regulator_gpio_of_match); 398 #endif 399 400 static struct platform_driver gpio_regulator_driver = { 401 .probe = gpio_regulator_probe, 402 .remove = gpio_regulator_remove, 403 .driver = { 404 .name = "gpio-regulator", 405 .of_match_table = of_match_ptr(regulator_gpio_of_match), 406 }, 407 }; 408 409 static int __init gpio_regulator_init(void) 410 { 411 return platform_driver_register(&gpio_regulator_driver); 412 } 413 subsys_initcall(gpio_regulator_init); 414 415 static void __exit gpio_regulator_exit(void) 416 { 417 platform_driver_unregister(&gpio_regulator_driver); 418 } 419 module_exit(gpio_regulator_exit); 420 421 MODULE_AUTHOR("Heiko Stuebner <heiko@sntech.de>"); 422 MODULE_DESCRIPTION("gpio voltage regulator"); 423 MODULE_LICENSE("GPL"); 424 MODULE_ALIAS("platform:gpio-regulator"); 425