1 /* 2 * fixed.c 3 * 4 * Copyright 2008 Wolfson Microelectronics PLC. 5 * 6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com> 7 * 8 * Copyright (c) 2009 Nokia Corporation 9 * Roger Quadros <ext-roger.quadros@nokia.com> 10 * 11 * This program is free software; you can redistribute it and/or 12 * modify it under the terms of the GNU General Public License as 13 * published by the Free Software Foundation; either version 2 of the 14 * License, or (at your option) any later version. 15 * 16 * This is useful for systems with mixed controllable and 17 * non-controllable regulators, as well as for allowing testing on 18 * systems with no controllable regulators. 19 */ 20 21 #include <linux/err.h> 22 #include <linux/mutex.h> 23 #include <linux/module.h> 24 #include <linux/platform_device.h> 25 #include <linux/regulator/driver.h> 26 #include <linux/regulator/fixed.h> 27 #include <linux/gpio.h> 28 #include <linux/slab.h> 29 #include <linux/of.h> 30 #include <linux/of_gpio.h> 31 #include <linux/regulator/of_regulator.h> 32 #include <linux/regulator/machine.h> 33 34 struct fixed_voltage_data { 35 struct regulator_desc desc; 36 struct regulator_dev *dev; 37 int microvolts; 38 int gpio; 39 unsigned startup_delay; 40 bool enable_high; 41 bool is_enabled; 42 }; 43 44 45 /** 46 * of_get_fixed_voltage_config - extract fixed_voltage_config structure info 47 * @dev: device requesting for fixed_voltage_config 48 * 49 * Populates fixed_voltage_config structure by extracting data from device 50 * tree node, returns a pointer to the populated structure of NULL if memory 51 * alloc fails. 52 */ 53 static struct fixed_voltage_config * 54 of_get_fixed_voltage_config(struct device *dev) 55 { 56 struct fixed_voltage_config *config; 57 struct device_node *np = dev->of_node; 58 const __be32 *delay; 59 struct regulator_init_data *init_data; 60 61 config = devm_kzalloc(dev, sizeof(struct fixed_voltage_config), 62 GFP_KERNEL); 63 if (!config) 64 return NULL; 65 66 config->init_data = of_get_regulator_init_data(dev, dev->of_node); 67 if (!config->init_data) 68 return NULL; 69 70 init_data = config->init_data; 71 init_data->constraints.apply_uV = 0; 72 73 config->supply_name = init_data->constraints.name; 74 if (init_data->constraints.min_uV == init_data->constraints.max_uV) { 75 config->microvolts = init_data->constraints.min_uV; 76 } else { 77 dev_err(dev, 78 "Fixed regulator specified with variable voltages\n"); 79 return NULL; 80 } 81 82 if (init_data->constraints.boot_on) 83 config->enabled_at_boot = true; 84 85 config->gpio = of_get_named_gpio(np, "gpio", 0); 86 delay = of_get_property(np, "startup-delay-us", NULL); 87 if (delay) 88 config->startup_delay = be32_to_cpu(*delay); 89 90 if (of_find_property(np, "enable-active-high", NULL)) 91 config->enable_high = true; 92 93 if (of_find_property(np, "gpio-open-drain", NULL)) 94 config->gpio_is_open_drain = true; 95 96 return config; 97 } 98 99 static int fixed_voltage_is_enabled(struct regulator_dev *dev) 100 { 101 struct fixed_voltage_data *data = rdev_get_drvdata(dev); 102 103 return data->is_enabled; 104 } 105 106 static int fixed_voltage_enable(struct regulator_dev *dev) 107 { 108 struct fixed_voltage_data *data = rdev_get_drvdata(dev); 109 110 gpio_set_value_cansleep(data->gpio, data->enable_high); 111 data->is_enabled = true; 112 113 return 0; 114 } 115 116 static int fixed_voltage_disable(struct regulator_dev *dev) 117 { 118 struct fixed_voltage_data *data = rdev_get_drvdata(dev); 119 120 gpio_set_value_cansleep(data->gpio, !data->enable_high); 121 data->is_enabled = false; 122 123 return 0; 124 } 125 126 static int fixed_voltage_enable_time(struct regulator_dev *dev) 127 { 128 struct fixed_voltage_data *data = rdev_get_drvdata(dev); 129 130 return data->startup_delay; 131 } 132 133 static int fixed_voltage_get_voltage(struct regulator_dev *dev) 134 { 135 struct fixed_voltage_data *data = rdev_get_drvdata(dev); 136 137 if (data->microvolts) 138 return data->microvolts; 139 else 140 return -EINVAL; 141 } 142 143 static int fixed_voltage_list_voltage(struct regulator_dev *dev, 144 unsigned selector) 145 { 146 struct fixed_voltage_data *data = rdev_get_drvdata(dev); 147 148 if (selector != 0) 149 return -EINVAL; 150 151 return data->microvolts; 152 } 153 154 static struct regulator_ops fixed_voltage_gpio_ops = { 155 .is_enabled = fixed_voltage_is_enabled, 156 .enable = fixed_voltage_enable, 157 .disable = fixed_voltage_disable, 158 .enable_time = fixed_voltage_enable_time, 159 .get_voltage = fixed_voltage_get_voltage, 160 .list_voltage = fixed_voltage_list_voltage, 161 }; 162 163 static struct regulator_ops fixed_voltage_ops = { 164 .get_voltage = fixed_voltage_get_voltage, 165 .list_voltage = fixed_voltage_list_voltage, 166 }; 167 168 static int __devinit reg_fixed_voltage_probe(struct platform_device *pdev) 169 { 170 struct fixed_voltage_config *config; 171 struct fixed_voltage_data *drvdata; 172 struct regulator_config cfg = { }; 173 int ret; 174 175 if (pdev->dev.of_node) 176 config = of_get_fixed_voltage_config(&pdev->dev); 177 else 178 config = pdev->dev.platform_data; 179 180 if (!config) 181 return -ENOMEM; 182 183 drvdata = devm_kzalloc(&pdev->dev, sizeof(struct fixed_voltage_data), 184 GFP_KERNEL); 185 if (drvdata == NULL) { 186 dev_err(&pdev->dev, "Failed to allocate device data\n"); 187 ret = -ENOMEM; 188 goto err; 189 } 190 191 drvdata->desc.name = kstrdup(config->supply_name, GFP_KERNEL); 192 if (drvdata->desc.name == NULL) { 193 dev_err(&pdev->dev, "Failed to allocate supply name\n"); 194 ret = -ENOMEM; 195 goto err; 196 } 197 drvdata->desc.type = REGULATOR_VOLTAGE; 198 drvdata->desc.owner = THIS_MODULE; 199 200 if (config->microvolts) 201 drvdata->desc.n_voltages = 1; 202 203 drvdata->microvolts = config->microvolts; 204 drvdata->gpio = config->gpio; 205 drvdata->startup_delay = config->startup_delay; 206 207 if (gpio_is_valid(config->gpio)) { 208 int gpio_flag; 209 drvdata->enable_high = config->enable_high; 210 211 /* FIXME: Remove below print warning 212 * 213 * config->gpio must be set to -EINVAL by platform code if 214 * GPIO control is not required. However, early adopters 215 * not requiring GPIO control may forget to initialize 216 * config->gpio to -EINVAL. This will cause GPIO 0 to be used 217 * for GPIO control. 218 * 219 * This warning will be removed once there are a couple of users 220 * for this driver. 221 */ 222 if (!config->gpio) 223 dev_warn(&pdev->dev, 224 "using GPIO 0 for regulator enable control\n"); 225 226 /* 227 * set output direction without changing state 228 * to prevent glitch 229 */ 230 drvdata->is_enabled = config->enabled_at_boot; 231 ret = drvdata->is_enabled ? 232 config->enable_high : !config->enable_high; 233 gpio_flag = ret ? GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW; 234 235 if (config->gpio_is_open_drain) 236 gpio_flag |= GPIOF_OPEN_DRAIN; 237 238 ret = gpio_request_one(config->gpio, gpio_flag, 239 config->supply_name); 240 if (ret) { 241 dev_err(&pdev->dev, 242 "Could not obtain regulator enable GPIO %d: %d\n", 243 config->gpio, ret); 244 goto err_name; 245 } 246 247 drvdata->desc.ops = &fixed_voltage_gpio_ops; 248 249 } else { 250 drvdata->desc.ops = &fixed_voltage_ops; 251 } 252 253 cfg.dev = &pdev->dev; 254 cfg.init_data = config->init_data; 255 cfg.driver_data = drvdata; 256 cfg.of_node = pdev->dev.of_node; 257 258 drvdata->dev = regulator_register(&drvdata->desc, &cfg); 259 if (IS_ERR(drvdata->dev)) { 260 ret = PTR_ERR(drvdata->dev); 261 dev_err(&pdev->dev, "Failed to register regulator: %d\n", ret); 262 goto err_gpio; 263 } 264 265 platform_set_drvdata(pdev, drvdata); 266 267 dev_dbg(&pdev->dev, "%s supplying %duV\n", drvdata->desc.name, 268 drvdata->microvolts); 269 270 return 0; 271 272 err_gpio: 273 if (gpio_is_valid(config->gpio)) 274 gpio_free(config->gpio); 275 err_name: 276 kfree(drvdata->desc.name); 277 err: 278 return ret; 279 } 280 281 static int __devexit reg_fixed_voltage_remove(struct platform_device *pdev) 282 { 283 struct fixed_voltage_data *drvdata = platform_get_drvdata(pdev); 284 285 regulator_unregister(drvdata->dev); 286 if (gpio_is_valid(drvdata->gpio)) 287 gpio_free(drvdata->gpio); 288 kfree(drvdata->desc.name); 289 290 return 0; 291 } 292 293 #if defined(CONFIG_OF) 294 static const struct of_device_id fixed_of_match[] __devinitconst = { 295 { .compatible = "regulator-fixed", }, 296 {}, 297 }; 298 MODULE_DEVICE_TABLE(of, fixed_of_match); 299 #else 300 #define fixed_of_match NULL 301 #endif 302 303 static struct platform_driver regulator_fixed_voltage_driver = { 304 .probe = reg_fixed_voltage_probe, 305 .remove = __devexit_p(reg_fixed_voltage_remove), 306 .driver = { 307 .name = "reg-fixed-voltage", 308 .owner = THIS_MODULE, 309 .of_match_table = fixed_of_match, 310 }, 311 }; 312 313 static int __init regulator_fixed_voltage_init(void) 314 { 315 return platform_driver_register(®ulator_fixed_voltage_driver); 316 } 317 subsys_initcall(regulator_fixed_voltage_init); 318 319 static void __exit regulator_fixed_voltage_exit(void) 320 { 321 platform_driver_unregister(®ulator_fixed_voltage_driver); 322 } 323 module_exit(regulator_fixed_voltage_exit); 324 325 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>"); 326 MODULE_DESCRIPTION("Fixed voltage regulator"); 327 MODULE_LICENSE("GPL"); 328 MODULE_ALIAS("platform:reg-fixed-voltage"); 329