diff options
author | Linus Torvalds <torvalds@linux-foundation.org> | 2009-01-08 17:51:11 -0500 |
---|---|---|
committer | Linus Torvalds <torvalds@linux-foundation.org> | 2009-01-08 17:51:11 -0500 |
commit | 022992ee59e90fef719493c09988884be157fb73 (patch) | |
tree | f532c33454d9fc3a7fb2cf488b25f69a93d00bc6 /drivers | |
parent | 5fbbf5f648a9c4ef99276854f05b2255d1b004d3 (diff) | |
parent | 0ba4887c6329043d6cee5b5b477cfe50c2b57674 (diff) |
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/lrg/voltage-2.6
* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/lrg/voltage-2.6:
regulator: fix kernel-doc warnings
regulator: catch some registration errors
regulator: Add basic DocBook manual
regulator: Fix some kerneldoc rendering issues
regulator: Add missing kerneldoc
regulator: Clean up kerneldoc warnings
regulator: Remove extraneous kerneldoc annotations
regulator: init/link earlier
regulator: move set_machine_constraints after regulator device initialization
regulator: da903x: make da903x_is_enabled return 0 or 1
regulator: da903x: add '\n' to error messages
regulator: sysfs attribute reduction (v2)
regulator: code shrink (v2)
regulator: improved mode error checks
regulator: enable/disable refcounting
regulator: struct device - replace bus_id with dev_name(), dev_set_name()
Diffstat (limited to 'drivers')
-rw-r--r-- | drivers/Makefile | 4 | ||||
-rw-r--r-- | drivers/regulator/core.c | 474 | ||||
-rw-r--r-- | drivers/regulator/da903x.c | 12 |
3 files changed, 300 insertions, 190 deletions
diff --git a/drivers/Makefile b/drivers/Makefile index e121b66ef082..6326f4dbbdab 100644 --- a/drivers/Makefile +++ b/drivers/Makefile | |||
@@ -18,6 +18,9 @@ obj-$(CONFIG_ARM_AMBA) += amba/ | |||
18 | 18 | ||
19 | obj-$(CONFIG_XEN) += xen/ | 19 | obj-$(CONFIG_XEN) += xen/ |
20 | 20 | ||
21 | # regulators early, since some subsystems rely on them to initialize | ||
22 | obj-$(CONFIG_REGULATOR) += regulator/ | ||
23 | |||
21 | # char/ comes before serial/ etc so that the VT console is the boot-time | 24 | # char/ comes before serial/ etc so that the VT console is the boot-time |
22 | # default. | 25 | # default. |
23 | obj-y += char/ | 26 | obj-y += char/ |
@@ -101,5 +104,4 @@ obj-$(CONFIG_PPC_PS3) += ps3/ | |||
101 | obj-$(CONFIG_OF) += of/ | 104 | obj-$(CONFIG_OF) += of/ |
102 | obj-$(CONFIG_SSB) += ssb/ | 105 | obj-$(CONFIG_SSB) += ssb/ |
103 | obj-$(CONFIG_VIRTIO) += virtio/ | 106 | obj-$(CONFIG_VIRTIO) += virtio/ |
104 | obj-$(CONFIG_REGULATOR) += regulator/ | ||
105 | obj-$(CONFIG_STAGING) += staging/ | 107 | obj-$(CONFIG_STAGING) += staging/ |
diff --git a/drivers/regulator/core.c b/drivers/regulator/core.c index 02a774424e8d..f511a406fcaa 100644 --- a/drivers/regulator/core.c +++ b/drivers/regulator/core.c | |||
@@ -29,7 +29,7 @@ static DEFINE_MUTEX(regulator_list_mutex); | |||
29 | static LIST_HEAD(regulator_list); | 29 | static LIST_HEAD(regulator_list); |
30 | static LIST_HEAD(regulator_map_list); | 30 | static LIST_HEAD(regulator_map_list); |
31 | 31 | ||
32 | /** | 32 | /* |
33 | * struct regulator_dev | 33 | * struct regulator_dev |
34 | * | 34 | * |
35 | * Voltage / Current regulator class device. One for each regulator. | 35 | * Voltage / Current regulator class device. One for each regulator. |
@@ -56,7 +56,7 @@ struct regulator_dev { | |||
56 | void *reg_data; /* regulator_dev data */ | 56 | void *reg_data; /* regulator_dev data */ |
57 | }; | 57 | }; |
58 | 58 | ||
59 | /** | 59 | /* |
60 | * struct regulator_map | 60 | * struct regulator_map |
61 | * | 61 | * |
62 | * Used to provide symbolic supply names to devices. | 62 | * Used to provide symbolic supply names to devices. |
@@ -79,7 +79,7 @@ struct regulator { | |||
79 | int uA_load; | 79 | int uA_load; |
80 | int min_uV; | 80 | int min_uV; |
81 | int max_uV; | 81 | int max_uV; |
82 | int enabled; /* client has called enabled */ | 82 | int enabled; /* count of client enables */ |
83 | char *supply_name; | 83 | char *supply_name; |
84 | struct device_attribute dev_attr; | 84 | struct device_attribute dev_attr; |
85 | struct regulator_dev *rdev; | 85 | struct regulator_dev *rdev; |
@@ -174,6 +174,16 @@ static int regulator_check_current_limit(struct regulator_dev *rdev, | |||
174 | /* operating mode constraint check */ | 174 | /* operating mode constraint check */ |
175 | static int regulator_check_mode(struct regulator_dev *rdev, int mode) | 175 | static int regulator_check_mode(struct regulator_dev *rdev, int mode) |
176 | { | 176 | { |
177 | switch (mode) { | ||
178 | case REGULATOR_MODE_FAST: | ||
179 | case REGULATOR_MODE_NORMAL: | ||
180 | case REGULATOR_MODE_IDLE: | ||
181 | case REGULATOR_MODE_STANDBY: | ||
182 | break; | ||
183 | default: | ||
184 | return -EINVAL; | ||
185 | } | ||
186 | |||
177 | if (!rdev->constraints) { | 187 | if (!rdev->constraints) { |
178 | printk(KERN_ERR "%s: no constraints for %s\n", __func__, | 188 | printk(KERN_ERR "%s: no constraints for %s\n", __func__, |
179 | rdev->desc->name); | 189 | rdev->desc->name); |
@@ -232,6 +242,7 @@ static ssize_t regulator_uV_show(struct device *dev, | |||
232 | 242 | ||
233 | return ret; | 243 | return ret; |
234 | } | 244 | } |
245 | static DEVICE_ATTR(microvolts, 0444, regulator_uV_show, NULL); | ||
235 | 246 | ||
236 | static ssize_t regulator_uA_show(struct device *dev, | 247 | static ssize_t regulator_uA_show(struct device *dev, |
237 | struct device_attribute *attr, char *buf) | 248 | struct device_attribute *attr, char *buf) |
@@ -240,6 +251,7 @@ static ssize_t regulator_uA_show(struct device *dev, | |||
240 | 251 | ||
241 | return sprintf(buf, "%d\n", _regulator_get_current_limit(rdev)); | 252 | return sprintf(buf, "%d\n", _regulator_get_current_limit(rdev)); |
242 | } | 253 | } |
254 | static DEVICE_ATTR(microamps, 0444, regulator_uA_show, NULL); | ||
243 | 255 | ||
244 | static ssize_t regulator_name_show(struct device *dev, | 256 | static ssize_t regulator_name_show(struct device *dev, |
245 | struct device_attribute *attr, char *buf) | 257 | struct device_attribute *attr, char *buf) |
@@ -257,12 +269,8 @@ static ssize_t regulator_name_show(struct device *dev, | |||
257 | return sprintf(buf, "%s\n", name); | 269 | return sprintf(buf, "%s\n", name); |
258 | } | 270 | } |
259 | 271 | ||
260 | static ssize_t regulator_opmode_show(struct device *dev, | 272 | static ssize_t regulator_print_opmode(char *buf, int mode) |
261 | struct device_attribute *attr, char *buf) | ||
262 | { | 273 | { |
263 | struct regulator_dev *rdev = dev_get_drvdata(dev); | ||
264 | int mode = _regulator_get_mode(rdev); | ||
265 | |||
266 | switch (mode) { | 274 | switch (mode) { |
267 | case REGULATOR_MODE_FAST: | 275 | case REGULATOR_MODE_FAST: |
268 | return sprintf(buf, "fast\n"); | 276 | return sprintf(buf, "fast\n"); |
@@ -276,12 +284,17 @@ static ssize_t regulator_opmode_show(struct device *dev, | |||
276 | return sprintf(buf, "unknown\n"); | 284 | return sprintf(buf, "unknown\n"); |
277 | } | 285 | } |
278 | 286 | ||
279 | static ssize_t regulator_state_show(struct device *dev, | 287 | static ssize_t regulator_opmode_show(struct device *dev, |
280 | struct device_attribute *attr, char *buf) | 288 | struct device_attribute *attr, char *buf) |
281 | { | 289 | { |
282 | struct regulator_dev *rdev = dev_get_drvdata(dev); | 290 | struct regulator_dev *rdev = dev_get_drvdata(dev); |
283 | int state = _regulator_is_enabled(rdev); | ||
284 | 291 | ||
292 | return regulator_print_opmode(buf, _regulator_get_mode(rdev)); | ||
293 | } | ||
294 | static DEVICE_ATTR(opmode, 0444, regulator_opmode_show, NULL); | ||
295 | |||
296 | static ssize_t regulator_print_state(char *buf, int state) | ||
297 | { | ||
285 | if (state > 0) | 298 | if (state > 0) |
286 | return sprintf(buf, "enabled\n"); | 299 | return sprintf(buf, "enabled\n"); |
287 | else if (state == 0) | 300 | else if (state == 0) |
@@ -290,6 +303,15 @@ static ssize_t regulator_state_show(struct device *dev, | |||
290 | return sprintf(buf, "unknown\n"); | 303 | return sprintf(buf, "unknown\n"); |
291 | } | 304 | } |
292 | 305 | ||
306 | static ssize_t regulator_state_show(struct device *dev, | ||
307 | struct device_attribute *attr, char *buf) | ||
308 | { | ||
309 | struct regulator_dev *rdev = dev_get_drvdata(dev); | ||
310 | |||
311 | return regulator_print_state(buf, _regulator_is_enabled(rdev)); | ||
312 | } | ||
313 | static DEVICE_ATTR(state, 0444, regulator_state_show, NULL); | ||
314 | |||
293 | static ssize_t regulator_min_uA_show(struct device *dev, | 315 | static ssize_t regulator_min_uA_show(struct device *dev, |
294 | struct device_attribute *attr, char *buf) | 316 | struct device_attribute *attr, char *buf) |
295 | { | 317 | { |
@@ -300,6 +322,7 @@ static ssize_t regulator_min_uA_show(struct device *dev, | |||
300 | 322 | ||
301 | return sprintf(buf, "%d\n", rdev->constraints->min_uA); | 323 | return sprintf(buf, "%d\n", rdev->constraints->min_uA); |
302 | } | 324 | } |
325 | static DEVICE_ATTR(min_microamps, 0444, regulator_min_uA_show, NULL); | ||
303 | 326 | ||
304 | static ssize_t regulator_max_uA_show(struct device *dev, | 327 | static ssize_t regulator_max_uA_show(struct device *dev, |
305 | struct device_attribute *attr, char *buf) | 328 | struct device_attribute *attr, char *buf) |
@@ -311,6 +334,7 @@ static ssize_t regulator_max_uA_show(struct device *dev, | |||
311 | 334 | ||
312 | return sprintf(buf, "%d\n", rdev->constraints->max_uA); | 335 | return sprintf(buf, "%d\n", rdev->constraints->max_uA); |
313 | } | 336 | } |
337 | static DEVICE_ATTR(max_microamps, 0444, regulator_max_uA_show, NULL); | ||
314 | 338 | ||
315 | static ssize_t regulator_min_uV_show(struct device *dev, | 339 | static ssize_t regulator_min_uV_show(struct device *dev, |
316 | struct device_attribute *attr, char *buf) | 340 | struct device_attribute *attr, char *buf) |
@@ -322,6 +346,7 @@ static ssize_t regulator_min_uV_show(struct device *dev, | |||
322 | 346 | ||
323 | return sprintf(buf, "%d\n", rdev->constraints->min_uV); | 347 | return sprintf(buf, "%d\n", rdev->constraints->min_uV); |
324 | } | 348 | } |
349 | static DEVICE_ATTR(min_microvolts, 0444, regulator_min_uV_show, NULL); | ||
325 | 350 | ||
326 | static ssize_t regulator_max_uV_show(struct device *dev, | 351 | static ssize_t regulator_max_uV_show(struct device *dev, |
327 | struct device_attribute *attr, char *buf) | 352 | struct device_attribute *attr, char *buf) |
@@ -333,6 +358,7 @@ static ssize_t regulator_max_uV_show(struct device *dev, | |||
333 | 358 | ||
334 | return sprintf(buf, "%d\n", rdev->constraints->max_uV); | 359 | return sprintf(buf, "%d\n", rdev->constraints->max_uV); |
335 | } | 360 | } |
361 | static DEVICE_ATTR(max_microvolts, 0444, regulator_max_uV_show, NULL); | ||
336 | 362 | ||
337 | static ssize_t regulator_total_uA_show(struct device *dev, | 363 | static ssize_t regulator_total_uA_show(struct device *dev, |
338 | struct device_attribute *attr, char *buf) | 364 | struct device_attribute *attr, char *buf) |
@@ -347,6 +373,7 @@ static ssize_t regulator_total_uA_show(struct device *dev, | |||
347 | mutex_unlock(&rdev->mutex); | 373 | mutex_unlock(&rdev->mutex); |
348 | return sprintf(buf, "%d\n", uA); | 374 | return sprintf(buf, "%d\n", uA); |
349 | } | 375 | } |
376 | static DEVICE_ATTR(requested_microamps, 0444, regulator_total_uA_show, NULL); | ||
350 | 377 | ||
351 | static ssize_t regulator_num_users_show(struct device *dev, | 378 | static ssize_t regulator_num_users_show(struct device *dev, |
352 | struct device_attribute *attr, char *buf) | 379 | struct device_attribute *attr, char *buf) |
@@ -374,153 +401,106 @@ static ssize_t regulator_suspend_mem_uV_show(struct device *dev, | |||
374 | { | 401 | { |
375 | struct regulator_dev *rdev = dev_get_drvdata(dev); | 402 | struct regulator_dev *rdev = dev_get_drvdata(dev); |
376 | 403 | ||
377 | if (!rdev->constraints) | ||
378 | return sprintf(buf, "not defined\n"); | ||
379 | return sprintf(buf, "%d\n", rdev->constraints->state_mem.uV); | 404 | return sprintf(buf, "%d\n", rdev->constraints->state_mem.uV); |
380 | } | 405 | } |
406 | static DEVICE_ATTR(suspend_mem_microvolts, 0444, | ||
407 | regulator_suspend_mem_uV_show, NULL); | ||
381 | 408 | ||
382 | static ssize_t regulator_suspend_disk_uV_show(struct device *dev, | 409 | static ssize_t regulator_suspend_disk_uV_show(struct device *dev, |
383 | struct device_attribute *attr, char *buf) | 410 | struct device_attribute *attr, char *buf) |
384 | { | 411 | { |
385 | struct regulator_dev *rdev = dev_get_drvdata(dev); | 412 | struct regulator_dev *rdev = dev_get_drvdata(dev); |
386 | 413 | ||
387 | if (!rdev->constraints) | ||
388 | return sprintf(buf, "not defined\n"); | ||
389 | return sprintf(buf, "%d\n", rdev->constraints->state_disk.uV); | 414 | return sprintf(buf, "%d\n", rdev->constraints->state_disk.uV); |
390 | } | 415 | } |
416 | static DEVICE_ATTR(suspend_disk_microvolts, 0444, | ||
417 | regulator_suspend_disk_uV_show, NULL); | ||
391 | 418 | ||
392 | static ssize_t regulator_suspend_standby_uV_show(struct device *dev, | 419 | static ssize_t regulator_suspend_standby_uV_show(struct device *dev, |
393 | struct device_attribute *attr, char *buf) | 420 | struct device_attribute *attr, char *buf) |
394 | { | 421 | { |
395 | struct regulator_dev *rdev = dev_get_drvdata(dev); | 422 | struct regulator_dev *rdev = dev_get_drvdata(dev); |
396 | 423 | ||
397 | if (!rdev->constraints) | ||
398 | return sprintf(buf, "not defined\n"); | ||
399 | return sprintf(buf, "%d\n", rdev->constraints->state_standby.uV); | 424 | return sprintf(buf, "%d\n", rdev->constraints->state_standby.uV); |
400 | } | 425 | } |
401 | 426 | static DEVICE_ATTR(suspend_standby_microvolts, 0444, | |
402 | static ssize_t suspend_opmode_show(struct regulator_dev *rdev, | 427 | regulator_suspend_standby_uV_show, NULL); |
403 | unsigned int mode, char *buf) | ||
404 | { | ||
405 | switch (mode) { | ||
406 | case REGULATOR_MODE_FAST: | ||
407 | return sprintf(buf, "fast\n"); | ||
408 | case REGULATOR_MODE_NORMAL: | ||
409 | return sprintf(buf, "normal\n"); | ||
410 | case REGULATOR_MODE_IDLE: | ||
411 | return sprintf(buf, "idle\n"); | ||
412 | case REGULATOR_MODE_STANDBY: | ||
413 | return sprintf(buf, "standby\n"); | ||
414 | } | ||
415 | return sprintf(buf, "unknown\n"); | ||
416 | } | ||
417 | 428 | ||
418 | static ssize_t regulator_suspend_mem_mode_show(struct device *dev, | 429 | static ssize_t regulator_suspend_mem_mode_show(struct device *dev, |
419 | struct device_attribute *attr, char *buf) | 430 | struct device_attribute *attr, char *buf) |
420 | { | 431 | { |
421 | struct regulator_dev *rdev = dev_get_drvdata(dev); | 432 | struct regulator_dev *rdev = dev_get_drvdata(dev); |
422 | 433 | ||
423 | if (!rdev->constraints) | 434 | return regulator_print_opmode(buf, |
424 | return sprintf(buf, "not defined\n"); | 435 | rdev->constraints->state_mem.mode); |
425 | return suspend_opmode_show(rdev, | ||
426 | rdev->constraints->state_mem.mode, buf); | ||
427 | } | 436 | } |
437 | static DEVICE_ATTR(suspend_mem_mode, 0444, | ||
438 | regulator_suspend_mem_mode_show, NULL); | ||
428 | 439 | ||
429 | static ssize_t regulator_suspend_disk_mode_show(struct device *dev, | 440 | static ssize_t regulator_suspend_disk_mode_show(struct device *dev, |
430 | struct device_attribute *attr, char *buf) | 441 | struct device_attribute *attr, char *buf) |
431 | { | 442 | { |
432 | struct regulator_dev *rdev = dev_get_drvdata(dev); | 443 | struct regulator_dev *rdev = dev_get_drvdata(dev); |
433 | 444 | ||
434 | if (!rdev->constraints) | 445 | return regulator_print_opmode(buf, |
435 | return sprintf(buf, "not defined\n"); | 446 | rdev->constraints->state_disk.mode); |
436 | return suspend_opmode_show(rdev, | ||
437 | rdev->constraints->state_disk.mode, buf); | ||
438 | } | 447 | } |
448 | static DEVICE_ATTR(suspend_disk_mode, 0444, | ||
449 | regulator_suspend_disk_mode_show, NULL); | ||
439 | 450 | ||
440 | static ssize_t regulator_suspend_standby_mode_show(struct device *dev, | 451 | static ssize_t regulator_suspend_standby_mode_show(struct device *dev, |
441 | struct device_attribute *attr, char *buf) | 452 | struct device_attribute *attr, char *buf) |
442 | { | 453 | { |
443 | struct regulator_dev *rdev = dev_get_drvdata(dev); | 454 | struct regulator_dev *rdev = dev_get_drvdata(dev); |
444 | 455 | ||
445 | if (!rdev->constraints) | 456 | return regulator_print_opmode(buf, |
446 | return sprintf(buf, "not defined\n"); | 457 | rdev->constraints->state_standby.mode); |
447 | return suspend_opmode_show(rdev, | ||
448 | rdev->constraints->state_standby.mode, buf); | ||
449 | } | 458 | } |
459 | static DEVICE_ATTR(suspend_standby_mode, 0444, | ||
460 | regulator_suspend_standby_mode_show, NULL); | ||
450 | 461 | ||
451 | static ssize_t regulator_suspend_mem_state_show(struct device *dev, | 462 | static ssize_t regulator_suspend_mem_state_show(struct device *dev, |
452 | struct device_attribute *attr, char *buf) | 463 | struct device_attribute *attr, char *buf) |
453 | { | 464 | { |
454 | struct regulator_dev *rdev = dev_get_drvdata(dev); | 465 | struct regulator_dev *rdev = dev_get_drvdata(dev); |
455 | 466 | ||
456 | if (!rdev->constraints) | 467 | return regulator_print_state(buf, |
457 | return sprintf(buf, "not defined\n"); | 468 | rdev->constraints->state_mem.enabled); |
458 | |||
459 | if (rdev->constraints->state_mem.enabled) | ||
460 | return sprintf(buf, "enabled\n"); | ||
461 | else | ||
462 | return sprintf(buf, "disabled\n"); | ||
463 | } | 469 | } |
470 | static DEVICE_ATTR(suspend_mem_state, 0444, | ||
471 | regulator_suspend_mem_state_show, NULL); | ||
464 | 472 | ||
465 | static ssize_t regulator_suspend_disk_state_show(struct device *dev, | 473 | static ssize_t regulator_suspend_disk_state_show(struct device *dev, |
466 | struct device_attribute *attr, char *buf) | 474 | struct device_attribute *attr, char *buf) |
467 | { | 475 | { |
468 | struct regulator_dev *rdev = dev_get_drvdata(dev); | 476 | struct regulator_dev *rdev = dev_get_drvdata(dev); |
469 | 477 | ||
470 | if (!rdev->constraints) | 478 | return regulator_print_state(buf, |
471 | return sprintf(buf, "not defined\n"); | 479 | rdev->constraints->state_disk.enabled); |
472 | |||
473 | if (rdev->constraints->state_disk.enabled) | ||
474 | return sprintf(buf, "enabled\n"); | ||
475 | else | ||
476 | return sprintf(buf, "disabled\n"); | ||
477 | } | 480 | } |
481 | static DEVICE_ATTR(suspend_disk_state, 0444, | ||
482 | regulator_suspend_disk_state_show, NULL); | ||
478 | 483 | ||
479 | static ssize_t regulator_suspend_standby_state_show(struct device *dev, | 484 | static ssize_t regulator_suspend_standby_state_show(struct device *dev, |
480 | struct device_attribute *attr, char *buf) | 485 | struct device_attribute *attr, char *buf) |
481 | { | 486 | { |
482 | struct regulator_dev *rdev = dev_get_drvdata(dev); | 487 | struct regulator_dev *rdev = dev_get_drvdata(dev); |
483 | 488 | ||
484 | if (!rdev->constraints) | 489 | return regulator_print_state(buf, |
485 | return sprintf(buf, "not defined\n"); | 490 | rdev->constraints->state_standby.enabled); |
486 | |||
487 | if (rdev->constraints->state_standby.enabled) | ||
488 | return sprintf(buf, "enabled\n"); | ||
489 | else | ||
490 | return sprintf(buf, "disabled\n"); | ||
491 | } | 491 | } |
492 | static DEVICE_ATTR(suspend_standby_state, 0444, | ||
493 | regulator_suspend_standby_state_show, NULL); | ||
492 | 494 | ||
495 | |||
496 | /* | ||
497 | * These are the only attributes are present for all regulators. | ||
498 | * Other attributes are a function of regulator functionality. | ||
499 | */ | ||
493 | static struct device_attribute regulator_dev_attrs[] = { | 500 | static struct device_attribute regulator_dev_attrs[] = { |
494 | __ATTR(name, 0444, regulator_name_show, NULL), | 501 | __ATTR(name, 0444, regulator_name_show, NULL), |
495 | __ATTR(microvolts, 0444, regulator_uV_show, NULL), | ||
496 | __ATTR(microamps, 0444, regulator_uA_show, NULL), | ||
497 | __ATTR(opmode, 0444, regulator_opmode_show, NULL), | ||
498 | __ATTR(state, 0444, regulator_state_show, NULL), | ||
499 | __ATTR(min_microvolts, 0444, regulator_min_uV_show, NULL), | ||
500 | __ATTR(min_microamps, 0444, regulator_min_uA_show, NULL), | ||
501 | __ATTR(max_microvolts, 0444, regulator_max_uV_show, NULL), | ||
502 | __ATTR(max_microamps, 0444, regulator_max_uA_show, NULL), | ||
503 | __ATTR(requested_microamps, 0444, regulator_total_uA_show, NULL), | ||
504 | __ATTR(num_users, 0444, regulator_num_users_show, NULL), | 502 | __ATTR(num_users, 0444, regulator_num_users_show, NULL), |
505 | __ATTR(type, 0444, regulator_type_show, NULL), | 503 | __ATTR(type, 0444, regulator_type_show, NULL), |
506 | __ATTR(suspend_mem_microvolts, 0444, | ||
507 | regulator_suspend_mem_uV_show, NULL), | ||
508 | __ATTR(suspend_disk_microvolts, 0444, | ||
509 | regulator_suspend_disk_uV_show, NULL), | ||
510 | __ATTR(suspend_standby_microvolts, 0444, | ||
511 | regulator_suspend_standby_uV_show, NULL), | ||
512 | __ATTR(suspend_mem_mode, 0444, | ||
513 | regulator_suspend_mem_mode_show, NULL), | ||
514 | __ATTR(suspend_disk_mode, 0444, | ||
515 | regulator_suspend_disk_mode_show, NULL), | ||
516 | __ATTR(suspend_standby_mode, 0444, | ||
517 | regulator_suspend_standby_mode_show, NULL), | ||
518 | __ATTR(suspend_mem_state, 0444, | ||
519 | regulator_suspend_mem_state_show, NULL), | ||
520 | __ATTR(suspend_disk_state, 0444, | ||
521 | regulator_suspend_disk_state_show, NULL), | ||
522 | __ATTR(suspend_standby_state, 0444, | ||
523 | regulator_suspend_standby_state_show, NULL), | ||
524 | __ATTR_NULL, | 504 | __ATTR_NULL, |
525 | }; | 505 | }; |
526 | 506 | ||
@@ -675,7 +655,8 @@ static void print_constraints(struct regulator_dev *rdev) | |||
675 | 655 | ||
676 | /** | 656 | /** |
677 | * set_machine_constraints - sets regulator constraints | 657 | * set_machine_constraints - sets regulator constraints |
678 | * @regulator: regulator source | 658 | * @rdev: regulator source |
659 | * @constraints: constraints to apply | ||
679 | * | 660 | * |
680 | * Allows platform initialisation code to define and constrain | 661 | * Allows platform initialisation code to define and constrain |
681 | * regulator circuits e.g. valid voltage/current ranges, etc. NOTE: | 662 | * regulator circuits e.g. valid voltage/current ranges, etc. NOTE: |
@@ -750,8 +731,8 @@ out: | |||
750 | 731 | ||
751 | /** | 732 | /** |
752 | * set_supply - set regulator supply regulator | 733 | * set_supply - set regulator supply regulator |
753 | * @regulator: regulator name | 734 | * @rdev: regulator name |
754 | * @supply: supply regulator name | 735 | * @supply_rdev: supply regulator name |
755 | * | 736 | * |
756 | * Called by platform initialisation code to set the supply regulator for this | 737 | * Called by platform initialisation code to set the supply regulator for this |
757 | * regulator. This ensures that a regulators supply will also be enabled by the | 738 | * regulator. This ensures that a regulators supply will also be enabled by the |
@@ -778,9 +759,9 @@ out: | |||
778 | 759 | ||
779 | /** | 760 | /** |
780 | * set_consumer_device_supply: Bind a regulator to a symbolic supply | 761 | * set_consumer_device_supply: Bind a regulator to a symbolic supply |
781 | * @regulator: regulator source | 762 | * @rdev: regulator source |
782 | * @dev: device the supply applies to | 763 | * @consumer_dev: device the supply applies to |
783 | * @supply: symbolic name for supply | 764 | * @supply: symbolic name for supply |
784 | * | 765 | * |
785 | * Allows platform initialisation code to map physical regulator | 766 | * Allows platform initialisation code to map physical regulator |
786 | * sources to symbolic names for supplies for use by devices. Devices | 767 | * sources to symbolic names for supplies for use by devices. Devices |
@@ -795,6 +776,20 @@ static int set_consumer_device_supply(struct regulator_dev *rdev, | |||
795 | if (supply == NULL) | 776 | if (supply == NULL) |
796 | return -EINVAL; | 777 | return -EINVAL; |
797 | 778 | ||
779 | list_for_each_entry(node, ®ulator_map_list, list) { | ||
780 | if (consumer_dev != node->dev) | ||
781 | continue; | ||
782 | if (strcmp(node->supply, supply) != 0) | ||
783 | continue; | ||
784 | |||
785 | dev_dbg(consumer_dev, "%s/%s is '%s' supply; fail %s/%s\n", | ||
786 | dev_name(&node->regulator->dev), | ||
787 | node->regulator->desc->name, | ||
788 | supply, | ||
789 | dev_name(&rdev->dev), rdev->desc->name); | ||
790 | return -EBUSY; | ||
791 | } | ||
792 | |||
798 | node = kmalloc(sizeof(struct regulator_map), GFP_KERNEL); | 793 | node = kmalloc(sizeof(struct regulator_map), GFP_KERNEL); |
799 | if (node == NULL) | 794 | if (node == NULL) |
800 | return -ENOMEM; | 795 | return -ENOMEM; |
@@ -963,16 +958,13 @@ void regulator_put(struct regulator *regulator) | |||
963 | if (regulator == NULL || IS_ERR(regulator)) | 958 | if (regulator == NULL || IS_ERR(regulator)) |
964 | return; | 959 | return; |
965 | 960 | ||
966 | if (regulator->enabled) { | ||
967 | printk(KERN_WARNING "Releasing supply %s while enabled\n", | ||
968 | regulator->supply_name); | ||
969 | WARN_ON(regulator->enabled); | ||
970 | regulator_disable(regulator); | ||
971 | } | ||
972 | |||
973 | mutex_lock(®ulator_list_mutex); | 961 | mutex_lock(®ulator_list_mutex); |
974 | rdev = regulator->rdev; | 962 | rdev = regulator->rdev; |
975 | 963 | ||
964 | if (WARN(regulator->enabled, "Releasing supply %s while enabled\n", | ||
965 | regulator->supply_name)) | ||
966 | _regulator_disable(rdev); | ||
967 | |||
976 | /* remove any sysfs entries */ | 968 | /* remove any sysfs entries */ |
977 | if (regulator->dev) { | 969 | if (regulator->dev) { |
978 | sysfs_remove_link(&rdev->dev.kobj, regulator->supply_name); | 970 | sysfs_remove_link(&rdev->dev.kobj, regulator->supply_name); |
@@ -1034,29 +1026,26 @@ static int _regulator_enable(struct regulator_dev *rdev) | |||
1034 | * regulator_enable - enable regulator output | 1026 | * regulator_enable - enable regulator output |
1035 | * @regulator: regulator source | 1027 | * @regulator: regulator source |
1036 | * | 1028 | * |
1037 | * Enable the regulator output at the predefined voltage or current value. | 1029 | * Request that the regulator be enabled with the regulator output at |
1030 | * the predefined voltage or current value. Calls to regulator_enable() | ||
1031 | * must be balanced with calls to regulator_disable(). | ||
1032 | * | ||
1038 | * NOTE: the output value can be set by other drivers, boot loader or may be | 1033 | * NOTE: the output value can be set by other drivers, boot loader or may be |
1039 | * hardwired in the regulator. | 1034 | * hardwired in the regulator. |
1040 | * NOTE: calls to regulator_enable() must be balanced with calls to | ||
1041 | * regulator_disable(). | ||
1042 | */ | 1035 | */ |
1043 | int regulator_enable(struct regulator *regulator) | 1036 | int regulator_enable(struct regulator *regulator) |
1044 | { | 1037 | { |
1045 | int ret; | 1038 | struct regulator_dev *rdev = regulator->rdev; |
1046 | 1039 | int ret = 0; | |
1047 | if (regulator->enabled) { | ||
1048 | printk(KERN_CRIT "Regulator %s already enabled\n", | ||
1049 | regulator->supply_name); | ||
1050 | WARN_ON(regulator->enabled); | ||
1051 | return 0; | ||
1052 | } | ||
1053 | 1040 | ||
1054 | mutex_lock(®ulator->rdev->mutex); | 1041 | mutex_lock(&rdev->mutex); |
1055 | regulator->enabled = 1; | 1042 | if (regulator->enabled == 0) |
1056 | ret = _regulator_enable(regulator->rdev); | 1043 | ret = _regulator_enable(rdev); |
1057 | if (ret != 0) | 1044 | else if (regulator->enabled < 0) |
1058 | regulator->enabled = 0; | 1045 | ret = -EIO; |
1059 | mutex_unlock(®ulator->rdev->mutex); | 1046 | if (ret == 0) |
1047 | regulator->enabled++; | ||
1048 | mutex_unlock(&rdev->mutex); | ||
1060 | return ret; | 1049 | return ret; |
1061 | } | 1050 | } |
1062 | EXPORT_SYMBOL_GPL(regulator_enable); | 1051 | EXPORT_SYMBOL_GPL(regulator_enable); |
@@ -1100,27 +1089,31 @@ static int _regulator_disable(struct regulator_dev *rdev) | |||
1100 | * regulator_disable - disable regulator output | 1089 | * regulator_disable - disable regulator output |
1101 | * @regulator: regulator source | 1090 | * @regulator: regulator source |
1102 | * | 1091 | * |
1103 | * Disable the regulator output voltage or current. | 1092 | * Disable the regulator output voltage or current. Calls to |
1104 | * NOTE: this will only disable the regulator output if no other consumer | 1093 | * regulator_enable() must be balanced with calls to |
1105 | * devices have it enabled. | ||
1106 | * NOTE: calls to regulator_enable() must be balanced with calls to | ||
1107 | * regulator_disable(). | 1094 | * regulator_disable(). |
1095 | * | ||
1096 | * NOTE: this will only disable the regulator output if no other consumer | ||
1097 | * devices have it enabled, the regulator device supports disabling and | ||
1098 | * machine constraints permit this operation. | ||
1108 | */ | 1099 | */ |
1109 | int regulator_disable(struct regulator *regulator) | 1100 | int regulator_disable(struct regulator *regulator) |
1110 | { | 1101 | { |
1111 | int ret; | 1102 | struct regulator_dev *rdev = regulator->rdev; |
1112 | 1103 | int ret = 0; | |
1113 | if (!regulator->enabled) { | ||
1114 | printk(KERN_ERR "%s: not in use by this consumer\n", | ||
1115 | __func__); | ||
1116 | return 0; | ||
1117 | } | ||
1118 | 1104 | ||
1119 | mutex_lock(®ulator->rdev->mutex); | 1105 | mutex_lock(&rdev->mutex); |
1120 | regulator->enabled = 0; | 1106 | if (regulator->enabled == 1) { |
1121 | regulator->uA_load = 0; | 1107 | ret = _regulator_disable(rdev); |
1122 | ret = _regulator_disable(regulator->rdev); | 1108 | if (ret == 0) |
1123 | mutex_unlock(®ulator->rdev->mutex); | 1109 | regulator->uA_load = 0; |
1110 | } else if (WARN(regulator->enabled <= 0, | ||
1111 | "unbalanced disables for supply %s\n", | ||
1112 | regulator->supply_name)) | ||
1113 | ret = -EIO; | ||
1114 | if (ret == 0) | ||
1115 | regulator->enabled--; | ||
1116 | mutex_unlock(&rdev->mutex); | ||
1124 | return ret; | 1117 | return ret; |
1125 | } | 1118 | } |
1126 | EXPORT_SYMBOL_GPL(regulator_disable); | 1119 | EXPORT_SYMBOL_GPL(regulator_disable); |
@@ -1196,7 +1189,13 @@ out: | |||
1196 | * regulator_is_enabled - is the regulator output enabled | 1189 | * regulator_is_enabled - is the regulator output enabled |
1197 | * @regulator: regulator source | 1190 | * @regulator: regulator source |
1198 | * | 1191 | * |
1199 | * Returns zero for disabled otherwise return number of enable requests. | 1192 | * Returns positive if the regulator driver backing the source/client |
1193 | * has requested that the device be enabled, zero if it hasn't, else a | ||
1194 | * negative errno code. | ||
1195 | * | ||
1196 | * Note that the device backing this regulator handle can have multiple | ||
1197 | * users, so it might be enabled even if regulator_enable() was never | ||
1198 | * called for this particular source. | ||
1200 | */ | 1199 | */ |
1201 | int regulator_is_enabled(struct regulator *regulator) | 1200 | int regulator_is_enabled(struct regulator *regulator) |
1202 | { | 1201 | { |
@@ -1219,7 +1218,7 @@ EXPORT_SYMBOL_GPL(regulator_is_enabled); | |||
1219 | * | 1218 | * |
1220 | * NOTE: If the regulator is shared between several devices then the lowest | 1219 | * NOTE: If the regulator is shared between several devices then the lowest |
1221 | * request voltage that meets the system constraints will be used. | 1220 | * request voltage that meets the system constraints will be used. |
1222 | * NOTE: Regulator system constraints must be set for this regulator before | 1221 | * Regulator system constraints must be set for this regulator before |
1223 | * calling this function otherwise this call will fail. | 1222 | * calling this function otherwise this call will fail. |
1224 | */ | 1223 | */ |
1225 | int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV) | 1224 | int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV) |
@@ -1493,7 +1492,8 @@ int regulator_set_optimum_mode(struct regulator *regulator, int uA_load) | |||
1493 | mode = rdev->desc->ops->get_optimum_mode(rdev, | 1492 | mode = rdev->desc->ops->get_optimum_mode(rdev, |
1494 | input_uV, output_uV, | 1493 | input_uV, output_uV, |
1495 | total_uA_load); | 1494 | total_uA_load); |
1496 | if (ret <= 0) { | 1495 | ret = regulator_check_mode(rdev, mode); |
1496 | if (ret < 0) { | ||
1497 | printk(KERN_ERR "%s: failed to get optimum mode for %s @" | 1497 | printk(KERN_ERR "%s: failed to get optimum mode for %s @" |
1498 | " %d uA %d -> %d uV\n", __func__, rdev->desc->name, | 1498 | " %d uA %d -> %d uV\n", __func__, rdev->desc->name, |
1499 | total_uA_load, input_uV, output_uV); | 1499 | total_uA_load, input_uV, output_uV); |
@@ -1501,7 +1501,7 @@ int regulator_set_optimum_mode(struct regulator *regulator, int uA_load) | |||
1501 | } | 1501 | } |
1502 | 1502 | ||
1503 | ret = rdev->desc->ops->set_mode(rdev, mode); | 1503 | ret = rdev->desc->ops->set_mode(rdev, mode); |
1504 | if (ret <= 0) { | 1504 | if (ret < 0) { |
1505 | printk(KERN_ERR "%s: failed to set optimum mode %x for %s\n", | 1505 | printk(KERN_ERR "%s: failed to set optimum mode %x for %s\n", |
1506 | __func__, mode, rdev->desc->name); | 1506 | __func__, mode, rdev->desc->name); |
1507 | goto out; | 1507 | goto out; |
@@ -1516,7 +1516,7 @@ EXPORT_SYMBOL_GPL(regulator_set_optimum_mode); | |||
1516 | /** | 1516 | /** |
1517 | * regulator_register_notifier - register regulator event notifier | 1517 | * regulator_register_notifier - register regulator event notifier |
1518 | * @regulator: regulator source | 1518 | * @regulator: regulator source |
1519 | * @notifier_block: notifier block | 1519 | * @nb: notifier block |
1520 | * | 1520 | * |
1521 | * Register notifier block to receive regulator events. | 1521 | * Register notifier block to receive regulator events. |
1522 | */ | 1522 | */ |
@@ -1531,7 +1531,7 @@ EXPORT_SYMBOL_GPL(regulator_register_notifier); | |||
1531 | /** | 1531 | /** |
1532 | * regulator_unregister_notifier - unregister regulator event notifier | 1532 | * regulator_unregister_notifier - unregister regulator event notifier |
1533 | * @regulator: regulator source | 1533 | * @regulator: regulator source |
1534 | * @notifier_block: notifier block | 1534 | * @nb: notifier block |
1535 | * | 1535 | * |
1536 | * Unregister regulator event notifier block. | 1536 | * Unregister regulator event notifier block. |
1537 | */ | 1537 | */ |
@@ -1697,9 +1697,9 @@ EXPORT_SYMBOL_GPL(regulator_bulk_free); | |||
1697 | 1697 | ||
1698 | /** | 1698 | /** |
1699 | * regulator_notifier_call_chain - call regulator event notifier | 1699 | * regulator_notifier_call_chain - call regulator event notifier |
1700 | * @regulator: regulator source | 1700 | * @rdev: regulator source |
1701 | * @event: notifier block | 1701 | * @event: notifier block |
1702 | * @data: | 1702 | * @data: callback-specific data. |
1703 | * | 1703 | * |
1704 | * Called by regulator drivers to notify clients a regulator event has | 1704 | * Called by regulator drivers to notify clients a regulator event has |
1705 | * occurred. We also notify regulator clients downstream. | 1705 | * occurred. We also notify regulator clients downstream. |
@@ -1713,10 +1713,122 @@ int regulator_notifier_call_chain(struct regulator_dev *rdev, | |||
1713 | } | 1713 | } |
1714 | EXPORT_SYMBOL_GPL(regulator_notifier_call_chain); | 1714 | EXPORT_SYMBOL_GPL(regulator_notifier_call_chain); |
1715 | 1715 | ||
1716 | /* | ||
1717 | * To avoid cluttering sysfs (and memory) with useless state, only | ||
1718 | * create attributes that can be meaningfully displayed. | ||
1719 | */ | ||
1720 | static int add_regulator_attributes(struct regulator_dev *rdev) | ||
1721 | { | ||
1722 | struct device *dev = &rdev->dev; | ||
1723 | struct regulator_ops *ops = rdev->desc->ops; | ||
1724 | int status = 0; | ||
1725 | |||
1726 | /* some attributes need specific methods to be displayed */ | ||
1727 | if (ops->get_voltage) { | ||
1728 | status = device_create_file(dev, &dev_attr_microvolts); | ||
1729 | if (status < 0) | ||
1730 | return status; | ||
1731 | } | ||
1732 | if (ops->get_current_limit) { | ||
1733 | status = device_create_file(dev, &dev_attr_microamps); | ||
1734 | if (status < 0) | ||
1735 | return status; | ||
1736 | } | ||
1737 | if (ops->get_mode) { | ||
1738 | status = device_create_file(dev, &dev_attr_opmode); | ||
1739 | if (status < 0) | ||
1740 | return status; | ||
1741 | } | ||
1742 | if (ops->is_enabled) { | ||
1743 | status = device_create_file(dev, &dev_attr_state); | ||
1744 | if (status < 0) | ||
1745 | return status; | ||
1746 | } | ||
1747 | |||
1748 | /* some attributes are type-specific */ | ||
1749 | if (rdev->desc->type == REGULATOR_CURRENT) { | ||
1750 | status = device_create_file(dev, &dev_attr_requested_microamps); | ||
1751 | if (status < 0) | ||
1752 | return status; | ||
1753 | } | ||
1754 | |||
1755 | /* all the other attributes exist to support constraints; | ||
1756 | * don't show them if there are no constraints, or if the | ||
1757 | * relevant supporting methods are missing. | ||
1758 | */ | ||
1759 | if (!rdev->constraints) | ||
1760 | return status; | ||
1761 | |||
1762 | /* constraints need specific supporting methods */ | ||
1763 | if (ops->set_voltage) { | ||
1764 | status = device_create_file(dev, &dev_attr_min_microvolts); | ||
1765 | if (status < 0) | ||
1766 | return status; | ||
1767 | status = device_create_file(dev, &dev_attr_max_microvolts); | ||
1768 | if (status < 0) | ||
1769 | return status; | ||
1770 | } | ||
1771 | if (ops->set_current_limit) { | ||
1772 | status = device_create_file(dev, &dev_attr_min_microamps); | ||
1773 | if (status < 0) | ||
1774 | return status; | ||
1775 | status = device_create_file(dev, &dev_attr_max_microamps); | ||
1776 | if (status < 0) | ||
1777 | return status; | ||
1778 | } | ||
1779 | |||
1780 | /* suspend mode constraints need multiple supporting methods */ | ||
1781 | if (!(ops->set_suspend_enable && ops->set_suspend_disable)) | ||
1782 | return status; | ||
1783 | |||
1784 | status = device_create_file(dev, &dev_attr_suspend_standby_state); | ||
1785 | if (status < 0) | ||
1786 | return status; | ||
1787 | status = device_create_file(dev, &dev_attr_suspend_mem_state); | ||
1788 | if (status < 0) | ||
1789 | return status; | ||
1790 | status = device_create_file(dev, &dev_attr_suspend_disk_state); | ||
1791 | if (status < 0) | ||
1792 | return status; | ||
1793 | |||
1794 | if (ops->set_suspend_voltage) { | ||
1795 | status = device_create_file(dev, | ||
1796 | &dev_attr_suspend_standby_microvolts); | ||
1797 | if (status < 0) | ||
1798 | return status; | ||
1799 | status = device_create_file(dev, | ||
1800 | &dev_attr_suspend_mem_microvolts); | ||
1801 | if (status < 0) | ||
1802 | return status; | ||
1803 | status = device_create_file(dev, | ||
1804 | &dev_attr_suspend_disk_microvolts); | ||
1805 | if (status < 0) | ||
1806 | return status; | ||
1807 | } | ||
1808 | |||
1809 | if (ops->set_suspend_mode) { | ||
1810 | status = device_create_file(dev, | ||
1811 | &dev_attr_suspend_standby_mode); | ||
1812 | if (status < 0) | ||
1813 | return status; | ||
1814 | status = device_create_file(dev, | ||
1815 | &dev_attr_suspend_mem_mode); | ||
1816 | if (status < 0) | ||
1817 | return status; | ||
1818 | status = device_create_file(dev, | ||
1819 | &dev_attr_suspend_disk_mode); | ||
1820 | if (status < 0) | ||
1821 | return status; | ||
1822 | } | ||
1823 | |||
1824 | return status; | ||
1825 | } | ||
1826 | |||
1716 | /** | 1827 | /** |
1717 | * regulator_register - register regulator | 1828 | * regulator_register - register regulator |
1718 | * @regulator: regulator source | 1829 | * @regulator_desc: regulator to register |
1719 | * @reg_data: private regulator data | 1830 | * @dev: struct device for the regulator |
1831 | * @driver_data: private regulator data | ||
1720 | * | 1832 | * |
1721 | * Called by regulator drivers to register a regulator. | 1833 | * Called by regulator drivers to register a regulator. |
1722 | * Returns 0 on success. | 1834 | * Returns 0 on success. |
@@ -1761,45 +1873,37 @@ struct regulator_dev *regulator_register(struct regulator_desc *regulator_desc, | |||
1761 | /* preform any regulator specific init */ | 1873 | /* preform any regulator specific init */ |
1762 | if (init_data->regulator_init) { | 1874 | if (init_data->regulator_init) { |
1763 | ret = init_data->regulator_init(rdev->reg_data); | 1875 | ret = init_data->regulator_init(rdev->reg_data); |
1764 | if (ret < 0) { | 1876 | if (ret < 0) |
1765 | kfree(rdev); | 1877 | goto clean; |
1766 | rdev = ERR_PTR(ret); | ||
1767 | goto out; | ||
1768 | } | ||
1769 | } | ||
1770 | |||
1771 | /* set regulator constraints */ | ||
1772 | ret = set_machine_constraints(rdev, &init_data->constraints); | ||
1773 | if (ret < 0) { | ||
1774 | kfree(rdev); | ||
1775 | rdev = ERR_PTR(ret); | ||
1776 | goto out; | ||
1777 | } | 1878 | } |
1778 | 1879 | ||
1779 | /* register with sysfs */ | 1880 | /* register with sysfs */ |
1780 | rdev->dev.class = ®ulator_class; | 1881 | rdev->dev.class = ®ulator_class; |
1781 | rdev->dev.parent = dev; | 1882 | rdev->dev.parent = dev; |
1782 | snprintf(rdev->dev.bus_id, sizeof(rdev->dev.bus_id), | 1883 | dev_set_name(&rdev->dev, "regulator.%d", |
1783 | "regulator.%d", atomic_inc_return(®ulator_no) - 1); | 1884 | atomic_inc_return(®ulator_no) - 1); |
1784 | ret = device_register(&rdev->dev); | 1885 | ret = device_register(&rdev->dev); |
1785 | if (ret != 0) { | 1886 | if (ret != 0) |
1786 | kfree(rdev); | 1887 | goto clean; |
1787 | rdev = ERR_PTR(ret); | ||
1788 | goto out; | ||
1789 | } | ||
1790 | 1888 | ||
1791 | dev_set_drvdata(&rdev->dev, rdev); | 1889 | dev_set_drvdata(&rdev->dev, rdev); |
1792 | 1890 | ||
1891 | /* set regulator constraints */ | ||
1892 | ret = set_machine_constraints(rdev, &init_data->constraints); | ||
1893 | if (ret < 0) | ||
1894 | goto scrub; | ||
1895 | |||
1896 | /* add attributes supported by this regulator */ | ||
1897 | ret = add_regulator_attributes(rdev); | ||
1898 | if (ret < 0) | ||
1899 | goto scrub; | ||
1900 | |||
1793 | /* set supply regulator if it exists */ | 1901 | /* set supply regulator if it exists */ |
1794 | if (init_data->supply_regulator_dev) { | 1902 | if (init_data->supply_regulator_dev) { |
1795 | ret = set_supply(rdev, | 1903 | ret = set_supply(rdev, |
1796 | dev_get_drvdata(init_data->supply_regulator_dev)); | 1904 | dev_get_drvdata(init_data->supply_regulator_dev)); |
1797 | if (ret < 0) { | 1905 | if (ret < 0) |
1798 | device_unregister(&rdev->dev); | 1906 | goto scrub; |
1799 | kfree(rdev); | ||
1800 | rdev = ERR_PTR(ret); | ||
1801 | goto out; | ||
1802 | } | ||
1803 | } | 1907 | } |
1804 | 1908 | ||
1805 | /* add consumers devices */ | 1909 | /* add consumers devices */ |
@@ -1811,10 +1915,7 @@ struct regulator_dev *regulator_register(struct regulator_desc *regulator_desc, | |||
1811 | for (--i; i >= 0; i--) | 1915 | for (--i; i >= 0; i--) |
1812 | unset_consumer_device_supply(rdev, | 1916 | unset_consumer_device_supply(rdev, |
1813 | init_data->consumer_supplies[i].dev); | 1917 | init_data->consumer_supplies[i].dev); |
1814 | device_unregister(&rdev->dev); | 1918 | goto scrub; |
1815 | kfree(rdev); | ||
1816 | rdev = ERR_PTR(ret); | ||
1817 | goto out; | ||
1818 | } | 1919 | } |
1819 | } | 1920 | } |
1820 | 1921 | ||
@@ -1822,12 +1923,19 @@ struct regulator_dev *regulator_register(struct regulator_desc *regulator_desc, | |||
1822 | out: | 1923 | out: |
1823 | mutex_unlock(®ulator_list_mutex); | 1924 | mutex_unlock(®ulator_list_mutex); |
1824 | return rdev; | 1925 | return rdev; |
1926 | |||
1927 | scrub: | ||
1928 | device_unregister(&rdev->dev); | ||
1929 | clean: | ||
1930 | kfree(rdev); | ||
1931 | rdev = ERR_PTR(ret); | ||
1932 | goto out; | ||
1825 | } | 1933 | } |
1826 | EXPORT_SYMBOL_GPL(regulator_register); | 1934 | EXPORT_SYMBOL_GPL(regulator_register); |
1827 | 1935 | ||
1828 | /** | 1936 | /** |
1829 | * regulator_unregister - unregister regulator | 1937 | * regulator_unregister - unregister regulator |
1830 | * @regulator: regulator source | 1938 | * @rdev: regulator to unregister |
1831 | * | 1939 | * |
1832 | * Called by regulator drivers to unregister a regulator. | 1940 | * Called by regulator drivers to unregister a regulator. |
1833 | */ | 1941 | */ |
@@ -1846,7 +1954,7 @@ void regulator_unregister(struct regulator_dev *rdev) | |||
1846 | EXPORT_SYMBOL_GPL(regulator_unregister); | 1954 | EXPORT_SYMBOL_GPL(regulator_unregister); |
1847 | 1955 | ||
1848 | /** | 1956 | /** |
1849 | * regulator_suspend_prepare: prepare regulators for system wide suspend | 1957 | * regulator_suspend_prepare - prepare regulators for system wide suspend |
1850 | * @state: system suspend state | 1958 | * @state: system suspend state |
1851 | * | 1959 | * |
1852 | * Configure each regulator with it's suspend operating parameters for state. | 1960 | * Configure each regulator with it's suspend operating parameters for state. |
@@ -1882,7 +1990,7 @@ EXPORT_SYMBOL_GPL(regulator_suspend_prepare); | |||
1882 | 1990 | ||
1883 | /** | 1991 | /** |
1884 | * rdev_get_drvdata - get rdev regulator driver data | 1992 | * rdev_get_drvdata - get rdev regulator driver data |
1885 | * @regulator: regulator | 1993 | * @rdev: regulator |
1886 | * | 1994 | * |
1887 | * Get rdev regulator driver private data. This call can be used in the | 1995 | * Get rdev regulator driver private data. This call can be used in the |
1888 | * regulator driver context. | 1996 | * regulator driver context. |
@@ -1919,7 +2027,7 @@ EXPORT_SYMBOL_GPL(regulator_set_drvdata); | |||
1919 | 2027 | ||
1920 | /** | 2028 | /** |
1921 | * regulator_get_id - get regulator ID | 2029 | * regulator_get_id - get regulator ID |
1922 | * @regulator: regulator | 2030 | * @rdev: regulator |
1923 | */ | 2031 | */ |
1924 | int rdev_get_id(struct regulator_dev *rdev) | 2032 | int rdev_get_id(struct regulator_dev *rdev) |
1925 | { | 2033 | { |
diff --git a/drivers/regulator/da903x.c b/drivers/regulator/da903x.c index 773b29cec8be..fe77730a7edb 100644 --- a/drivers/regulator/da903x.c +++ b/drivers/regulator/da903x.c | |||
@@ -102,7 +102,7 @@ static int da903x_set_ldo_voltage(struct regulator_dev *rdev, | |||
102 | uint8_t val, mask; | 102 | uint8_t val, mask; |
103 | 103 | ||
104 | if (check_range(info, min_uV, max_uV)) { | 104 | if (check_range(info, min_uV, max_uV)) { |
105 | pr_err("invalid voltage range (%d, %d) uV", min_uV, max_uV); | 105 | pr_err("invalid voltage range (%d, %d) uV\n", min_uV, max_uV); |
106 | return -EINVAL; | 106 | return -EINVAL; |
107 | } | 107 | } |
108 | 108 | ||
@@ -159,7 +159,7 @@ static int da903x_is_enabled(struct regulator_dev *rdev) | |||
159 | if (ret) | 159 | if (ret) |
160 | return ret; | 160 | return ret; |
161 | 161 | ||
162 | return reg_val & (1 << info->enable_bit); | 162 | return !!(reg_val & (1 << info->enable_bit)); |
163 | } | 163 | } |
164 | 164 | ||
165 | /* DA9030 specific operations */ | 165 | /* DA9030 specific operations */ |
@@ -172,7 +172,7 @@ static int da9030_set_ldo1_15_voltage(struct regulator_dev *rdev, | |||
172 | int ret; | 172 | int ret; |
173 | 173 | ||
174 | if (check_range(info, min_uV, max_uV)) { | 174 | if (check_range(info, min_uV, max_uV)) { |
175 | pr_err("invalid voltage range (%d, %d) uV", min_uV, max_uV); | 175 | pr_err("invalid voltage range (%d, %d) uV\n", min_uV, max_uV); |
176 | return -EINVAL; | 176 | return -EINVAL; |
177 | } | 177 | } |
178 | 178 | ||
@@ -199,7 +199,7 @@ static int da9030_set_ldo14_voltage(struct regulator_dev *rdev, | |||
199 | int thresh; | 199 | int thresh; |
200 | 200 | ||
201 | if (check_range(info, min_uV, max_uV)) { | 201 | if (check_range(info, min_uV, max_uV)) { |
202 | pr_err("invalid voltage range (%d, %d) uV", min_uV, max_uV); | 202 | pr_err("invalid voltage range (%d, %d) uV\n", min_uV, max_uV); |
203 | return -EINVAL; | 203 | return -EINVAL; |
204 | } | 204 | } |
205 | 205 | ||
@@ -248,7 +248,7 @@ static int da9034_set_dvc_voltage(struct regulator_dev *rdev, | |||
248 | int ret; | 248 | int ret; |
249 | 249 | ||
250 | if (check_range(info, min_uV, max_uV)) { | 250 | if (check_range(info, min_uV, max_uV)) { |
251 | pr_err("invalid voltage range (%d, %d) uV", min_uV, max_uV); | 251 | pr_err("invalid voltage range (%d, %d) uV\n", min_uV, max_uV); |
252 | return -EINVAL; | 252 | return -EINVAL; |
253 | } | 253 | } |
254 | 254 | ||
@@ -273,7 +273,7 @@ static int da9034_set_ldo12_voltage(struct regulator_dev *rdev, | |||
273 | uint8_t val, mask; | 273 | uint8_t val, mask; |
274 | 274 | ||
275 | if (check_range(info, min_uV, max_uV)) { | 275 | if (check_range(info, min_uV, max_uV)) { |
276 | pr_err("invalid voltage range (%d, %d) uV", min_uV, max_uV); | 276 | pr_err("invalid voltage range (%d, %d) uV\n", min_uV, max_uV); |
277 | return -EINVAL; | 277 | return -EINVAL; |
278 | } | 278 | } |
279 | 279 | ||