1 /* 2 * Regulator driver for PWM Regulators 3 * 4 * Copyright (C) 2014 - STMicroelectronics Inc. 5 * 6 * Author: Lee Jones <lee.jones@linaro.org> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License version 2 as 10 * published by the Free Software Foundation. 11 */ 12 13 #include <linux/delay.h> 14 #include <linux/module.h> 15 #include <linux/init.h> 16 #include <linux/err.h> 17 #include <linux/regulator/driver.h> 18 #include <linux/regulator/machine.h> 19 #include <linux/regulator/of_regulator.h> 20 #include <linux/of.h> 21 #include <linux/of_device.h> 22 #include <linux/pwm.h> 23 #include <linux/gpio/consumer.h> 24 25 struct pwm_continuous_reg_data { 26 unsigned int min_uV_dutycycle; 27 unsigned int max_uV_dutycycle; 28 unsigned int dutycycle_unit; 29 }; 30 31 struct pwm_regulator_data { 32 /* Shared */ 33 struct pwm_device *pwm; 34 35 /* Voltage table */ 36 struct pwm_voltages *duty_cycle_table; 37 38 /* Continuous mode info */ 39 struct pwm_continuous_reg_data continuous; 40 41 /* regulator descriptor */ 42 struct regulator_desc desc; 43 44 /* Regulator ops */ 45 struct regulator_ops ops; 46 47 int state; 48 49 /* Enable GPIO */ 50 struct gpio_desc *enb_gpio; 51 }; 52 53 struct pwm_voltages { 54 unsigned int uV; 55 unsigned int dutycycle; 56 }; 57 58 /** 59 * Voltage table call-backs 60 */ 61 static void pwm_regulator_init_state(struct regulator_dev *rdev) 62 { 63 struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev); 64 struct pwm_state pwm_state; 65 unsigned int dutycycle; 66 int i; 67 68 pwm_get_state(drvdata->pwm, &pwm_state); 69 dutycycle = pwm_get_relative_duty_cycle(&pwm_state, 100); 70 71 for (i = 0; i < rdev->desc->n_voltages; i++) { 72 if (dutycycle == drvdata->duty_cycle_table[i].dutycycle) { 73 drvdata->state = i; 74 return; 75 } 76 } 77 } 78 79 static int pwm_regulator_get_voltage_sel(struct regulator_dev *rdev) 80 { 81 struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev); 82 83 if (drvdata->state < 0) 84 pwm_regulator_init_state(rdev); 85 86 return drvdata->state; 87 } 88 89 static int pwm_regulator_set_voltage_sel(struct regulator_dev *rdev, 90 unsigned selector) 91 { 92 struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev); 93 struct pwm_state pstate; 94 int ret; 95 96 pwm_init_state(drvdata->pwm, &pstate); 97 pwm_set_relative_duty_cycle(&pstate, 98 drvdata->duty_cycle_table[selector].dutycycle, 100); 99 100 ret = pwm_apply_state(drvdata->pwm, &pstate); 101 if (ret) { 102 dev_err(&rdev->dev, "Failed to configure PWM: %d\n", ret); 103 return ret; 104 } 105 106 drvdata->state = selector; 107 108 return 0; 109 } 110 111 static int pwm_regulator_list_voltage(struct regulator_dev *rdev, 112 unsigned selector) 113 { 114 struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev); 115 116 if (selector >= rdev->desc->n_voltages) 117 return -EINVAL; 118 119 return drvdata->duty_cycle_table[selector].uV; 120 } 121 122 static int pwm_regulator_enable(struct regulator_dev *dev) 123 { 124 struct pwm_regulator_data *drvdata = rdev_get_drvdata(dev); 125 126 if (drvdata->enb_gpio) 127 gpiod_set_value_cansleep(drvdata->enb_gpio, 1); 128 129 return pwm_enable(drvdata->pwm); 130 } 131 132 static int pwm_regulator_disable(struct regulator_dev *dev) 133 { 134 struct pwm_regulator_data *drvdata = rdev_get_drvdata(dev); 135 136 pwm_disable(drvdata->pwm); 137 138 if (drvdata->enb_gpio) 139 gpiod_set_value_cansleep(drvdata->enb_gpio, 0); 140 141 return 0; 142 } 143 144 static int pwm_regulator_is_enabled(struct regulator_dev *dev) 145 { 146 struct pwm_regulator_data *drvdata = rdev_get_drvdata(dev); 147 148 if (drvdata->enb_gpio && !gpiod_get_value_cansleep(drvdata->enb_gpio)) 149 return false; 150 151 return pwm_is_enabled(drvdata->pwm); 152 } 153 154 static int pwm_regulator_get_voltage(struct regulator_dev *rdev) 155 { 156 struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev); 157 unsigned int min_uV_duty = drvdata->continuous.min_uV_dutycycle; 158 unsigned int max_uV_duty = drvdata->continuous.max_uV_dutycycle; 159 unsigned int duty_unit = drvdata->continuous.dutycycle_unit; 160 int min_uV = rdev->constraints->min_uV; 161 int max_uV = rdev->constraints->max_uV; 162 int diff_uV = max_uV - min_uV; 163 struct pwm_state pstate; 164 unsigned int diff_duty; 165 unsigned int voltage; 166 167 pwm_get_state(drvdata->pwm, &pstate); 168 169 voltage = pwm_get_relative_duty_cycle(&pstate, duty_unit); 170 171 /* 172 * The dutycycle for min_uV might be greater than the one for max_uV. 173 * This is happening when the user needs an inversed polarity, but the 174 * PWM device does not support inversing it in hardware. 175 */ 176 if (max_uV_duty < min_uV_duty) { 177 voltage = min_uV_duty - voltage; 178 diff_duty = min_uV_duty - max_uV_duty; 179 } else { 180 voltage = voltage - min_uV_duty; 181 diff_duty = max_uV_duty - min_uV_duty; 182 } 183 184 voltage = DIV_ROUND_CLOSEST_ULL((u64)voltage * diff_uV, diff_duty); 185 186 return voltage + min_uV; 187 } 188 189 static int pwm_regulator_set_voltage(struct regulator_dev *rdev, 190 int req_min_uV, int req_max_uV, 191 unsigned int *selector) 192 { 193 struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev); 194 unsigned int min_uV_duty = drvdata->continuous.min_uV_dutycycle; 195 unsigned int max_uV_duty = drvdata->continuous.max_uV_dutycycle; 196 unsigned int duty_unit = drvdata->continuous.dutycycle_unit; 197 unsigned int ramp_delay = rdev->constraints->ramp_delay; 198 int min_uV = rdev->constraints->min_uV; 199 int max_uV = rdev->constraints->max_uV; 200 int diff_uV = max_uV - min_uV; 201 struct pwm_state pstate; 202 int old_uV = pwm_regulator_get_voltage(rdev); 203 unsigned int diff_duty; 204 unsigned int dutycycle; 205 int ret; 206 207 pwm_init_state(drvdata->pwm, &pstate); 208 209 /* 210 * The dutycycle for min_uV might be greater than the one for max_uV. 211 * This is happening when the user needs an inversed polarity, but the 212 * PWM device does not support inversing it in hardware. 213 */ 214 if (max_uV_duty < min_uV_duty) 215 diff_duty = min_uV_duty - max_uV_duty; 216 else 217 diff_duty = max_uV_duty - min_uV_duty; 218 219 dutycycle = DIV_ROUND_CLOSEST_ULL((u64)(req_min_uV - min_uV) * 220 diff_duty, 221 diff_uV); 222 223 if (max_uV_duty < min_uV_duty) 224 dutycycle = min_uV_duty - dutycycle; 225 else 226 dutycycle = min_uV_duty + dutycycle; 227 228 pwm_set_relative_duty_cycle(&pstate, dutycycle, duty_unit); 229 230 ret = pwm_apply_state(drvdata->pwm, &pstate); 231 if (ret) { 232 dev_err(&rdev->dev, "Failed to configure PWM: %d\n", ret); 233 return ret; 234 } 235 236 if ((ramp_delay == 0) || !pwm_regulator_is_enabled(rdev)) 237 return 0; 238 239 /* Ramp delay is in uV/uS. Adjust to uS and delay */ 240 ramp_delay = DIV_ROUND_UP(abs(req_min_uV - old_uV), ramp_delay); 241 usleep_range(ramp_delay, ramp_delay + DIV_ROUND_UP(ramp_delay, 10)); 242 243 return 0; 244 } 245 246 static struct regulator_ops pwm_regulator_voltage_table_ops = { 247 .set_voltage_sel = pwm_regulator_set_voltage_sel, 248 .get_voltage_sel = pwm_regulator_get_voltage_sel, 249 .list_voltage = pwm_regulator_list_voltage, 250 .map_voltage = regulator_map_voltage_iterate, 251 .enable = pwm_regulator_enable, 252 .disable = pwm_regulator_disable, 253 .is_enabled = pwm_regulator_is_enabled, 254 }; 255 256 static struct regulator_ops pwm_regulator_voltage_continuous_ops = { 257 .get_voltage = pwm_regulator_get_voltage, 258 .set_voltage = pwm_regulator_set_voltage, 259 .enable = pwm_regulator_enable, 260 .disable = pwm_regulator_disable, 261 .is_enabled = pwm_regulator_is_enabled, 262 }; 263 264 static struct regulator_desc pwm_regulator_desc = { 265 .name = "pwm-regulator", 266 .type = REGULATOR_VOLTAGE, 267 .owner = THIS_MODULE, 268 .supply_name = "pwm", 269 }; 270 271 static int pwm_regulator_init_table(struct platform_device *pdev, 272 struct pwm_regulator_data *drvdata) 273 { 274 struct device_node *np = pdev->dev.of_node; 275 struct pwm_voltages *duty_cycle_table; 276 unsigned int length = 0; 277 int ret; 278 279 of_find_property(np, "voltage-table", &length); 280 281 if ((length < sizeof(*duty_cycle_table)) || 282 (length % sizeof(*duty_cycle_table))) { 283 dev_err(&pdev->dev, "voltage-table length(%d) is invalid\n", 284 length); 285 return -EINVAL; 286 } 287 288 duty_cycle_table = devm_kzalloc(&pdev->dev, length, GFP_KERNEL); 289 if (!duty_cycle_table) 290 return -ENOMEM; 291 292 ret = of_property_read_u32_array(np, "voltage-table", 293 (u32 *)duty_cycle_table, 294 length / sizeof(u32)); 295 if (ret) { 296 dev_err(&pdev->dev, "Failed to read voltage-table: %d\n", ret); 297 return ret; 298 } 299 300 drvdata->state = -EINVAL; 301 drvdata->duty_cycle_table = duty_cycle_table; 302 memcpy(&drvdata->ops, &pwm_regulator_voltage_table_ops, 303 sizeof(drvdata->ops)); 304 drvdata->desc.ops = &drvdata->ops; 305 drvdata->desc.n_voltages = length / sizeof(*duty_cycle_table); 306 307 return 0; 308 } 309 310 static int pwm_regulator_init_continuous(struct platform_device *pdev, 311 struct pwm_regulator_data *drvdata) 312 { 313 u32 dutycycle_range[2] = { 0, 100 }; 314 u32 dutycycle_unit = 100; 315 316 memcpy(&drvdata->ops, &pwm_regulator_voltage_continuous_ops, 317 sizeof(drvdata->ops)); 318 drvdata->desc.ops = &drvdata->ops; 319 drvdata->desc.continuous_voltage_range = true; 320 321 of_property_read_u32_array(pdev->dev.of_node, 322 "pwm-dutycycle-range", 323 dutycycle_range, 2); 324 of_property_read_u32(pdev->dev.of_node, "pwm-dutycycle-unit", 325 &dutycycle_unit); 326 327 if (dutycycle_range[0] > dutycycle_unit || 328 dutycycle_range[1] > dutycycle_unit) 329 return -EINVAL; 330 331 drvdata->continuous.dutycycle_unit = dutycycle_unit; 332 drvdata->continuous.min_uV_dutycycle = dutycycle_range[0]; 333 drvdata->continuous.max_uV_dutycycle = dutycycle_range[1]; 334 335 return 0; 336 } 337 338 static int pwm_regulator_probe(struct platform_device *pdev) 339 { 340 const struct regulator_init_data *init_data; 341 struct pwm_regulator_data *drvdata; 342 struct regulator_dev *regulator; 343 struct regulator_config config = { }; 344 struct device_node *np = pdev->dev.of_node; 345 enum gpiod_flags gpio_flags; 346 int ret; 347 348 if (!np) { 349 dev_err(&pdev->dev, "Device Tree node missing\n"); 350 return -EINVAL; 351 } 352 353 drvdata = devm_kzalloc(&pdev->dev, sizeof(*drvdata), GFP_KERNEL); 354 if (!drvdata) 355 return -ENOMEM; 356 357 memcpy(&drvdata->desc, &pwm_regulator_desc, sizeof(drvdata->desc)); 358 359 if (of_find_property(np, "voltage-table", NULL)) 360 ret = pwm_regulator_init_table(pdev, drvdata); 361 else 362 ret = pwm_regulator_init_continuous(pdev, drvdata); 363 if (ret) 364 return ret; 365 366 init_data = of_get_regulator_init_data(&pdev->dev, np, 367 &drvdata->desc); 368 if (!init_data) 369 return -ENOMEM; 370 371 config.of_node = np; 372 config.dev = &pdev->dev; 373 config.driver_data = drvdata; 374 config.init_data = init_data; 375 376 drvdata->pwm = devm_pwm_get(&pdev->dev, NULL); 377 if (IS_ERR(drvdata->pwm)) { 378 ret = PTR_ERR(drvdata->pwm); 379 dev_err(&pdev->dev, "Failed to get PWM: %d\n", ret); 380 return ret; 381 } 382 383 if (init_data->constraints.boot_on || init_data->constraints.always_on) 384 gpio_flags = GPIOD_OUT_HIGH; 385 else 386 gpio_flags = GPIOD_OUT_LOW; 387 drvdata->enb_gpio = devm_gpiod_get_optional(&pdev->dev, "enable", 388 gpio_flags); 389 if (IS_ERR(drvdata->enb_gpio)) { 390 ret = PTR_ERR(drvdata->enb_gpio); 391 dev_err(&pdev->dev, "Failed to get enable GPIO: %d\n", ret); 392 return ret; 393 } 394 395 ret = pwm_adjust_config(drvdata->pwm); 396 if (ret) 397 return ret; 398 399 regulator = devm_regulator_register(&pdev->dev, 400 &drvdata->desc, &config); 401 if (IS_ERR(regulator)) { 402 ret = PTR_ERR(regulator); 403 dev_err(&pdev->dev, "Failed to register regulator %s: %d\n", 404 drvdata->desc.name, ret); 405 return ret; 406 } 407 408 return 0; 409 } 410 411 static const struct of_device_id pwm_of_match[] = { 412 { .compatible = "pwm-regulator" }, 413 { }, 414 }; 415 MODULE_DEVICE_TABLE(of, pwm_of_match); 416 417 static struct platform_driver pwm_regulator_driver = { 418 .driver = { 419 .name = "pwm-regulator", 420 .of_match_table = of_match_ptr(pwm_of_match), 421 }, 422 .probe = pwm_regulator_probe, 423 }; 424 425 module_platform_driver(pwm_regulator_driver); 426 427 MODULE_LICENSE("GPL"); 428 MODULE_AUTHOR("Lee Jones <lee.jones@linaro.org>"); 429 MODULE_DESCRIPTION("PWM Regulator Driver"); 430 MODULE_ALIAS("platform:pwm-regulator"); 431