Kernel

Kernel Git Source Tree

Root/drivers/regulator/core.c

1	/*
2	* core.c -- Voltage/Current Regulator framework.
3	*
4	* Copyright 2007, 2008 Wolfson Microelectronics PLC.
5	* Copyright 2008 SlimLogic Ltd.
6	*
7	* Author: Liam Girdwood <lrg@slimlogic.co.uk>
8	*
9	* This program is free software; you can redistribute it and/or modify it
10	* under the terms of the GNU General Public License as published by the
11	* Free Software Foundation; either version 2 of the License, or (at your
12	* option) any later version.
13	*
14	*/
15
16	#include <linux/kernel.h>
17	#include <linux/init.h>
18	#include <linux/debugfs.h>
19	#include <linux/device.h>
20	#include <linux/slab.h>
21	#include <linux/async.h>
22	#include <linux/err.h>
23	#include <linux/mutex.h>
24	#include <linux/suspend.h>
25	#include <linux/delay.h>
26	#include <linux/gpio.h>
27	#include <linux/of.h>
28	#include <linux/regmap.h>
29	#include <linux/regulator/of_regulator.h>
30	#include <linux/regulator/consumer.h>
31	#include <linux/regulator/driver.h>
32	#include <linux/regulator/machine.h>
33	#include <linux/module.h>
34
35	#define CREATE_TRACE_POINTS
36	#include <trace/events/regulator.h>
37
38	#include "dummy.h"
39
40	#define rdev_crit(rdev, fmt, ...) \
41	pr_crit("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
42	#define rdev_err(rdev, fmt, ...) \
43	pr_err("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
44	#define rdev_warn(rdev, fmt, ...) \
45	pr_warn("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
46	#define rdev_info(rdev, fmt, ...) \
47	pr_info("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
48	#define rdev_dbg(rdev, fmt, ...) \
49	pr_debug("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
50
51	static DEFINE_MUTEX(regulator_list_mutex);
52	static LIST_HEAD(regulator_list);
53	static LIST_HEAD(regulator_map_list);
54	static bool has_full_constraints;
55	static bool board_wants_dummy_regulator;
56
57	static struct dentry *debugfs_root;
58
59	/*
60	* struct regulator_map
61	*
62	* Used to provide symbolic supply names to devices.
63	*/
64	struct regulator_map {
65	struct list_head list;
66	const char dev_name; / The dev_name() for the consumer */
67	const char *supply;
68	struct regulator_dev *regulator;
69	};
70
71	/*
72	* struct regulator
73	*
74	* One for each consumer device.
75	*/
76	struct regulator {
77	struct device *dev;
78	struct list_head list;
79	unsigned int always_on:1;
80	int uA_load;
81	int min_uV;
82	int max_uV;
83	char *supply_name;
84	struct device_attribute dev_attr;
85	struct regulator_dev *rdev;
86	struct dentry *debugfs;
87	};
88
89	static int _regulator_is_enabled(struct regulator_dev *rdev);
90	static int _regulator_disable(struct regulator_dev *rdev);
91	static int _regulator_get_voltage(struct regulator_dev *rdev);
92	static int _regulator_get_current_limit(struct regulator_dev *rdev);
93	static unsigned int _regulator_get_mode(struct regulator_dev *rdev);
94	static void _notifier_call_chain(struct regulator_dev *rdev,
95	unsigned long event, void *data);
96	static int _regulator_do_set_voltage(struct regulator_dev *rdev,
97	int min_uV, int max_uV);
98	static struct regulator create_regulator(struct regulator_dev rdev,
99	struct device *dev,
100	const char *supply_name);
101
102	static const char rdev_get_name(struct regulator_dev rdev)
103	{
104	if (rdev->constraints && rdev->constraints->name)
105	return rdev->constraints->name;
106	else if (rdev->desc->name)
107	return rdev->desc->name;
108	else
109	return "";
110	}
111
112	/**
113	* of_get_regulator - get a regulator device node based on supply name
114	* @dev: Device pointer for the consumer (of regulator) device
115	* @supply: regulator supply name
116	*
117	* Extract the regulator device node corresponding to the supply name.
118	* retruns the device node corresponding to the regulator if found, else
119	* returns NULL.
120	*/
121	static struct device_node of_get_regulator(struct device dev, const char *supply)
122	{
123	struct device_node *regnode = NULL;
124	char prop_name[32]; /* 32 is max size of property name */
125
126	dev_dbg(dev, "Looking up %s-supply from device tree\n", supply);
127
128	snprintf(prop_name, 32, "%s-supply", supply);
129	regnode = of_parse_phandle(dev->of_node, prop_name, 0);
130
131	if (!regnode) {
132	dev_dbg(dev, "Looking up %s property in node %s failed",
133	prop_name, dev->of_node->full_name);
134	return NULL;
135	}
136	return regnode;
137	}
138
139	static int _regulator_can_change_status(struct regulator_dev *rdev)
140	{
141	if (!rdev->constraints)
142	return 0;
143
144	if (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_STATUS)
145	return 1;
146	else
147	return 0;
148	}
149
150	/* Platform voltage constraint check */
151	static int regulator_check_voltage(struct regulator_dev *rdev,
152	int min_uV, int max_uV)
153	{
154	BUG_ON(min_uV > max_uV);
155
156	if (!rdev->constraints) {
157	rdev_err(rdev, "no constraints\n");
158	return -ENODEV;
159	}
160	if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) {
161	rdev_err(rdev, "operation not allowed\n");
162	return -EPERM;
163	}
164
165	if (*max_uV > rdev->constraints->max_uV)
166	*max_uV = rdev->constraints->max_uV;
167	if (*min_uV < rdev->constraints->min_uV)
168	*min_uV = rdev->constraints->min_uV;
169
170	if (min_uV > max_uV) {
171	rdev_err(rdev, "unsupportable voltage range: %d-%duV\n",
172	min_uV, max_uV);
173	return -EINVAL;
174	}
175
176	return 0;
177	}
178
179	/* Make sure we select a voltage that suits the needs of all
180	* regulator consumers
181	*/
182	static int regulator_check_consumers(struct regulator_dev *rdev,
183	int min_uV, int max_uV)
184	{
185	struct regulator *regulator;
186
187	list_for_each_entry(regulator, &rdev->consumer_list, list) {
188	/*
189	* Assume consumers that didn't say anything are OK
190	* with anything in the constraint range.
191	*/
192	if (!regulator->min_uV && !regulator->max_uV)
193	continue;
194
195	if (*max_uV > regulator->max_uV)
196	*max_uV = regulator->max_uV;
197	if (*min_uV < regulator->min_uV)
198	*min_uV = regulator->min_uV;
199	}
200
201	if (min_uV > max_uV)
202	return -EINVAL;
203
204	return 0;
205	}
206
207	/* current constraint check */
208	static int regulator_check_current_limit(struct regulator_dev *rdev,
209	int min_uA, int max_uA)
210	{
211	BUG_ON(min_uA > max_uA);
212
213	if (!rdev->constraints) {
214	rdev_err(rdev, "no constraints\n");
215	return -ENODEV;
216	}
217	if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_CURRENT)) {
218	rdev_err(rdev, "operation not allowed\n");
219	return -EPERM;
220	}
221
222	if (*max_uA > rdev->constraints->max_uA)
223	*max_uA = rdev->constraints->max_uA;
224	if (*min_uA < rdev->constraints->min_uA)
225	*min_uA = rdev->constraints->min_uA;
226
227	if (min_uA > max_uA) {
228	rdev_err(rdev, "unsupportable current range: %d-%duA\n",
229	min_uA, max_uA);
230	return -EINVAL;
231	}
232
233	return 0;
234	}
235
236	/* operating mode constraint check */
237	static int regulator_mode_constrain(struct regulator_dev rdev, int mode)
238	{
239	switch (*mode) {
240	case REGULATOR_MODE_FAST:
241	case REGULATOR_MODE_NORMAL:
242	case REGULATOR_MODE_IDLE:
243	case REGULATOR_MODE_STANDBY:
244	break;
245	default:
246	rdev_err(rdev, "invalid mode %x specified\n", *mode);
247	return -EINVAL;
248	}
249
250	if (!rdev->constraints) {
251	rdev_err(rdev, "no constraints\n");
252	return -ENODEV;
253	}
254	if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_MODE)) {
255	rdev_err(rdev, "operation not allowed\n");
256	return -EPERM;
257	}
258
259	/* The modes are bitmasks, the most power hungry modes having
260	* the lowest values. If the requested mode isn't supported
261	* try higher modes. */
262	while (*mode) {
263	if (rdev->constraints->valid_modes_mask & *mode)
264	return 0;
265	*mode /= 2;
266	}
267
268	return -EINVAL;
269	}
270
271	/* dynamic regulator mode switching constraint check */
272	static int regulator_check_drms(struct regulator_dev *rdev)
273	{
274	if (!rdev->constraints) {
275	rdev_err(rdev, "no constraints\n");
276	return -ENODEV;
277	}
278	if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS)) {
279	rdev_err(rdev, "operation not allowed\n");
280	return -EPERM;
281	}
282	return 0;
283	}
284
285	static ssize_t regulator_uV_show(struct device *dev,
286	struct device_attribute attr, char buf)
287	{
288	struct regulator_dev *rdev = dev_get_drvdata(dev);
289	ssize_t ret;
290
291	mutex_lock(&rdev->mutex);
292	ret = sprintf(buf, "%d\n", _regulator_get_voltage(rdev));
293	mutex_unlock(&rdev->mutex);
294
295	return ret;
296	}
297	static DEVICE_ATTR(microvolts, 0444, regulator_uV_show, NULL);
298
299	static ssize_t regulator_uA_show(struct device *dev,
300	struct device_attribute attr, char buf)
301	{
302	struct regulator_dev *rdev = dev_get_drvdata(dev);
303
304	return sprintf(buf, "%d\n", _regulator_get_current_limit(rdev));
305	}
306	static DEVICE_ATTR(microamps, 0444, regulator_uA_show, NULL);
307
308	static ssize_t regulator_name_show(struct device *dev,
309	struct device_attribute attr, char buf)
310	{
311	struct regulator_dev *rdev = dev_get_drvdata(dev);
312
313	return sprintf(buf, "%s\n", rdev_get_name(rdev));
314	}
315
316	static ssize_t regulator_print_opmode(char *buf, int mode)
317	{
318	switch (mode) {
319	case REGULATOR_MODE_FAST:
320	return sprintf(buf, "fast\n");
321	case REGULATOR_MODE_NORMAL:
322	return sprintf(buf, "normal\n");
323	case REGULATOR_MODE_IDLE:
324	return sprintf(buf, "idle\n");
325	case REGULATOR_MODE_STANDBY:
326	return sprintf(buf, "standby\n");
327	}
328	return sprintf(buf, "unknown\n");
329	}
330
331	static ssize_t regulator_opmode_show(struct device *dev,
332	struct device_attribute attr, char buf)
333	{
334	struct regulator_dev *rdev = dev_get_drvdata(dev);
335
336	return regulator_print_opmode(buf, _regulator_get_mode(rdev));
337	}
338	static DEVICE_ATTR(opmode, 0444, regulator_opmode_show, NULL);
339
340	static ssize_t regulator_print_state(char *buf, int state)
341	{
342	if (state > 0)
343	return sprintf(buf, "enabled\n");
344	else if (state == 0)
345	return sprintf(buf, "disabled\n");
346	else
347	return sprintf(buf, "unknown\n");
348	}
349
350	static ssize_t regulator_state_show(struct device *dev,
351	struct device_attribute attr, char buf)
352	{
353	struct regulator_dev *rdev = dev_get_drvdata(dev);
354	ssize_t ret;
355
356	mutex_lock(&rdev->mutex);
357	ret = regulator_print_state(buf, _regulator_is_enabled(rdev));
358	mutex_unlock(&rdev->mutex);
359
360	return ret;
361	}
362	static DEVICE_ATTR(state, 0444, regulator_state_show, NULL);
363
364	static ssize_t regulator_status_show(struct device *dev,
365	struct device_attribute attr, char buf)
366	{
367	struct regulator_dev *rdev = dev_get_drvdata(dev);
368	int status;
369	char *label;
370
371	status = rdev->desc->ops->get_status(rdev);
372	if (status < 0)
373	return status;
374
375	switch (status) {
376	case REGULATOR_STATUS_OFF:
377	label = "off";
378	break;
379	case REGULATOR_STATUS_ON:
380	label = "on";
381	break;
382	case REGULATOR_STATUS_ERROR:
383	label = "error";
384	break;
385	case REGULATOR_STATUS_FAST:
386	label = "fast";
387	break;
388	case REGULATOR_STATUS_NORMAL:
389	label = "normal";
390	break;
391	case REGULATOR_STATUS_IDLE:
392	label = "idle";
393	break;
394	case REGULATOR_STATUS_STANDBY:
395	label = "standby";
396	break;
397	case REGULATOR_STATUS_UNDEFINED:
398	label = "undefined";
399	break;
400	default:
401	return -ERANGE;
402	}
403
404	return sprintf(buf, "%s\n", label);
405	}
406	static DEVICE_ATTR(status, 0444, regulator_status_show, NULL);
407
408	static ssize_t regulator_min_uA_show(struct device *dev,
409	struct device_attribute attr, char buf)
410	{
411	struct regulator_dev *rdev = dev_get_drvdata(dev);
412
413	if (!rdev->constraints)
414	return sprintf(buf, "constraint not defined\n");
415
416	return sprintf(buf, "%d\n", rdev->constraints->min_uA);
417	}
418	static DEVICE_ATTR(min_microamps, 0444, regulator_min_uA_show, NULL);
419
420	static ssize_t regulator_max_uA_show(struct device *dev,
421	struct device_attribute attr, char buf)
422	{
423	struct regulator_dev *rdev = dev_get_drvdata(dev);
424
425	if (!rdev->constraints)
426	return sprintf(buf, "constraint not defined\n");
427
428	return sprintf(buf, "%d\n", rdev->constraints->max_uA);
429	}
430	static DEVICE_ATTR(max_microamps, 0444, regulator_max_uA_show, NULL);
431
432	static ssize_t regulator_min_uV_show(struct device *dev,
433	struct device_attribute attr, char buf)
434	{
435	struct regulator_dev *rdev = dev_get_drvdata(dev);
436
437	if (!rdev->constraints)
438	return sprintf(buf, "constraint not defined\n");
439
440	return sprintf(buf, "%d\n", rdev->constraints->min_uV);
441	}
442	static DEVICE_ATTR(min_microvolts, 0444, regulator_min_uV_show, NULL);
443
444	static ssize_t regulator_max_uV_show(struct device *dev,
445	struct device_attribute attr, char buf)
446	{
447	struct regulator_dev *rdev = dev_get_drvdata(dev);
448
449	if (!rdev->constraints)
450	return sprintf(buf, "constraint not defined\n");
451
452	return sprintf(buf, "%d\n", rdev->constraints->max_uV);
453	}
454	static DEVICE_ATTR(max_microvolts, 0444, regulator_max_uV_show, NULL);
455
456	static ssize_t regulator_total_uA_show(struct device *dev,
457	struct device_attribute attr, char buf)
458	{
459	struct regulator_dev *rdev = dev_get_drvdata(dev);
460	struct regulator *regulator;
461	int uA = 0;
462
463	mutex_lock(&rdev->mutex);
464	list_for_each_entry(regulator, &rdev->consumer_list, list)
465	uA += regulator->uA_load;
466	mutex_unlock(&rdev->mutex);
467	return sprintf(buf, "%d\n", uA);
468	}
469	static DEVICE_ATTR(requested_microamps, 0444, regulator_total_uA_show, NULL);
470
471	static ssize_t regulator_num_users_show(struct device *dev,
472	struct device_attribute attr, char buf)
473	{
474	struct regulator_dev *rdev = dev_get_drvdata(dev);
475	return sprintf(buf, "%d\n", rdev->use_count);
476	}
477
478	static ssize_t regulator_type_show(struct device *dev,
479	struct device_attribute attr, char buf)
480	{
481	struct regulator_dev *rdev = dev_get_drvdata(dev);
482
483	switch (rdev->desc->type) {
484	case REGULATOR_VOLTAGE:
485	return sprintf(buf, "voltage\n");
486	case REGULATOR_CURRENT:
487	return sprintf(buf, "current\n");
488	}
489	return sprintf(buf, "unknown\n");
490	}
491
492	static ssize_t regulator_suspend_mem_uV_show(struct device *dev,
493	struct device_attribute attr, char buf)
494	{
495	struct regulator_dev *rdev = dev_get_drvdata(dev);
496
497	return sprintf(buf, "%d\n", rdev->constraints->state_mem.uV);
498	}
499	static DEVICE_ATTR(suspend_mem_microvolts, 0444,
500	regulator_suspend_mem_uV_show, NULL);
501
502	static ssize_t regulator_suspend_disk_uV_show(struct device *dev,
503	struct device_attribute attr, char buf)
504	{
505	struct regulator_dev *rdev = dev_get_drvdata(dev);
506
507	return sprintf(buf, "%d\n", rdev->constraints->state_disk.uV);
508	}
509	static DEVICE_ATTR(suspend_disk_microvolts, 0444,
510	regulator_suspend_disk_uV_show, NULL);
511
512	static ssize_t regulator_suspend_standby_uV_show(struct device *dev,
513	struct device_attribute attr, char buf)
514	{
515	struct regulator_dev *rdev = dev_get_drvdata(dev);
516
517	return sprintf(buf, "%d\n", rdev->constraints->state_standby.uV);
518	}
519	static DEVICE_ATTR(suspend_standby_microvolts, 0444,
520	regulator_suspend_standby_uV_show, NULL);
521
522	static ssize_t regulator_suspend_mem_mode_show(struct device *dev,
523	struct device_attribute attr, char buf)
524	{
525	struct regulator_dev *rdev = dev_get_drvdata(dev);
526
527	return regulator_print_opmode(buf,
528	rdev->constraints->state_mem.mode);
529	}
530	static DEVICE_ATTR(suspend_mem_mode, 0444,
531	regulator_suspend_mem_mode_show, NULL);
532
533	static ssize_t regulator_suspend_disk_mode_show(struct device *dev,
534	struct device_attribute attr, char buf)
535	{
536	struct regulator_dev *rdev = dev_get_drvdata(dev);
537
538	return regulator_print_opmode(buf,
539	rdev->constraints->state_disk.mode);
540	}
541	static DEVICE_ATTR(suspend_disk_mode, 0444,
542	regulator_suspend_disk_mode_show, NULL);
543
544	static ssize_t regulator_suspend_standby_mode_show(struct device *dev,
545	struct device_attribute attr, char buf)
546	{
547	struct regulator_dev *rdev = dev_get_drvdata(dev);
548
549	return regulator_print_opmode(buf,
550	rdev->constraints->state_standby.mode);
551	}
552	static DEVICE_ATTR(suspend_standby_mode, 0444,
553	regulator_suspend_standby_mode_show, NULL);
554
555	static ssize_t regulator_suspend_mem_state_show(struct device *dev,
556	struct device_attribute attr, char buf)
557	{
558	struct regulator_dev *rdev = dev_get_drvdata(dev);
559
560	return regulator_print_state(buf,
561	rdev->constraints->state_mem.enabled);
562	}
563	static DEVICE_ATTR(suspend_mem_state, 0444,
564	regulator_suspend_mem_state_show, NULL);
565
566	static ssize_t regulator_suspend_disk_state_show(struct device *dev,
567	struct device_attribute attr, char buf)
568	{
569	struct regulator_dev *rdev = dev_get_drvdata(dev);
570
571	return regulator_print_state(buf,
572	rdev->constraints->state_disk.enabled);
573	}
574	static DEVICE_ATTR(suspend_disk_state, 0444,
575	regulator_suspend_disk_state_show, NULL);
576
577	static ssize_t regulator_suspend_standby_state_show(struct device *dev,
578	struct device_attribute attr, char buf)
579	{
580	struct regulator_dev *rdev = dev_get_drvdata(dev);
581
582	return regulator_print_state(buf,
583	rdev->constraints->state_standby.enabled);
584	}
585	static DEVICE_ATTR(suspend_standby_state, 0444,
586	regulator_suspend_standby_state_show, NULL);
587
588
589	/*
590	* These are the only attributes are present for all regulators.
591	* Other attributes are a function of regulator functionality.
592	*/
593	static struct device_attribute regulator_dev_attrs[] = {
594	__ATTR(name, 0444, regulator_name_show, NULL),
595	__ATTR(num_users, 0444, regulator_num_users_show, NULL),
596	__ATTR(type, 0444, regulator_type_show, NULL),
597	__ATTR_NULL,
598	};
599
600	static void regulator_dev_release(struct device *dev)
601	{
602	struct regulator_dev *rdev = dev_get_drvdata(dev);
603	kfree(rdev);
604	}
605
606	static struct class regulator_class = {
607	.name = "regulator",
608	.dev_release = regulator_dev_release,
609	.dev_attrs = regulator_dev_attrs,
610	};
611
612	/* Calculate the new optimum regulator operating mode based on the new total
613	* consumer load. All locks held by caller */
614	static void drms_uA_update(struct regulator_dev *rdev)
615	{
616	struct regulator *sibling;
617	int current_uA = 0, output_uV, input_uV, err;
618	unsigned int mode;
619
620	err = regulator_check_drms(rdev);
621	if (err < 0 \|\| !rdev->desc->ops->get_optimum_mode \|\|
622	(!rdev->desc->ops->get_voltage &&
623	!rdev->desc->ops->get_voltage_sel) \|\|
624	!rdev->desc->ops->set_mode)
625	return;
626
627	/* get output voltage */
628	output_uV = _regulator_get_voltage(rdev);
629	if (output_uV <= 0)
630	return;
631
632	/* get input voltage */
633	input_uV = 0;
634	if (rdev->supply)
635	input_uV = regulator_get_voltage(rdev->supply);
636	if (input_uV <= 0)
637	input_uV = rdev->constraints->input_uV;
638	if (input_uV <= 0)
639	return;
640
641	/* calc total requested load */
642	list_for_each_entry(sibling, &rdev->consumer_list, list)
643	current_uA += sibling->uA_load;
644
645	/* now get the optimum mode for our new total regulator load */
646	mode = rdev->desc->ops->get_optimum_mode(rdev, input_uV,
647	output_uV, current_uA);
648
649	/* check the new mode is allowed */
650	err = regulator_mode_constrain(rdev, &mode);
651	if (err == 0)
652	rdev->desc->ops->set_mode(rdev, mode);
653	}
654
655	static int suspend_set_state(struct regulator_dev *rdev,
656	struct regulator_state *rstate)
657	{
658	int ret = 0;
659
660	/* If we have no suspend mode configration don't set anything;
661	* only warn if the driver implements set_suspend_voltage or
662	* set_suspend_mode callback.
663	*/
664	if (!rstate->enabled && !rstate->disabled) {
665	if (rdev->desc->ops->set_suspend_voltage \|\|
666	rdev->desc->ops->set_suspend_mode)
667	rdev_warn(rdev, "No configuration\n");
668	return 0;
669	}
670
671	if (rstate->enabled && rstate->disabled) {
672	rdev_err(rdev, "invalid configuration\n");
673	return -EINVAL;
674	}
675
676	if (rstate->enabled && rdev->desc->ops->set_suspend_enable)
677	ret = rdev->desc->ops->set_suspend_enable(rdev);
678	else if (rstate->disabled && rdev->desc->ops->set_suspend_disable)
679	ret = rdev->desc->ops->set_suspend_disable(rdev);
680	else /* OK if set_suspend_enable or set_suspend_disable is NULL */
681	ret = 0;
682
683	if (ret < 0) {
684	rdev_err(rdev, "failed to enabled/disable\n");
685	return ret;
686	}
687
688	if (rdev->desc->ops->set_suspend_voltage && rstate->uV > 0) {
689	ret = rdev->desc->ops->set_suspend_voltage(rdev, rstate->uV);
690	if (ret < 0) {
691	rdev_err(rdev, "failed to set voltage\n");
692	return ret;
693	}
694	}
695
696	if (rdev->desc->ops->set_suspend_mode && rstate->mode > 0) {
697	ret = rdev->desc->ops->set_suspend_mode(rdev, rstate->mode);
698	if (ret < 0) {
699	rdev_err(rdev, "failed to set mode\n");
700	return ret;
701	}
702	}
703	return ret;
704	}
705
706	/* locks held by caller */
707	static int suspend_prepare(struct regulator_dev *rdev, suspend_state_t state)
708	{
709	if (!rdev->constraints)
710	return -EINVAL;
711
712	switch (state) {
713	case PM_SUSPEND_STANDBY:
714	return suspend_set_state(rdev,
715	&rdev->constraints->state_standby);
716	case PM_SUSPEND_MEM:
717	return suspend_set_state(rdev,
718	&rdev->constraints->state_mem);
719	case PM_SUSPEND_MAX:
720	return suspend_set_state(rdev,
721	&rdev->constraints->state_disk);
722	default:
723	return -EINVAL;
724	}
725	}
726
727	static void print_constraints(struct regulator_dev *rdev)
728	{
729	struct regulation_constraints *constraints = rdev->constraints;
730	char buf[80] = "";
731	int count = 0;
732	int ret;
733
734	if (constraints->min_uV && constraints->max_uV) {
735	if (constraints->min_uV == constraints->max_uV)
736	count += sprintf(buf + count, "%d mV ",
737	constraints->min_uV / 1000);
738	else
739	count += sprintf(buf + count, "%d <--> %d mV ",
740	constraints->min_uV / 1000,
741	constraints->max_uV / 1000);
742	}
743
744	if (!constraints->min_uV \|\|
745	constraints->min_uV != constraints->max_uV) {
746	ret = _regulator_get_voltage(rdev);
747	if (ret > 0)
748	count += sprintf(buf + count, "at %d mV ", ret / 1000);
749	}
750
751	if (constraints->uV_offset)
752	count += sprintf(buf, "%dmV offset ",
753	constraints->uV_offset / 1000);
754
755	if (constraints->min_uA && constraints->max_uA) {
756	if (constraints->min_uA == constraints->max_uA)
757	count += sprintf(buf + count, "%d mA ",
758	constraints->min_uA / 1000);
759	else
760	count += sprintf(buf + count, "%d <--> %d mA ",
761	constraints->min_uA / 1000,
762	constraints->max_uA / 1000);
763	}
764
765	if (!constraints->min_uA \|\|
766	constraints->min_uA != constraints->max_uA) {
767	ret = _regulator_get_current_limit(rdev);
768	if (ret > 0)
769	count += sprintf(buf + count, "at %d mA ", ret / 1000);
770	}
771
772	if (constraints->valid_modes_mask & REGULATOR_MODE_FAST)
773	count += sprintf(buf + count, "fast ");
774	if (constraints->valid_modes_mask & REGULATOR_MODE_NORMAL)
775	count += sprintf(buf + count, "normal ");
776	if (constraints->valid_modes_mask & REGULATOR_MODE_IDLE)
777	count += sprintf(buf + count, "idle ");
778	if (constraints->valid_modes_mask & REGULATOR_MODE_STANDBY)
779	count += sprintf(buf + count, "standby");
780
781	rdev_info(rdev, "%s\n", buf);
782
783	if ((constraints->min_uV != constraints->max_uV) &&
784	!(constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE))
785	rdev_warn(rdev,
786	"Voltage range but no REGULATOR_CHANGE_VOLTAGE\n");
787	}
788
789	static int machine_constraints_voltage(struct regulator_dev *rdev,
790	struct regulation_constraints *constraints)
791	{
792	struct regulator_ops *ops = rdev->desc->ops;
793	int ret;
794
795	/* do we need to apply the constraint voltage */
796	if (rdev->constraints->apply_uV &&
797	rdev->constraints->min_uV == rdev->constraints->max_uV) {
798	ret = _regulator_do_set_voltage(rdev,
799	rdev->constraints->min_uV,
800	rdev->constraints->max_uV);
801	if (ret < 0) {
802	rdev_err(rdev, "failed to apply %duV constraint\n",
803	rdev->constraints->min_uV);
804	return ret;
805	}
806	}
807
808	/* constrain machine-level voltage specs to fit
809	* the actual range supported by this regulator.
810	*/
811	if (ops->list_voltage && rdev->desc->n_voltages) {
812	int count = rdev->desc->n_voltages;
813	int i;
814	int min_uV = INT_MAX;
815	int max_uV = INT_MIN;
816	int cmin = constraints->min_uV;
817	int cmax = constraints->max_uV;
818
819	/* it's safe to autoconfigure fixed-voltage supplies
820	and the constraints are used by list_voltage. */
821	if (count == 1 && !cmin) {
822	cmin = 1;
823	cmax = INT_MAX;
824	constraints->min_uV = cmin;
825	constraints->max_uV = cmax;
826	}
827
828	/* voltage constraints are optional */
829	if ((cmin == 0) && (cmax == 0))
830	return 0;
831
832	/* else require explicit machine-level constraints */
833	if (cmin <= 0 \|\| cmax <= 0 \|\| cmax < cmin) {
834	rdev_err(rdev, "invalid voltage constraints\n");
835	return -EINVAL;
836	}
837
838	/* initial: [cmin..cmax] valid, [min_uV..max_uV] not */
839	for (i = 0; i < count; i++) {
840	int value;
841
842	value = ops->list_voltage(rdev, i);
843	if (value <= 0)
844	continue;
845
846	/* maybe adjust [min_uV..max_uV] */
847	if (value >= cmin && value < min_uV)
848	min_uV = value;
849	if (value <= cmax && value > max_uV)
850	max_uV = value;
851	}
852
853	/* final: [min_uV..max_uV] valid iff constraints valid */
854	if (max_uV < min_uV) {
855	rdev_err(rdev, "unsupportable voltage constraints\n");
856	return -EINVAL;
857	}
858
859	/* use regulator's subset of machine constraints */
860	if (constraints->min_uV < min_uV) {
861	rdev_dbg(rdev, "override min_uV, %d -> %d\n",
862	constraints->min_uV, min_uV);
863	constraints->min_uV = min_uV;
864	}
865	if (constraints->max_uV > max_uV) {
866	rdev_dbg(rdev, "override max_uV, %d -> %d\n",
867	constraints->max_uV, max_uV);
868	constraints->max_uV = max_uV;
869	}
870	}
871
872	return 0;
873	}
874
875	/**
876	* set_machine_constraints - sets regulator constraints
877	* @rdev: regulator source
878	* @constraints: constraints to apply
879	*
880	* Allows platform initialisation code to define and constrain
881	* regulator circuits e.g. valid voltage/current ranges, etc. NOTE:
882	* Constraints must be set by platform code in order for some
883	* regulator operations to proceed i.e. set_voltage, set_current_limit,
884	* set_mode.
885	*/
886	static int set_machine_constraints(struct regulator_dev *rdev,
887	const struct regulation_constraints *constraints)
888	{
889	int ret = 0;
890	struct regulator_ops *ops = rdev->desc->ops;
891
892	if (constraints)
893	rdev->constraints = kmemdup(constraints, sizeof(*constraints),
894	GFP_KERNEL);
895	else
896	rdev->constraints = kzalloc(sizeof(*constraints),
897	GFP_KERNEL);
898	if (!rdev->constraints)
899	return -ENOMEM;
900
901	ret = machine_constraints_voltage(rdev, rdev->constraints);
902	if (ret != 0)
903	goto out;
904
905	/* do we need to setup our suspend state */
906	if (rdev->constraints->initial_state) {
907	ret = suspend_prepare(rdev, rdev->constraints->initial_state);
908	if (ret < 0) {
909	rdev_err(rdev, "failed to set suspend state\n");
910	goto out;
911	}
912	}
913
914	if (rdev->constraints->initial_mode) {
915	if (!ops->set_mode) {
916	rdev_err(rdev, "no set_mode operation\n");
917	ret = -EINVAL;
918	goto out;
919	}
920
921	ret = ops->set_mode(rdev, rdev->constraints->initial_mode);
922	if (ret < 0) {
923	rdev_err(rdev, "failed to set initial mode: %d\n", ret);
924	goto out;
925	}
926	}
927
928	/* If the constraints say the regulator should be on at this point
929	* and we have control then make sure it is enabled.
930	*/
931	if ((rdev->constraints->always_on \|\| rdev->constraints->boot_on) &&
932	ops->enable) {
933	ret = ops->enable(rdev);
934	if (ret < 0) {
935	rdev_err(rdev, "failed to enable\n");
936	goto out;
937	}
938	}
939
940	if (rdev->constraints->ramp_delay && ops->set_ramp_delay) {
941	ret = ops->set_ramp_delay(rdev, rdev->constraints->ramp_delay);
942	if (ret < 0) {
943	rdev_err(rdev, "failed to set ramp_delay\n");
944	goto out;
945	}
946	}
947
948	print_constraints(rdev);
949	return 0;
950	out:
951	kfree(rdev->constraints);
952	rdev->constraints = NULL;
953	return ret;
954	}
955
956	/**
957	* set_supply - set regulator supply regulator
958	* @rdev: regulator name
959	* @supply_rdev: supply regulator name
960	*
961	* Called by platform initialisation code to set the supply regulator for this
962	* regulator. This ensures that a regulators supply will also be enabled by the
963	* core if it's child is enabled.
964	*/
965	static int set_supply(struct regulator_dev *rdev,
966	struct regulator_dev *supply_rdev)
967	{
968	int err;
969
970	rdev_info(rdev, "supplied by %s\n", rdev_get_name(supply_rdev));
971
972	rdev->supply = create_regulator(supply_rdev, &rdev->dev, "SUPPLY");
973	if (rdev->supply == NULL) {
974	err = -ENOMEM;
975	return err;
976	}
977
978	return 0;
979	}
980
981	/**
982	* set_consumer_device_supply - Bind a regulator to a symbolic supply
983	* @rdev: regulator source
984	* @consumer_dev_name: dev_name() string for device supply applies to
985	* @supply: symbolic name for supply
986	*
987	* Allows platform initialisation code to map physical regulator
988	* sources to symbolic names for supplies for use by devices. Devices
989	* should use these symbolic names to request regulators, avoiding the
990	* need to provide board-specific regulator names as platform data.
991	*/
992	static int set_consumer_device_supply(struct regulator_dev *rdev,
993	const char *consumer_dev_name,
994	const char *supply)
995	{
996	struct regulator_map *node;
997	int has_dev;
998
999	if (supply == NULL)
1000	return -EINVAL;
1001
1002	if (consumer_dev_name != NULL)
1003	has_dev = 1;
1004	else
1005	has_dev = 0;
1006
1007	list_for_each_entry(node, &regulator_map_list, list) {
1008	if (node->dev_name && consumer_dev_name) {
1009	if (strcmp(node->dev_name, consumer_dev_name) != 0)
1010	continue;
1011	} else if (node->dev_name \|\| consumer_dev_name) {
1012	continue;
1013	}
1014
1015	if (strcmp(node->supply, supply) != 0)
1016	continue;
1017
1018	pr_debug("%s: %s/%s is '%s' supply; fail %s/%s\n",
1019	consumer_dev_name,
1020	dev_name(&node->regulator->dev),
1021	node->regulator->desc->name,
1022	supply,
1023	dev_name(&rdev->dev), rdev_get_name(rdev));
1024	return -EBUSY;
1025	}
1026
1027	node = kzalloc(sizeof(struct regulator_map), GFP_KERNEL);
1028	if (node == NULL)
1029	return -ENOMEM;
1030
1031	node->regulator = rdev;
1032	node->supply = supply;
1033
1034	if (has_dev) {
1035	node->dev_name = kstrdup(consumer_dev_name, GFP_KERNEL);
1036	if (node->dev_name == NULL) {
1037	kfree(node);
1038	return -ENOMEM;
1039	}
1040	}
1041
1042	list_add(&node->list, &regulator_map_list);
1043	return 0;
1044	}
1045
1046	static void unset_regulator_supplies(struct regulator_dev *rdev)
1047	{
1048	struct regulator_map node, n;
1049
1050	list_for_each_entry_safe(node, n, &regulator_map_list, list) {
1051	if (rdev == node->regulator) {
1052	list_del(&node->list);
1053	kfree(node->dev_name);
1054	kfree(node);
1055	}
1056	}
1057	}
1058
1059	#define REG_STR_SIZE 64
1060
1061	static struct regulator create_regulator(struct regulator_dev rdev,
1062	struct device *dev,
1063	const char *supply_name)
1064	{
1065	struct regulator *regulator;
1066	char buf[REG_STR_SIZE];
1067	int err, size;
1068
1069	regulator = kzalloc(sizeof(*regulator), GFP_KERNEL);
1070	if (regulator == NULL)
1071	return NULL;
1072
1073	mutex_lock(&rdev->mutex);
1074	regulator->rdev = rdev;
1075	list_add(&regulator->list, &rdev->consumer_list);
1076
1077	if (dev) {
1078	regulator->dev = dev;
1079
1080	/* Add a link to the device sysfs entry */
1081	size = scnprintf(buf, REG_STR_SIZE, "%s-%s",
1082	dev->kobj.name, supply_name);
1083	if (size >= REG_STR_SIZE)
1084	goto overflow_err;
1085
1086	regulator->supply_name = kstrdup(buf, GFP_KERNEL);
1087	if (regulator->supply_name == NULL)
1088	goto overflow_err;
1089
1090	err = sysfs_create_link(&rdev->dev.kobj, &dev->kobj,
1091	buf);
1092	if (err) {
1093	rdev_warn(rdev, "could not add device link %s err %d\n",
1094	dev->kobj.name, err);
1095	/* non-fatal */
1096	}
1097	} else {
1098	regulator->supply_name = kstrdup(supply_name, GFP_KERNEL);
1099	if (regulator->supply_name == NULL)
1100	goto overflow_err;
1101	}
1102
1103	regulator->debugfs = debugfs_create_dir(regulator->supply_name,
1104	rdev->debugfs);
1105	if (!regulator->debugfs) {
1106	rdev_warn(rdev, "Failed to create debugfs directory\n");
1107	} else {
1108	debugfs_create_u32("uA_load", 0444, regulator->debugfs,
1109	&regulator->uA_load);
1110	debugfs_create_u32("min_uV", 0444, regulator->debugfs,
1111	&regulator->min_uV);
1112	debugfs_create_u32("max_uV", 0444, regulator->debugfs,
1113	&regulator->max_uV);
1114	}
1115
1116	/*
1117	* Check now if the regulator is an always on regulator - if
1118	* it is then we don't need to do nearly so much work for
1119	* enable/disable calls.
1120	*/
1121	if (!_regulator_can_change_status(rdev) &&
1122	_regulator_is_enabled(rdev))
1123	regulator->always_on = true;
1124
1125	mutex_unlock(&rdev->mutex);
1126	return regulator;
1127	overflow_err:
1128	list_del(&regulator->list);
1129	kfree(regulator);
1130	mutex_unlock(&rdev->mutex);
1131	return NULL;
1132	}
1133
1134	static int _regulator_get_enable_time(struct regulator_dev *rdev)
1135	{
1136	if (!rdev->desc->ops->enable_time)
1137	return rdev->desc->enable_time;
1138	return rdev->desc->ops->enable_time(rdev);
1139	}
1140
1141	static struct regulator_dev regulator_dev_lookup(struct device dev,
1142	const char *supply,
1143	int *ret)
1144	{
1145	struct regulator_dev *r;
1146	struct device_node *node;
1147	struct regulator_map *map;
1148	const char *devname = NULL;
1149
1150	/* first do a dt based lookup */
1151	if (dev && dev->of_node) {
1152	node = of_get_regulator(dev, supply);
1153	if (node) {
1154	list_for_each_entry(r, &regulator_list, list)
1155	if (r->dev.parent &&
1156	node == r->dev.of_node)
1157	return r;
1158	} else {
1159	/*
1160	* If we couldn't even get the node then it's
1161	* not just that the device didn't register
1162	* yet, there's no node and we'll never
1163	* succeed.
1164	*/
1165	*ret = -ENODEV;
1166	}
1167	}
1168
1169	/* if not found, try doing it non-dt way */
1170	if (dev)
1171	devname = dev_name(dev);
1172
1173	list_for_each_entry(r, &regulator_list, list)
1174	if (strcmp(rdev_get_name(r), supply) == 0)
1175	return r;
1176
1177	list_for_each_entry(map, &regulator_map_list, list) {
1178	/* If the mapping has a device set up it must match */
1179	if (map->dev_name &&
1180	(!devname \|\| strcmp(map->dev_name, devname)))
1181	continue;
1182
1183	if (strcmp(map->supply, supply) == 0)
1184	return map->regulator;
1185	}
1186
1187
1188	return NULL;
1189	}
1190
1191	/* Internal regulator request function */
1192	static struct regulator _regulator_get(struct device dev, const char *id,
1193	int exclusive)
1194	{
1195	struct regulator_dev *rdev;
1196	struct regulator *regulator = ERR_PTR(-EPROBE_DEFER);
1197	const char *devname = NULL;
1198	int ret;
1199
1200	if (id == NULL) {
1201	pr_err("get() with no identifier\n");
1202	return regulator;
1203	}
1204
1205	if (dev)
1206	devname = dev_name(dev);
1207
1208	mutex_lock(&regulator_list_mutex);
1209
1210	rdev = regulator_dev_lookup(dev, id, &ret);
1211	if (rdev)
1212	goto found;
1213
1214	if (board_wants_dummy_regulator) {
1215	rdev = dummy_regulator_rdev;
1216	goto found;
1217	}
1218
1219	#ifdef CONFIG_REGULATOR_DUMMY
1220	if (!devname)
1221	devname = "deviceless";
1222
1223	/* If the board didn't flag that it was fully constrained then
1224	* substitute in a dummy regulator so consumers can continue.
1225	*/
1226	if (!has_full_constraints) {
1227	pr_warn("%s supply %s not found, using dummy regulator\n",
1228	devname, id);
1229	rdev = dummy_regulator_rdev;
1230	goto found;
1231	}
1232	#endif
1233
1234	mutex_unlock(&regulator_list_mutex);
1235	return regulator;
1236
1237	found:
1238	if (rdev->exclusive) {
1239	regulator = ERR_PTR(-EPERM);
1240	goto out;
1241	}
1242
1243	if (exclusive && rdev->open_count) {
1244	regulator = ERR_PTR(-EBUSY);
1245	goto out;
1246	}
1247
1248	if (!try_module_get(rdev->owner))
1249	goto out;
1250
1251	regulator = create_regulator(rdev, dev, id);
1252	if (regulator == NULL) {
1253	regulator = ERR_PTR(-ENOMEM);
1254	module_put(rdev->owner);
1255	goto out;
1256	}
1257
1258	rdev->open_count++;
1259	if (exclusive) {
1260	rdev->exclusive = 1;
1261
1262	ret = _regulator_is_enabled(rdev);
1263	if (ret > 0)
1264	rdev->use_count = 1;
1265	else
1266	rdev->use_count = 0;
1267	}
1268
1269	out:
1270	mutex_unlock(&regulator_list_mutex);
1271
1272	return regulator;
1273	}
1274
1275	/**
1276	* regulator_get - lookup and obtain a reference to a regulator.
1277	* @dev: device for regulator "consumer"
1278	* @id: Supply name or regulator ID.
1279	*
1280	* Returns a struct regulator corresponding to the regulator producer,
1281	* or IS_ERR() condition containing errno.
1282	*
1283	* Use of supply names configured via regulator_set_device_supply() is
1284	* strongly encouraged. It is recommended that the supply name used
1285	* should match the name used for the supply and/or the relevant
1286	* device pins in the datasheet.
1287	*/
1288	struct regulator regulator_get(struct device dev, const char *id)
1289	{
1290	return _regulator_get(dev, id, 0);
1291	}
1292	EXPORT_SYMBOL_GPL(regulator_get);
1293
1294	static void devm_regulator_release(struct device dev, void res)
1295	{
1296	regulator_put((struct regulator *)res);
1297	}
1298
1299	/**
1300	* devm_regulator_get - Resource managed regulator_get()
1301	* @dev: device for regulator "consumer"
1302	* @id: Supply name or regulator ID.
1303	*
1304	* Managed regulator_get(). Regulators returned from this function are
1305	* automatically regulator_put() on driver detach. See regulator_get() for more
1306	* information.
1307	*/
1308	struct regulator devm_regulator_get(struct device dev, const char *id)
1309	{
1310	struct regulator *ptr, regulator;
1311
1312	ptr = devres_alloc(devm_regulator_release, sizeof(*ptr), GFP_KERNEL);
1313	if (!ptr)
1314	return ERR_PTR(-ENOMEM);
1315
1316	regulator = regulator_get(dev, id);
1317	if (!IS_ERR(regulator)) {
1318	*ptr = regulator;
1319	devres_add(dev, ptr);
1320	} else {
1321	devres_free(ptr);
1322	}
1323
1324	return regulator;
1325	}
1326	EXPORT_SYMBOL_GPL(devm_regulator_get);
1327
1328	/**
1329	* regulator_get_exclusive - obtain exclusive access to a regulator.
1330	* @dev: device for regulator "consumer"
1331	* @id: Supply name or regulator ID.
1332	*
1333	* Returns a struct regulator corresponding to the regulator producer,
1334	* or IS_ERR() condition containing errno. Other consumers will be
1335	* unable to obtain this reference is held and the use count for the
1336	* regulator will be initialised to reflect the current state of the
1337	* regulator.
1338	*
1339	* This is intended for use by consumers which cannot tolerate shared
1340	* use of the regulator such as those which need to force the
1341	* regulator off for correct operation of the hardware they are
1342	* controlling.
1343	*
1344	* Use of supply names configured via regulator_set_device_supply() is
1345	* strongly encouraged. It is recommended that the supply name used
1346	* should match the name used for the supply and/or the relevant
1347	* device pins in the datasheet.
1348	*/
1349	struct regulator regulator_get_exclusive(struct device dev, const char *id)
1350	{
1351	return _regulator_get(dev, id, 1);
1352	}
1353	EXPORT_SYMBOL_GPL(regulator_get_exclusive);
1354
1355	/**
1356	* regulator_put - "free" the regulator source
1357	* @regulator: regulator source
1358	*
1359	* Note: drivers must ensure that all regulator_enable calls made on this
1360	* regulator source are balanced by regulator_disable calls prior to calling
1361	* this function.
1362	*/
1363	void regulator_put(struct regulator *regulator)
1364	{
1365	struct regulator_dev *rdev;
1366
1367	if (regulator == NULL \|\| IS_ERR(regulator))
1368	return;
1369
1370	mutex_lock(&regulator_list_mutex);
1371	rdev = regulator->rdev;
1372
1373	debugfs_remove_recursive(regulator->debugfs);
1374
1375	/* remove any sysfs entries */
1376	if (regulator->dev)
1377	sysfs_remove_link(&rdev->dev.kobj, regulator->supply_name);
1378	kfree(regulator->supply_name);
1379	list_del(&regulator->list);
1380	kfree(regulator);
1381
1382	rdev->open_count--;
1383	rdev->exclusive = 0;
1384
1385	module_put(rdev->owner);
1386	mutex_unlock(&regulator_list_mutex);
1387	}
1388	EXPORT_SYMBOL_GPL(regulator_put);
1389
1390	static int devm_regulator_match(struct device dev, void res, void *data)
1391	{
1392	struct regulator **r = res;
1393	if (!r \|\| !*r) {
1394	WARN_ON(!r \|\| !*r);
1395	return 0;
1396	}
1397	return *r == data;
1398	}
1399
1400	/**
1401	* devm_regulator_put - Resource managed regulator_put()
1402	* @regulator: regulator to free
1403	*
1404	* Deallocate a regulator allocated with devm_regulator_get(). Normally
1405	* this function will not need to be called and the resource management
1406	* code will ensure that the resource is freed.
1407	*/
1408	void devm_regulator_put(struct regulator *regulator)
1409	{
1410	int rc;
1411
1412	rc = devres_release(regulator->dev, devm_regulator_release,
1413	devm_regulator_match, regulator);
1414	if (rc != 0)
1415	WARN_ON(rc);
1416	}
1417	EXPORT_SYMBOL_GPL(devm_regulator_put);
1418
1419	static int _regulator_do_enable(struct regulator_dev *rdev)
1420	{
1421	int ret, delay;
1422
1423	/* Query before enabling in case configuration dependent. */
1424	ret = _regulator_get_enable_time(rdev);
1425	if (ret >= 0) {
1426	delay = ret;
1427	} else {
1428	rdev_warn(rdev, "enable_time() failed: %d\n", ret);
1429	delay = 0;
1430	}
1431
1432	trace_regulator_enable(rdev_get_name(rdev));
1433
1434	if (rdev->ena_gpio) {
1435	gpio_set_value_cansleep(rdev->ena_gpio,
1436	!rdev->ena_gpio_invert);
1437	rdev->ena_gpio_state = 1;
1438	} else if (rdev->desc->ops->enable) {
1439	ret = rdev->desc->ops->enable(rdev);
1440	if (ret < 0)
1441	return ret;
1442	} else {
1443	return -EINVAL;
1444	}
1445
1446	/* Allow the regulator to ramp; it would be useful to extend
1447	* this for bulk operations so that the regulators can ramp
1448	* together. */
1449	trace_regulator_enable_delay(rdev_get_name(rdev));
1450
1451	if (delay >= 1000) {
1452	mdelay(delay / 1000);
1453	udelay(delay % 1000);
1454	} else if (delay) {
1455	udelay(delay);
1456	}
1457
1458	trace_regulator_enable_complete(rdev_get_name(rdev));
1459
1460	return 0;
1461	}
1462
1463	/* locks held by regulator_enable() */
1464	static int _regulator_enable(struct regulator_dev *rdev)
1465	{
1466	int ret;
1467
1468	/* check voltage and requested load before enabling */
1469	if (rdev->constraints &&
1470	(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS))
1471	drms_uA_update(rdev);
1472
1473	if (rdev->use_count == 0) {
1474	/* The regulator may on if it's not switchable or left on */
1475	ret = _regulator_is_enabled(rdev);
1476	if (ret == -EINVAL \|\| ret == 0) {
1477	if (!_regulator_can_change_status(rdev))
1478	return -EPERM;
1479
1480	ret = _regulator_do_enable(rdev);
1481	if (ret < 0)
1482	return ret;
1483
1484	} else if (ret < 0) {
1485	rdev_err(rdev, "is_enabled() failed: %d\n", ret);
1486	return ret;
1487	}
1488	/* Fallthrough on positive return values - already enabled */
1489	}
1490
1491	rdev->use_count++;
1492
1493	return 0;
1494	}
1495
1496	/**
1497	* regulator_enable - enable regulator output
1498	* @regulator: regulator source
1499	*
1500	* Request that the regulator be enabled with the regulator output at
1501	* the predefined voltage or current value. Calls to regulator_enable()
1502	* must be balanced with calls to regulator_disable().
1503	*
1504	* NOTE: the output value can be set by other drivers, boot loader or may be
1505	* hardwired in the regulator.
1506	*/
1507	int regulator_enable(struct regulator *regulator)
1508	{
1509	struct regulator_dev *rdev = regulator->rdev;
1510	int ret = 0;
1511
1512	if (regulator->always_on)
1513	return 0;
1514
1515	if (rdev->supply) {
1516	ret = regulator_enable(rdev->supply);
1517	if (ret != 0)
1518	return ret;
1519	}
1520
1521	mutex_lock(&rdev->mutex);
1522	ret = _regulator_enable(rdev);
1523	mutex_unlock(&rdev->mutex);
1524
1525	if (ret != 0 && rdev->supply)
1526	regulator_disable(rdev->supply);
1527
1528	return ret;
1529	}
1530	EXPORT_SYMBOL_GPL(regulator_enable);
1531
1532	static int _regulator_do_disable(struct regulator_dev *rdev)
1533	{
1534	int ret;
1535
1536	trace_regulator_disable(rdev_get_name(rdev));
1537
1538	if (rdev->ena_gpio) {
1539	gpio_set_value_cansleep(rdev->ena_gpio,
1540	rdev->ena_gpio_invert);
1541	rdev->ena_gpio_state = 0;
1542
1543	} else if (rdev->desc->ops->disable) {
1544	ret = rdev->desc->ops->disable(rdev);
1545	if (ret != 0)
1546	return ret;
1547	}
1548
1549	trace_regulator_disable_complete(rdev_get_name(rdev));
1550
1551	_notifier_call_chain(rdev, REGULATOR_EVENT_DISABLE,
1552	NULL);
1553	return 0;
1554	}
1555
1556	/* locks held by regulator_disable() */
1557	static int _regulator_disable(struct regulator_dev *rdev)
1558	{
1559	int ret = 0;
1560
1561	if (WARN(rdev->use_count <= 0,
1562	"unbalanced disables for %s\n", rdev_get_name(rdev)))
1563	return -EIO;
1564
1565	/* are we the last user and permitted to disable ? */
1566	if (rdev->use_count == 1 &&
1567	(rdev->constraints && !rdev->constraints->always_on)) {
1568
1569	/* we are last user */
1570	if (_regulator_can_change_status(rdev)) {
1571	ret = _regulator_do_disable(rdev);
1572	if (ret < 0) {
1573	rdev_err(rdev, "failed to disable\n");
1574	return ret;
1575	}
1576	}
1577
1578	rdev->use_count = 0;
1579	} else if (rdev->use_count > 1) {
1580
1581	if (rdev->constraints &&
1582	(rdev->constraints->valid_ops_mask &
1583	REGULATOR_CHANGE_DRMS))
1584	drms_uA_update(rdev);
1585
1586	rdev->use_count--;
1587	}
1588
1589	return ret;
1590	}
1591
1592	/**
1593	* regulator_disable - disable regulator output
1594	* @regulator: regulator source
1595	*
1596	* Disable the regulator output voltage or current. Calls to
1597	* regulator_enable() must be balanced with calls to
1598	* regulator_disable().
1599	*
1600	* NOTE: this will only disable the regulator output if no other consumer
1601	* devices have it enabled, the regulator device supports disabling and
1602	* machine constraints permit this operation.
1603	*/
1604	int regulator_disable(struct regulator *regulator)
1605	{
1606	struct regulator_dev *rdev = regulator->rdev;
1607	int ret = 0;
1608
1609	if (regulator->always_on)
1610	return 0;
1611
1612	mutex_lock(&rdev->mutex);
1613	ret = _regulator_disable(rdev);
1614	mutex_unlock(&rdev->mutex);
1615
1616	if (ret == 0 && rdev->supply)
1617	regulator_disable(rdev->supply);
1618
1619	return ret;
1620	}
1621	EXPORT_SYMBOL_GPL(regulator_disable);
1622
1623	/* locks held by regulator_force_disable() */
1624	static int _regulator_force_disable(struct regulator_dev *rdev)
1625	{
1626	int ret = 0;
1627
1628	/* force disable */
1629	if (rdev->desc->ops->disable) {
1630	/* ah well, who wants to live forever... */
1631	ret = rdev->desc->ops->disable(rdev);
1632	if (ret < 0) {
1633	rdev_err(rdev, "failed to force disable\n");
1634	return ret;
1635	}
1636	/* notify other consumers that power has been forced off */
1637	_notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE \|
1638	REGULATOR_EVENT_DISABLE, NULL);
1639	}
1640
1641	return ret;
1642	}
1643
1644	/**
1645	* regulator_force_disable - force disable regulator output
1646	* @regulator: regulator source
1647	*
1648	* Forcibly disable the regulator output voltage or current.
1649	* NOTE: this will disable the regulator output even if other consumer
1650	* devices have it enabled. This should be used for situations when device
1651	* damage will likely occur if the regulator is not disabled (e.g. over temp).
1652	*/
1653	int regulator_force_disable(struct regulator *regulator)
1654	{
1655	struct regulator_dev *rdev = regulator->rdev;
1656	int ret;
1657
1658	mutex_lock(&rdev->mutex);
1659	regulator->uA_load = 0;
1660	ret = _regulator_force_disable(regulator->rdev);
1661	mutex_unlock(&rdev->mutex);
1662
1663	if (rdev->supply)
1664	while (rdev->open_count--)
1665	regulator_disable(rdev->supply);
1666
1667	return ret;
1668	}
1669	EXPORT_SYMBOL_GPL(regulator_force_disable);
1670
1671	static void regulator_disable_work(struct work_struct *work)
1672	{
1673	struct regulator_dev *rdev = container_of(work, struct regulator_dev,
1674	disable_work.work);
1675	int count, i, ret;
1676
1677	mutex_lock(&rdev->mutex);
1678
1679	BUG_ON(!rdev->deferred_disables);
1680
1681	count = rdev->deferred_disables;
1682	rdev->deferred_disables = 0;
1683
1684	for (i = 0; i < count; i++) {
1685	ret = _regulator_disable(rdev);
1686	if (ret != 0)
1687	rdev_err(rdev, "Deferred disable failed: %d\n", ret);
1688	}
1689
1690	mutex_unlock(&rdev->mutex);
1691
1692	if (rdev->supply) {
1693	for (i = 0; i < count; i++) {
1694	ret = regulator_disable(rdev->supply);
1695	if (ret != 0) {
1696	rdev_err(rdev,
1697	"Supply disable failed: %d\n", ret);
1698	}
1699	}
1700	}
1701	}
1702
1703	/**
1704	* regulator_disable_deferred - disable regulator output with delay
1705	* @regulator: regulator source
1706	* @ms: miliseconds until the regulator is disabled
1707	*
1708	* Execute regulator_disable() on the regulator after a delay. This
1709	* is intended for use with devices that require some time to quiesce.
1710	*
1711	* NOTE: this will only disable the regulator output if no other consumer
1712	* devices have it enabled, the regulator device supports disabling and
1713	* machine constraints permit this operation.
1714	*/
1715	int regulator_disable_deferred(struct regulator *regulator, int ms)
1716	{
1717	struct regulator_dev *rdev = regulator->rdev;
1718	int ret;
1719
1720	if (regulator->always_on)
1721	return 0;
1722
1723	mutex_lock(&rdev->mutex);
1724	rdev->deferred_disables++;
1725	mutex_unlock(&rdev->mutex);
1726
1727	ret = schedule_delayed_work(&rdev->disable_work,
1728	msecs_to_jiffies(ms));
1729	if (ret < 0)
1730	return ret;
1731	else
1732	return 0;
1733	}
1734	EXPORT_SYMBOL_GPL(regulator_disable_deferred);
1735
1736	/**
1737	* regulator_is_enabled_regmap - standard is_enabled() for regmap users
1738	*
1739	* @rdev: regulator to operate on
1740	*
1741	* Regulators that use regmap for their register I/O can set the
1742	* enable_reg and enable_mask fields in their descriptor and then use
1743	* this as their is_enabled operation, saving some code.
1744	*/
1745	int regulator_is_enabled_regmap(struct regulator_dev *rdev)
1746	{
1747	unsigned int val;
1748	int ret;
1749
1750	ret = regmap_read(rdev->regmap, rdev->desc->enable_reg, &val);
1751	if (ret != 0)
1752	return ret;
1753
1754	return (val & rdev->desc->enable_mask) != 0;
1755	}
1756	EXPORT_SYMBOL_GPL(regulator_is_enabled_regmap);
1757
1758	/**
1759	* regulator_enable_regmap - standard enable() for regmap users
1760	*
1761	* @rdev: regulator to operate on
1762	*
1763	* Regulators that use regmap for their register I/O can set the
1764	* enable_reg and enable_mask fields in their descriptor and then use
1765	* this as their enable() operation, saving some code.
1766	*/
1767	int regulator_enable_regmap(struct regulator_dev *rdev)
1768	{
1769	return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
1770	rdev->desc->enable_mask,
1771	rdev->desc->enable_mask);
1772	}
1773	EXPORT_SYMBOL_GPL(regulator_enable_regmap);
1774
1775	/**
1776	* regulator_disable_regmap - standard disable() for regmap users
1777	*
1778	* @rdev: regulator to operate on
1779	*
1780	* Regulators that use regmap for their register I/O can set the
1781	* enable_reg and enable_mask fields in their descriptor and then use
1782	* this as their disable() operation, saving some code.
1783	*/
1784	int regulator_disable_regmap(struct regulator_dev *rdev)
1785	{
1786	return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
1787	rdev->desc->enable_mask, 0);
1788	}
1789	EXPORT_SYMBOL_GPL(regulator_disable_regmap);
1790
1791	static int _regulator_is_enabled(struct regulator_dev *rdev)
1792	{
1793	/* A GPIO control always takes precedence */
1794	if (rdev->ena_gpio)
1795	return rdev->ena_gpio_state;
1796
1797	/* If we don't know then assume that the regulator is always on */
1798	if (!rdev->desc->ops->is_enabled)
1799	return 1;
1800
1801	return rdev->desc->ops->is_enabled(rdev);
1802	}
1803
1804	/**
1805	* regulator_is_enabled - is the regulator output enabled
1806	* @regulator: regulator source
1807	*
1808	* Returns positive if the regulator driver backing the source/client
1809	* has requested that the device be enabled, zero if it hasn't, else a
1810	* negative errno code.
1811	*
1812	* Note that the device backing this regulator handle can have multiple
1813	* users, so it might be enabled even if regulator_enable() was never
1814	* called for this particular source.
1815	*/
1816	int regulator_is_enabled(struct regulator *regulator)
1817	{
1818	int ret;
1819
1820	if (regulator->always_on)
1821	return 1;
1822
1823	mutex_lock(&regulator->rdev->mutex);
1824	ret = _regulator_is_enabled(regulator->rdev);
1825	mutex_unlock(&regulator->rdev->mutex);
1826
1827	return ret;
1828	}
1829	EXPORT_SYMBOL_GPL(regulator_is_enabled);
1830
1831	/**
1832	* regulator_count_voltages - count regulator_list_voltage() selectors
1833	* @regulator: regulator source
1834	*
1835	* Returns number of selectors, or negative errno. Selectors are
1836	* numbered starting at zero, and typically correspond to bitfields
1837	* in hardware registers.
1838	*/
1839	int regulator_count_voltages(struct regulator *regulator)
1840	{
1841	struct regulator_dev *rdev = regulator->rdev;
1842
1843	return rdev->desc->n_voltages ? : -EINVAL;
1844	}
1845	EXPORT_SYMBOL_GPL(regulator_count_voltages);
1846
1847	/**
1848	* regulator_list_voltage_linear - List voltages with simple calculation
1849	*
1850	* @rdev: Regulator device
1851	* @selector: Selector to convert into a voltage
1852	*
1853	* Regulators with a simple linear mapping between voltages and
1854	* selectors can set min_uV and uV_step in the regulator descriptor
1855	* and then use this function as their list_voltage() operation,
1856	*/
1857	int regulator_list_voltage_linear(struct regulator_dev *rdev,
1858	unsigned int selector)
1859	{
1860	if (selector >= rdev->desc->n_voltages)
1861	return -EINVAL;
1862
1863	return rdev->desc->min_uV + (rdev->desc->uV_step * selector);
1864	}
1865	EXPORT_SYMBOL_GPL(regulator_list_voltage_linear);
1866
1867	/**
1868	* regulator_list_voltage_table - List voltages with table based mapping
1869	*
1870	* @rdev: Regulator device
1871	* @selector: Selector to convert into a voltage
1872	*
1873	* Regulators with table based mapping between voltages and
1874	* selectors can set volt_table in the regulator descriptor
1875	* and then use this function as their list_voltage() operation.
1876	*/
1877	int regulator_list_voltage_table(struct regulator_dev *rdev,
1878	unsigned int selector)
1879	{
1880	if (!rdev->desc->volt_table) {
1881	BUG_ON(!rdev->desc->volt_table);
1882	return -EINVAL;
1883	}
1884
1885	if (selector >= rdev->desc->n_voltages)
1886	return -EINVAL;
1887
1888	return rdev->desc->volt_table[selector];
1889	}
1890	EXPORT_SYMBOL_GPL(regulator_list_voltage_table);
1891
1892	/**
1893	* regulator_list_voltage - enumerate supported voltages
1894	* @regulator: regulator source
1895	* @selector: identify voltage to list
1896	* Context: can sleep
1897	*
1898	* Returns a voltage that can be passed to @regulator_set_voltage(),
1899	* zero if this selector code can't be used on this system, or a
1900	* negative errno.
1901	*/
1902	int regulator_list_voltage(struct regulator *regulator, unsigned selector)
1903	{
1904	struct regulator_dev *rdev = regulator->rdev;
1905	struct regulator_ops *ops = rdev->desc->ops;
1906	int ret;
1907
1908	if (!ops->list_voltage \|\| selector >= rdev->desc->n_voltages)
1909	return -EINVAL;
1910
1911	mutex_lock(&rdev->mutex);
1912	ret = ops->list_voltage(rdev, selector);
1913	mutex_unlock(&rdev->mutex);
1914
1915	if (ret > 0) {
1916	if (ret < rdev->constraints->min_uV)
1917	ret = 0;
1918	else if (ret > rdev->constraints->max_uV)
1919	ret = 0;
1920	}
1921
1922	return ret;
1923	}
1924	EXPORT_SYMBOL_GPL(regulator_list_voltage);
1925
1926	/**
1927	* regulator_is_supported_voltage - check if a voltage range can be supported
1928	*
1929	* @regulator: Regulator to check.
1930	* @min_uV: Minimum required voltage in uV.
1931	* @max_uV: Maximum required voltage in uV.
1932	*
1933	* Returns a boolean or a negative error code.
1934	*/
1935	int regulator_is_supported_voltage(struct regulator *regulator,
1936	int min_uV, int max_uV)
1937	{
1938	struct regulator_dev *rdev = regulator->rdev;
1939	int i, voltages, ret;
1940
1941	/* If we can't change voltage check the current voltage */
1942	if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) {
1943	ret = regulator_get_voltage(regulator);
1944	if (ret >= 0)
1945	return (min_uV >= ret && ret <= max_uV);
1946	else
1947	return ret;
1948	}
1949
1950	ret = regulator_count_voltages(regulator);
1951	if (ret < 0)
1952	return ret;
1953	voltages = ret;
1954
1955	for (i = 0; i < voltages; i++) {
1956	ret = regulator_list_voltage(regulator, i);
1957
1958	if (ret >= min_uV && ret <= max_uV)
1959	return 1;
1960	}
1961
1962	return 0;
1963	}
1964	EXPORT_SYMBOL_GPL(regulator_is_supported_voltage);
1965
1966	/**
1967	* regulator_get_voltage_sel_regmap - standard get_voltage_sel for regmap users
1968	*
1969	* @rdev: regulator to operate on
1970	*
1971	* Regulators that use regmap for their register I/O can set the
1972	* vsel_reg and vsel_mask fields in their descriptor and then use this
1973	* as their get_voltage_vsel operation, saving some code.
1974	*/
1975	int regulator_get_voltage_sel_regmap(struct regulator_dev *rdev)
1976	{
1977	unsigned int val;
1978	int ret;
1979
1980	ret = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &val);
1981	if (ret != 0)
1982	return ret;
1983
1984	val &= rdev->desc->vsel_mask;
1985	val >>= ffs(rdev->desc->vsel_mask) - 1;
1986
1987	return val;
1988	}
1989	EXPORT_SYMBOL_GPL(regulator_get_voltage_sel_regmap);
1990
1991	/**
1992	* regulator_set_voltage_sel_regmap - standard set_voltage_sel for regmap users
1993	*
1994	* @rdev: regulator to operate on
1995	* @sel: Selector to set
1996	*
1997	* Regulators that use regmap for their register I/O can set the
1998	* vsel_reg and vsel_mask fields in their descriptor and then use this
1999	* as their set_voltage_vsel operation, saving some code.
2000	*/
2001	int regulator_set_voltage_sel_regmap(struct regulator_dev *rdev, unsigned sel)
2002	{
2003	sel <<= ffs(rdev->desc->vsel_mask) - 1;
2004
2005	return regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg,
2006	rdev->desc->vsel_mask, sel);
2007	}
2008	EXPORT_SYMBOL_GPL(regulator_set_voltage_sel_regmap);
2009
2010	/**
2011	* regulator_map_voltage_iterate - map_voltage() based on list_voltage()
2012	*
2013	* @rdev: Regulator to operate on
2014	* @min_uV: Lower bound for voltage
2015	* @max_uV: Upper bound for voltage
2016	*
2017	* Drivers implementing set_voltage_sel() and list_voltage() can use
2018	* this as their map_voltage() operation. It will find a suitable
2019	* voltage by calling list_voltage() until it gets something in bounds
2020	* for the requested voltages.
2021	*/
2022	int regulator_map_voltage_iterate(struct regulator_dev *rdev,
2023	int min_uV, int max_uV)
2024	{
2025	int best_val = INT_MAX;
2026	int selector = 0;
2027	int i, ret;
2028
2029	/* Find the smallest voltage that falls within the specified
2030	* range.
2031	*/
2032	for (i = 0; i < rdev->desc->n_voltages; i++) {
2033	ret = rdev->desc->ops->list_voltage(rdev, i);
2034	if (ret < 0)
2035	continue;
2036
2037	if (ret < best_val && ret >= min_uV && ret <= max_uV) {
2038	best_val = ret;
2039	selector = i;
2040	}
2041	}
2042
2043	if (best_val != INT_MAX)
2044	return selector;
2045	else
2046	return -EINVAL;
2047	}
2048	EXPORT_SYMBOL_GPL(regulator_map_voltage_iterate);
2049
2050	/**
2051	* regulator_map_voltage_linear - map_voltage() for simple linear mappings
2052	*
2053	* @rdev: Regulator to operate on
2054	* @min_uV: Lower bound for voltage
2055	* @max_uV: Upper bound for voltage
2056	*
2057	* Drivers providing min_uV and uV_step in their regulator_desc can
2058	* use this as their map_voltage() operation.
2059	*/
2060	int regulator_map_voltage_linear(struct regulator_dev *rdev,
2061	int min_uV, int max_uV)
2062	{
2063	int ret, voltage;
2064
2065	/* Allow uV_step to be 0 for fixed voltage */
2066	if (rdev->desc->n_voltages == 1 && rdev->desc->uV_step == 0) {
2067	if (min_uV <= rdev->desc->min_uV && rdev->desc->min_uV <= max_uV)
2068	return 0;
2069	else
2070	return -EINVAL;
2071	}
2072
2073	if (!rdev->desc->uV_step) {
2074	BUG_ON(!rdev->desc->uV_step);
2075	return -EINVAL;
2076	}
2077
2078	if (min_uV < rdev->desc->min_uV)
2079	min_uV = rdev->desc->min_uV;
2080
2081	ret = DIV_ROUND_UP(min_uV - rdev->desc->min_uV, rdev->desc->uV_step);
2082	if (ret < 0)
2083	return ret;
2084
2085	/* Map back into a voltage to verify we're still in bounds */
2086	voltage = rdev->desc->ops->list_voltage(rdev, ret);
2087	if (voltage < min_uV \|\| voltage > max_uV)
2088	return -EINVAL;
2089
2090	return ret;
2091	}
2092	EXPORT_SYMBOL_GPL(regulator_map_voltage_linear);
2093
2094	static int _regulator_do_set_voltage(struct regulator_dev *rdev,
2095	int min_uV, int max_uV)
2096	{
2097	int ret;
2098	int delay = 0;
2099	int best_val = 0;
2100	unsigned int selector;
2101	int old_selector = -1;
2102
2103	trace_regulator_set_voltage(rdev_get_name(rdev), min_uV, max_uV);
2104
2105	min_uV += rdev->constraints->uV_offset;
2106	max_uV += rdev->constraints->uV_offset;
2107
2108	/*
2109	* If we can't obtain the old selector there is not enough
2110	* info to call set_voltage_time_sel().
2111	*/
2112	if (_regulator_is_enabled(rdev) &&
2113	rdev->desc->ops->set_voltage_time_sel &&
2114	rdev->desc->ops->get_voltage_sel) {
2115	old_selector = rdev->desc->ops->get_voltage_sel(rdev);
2116	if (old_selector < 0)
2117	return old_selector;
2118	}
2119
2120	if (rdev->desc->ops->set_voltage) {
2121	ret = rdev->desc->ops->set_voltage(rdev, min_uV, max_uV,
2122	&selector);
2123
2124	if (ret >= 0) {
2125	if (rdev->desc->ops->list_voltage)
2126	best_val = rdev->desc->ops->list_voltage(rdev,
2127	selector);
2128	else
2129	best_val = _regulator_get_voltage(rdev);
2130	}
2131
2132	} else if (rdev->desc->ops->set_voltage_sel) {
2133	if (rdev->desc->ops->map_voltage) {
2134	ret = rdev->desc->ops->map_voltage(rdev, min_uV,
2135	max_uV);
2136	} else {
2137	if (rdev->desc->ops->list_voltage ==
2138	regulator_list_voltage_linear)
2139	ret = regulator_map_voltage_linear(rdev,
2140	min_uV, max_uV);
2141	else
2142	ret = regulator_map_voltage_iterate(rdev,
2143	min_uV, max_uV);
2144	}
2145
2146	if (ret >= 0) {
2147	best_val = rdev->desc->ops->list_voltage(rdev, ret);
2148	if (min_uV <= best_val && max_uV >= best_val) {
2149	selector = ret;
2150	ret = rdev->desc->ops->set_voltage_sel(rdev,
2151	ret);
2152	} else {
2153	ret = -EINVAL;
2154	}
2155	}
2156	} else {
2157	ret = -EINVAL;
2158	}
2159
2160	/* Call set_voltage_time_sel if successfully obtained old_selector */
2161	if (ret == 0 && _regulator_is_enabled(rdev) && old_selector >= 0 &&
2162	rdev->desc->ops->set_voltage_time_sel) {
2163
2164	delay = rdev->desc->ops->set_voltage_time_sel(rdev,
2165	old_selector, selector);
2166	if (delay < 0) {
2167	rdev_warn(rdev, "set_voltage_time_sel() failed: %d\n",
2168	delay);
2169	delay = 0;
2170	}
2171
2172	/* Insert any necessary delays */
2173	if (delay >= 1000) {
2174	mdelay(delay / 1000);
2175	udelay(delay % 1000);
2176	} else if (delay) {
2177	udelay(delay);
2178	}
2179	}
2180
2181	if (ret == 0 && best_val >= 0)
2182	_notifier_call_chain(rdev, REGULATOR_EVENT_VOLTAGE_CHANGE,
2183	(void *)best_val);
2184
2185	trace_regulator_set_voltage_complete(rdev_get_name(rdev), best_val);
2186
2187	return ret;
2188	}
2189
2190	/**
2191	* regulator_set_voltage - set regulator output voltage
2192	* @regulator: regulator source
2193	* @min_uV: Minimum required voltage in uV
2194	* @max_uV: Maximum acceptable voltage in uV
2195	*
2196	* Sets a voltage regulator to the desired output voltage. This can be set
2197	* during any regulator state. IOW, regulator can be disabled or enabled.
2198	*
2199	* If the regulator is enabled then the voltage will change to the new value
2200	* immediately otherwise if the regulator is disabled the regulator will
2201	* output at the new voltage when enabled.
2202	*
2203	* NOTE: If the regulator is shared between several devices then the lowest
2204	* request voltage that meets the system constraints will be used.
2205	* Regulator system constraints must be set for this regulator before
2206	* calling this function otherwise this call will fail.
2207	*/
2208	int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV)
2209	{
2210	struct regulator_dev *rdev = regulator->rdev;
2211	int ret = 0;
2212
2213	mutex_lock(&rdev->mutex);
2214
2215	/* If we're setting the same range as last time the change
2216	* should be a noop (some cpufreq implementations use the same
2217	* voltage for multiple frequencies, for example).
2218	*/
2219	if (regulator->min_uV == min_uV && regulator->max_uV == max_uV)
2220	goto out;
2221
2222	/* sanity check */
2223	if (!rdev->desc->ops->set_voltage &&
2224	!rdev->desc->ops->set_voltage_sel) {
2225	ret = -EINVAL;
2226	goto out;
2227	}
2228
2229	/* constraints check */
2230	ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
2231	if (ret < 0)
2232	goto out;
2233	regulator->min_uV = min_uV;
2234	regulator->max_uV = max_uV;
2235
2236	ret = regulator_check_consumers(rdev, &min_uV, &max_uV);
2237	if (ret < 0)
2238	goto out;
2239
2240	ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
2241
2242	out:
2243	mutex_unlock(&rdev->mutex);
2244	return ret;
2245	}
2246	EXPORT_SYMBOL_GPL(regulator_set_voltage);
2247
2248	/**
2249	* regulator_set_voltage_time - get raise/fall time
2250	* @regulator: regulator source
2251	* @old_uV: starting voltage in microvolts
2252	* @new_uV: target voltage in microvolts
2253	*
2254	* Provided with the starting and ending voltage, this function attempts to
2255	* calculate the time in microseconds required to rise or fall to this new
2256	* voltage.
2257	*/
2258	int regulator_set_voltage_time(struct regulator *regulator,
2259	int old_uV, int new_uV)
2260	{
2261	struct regulator_dev *rdev = regulator->rdev;
2262	struct regulator_ops *ops = rdev->desc->ops;
2263	int old_sel = -1;
2264	int new_sel = -1;
2265	int voltage;
2266	int i;
2267
2268	/* Currently requires operations to do this */
2269	if (!ops->list_voltage \|\| !ops->set_voltage_time_sel
2270	\|\| !rdev->desc->n_voltages)
2271	return -EINVAL;
2272
2273	for (i = 0; i < rdev->desc->n_voltages; i++) {
2274	/* We only look for exact voltage matches here */
2275	voltage = regulator_list_voltage(regulator, i);
2276	if (voltage < 0)
2277	return -EINVAL;
2278	if (voltage == 0)
2279	continue;
2280	if (voltage == old_uV)
2281	old_sel = i;
2282	if (voltage == new_uV)
2283	new_sel = i;
2284	}
2285
2286	if (old_sel < 0 \|\| new_sel < 0)
2287	return -EINVAL;
2288
2289	return ops->set_voltage_time_sel(rdev, old_sel, new_sel);
2290	}
2291	EXPORT_SYMBOL_GPL(regulator_set_voltage_time);
2292
2293	/**
2294	*regulator_set_voltage_time_sel - get raise/fall time
2295	* @regulator: regulator source
2296	* @old_selector: selector for starting voltage
2297	* @new_selector: selector for target voltage
2298	*
2299	* Provided with the starting and target voltage selectors, this function
2300	* returns time in microseconds required to rise or fall to this new voltage
2301	*
2302	* Drivers providing ramp_delay in regulation_constraints can use this as their
2303	* set_voltage_time_sel() operation.
2304	*/
2305	int regulator_set_voltage_time_sel(struct regulator_dev *rdev,
2306	unsigned int old_selector,
2307	unsigned int new_selector)
2308	{
2309	unsigned int ramp_delay = 0;
2310	int old_volt, new_volt;
2311
2312	if (rdev->constraints->ramp_delay)
2313	ramp_delay = rdev->constraints->ramp_delay;
2314	else if (rdev->desc->ramp_delay)
2315	ramp_delay = rdev->desc->ramp_delay;
2316
2317	if (ramp_delay == 0) {
2318	rdev_warn(rdev, "ramp_delay not set\n");
2319	return 0;
2320	}
2321
2322	/* sanity check */
2323	if (!rdev->desc->ops->list_voltage)
2324	return -EINVAL;
2325
2326	old_volt = rdev->desc->ops->list_voltage(rdev, old_selector);
2327	new_volt = rdev->desc->ops->list_voltage(rdev, new_selector);
2328
2329	return DIV_ROUND_UP(abs(new_volt - old_volt), ramp_delay);
2330	}
2331	EXPORT_SYMBOL_GPL(regulator_set_voltage_time_sel);
2332
2333	/**
2334	* regulator_sync_voltage - re-apply last regulator output voltage
2335	* @regulator: regulator source
2336	*
2337	* Re-apply the last configured voltage. This is intended to be used
2338	* where some external control source the consumer is cooperating with
2339	* has caused the configured voltage to change.
2340	*/
2341	int regulator_sync_voltage(struct regulator *regulator)
2342	{
2343	struct regulator_dev *rdev = regulator->rdev;
2344	int ret, min_uV, max_uV;
2345
2346	mutex_lock(&rdev->mutex);
2347
2348	if (!rdev->desc->ops->set_voltage &&
2349	!rdev->desc->ops->set_voltage_sel) {
2350	ret = -EINVAL;
2351	goto out;
2352	}
2353
2354	/* This is only going to work if we've had a voltage configured. */
2355	if (!regulator->min_uV && !regulator->max_uV) {
2356	ret = -EINVAL;
2357	goto out;
2358	}
2359
2360	min_uV = regulator->min_uV;
2361	max_uV = regulator->max_uV;
2362
2363	/* This should be a paranoia check... */
2364	ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
2365	if (ret < 0)
2366	goto out;
2367
2368	ret = regulator_check_consumers(rdev, &min_uV, &max_uV);
2369	if (ret < 0)
2370	goto out;
2371
2372	ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
2373
2374	out:
2375	mutex_unlock(&rdev->mutex);
2376	return ret;
2377	}
2378	EXPORT_SYMBOL_GPL(regulator_sync_voltage);
2379
2380	static int _regulator_get_voltage(struct regulator_dev *rdev)
2381	{
2382	int sel, ret;
2383
2384	if (rdev->desc->ops->get_voltage_sel) {
2385	sel = rdev->desc->ops->get_voltage_sel(rdev);
2386	if (sel < 0)
2387	return sel;
2388	ret = rdev->desc->ops->list_voltage(rdev, sel);
2389	} else if (rdev->desc->ops->get_voltage) {
2390	ret = rdev->desc->ops->get_voltage(rdev);
2391	} else {
2392	return -EINVAL;
2393	}
2394
2395	if (ret < 0)
2396	return ret;
2397	return ret - rdev->constraints->uV_offset;
2398	}
2399
2400	/**
2401	* regulator_get_voltage - get regulator output voltage
2402	* @regulator: regulator source
2403	*
2404	* This returns the current regulator voltage in uV.
2405	*
2406	* NOTE: If the regulator is disabled it will return the voltage value. This
2407	* function should not be used to determine regulator state.
2408	*/
2409	int regulator_get_voltage(struct regulator *regulator)
2410	{
2411	int ret;
2412
2413	mutex_lock(&regulator->rdev->mutex);
2414
2415	ret = _regulator_get_voltage(regulator->rdev);
2416
2417	mutex_unlock(&regulator->rdev->mutex);
2418
2419	return ret;
2420	}
2421	EXPORT_SYMBOL_GPL(regulator_get_voltage);
2422
2423	/**
2424	* regulator_set_current_limit - set regulator output current limit
2425	* @regulator: regulator source
2426	* @min_uA: Minimuum supported current in uA
2427	* @max_uA: Maximum supported current in uA
2428	*
2429	* Sets current sink to the desired output current. This can be set during
2430	* any regulator state. IOW, regulator can be disabled or enabled.
2431	*
2432	* If the regulator is enabled then the current will change to the new value
2433	* immediately otherwise if the regulator is disabled the regulator will
2434	* output at the new current when enabled.
2435	*
2436	* NOTE: Regulator system constraints must be set for this regulator before
2437	* calling this function otherwise this call will fail.
2438	*/
2439	int regulator_set_current_limit(struct regulator *regulator,
2440	int min_uA, int max_uA)
2441	{
2442	struct regulator_dev *rdev = regulator->rdev;
2443	int ret;
2444
2445	mutex_lock(&rdev->mutex);
2446
2447	/* sanity check */
2448	if (!rdev->desc->ops->set_current_limit) {
2449	ret = -EINVAL;
2450	goto out;
2451	}
2452
2453	/* constraints check */
2454	ret = regulator_check_current_limit(rdev, &min_uA, &max_uA);
2455	if (ret < 0)
2456	goto out;
2457
2458	ret = rdev->desc->ops->set_current_limit(rdev, min_uA, max_uA);
2459	out:
2460	mutex_unlock(&rdev->mutex);
2461	return ret;
2462	}
2463	EXPORT_SYMBOL_GPL(regulator_set_current_limit);
2464
2465	static int _regulator_get_current_limit(struct regulator_dev *rdev)
2466	{
2467	int ret;
2468
2469	mutex_lock(&rdev->mutex);
2470
2471	/* sanity check */
2472	if (!rdev->desc->ops->get_current_limit) {
2473	ret = -EINVAL;
2474	goto out;
2475	}
2476
2477	ret = rdev->desc->ops->get_current_limit(rdev);
2478	out:
2479	mutex_unlock(&rdev->mutex);
2480	return ret;
2481	}
2482
2483	/**
2484	* regulator_get_current_limit - get regulator output current
2485	* @regulator: regulator source
2486	*
2487	* This returns the current supplied by the specified current sink in uA.
2488	*
2489	* NOTE: If the regulator is disabled it will return the current value. This
2490	* function should not be used to determine regulator state.
2491	*/
2492	int regulator_get_current_limit(struct regulator *regulator)
2493	{
2494	return _regulator_get_current_limit(regulator->rdev);
2495	}
2496	EXPORT_SYMBOL_GPL(regulator_get_current_limit);
2497
2498	/**
2499	* regulator_set_mode - set regulator operating mode
2500	* @regulator: regulator source
2501	* @mode: operating mode - one of the REGULATOR_MODE constants
2502	*
2503	* Set regulator operating mode to increase regulator efficiency or improve
2504	* regulation performance.
2505	*
2506	* NOTE: Regulator system constraints must be set for this regulator before
2507	* calling this function otherwise this call will fail.
2508	*/
2509	int regulator_set_mode(struct regulator *regulator, unsigned int mode)
2510	{
2511	struct regulator_dev *rdev = regulator->rdev;
2512	int ret;
2513	int regulator_curr_mode;
2514
2515	mutex_lock(&rdev->mutex);
2516
2517	/* sanity check */
2518	if (!rdev->desc->ops->set_mode) {
2519	ret = -EINVAL;
2520	goto out;
2521	}
2522
2523	/* return if the same mode is requested */
2524	if (rdev->desc->ops->get_mode) {
2525	regulator_curr_mode = rdev->desc->ops->get_mode(rdev);
2526	if (regulator_curr_mode == mode) {
2527	ret = 0;
2528	goto out;
2529	}
2530	}
2531
2532	/* constraints check */
2533	ret = regulator_mode_constrain(rdev, &mode);
2534	if (ret < 0)
2535	goto out;
2536
2537	ret = rdev->desc->ops->set_mode(rdev, mode);
2538	out:
2539	mutex_unlock(&rdev->mutex);
2540	return ret;
2541	}
2542	EXPORT_SYMBOL_GPL(regulator_set_mode);
2543
2544	static unsigned int _regulator_get_mode(struct regulator_dev *rdev)
2545	{
2546	int ret;
2547
2548	mutex_lock(&rdev->mutex);
2549
2550	/* sanity check */
2551	if (!rdev->desc->ops->get_mode) {
2552	ret = -EINVAL;
2553	goto out;
2554	}
2555
2556	ret = rdev->desc->ops->get_mode(rdev);
2557	out:
2558	mutex_unlock(&rdev->mutex);
2559	return ret;
2560	}
2561
2562	/**
2563	* regulator_get_mode - get regulator operating mode
2564	* @regulator: regulator source
2565	*
2566	* Get the current regulator operating mode.
2567	*/
2568	unsigned int regulator_get_mode(struct regulator *regulator)
2569	{
2570	return _regulator_get_mode(regulator->rdev);
2571	}
2572	EXPORT_SYMBOL_GPL(regulator_get_mode);
2573
2574	/**
2575	* regulator_set_optimum_mode - set regulator optimum operating mode
2576	* @regulator: regulator source
2577	* @uA_load: load current
2578	*
2579	* Notifies the regulator core of a new device load. This is then used by
2580	* DRMS (if enabled by constraints) to set the most efficient regulator
2581	* operating mode for the new regulator loading.
2582	*
2583	* Consumer devices notify their supply regulator of the maximum power
2584	* they will require (can be taken from device datasheet in the power
2585	* consumption tables) when they change operational status and hence power
2586	* state. Examples of operational state changes that can affect power
2587	* consumption are :-
2588	*
2589	* o Device is opened / closed.
2590	* o Device I/O is about to begin or has just finished.
2591	* o Device is idling in between work.
2592	*
2593	* This information is also exported via sysfs to userspace.
2594	*
2595	* DRMS will sum the total requested load on the regulator and change
2596	* to the most efficient operating mode if platform constraints allow.
2597	*
2598	* Returns the new regulator mode or error.
2599	*/
2600	int regulator_set_optimum_mode(struct regulator *regulator, int uA_load)
2601	{
2602	struct regulator_dev *rdev = regulator->rdev;
2603	struct regulator *consumer;
2604	int ret, output_uV, input_uV = 0, total_uA_load = 0;
2605	unsigned int mode;
2606
2607	if (rdev->supply)
2608	input_uV = regulator_get_voltage(rdev->supply);
2609
2610	mutex_lock(&rdev->mutex);
2611
2612	/*
2613	* first check to see if we can set modes at all, otherwise just
2614	* tell the consumer everything is OK.
2615	*/
2616	regulator->uA_load = uA_load;
2617	ret = regulator_check_drms(rdev);
2618	if (ret < 0) {
2619	ret = 0;
2620	goto out;
2621	}
2622
2623	if (!rdev->desc->ops->get_optimum_mode)
2624	goto out;
2625
2626	/*
2627	* we can actually do this so any errors are indicators of
2628	* potential real failure.
2629	*/
2630	ret = -EINVAL;
2631
2632	if (!rdev->desc->ops->set_mode)
2633	goto out;
2634
2635	/* get output voltage */
2636	output_uV = _regulator_get_voltage(rdev);
2637	if (output_uV <= 0) {
2638	rdev_err(rdev, "invalid output voltage found\n");
2639	goto out;
2640	}
2641
2642	/* No supply? Use constraint voltage */
2643	if (input_uV <= 0)
2644	input_uV = rdev->constraints->input_uV;
2645	if (input_uV <= 0) {
2646	rdev_err(rdev, "invalid input voltage found\n");
2647	goto out;
2648	}
2649
2650	/* calc total requested load for this regulator */
2651	list_for_each_entry(consumer, &rdev->consumer_list, list)
2652	total_uA_load += consumer->uA_load;
2653
2654	mode = rdev->desc->ops->get_optimum_mode(rdev,
2655	input_uV, output_uV,
2656	total_uA_load);
2657	ret = regulator_mode_constrain(rdev, &mode);
2658	if (ret < 0) {
2659	rdev_err(rdev, "failed to get optimum mode @ %d uA %d -> %d uV\n",
2660	total_uA_load, input_uV, output_uV);
2661	goto out;
2662	}
2663
2664	ret = rdev->desc->ops->set_mode(rdev, mode);
2665	if (ret < 0) {
2666	rdev_err(rdev, "failed to set optimum mode %x\n", mode);
2667	goto out;
2668	}
2669	ret = mode;
2670	out:
2671	mutex_unlock(&rdev->mutex);
2672	return ret;
2673	}
2674	EXPORT_SYMBOL_GPL(regulator_set_optimum_mode);
2675
2676	/**
2677	* regulator_register_notifier - register regulator event notifier
2678	* @regulator: regulator source
2679	* @nb: notifier block
2680	*
2681	* Register notifier block to receive regulator events.
2682	*/
2683	int regulator_register_notifier(struct regulator *regulator,
2684	struct notifier_block *nb)
2685	{
2686	return blocking_notifier_chain_register(&regulator->rdev->notifier,
2687	nb);
2688	}
2689	EXPORT_SYMBOL_GPL(regulator_register_notifier);
2690
2691	/**
2692	* regulator_unregister_notifier - unregister regulator event notifier
2693	* @regulator: regulator source
2694	* @nb: notifier block
2695	*
2696	* Unregister regulator event notifier block.
2697	*/
2698	int regulator_unregister_notifier(struct regulator *regulator,
2699	struct notifier_block *nb)
2700	{
2701	return blocking_notifier_chain_unregister(&regulator->rdev->notifier,
2702	nb);
2703	}
2704	EXPORT_SYMBOL_GPL(regulator_unregister_notifier);
2705
2706	/* notify regulator consumers and downstream regulator consumers.
2707	* Note mutex must be held by caller.
2708	*/
2709	static void _notifier_call_chain(struct regulator_dev *rdev,
2710	unsigned long event, void *data)
2711	{
2712	/* call rdev chain first */
2713	blocking_notifier_call_chain(&rdev->notifier, event, data);
2714	}
2715
2716	/**
2717	* regulator_bulk_get - get multiple regulator consumers
2718	*
2719	* @dev: Device to supply
2720	* @num_consumers: Number of consumers to register
2721	* @consumers: Configuration of consumers; clients are stored here.
2722	*
2723	* @return 0 on success, an errno on failure.
2724	*
2725	* This helper function allows drivers to get several regulator
2726	* consumers in one operation. If any of the regulators cannot be
2727	* acquired then any regulators that were allocated will be freed
2728	* before returning to the caller.
2729	*/
2730	int regulator_bulk_get(struct device *dev, int num_consumers,
2731	struct regulator_bulk_data *consumers)
2732	{
2733	int i;
2734	int ret;
2735
2736	for (i = 0; i < num_consumers; i++)
2737	consumers[i].consumer = NULL;
2738
2739	for (i = 0; i < num_consumers; i++) {
2740	consumers[i].consumer = regulator_get(dev,
2741	consumers[i].supply);
2742	if (IS_ERR(consumers[i].consumer)) {
2743	ret = PTR_ERR(consumers[i].consumer);
2744	dev_err(dev, "Failed to get supply '%s': %d\n",
2745	consumers[i].supply, ret);
2746	consumers[i].consumer = NULL;
2747	goto err;
2748	}
2749	}
2750
2751	return 0;
2752
2753	err:
2754	while (--i >= 0)
2755	regulator_put(consumers[i].consumer);
2756
2757	return ret;
2758	}
2759	EXPORT_SYMBOL_GPL(regulator_bulk_get);
2760
2761	/**
2762	* devm_regulator_bulk_get - managed get multiple regulator consumers
2763	*
2764	* @dev: Device to supply
2765	* @num_consumers: Number of consumers to register
2766	* @consumers: Configuration of consumers; clients are stored here.
2767	*
2768	* @return 0 on success, an errno on failure.
2769	*
2770	* This helper function allows drivers to get several regulator
2771	* consumers in one operation with management, the regulators will
2772	* automatically be freed when the device is unbound. If any of the
2773	* regulators cannot be acquired then any regulators that were
2774	* allocated will be freed before returning to the caller.
2775	*/
2776	int devm_regulator_bulk_get(struct device *dev, int num_consumers,
2777	struct regulator_bulk_data *consumers)
2778	{
2779	int i;
2780	int ret;
2781
2782	for (i = 0; i < num_consumers; i++)
2783	consumers[i].consumer = NULL;
2784
2785	for (i = 0; i < num_consumers; i++) {
2786	consumers[i].consumer = devm_regulator_get(dev,
2787	consumers[i].supply);
2788	if (IS_ERR(consumers[i].consumer)) {
2789	ret = PTR_ERR(consumers[i].consumer);
2790	dev_err(dev, "Failed to get supply '%s': %d\n",
2791	consumers[i].supply, ret);
2792	consumers[i].consumer = NULL;
2793	goto err;
2794	}
2795	}
2796
2797	return 0;
2798
2799	err:
2800	for (i = 0; i < num_consumers && consumers[i].consumer; i++)
2801	devm_regulator_put(consumers[i].consumer);
2802
2803	return ret;
2804	}
2805	EXPORT_SYMBOL_GPL(devm_regulator_bulk_get);
2806
2807	static void regulator_bulk_enable_async(void *data, async_cookie_t cookie)
2808	{
2809	struct regulator_bulk_data *bulk = data;
2810
2811	bulk->ret = regulator_enable(bulk->consumer);
2812	}
2813
2814	/**
2815	* regulator_bulk_enable - enable multiple regulator consumers
2816	*
2817	* @num_consumers: Number of consumers
2818	* @consumers: Consumer data; clients are stored here.
2819	* @return 0 on success, an errno on failure
2820	*
2821	* This convenience API allows consumers to enable multiple regulator
2822	* clients in a single API call. If any consumers cannot be enabled
2823	* then any others that were enabled will be disabled again prior to
2824	* return.
2825	*/
2826	int regulator_bulk_enable(int num_consumers,
2827	struct regulator_bulk_data *consumers)
2828	{
2829	ASYNC_DOMAIN_EXCLUSIVE(async_domain);
2830	int i;
2831	int ret = 0;
2832
2833	for (i = 0; i < num_consumers; i++) {
2834	if (consumers[i].consumer->always_on)
2835	consumers[i].ret = 0;
2836	else
2837	async_schedule_domain(regulator_bulk_enable_async,
2838	&consumers[i], &async_domain);
2839	}
2840
2841	async_synchronize_full_domain(&async_domain);
2842
2843	/* If any consumer failed we need to unwind any that succeeded */
2844	for (i = 0; i < num_consumers; i++) {
2845	if (consumers[i].ret != 0) {
2846	ret = consumers[i].ret;
2847	goto err;
2848	}
2849	}
2850
2851	return 0;
2852
2853	err:
2854	pr_err("Failed to enable %s: %d\n", consumers[i].supply, ret);
2855	while (--i >= 0)
2856	regulator_disable(consumers[i].consumer);
2857
2858	return ret;
2859	}
2860	EXPORT_SYMBOL_GPL(regulator_bulk_enable);
2861
2862	/**
2863	* regulator_bulk_disable - disable multiple regulator consumers
2864	*
2865	* @num_consumers: Number of consumers
2866	* @consumers: Consumer data; clients are stored here.
2867	* @return 0 on success, an errno on failure
2868	*
2869	* This convenience API allows consumers to disable multiple regulator
2870	* clients in a single API call. If any consumers cannot be disabled
2871	* then any others that were disabled will be enabled again prior to
2872	* return.
2873	*/
2874	int regulator_bulk_disable(int num_consumers,
2875	struct regulator_bulk_data *consumers)
2876	{
2877	int i;
2878	int ret, r;
2879
2880	for (i = num_consumers - 1; i >= 0; --i) {
2881	ret = regulator_disable(consumers[i].consumer);
2882	if (ret != 0)
2883	goto err;
2884	}
2885
2886	return 0;
2887
2888	err:
2889	pr_err("Failed to disable %s: %d\n", consumers[i].supply, ret);
2890	for (++i; i < num_consumers; ++i) {
2891	r = regulator_enable(consumers[i].consumer);
2892	if (r != 0)
2893	pr_err("Failed to reename %s: %d\n",
2894	consumers[i].supply, r);
2895	}
2896
2897	return ret;
2898	}
2899	EXPORT_SYMBOL_GPL(regulator_bulk_disable);
2900
2901	/**
2902	* regulator_bulk_force_disable - force disable multiple regulator consumers
2903	*
2904	* @num_consumers: Number of consumers
2905	* @consumers: Consumer data; clients are stored here.
2906	* @return 0 on success, an errno on failure
2907	*
2908	* This convenience API allows consumers to forcibly disable multiple regulator
2909	* clients in a single API call.
2910	* NOTE: This should be used for situations when device damage will
2911	* likely occur if the regulators are not disabled (e.g. over temp).
2912	* Although regulator_force_disable function call for some consumers can
2913	* return error numbers, the function is called for all consumers.
2914	*/
2915	int regulator_bulk_force_disable(int num_consumers,
2916	struct regulator_bulk_data *consumers)
2917	{
2918	int i;
2919	int ret;
2920
2921	for (i = 0; i < num_consumers; i++)
2922	consumers[i].ret =
2923	regulator_force_disable(consumers[i].consumer);
2924
2925	for (i = 0; i < num_consumers; i++) {
2926	if (consumers[i].ret != 0) {
2927	ret = consumers[i].ret;
2928	goto out;
2929	}
2930	}
2931
2932	return 0;
2933	out:
2934	return ret;
2935	}
2936	EXPORT_SYMBOL_GPL(regulator_bulk_force_disable);
2937
2938	/**
2939	* regulator_bulk_free - free multiple regulator consumers
2940	*
2941	* @num_consumers: Number of consumers
2942	* @consumers: Consumer data; clients are stored here.
2943	*
2944	* This convenience API allows consumers to free multiple regulator
2945	* clients in a single API call.
2946	*/
2947	void regulator_bulk_free(int num_consumers,
2948	struct regulator_bulk_data *consumers)
2949	{
2950	int i;
2951
2952	for (i = 0; i < num_consumers; i++) {
2953	regulator_put(consumers[i].consumer);
2954	consumers[i].consumer = NULL;
2955	}
2956	}
2957	EXPORT_SYMBOL_GPL(regulator_bulk_free);
2958
2959	/**
2960	* regulator_notifier_call_chain - call regulator event notifier
2961	* @rdev: regulator source
2962	* @event: notifier block
2963	* @data: callback-specific data.
2964	*
2965	* Called by regulator drivers to notify clients a regulator event has
2966	* occurred. We also notify regulator clients downstream.
2967	* Note lock must be held by caller.
2968	*/
2969	int regulator_notifier_call_chain(struct regulator_dev *rdev,
2970	unsigned long event, void *data)
2971	{
2972	_notifier_call_chain(rdev, event, data);
2973	return NOTIFY_DONE;
2974
2975	}
2976	EXPORT_SYMBOL_GPL(regulator_notifier_call_chain);
2977
2978	/**
2979	* regulator_mode_to_status - convert a regulator mode into a status
2980	*
2981	* @mode: Mode to convert
2982	*
2983	* Convert a regulator mode into a status.
2984	*/
2985	int regulator_mode_to_status(unsigned int mode)
2986	{
2987	switch (mode) {
2988	case REGULATOR_MODE_FAST:
2989	return REGULATOR_STATUS_FAST;
2990	case REGULATOR_MODE_NORMAL:
2991	return REGULATOR_STATUS_NORMAL;
2992	case REGULATOR_MODE_IDLE:
2993	return REGULATOR_STATUS_IDLE;
2994	case REGULATOR_MODE_STANDBY:
2995	return REGULATOR_STATUS_STANDBY;
2996	default:
2997	return REGULATOR_STATUS_UNDEFINED;
2998	}
2999	}
3000	EXPORT_SYMBOL_GPL(regulator_mode_to_status);
3001
3002	/*
3003	* To avoid cluttering sysfs (and memory) with useless state, only
3004	* create attributes that can be meaningfully displayed.
3005	*/
3006	static int add_regulator_attributes(struct regulator_dev *rdev)
3007	{
3008	struct device *dev = &rdev->dev;
3009	struct regulator_ops *ops = rdev->desc->ops;
3010	int status = 0;
3011
3012	/* some attributes need specific methods to be displayed */
3013	if ((ops->get_voltage && ops->get_voltage(rdev) >= 0) \|\|
3014	(ops->get_voltage_sel && ops->get_voltage_sel(rdev) >= 0)) {
3015	status = device_create_file(dev, &dev_attr_microvolts);
3016	if (status < 0)
3017	return status;
3018	}
3019	if (ops->get_current_limit) {
3020	status = device_create_file(dev, &dev_attr_microamps);
3021	if (status < 0)
3022	return status;
3023	}
3024	if (ops->get_mode) {
3025	status = device_create_file(dev, &dev_attr_opmode);
3026	if (status < 0)
3027	return status;
3028	}
3029	if (ops->is_enabled) {
3030	status = device_create_file(dev, &dev_attr_state);
3031	if (status < 0)
3032	return status;
3033	}
3034	if (ops->get_status) {
3035	status = device_create_file(dev, &dev_attr_status);
3036	if (status < 0)
3037	return status;
3038	}
3039
3040	/* some attributes are type-specific */
3041	if (rdev->desc->type == REGULATOR_CURRENT) {
3042	status = device_create_file(dev, &dev_attr_requested_microamps);
3043	if (status < 0)
3044	return status;
3045	}
3046
3047	/* all the other attributes exist to support constraints;
3048	* don't show them if there are no constraints, or if the
3049	* relevant supporting methods are missing.
3050	*/
3051	if (!rdev->constraints)
3052	return status;
3053
3054	/* constraints need specific supporting methods */
3055	if (ops->set_voltage \|\| ops->set_voltage_sel) {
3056	status = device_create_file(dev, &dev_attr_min_microvolts);
3057	if (status < 0)
3058	return status;
3059	status = device_create_file(dev, &dev_attr_max_microvolts);
3060	if (status < 0)
3061	return status;
3062	}
3063	if (ops->set_current_limit) {
3064	status = device_create_file(dev, &dev_attr_min_microamps);
3065	if (status < 0)
3066	return status;
3067	status = device_create_file(dev, &dev_attr_max_microamps);
3068	if (status < 0)
3069	return status;
3070	}
3071
3072	status = device_create_file(dev, &dev_attr_suspend_standby_state);
3073	if (status < 0)
3074	return status;
3075	status = device_create_file(dev, &dev_attr_suspend_mem_state);
3076	if (status < 0)
3077	return status;
3078	status = device_create_file(dev, &dev_attr_suspend_disk_state);
3079	if (status < 0)
3080	return status;
3081
3082	if (ops->set_suspend_voltage) {
3083	status = device_create_file(dev,
3084	&dev_attr_suspend_standby_microvolts);
3085	if (status < 0)
3086	return status;
3087	status = device_create_file(dev,
3088	&dev_attr_suspend_mem_microvolts);
3089	if (status < 0)
3090	return status;
3091	status = device_create_file(dev,
3092	&dev_attr_suspend_disk_microvolts);
3093	if (status < 0)
3094	return status;
3095	}
3096
3097	if (ops->set_suspend_mode) {
3098	status = device_create_file(dev,
3099	&dev_attr_suspend_standby_mode);
3100	if (status < 0)
3101	return status;
3102	status = device_create_file(dev,
3103	&dev_attr_suspend_mem_mode);
3104	if (status < 0)
3105	return status;
3106	status = device_create_file(dev,
3107	&dev_attr_suspend_disk_mode);
3108	if (status < 0)
3109	return status;
3110	}
3111
3112	return status;
3113	}
3114
3115	static void rdev_init_debugfs(struct regulator_dev *rdev)
3116	{
3117	rdev->debugfs = debugfs_create_dir(rdev_get_name(rdev), debugfs_root);
3118	if (!rdev->debugfs) {
3119	rdev_warn(rdev, "Failed to create debugfs directory\n");
3120	return;
3121	}
3122
3123	debugfs_create_u32("use_count", 0444, rdev->debugfs,
3124	&rdev->use_count);
3125	debugfs_create_u32("open_count", 0444, rdev->debugfs,
3126	&rdev->open_count);
3127	}
3128
3129	/**
3130	* regulator_register - register regulator
3131	* @regulator_desc: regulator to register
3132	* @config: runtime configuration for regulator
3133	*
3134	* Called by regulator drivers to register a regulator.
3135	* Returns 0 on success.
3136	*/
3137	struct regulator_dev *
3138	regulator_register(const struct regulator_desc *regulator_desc,
3139	const struct regulator_config *config)
3140	{
3141	const struct regulation_constraints *constraints = NULL;
3142	const struct regulator_init_data *init_data;
3143	static atomic_t regulator_no = ATOMIC_INIT(0);
3144	struct regulator_dev *rdev;
3145	struct device *dev;
3146	int ret, i;
3147	const char *supply = NULL;
3148
3149	if (regulator_desc == NULL \|\| config == NULL)
3150	return ERR_PTR(-EINVAL);
3151
3152	dev = config->dev;
3153	WARN_ON(!dev);
3154
3155	if (regulator_desc->name == NULL \|\| regulator_desc->ops == NULL)
3156	return ERR_PTR(-EINVAL);
3157
3158	if (regulator_desc->type != REGULATOR_VOLTAGE &&
3159	regulator_desc->type != REGULATOR_CURRENT)
3160	return ERR_PTR(-EINVAL);
3161
3162	/* Only one of each should be implemented */
3163	WARN_ON(regulator_desc->ops->get_voltage &&
3164	regulator_desc->ops->get_voltage_sel);
3165	WARN_ON(regulator_desc->ops->set_voltage &&
3166	regulator_desc->ops->set_voltage_sel);
3167
3168	/* If we're using selectors we must implement list_voltage. */
3169	if (regulator_desc->ops->get_voltage_sel &&
3170	!regulator_desc->ops->list_voltage) {
3171	return ERR_PTR(-EINVAL);
3172	}
3173	if (regulator_desc->ops->set_voltage_sel &&
3174	!regulator_desc->ops->list_voltage) {
3175	return ERR_PTR(-EINVAL);
3176	}
3177
3178	init_data = config->init_data;
3179
3180	rdev = kzalloc(sizeof(struct regulator_dev), GFP_KERNEL);
3181	if (rdev == NULL)
3182	return ERR_PTR(-ENOMEM);
3183
3184	mutex_lock(&regulator_list_mutex);
3185
3186	mutex_init(&rdev->mutex);
3187	rdev->reg_data = config->driver_data;
3188	rdev->owner = regulator_desc->owner;
3189	rdev->desc = regulator_desc;
3190	if (config->regmap)
3191	rdev->regmap = config->regmap;
3192	else
3193	rdev->regmap = dev_get_regmap(dev, NULL);
3194	INIT_LIST_HEAD(&rdev->consumer_list);
3195	INIT_LIST_HEAD(&rdev->list);
3196	BLOCKING_INIT_NOTIFIER_HEAD(&rdev->notifier);
3197	INIT_DELAYED_WORK(&rdev->disable_work, regulator_disable_work);
3198
3199	/* preform any regulator specific init */
3200	if (init_data && init_data->regulator_init) {
3201	ret = init_data->regulator_init(rdev->reg_data);
3202	if (ret < 0)
3203	goto clean;
3204	}
3205
3206	/* register with sysfs */
3207	rdev->dev.class = &regulator_class;
3208	rdev->dev.of_node = config->of_node;
3209	rdev->dev.parent = dev;
3210	dev_set_name(&rdev->dev, "regulator.%d",
3211	atomic_inc_return(&regulator_no) - 1);
3212	ret = device_register(&rdev->dev);
3213	if (ret != 0) {
3214	put_device(&rdev->dev);
3215	goto clean;
3216	}
3217
3218	dev_set_drvdata(&rdev->dev, rdev);
3219
3220	if (config->ena_gpio && gpio_is_valid(config->ena_gpio)) {
3221	ret = gpio_request_one(config->ena_gpio,
3222	GPIOF_DIR_OUT \| config->ena_gpio_flags,
3223	rdev_get_name(rdev));
3224	if (ret != 0) {
3225	rdev_err(rdev, "Failed to request enable GPIO%d: %d\n",
3226	config->ena_gpio, ret);
3227	goto clean;
3228	}
3229
3230	rdev->ena_gpio = config->ena_gpio;
3231	rdev->ena_gpio_invert = config->ena_gpio_invert;
3232
3233	if (config->ena_gpio_flags & GPIOF_OUT_INIT_HIGH)
3234	rdev->ena_gpio_state = 1;
3235
3236	if (rdev->ena_gpio_invert)
3237	rdev->ena_gpio_state = !rdev->ena_gpio_state;
3238	}
3239
3240	/* set regulator constraints */
3241	if (init_data)
3242	constraints = &init_data->constraints;
3243
3244	ret = set_machine_constraints(rdev, constraints);
3245	if (ret < 0)
3246	goto scrub;
3247
3248	/* add attributes supported by this regulator */
3249	ret = add_regulator_attributes(rdev);
3250	if (ret < 0)
3251	goto scrub;
3252
3253	if (init_data && init_data->supply_regulator)
3254	supply = init_data->supply_regulator;
3255	else if (regulator_desc->supply_name)
3256	supply = regulator_desc->supply_name;
3257
3258	if (supply) {
3259	struct regulator_dev *r;
3260
3261	r = regulator_dev_lookup(dev, supply, &ret);
3262
3263	if (!r) {
3264	dev_err(dev, "Failed to find supply %s\n", supply);
3265	ret = -EPROBE_DEFER;
3266	goto scrub;
3267	}
3268
3269	ret = set_supply(rdev, r);
3270	if (ret < 0)
3271	goto scrub;
3272
3273	/* Enable supply if rail is enabled */
3274	if (_regulator_is_enabled(rdev)) {
3275	ret = regulator_enable(rdev->supply);
3276	if (ret < 0)
3277	goto scrub;
3278	}
3279	}
3280
3281	/* add consumers devices */
3282	if (init_data) {
3283	for (i = 0; i < init_data->num_consumer_supplies; i++) {
3284	ret = set_consumer_device_supply(rdev,
3285	init_data->consumer_supplies[i].dev_name,
3286	init_data->consumer_supplies[i].supply);
3287	if (ret < 0) {
3288	dev_err(dev, "Failed to set supply %s\n",
3289	init_data->consumer_supplies[i].supply);
3290	goto unset_supplies;
3291	}
3292	}
3293	}
3294
3295	list_add(&rdev->list, &regulator_list);
3296
3297	rdev_init_debugfs(rdev);
3298	out:
3299	mutex_unlock(&regulator_list_mutex);
3300	return rdev;
3301
3302	unset_supplies:
3303	unset_regulator_supplies(rdev);
3304
3305	scrub:
3306	if (rdev->supply)
3307	regulator_put(rdev->supply);
3308	if (rdev->ena_gpio)
3309	gpio_free(rdev->ena_gpio);
3310	kfree(rdev->constraints);
3311	device_unregister(&rdev->dev);
3312	/* device core frees rdev */
3313	rdev = ERR_PTR(ret);
3314	goto out;
3315
3316	clean:
3317	kfree(rdev);
3318	rdev = ERR_PTR(ret);
3319	goto out;
3320	}
3321	EXPORT_SYMBOL_GPL(regulator_register);
3322
3323	/**
3324	* regulator_unregister - unregister regulator
3325	* @rdev: regulator to unregister
3326	*
3327	* Called by regulator drivers to unregister a regulator.
3328	*/
3329	void regulator_unregister(struct regulator_dev *rdev)
3330	{
3331	if (rdev == NULL)
3332	return;
3333
3334	if (rdev->supply)
3335	regulator_put(rdev->supply);
3336	mutex_lock(&regulator_list_mutex);
3337	debugfs_remove_recursive(rdev->debugfs);
3338	flush_work_sync(&rdev->disable_work.work);
3339	WARN_ON(rdev->open_count);
3340	unset_regulator_supplies(rdev);
3341	list_del(&rdev->list);
3342	kfree(rdev->constraints);
3343	if (rdev->ena_gpio)
3344	gpio_free(rdev->ena_gpio);
3345	device_unregister(&rdev->dev);
3346	mutex_unlock(&regulator_list_mutex);
3347	}
3348	EXPORT_SYMBOL_GPL(regulator_unregister);
3349
3350	/**
3351	* regulator_suspend_prepare - prepare regulators for system wide suspend
3352	* @state: system suspend state
3353	*
3354	* Configure each regulator with it's suspend operating parameters for state.
3355	* This will usually be called by machine suspend code prior to supending.
3356	*/
3357	int regulator_suspend_prepare(suspend_state_t state)
3358	{
3359	struct regulator_dev *rdev;
3360	int ret = 0;
3361
3362	/* ON is handled by regulator active state */
3363	if (state == PM_SUSPEND_ON)
3364	return -EINVAL;
3365
3366	mutex_lock(&regulator_list_mutex);
3367	list_for_each_entry(rdev, &regulator_list, list) {
3368
3369	mutex_lock(&rdev->mutex);
3370	ret = suspend_prepare(rdev, state);
3371	mutex_unlock(&rdev->mutex);
3372
3373	if (ret < 0) {
3374	rdev_err(rdev, "failed to prepare\n");
3375	goto out;
3376	}
3377	}
3378	out:
3379	mutex_unlock(&regulator_list_mutex);
3380	return ret;
3381	}
3382	EXPORT_SYMBOL_GPL(regulator_suspend_prepare);
3383
3384	/**
3385	* regulator_suspend_finish - resume regulators from system wide suspend
3386	*
3387	* Turn on regulators that might be turned off by regulator_suspend_prepare
3388	* and that should be turned on according to the regulators properties.
3389	*/
3390	int regulator_suspend_finish(void)
3391	{
3392	struct regulator_dev *rdev;
3393	int ret = 0, error;
3394
3395	mutex_lock(&regulator_list_mutex);
3396	list_for_each_entry(rdev, &regulator_list, list) {
3397	struct regulator_ops *ops = rdev->desc->ops;
3398
3399	mutex_lock(&rdev->mutex);
3400	if ((rdev->use_count > 0 \|\| rdev->constraints->always_on) &&
3401	ops->enable) {
3402	error = ops->enable(rdev);
3403	if (error)
3404	ret = error;
3405	} else {
3406	if (!has_full_constraints)
3407	goto unlock;
3408	if (!ops->disable)
3409	goto unlock;
3410	if (!_regulator_is_enabled(rdev))
3411	goto unlock;
3412
3413	error = ops->disable(rdev);
3414	if (error)
3415	ret = error;
3416	}
3417	unlock:
3418	mutex_unlock(&rdev->mutex);
3419	}
3420	mutex_unlock(&regulator_list_mutex);
3421	return ret;
3422	}
3423	EXPORT_SYMBOL_GPL(regulator_suspend_finish);
3424
3425	/**
3426	* regulator_has_full_constraints - the system has fully specified constraints
3427	*
3428	* Calling this function will cause the regulator API to disable all
3429	* regulators which have a zero use count and don't have an always_on
3430	* constraint in a late_initcall.
3431	*
3432	* The intention is that this will become the default behaviour in a
3433	* future kernel release so users are encouraged to use this facility
3434	* now.
3435	*/
3436	void regulator_has_full_constraints(void)
3437	{
3438	has_full_constraints = 1;
3439	}
3440	EXPORT_SYMBOL_GPL(regulator_has_full_constraints);
3441
3442	/**
3443	* regulator_use_dummy_regulator - Provide a dummy regulator when none is found
3444	*
3445	* Calling this function will cause the regulator API to provide a
3446	* dummy regulator to consumers if no physical regulator is found,
3447	* allowing most consumers to proceed as though a regulator were
3448	* configured. This allows systems such as those with software
3449	* controllable regulators for the CPU core only to be brought up more
3450	* readily.
3451	*/
3452	void regulator_use_dummy_regulator(void)
3453	{
3454	board_wants_dummy_regulator = true;
3455	}
3456	EXPORT_SYMBOL_GPL(regulator_use_dummy_regulator);
3457
3458	/**
3459	* rdev_get_drvdata - get rdev regulator driver data
3460	* @rdev: regulator
3461	*
3462	* Get rdev regulator driver private data. This call can be used in the
3463	* regulator driver context.
3464	*/
3465	void rdev_get_drvdata(struct regulator_dev rdev)
3466	{
3467	return rdev->reg_data;
3468	}
3469	EXPORT_SYMBOL_GPL(rdev_get_drvdata);
3470
3471	/**
3472	* regulator_get_drvdata - get regulator driver data
3473	* @regulator: regulator
3474	*
3475	* Get regulator driver private data. This call can be used in the consumer
3476	* driver context when non API regulator specific functions need to be called.
3477	*/
3478	void regulator_get_drvdata(struct regulator regulator)
3479	{
3480	return regulator->rdev->reg_data;
3481	}
3482	EXPORT_SYMBOL_GPL(regulator_get_drvdata);
3483
3484	/**
3485	* regulator_set_drvdata - set regulator driver data
3486	* @regulator: regulator
3487	* @data: data
3488	*/
3489	void regulator_set_drvdata(struct regulator regulator, void data)
3490	{
3491	regulator->rdev->reg_data = data;
3492	}
3493	EXPORT_SYMBOL_GPL(regulator_set_drvdata);
3494
3495	/**
3496	* regulator_get_id - get regulator ID
3497	* @rdev: regulator
3498	*/
3499	int rdev_get_id(struct regulator_dev *rdev)
3500	{
3501	return rdev->desc->id;
3502	}
3503	EXPORT_SYMBOL_GPL(rdev_get_id);
3504
3505	struct device rdev_get_dev(struct regulator_dev rdev)
3506	{
3507	return &rdev->dev;
3508	}
3509	EXPORT_SYMBOL_GPL(rdev_get_dev);
3510
3511	void regulator_get_init_drvdata(struct regulator_init_data reg_init_data)
3512	{
3513	return reg_init_data->driver_data;
3514	}
3515	EXPORT_SYMBOL_GPL(regulator_get_init_drvdata);
3516
3517	#ifdef CONFIG_DEBUG_FS
3518	static ssize_t supply_map_read_file(struct file file, char __user user_buf,
3519	size_t count, loff_t *ppos)
3520	{
3521	char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
3522	ssize_t len, ret = 0;
3523	struct regulator_map *map;
3524
3525	if (!buf)
3526	return -ENOMEM;
3527
3528	list_for_each_entry(map, &regulator_map_list, list) {
3529	len = snprintf(buf + ret, PAGE_SIZE - ret,
3530	"%s -> %s.%s\n",
3531	rdev_get_name(map->regulator), map->dev_name,
3532	map->supply);
3533	if (len >= 0)
3534	ret += len;
3535	if (ret > PAGE_SIZE) {
3536	ret = PAGE_SIZE;
3537	break;
3538	}
3539	}
3540
3541	ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
3542
3543	kfree(buf);
3544
3545	return ret;
3546	}
3547	#endif
3548
3549	static const struct file_operations supply_map_fops = {
3550	#ifdef CONFIG_DEBUG_FS
3551	.read = supply_map_read_file,
3552	.llseek = default_llseek,
3553	#endif
3554	};
3555
3556	static int __init regulator_init(void)
3557	{
3558	int ret;
3559
3560	ret = class_register(&regulator_class);
3561
3562	debugfs_root = debugfs_create_dir("regulator", NULL);
3563	if (!debugfs_root)
3564	pr_warn("regulator: Failed to create debugfs directory\n");
3565
3566	debugfs_create_file("supply_map", 0444, debugfs_root, NULL,
3567	&supply_map_fops);
3568
3569	regulator_dummy_init();
3570
3571	return ret;
3572	}
3573
3574	/* init early to allow our consumers to complete system booting */
3575	core_initcall(regulator_init);
3576
3577	static int __init regulator_init_complete(void)
3578	{
3579	struct regulator_dev *rdev;
3580	struct regulator_ops *ops;
3581	struct regulation_constraints *c;
3582	int enabled, ret;
3583
3584	/*
3585	* Since DT doesn't provide an idiomatic mechanism for
3586	* enabling full constraints and since it's much more natural
3587	* with DT to provide them just assume that a DT enabled
3588	* system has full constraints.
3589	*/
3590	if (of_have_populated_dt())
3591	has_full_constraints = true;
3592
3593	mutex_lock(&regulator_list_mutex);
3594
3595	/* If we have a full configuration then disable any regulators
3596	* which are not in use or always_on. This will become the
3597	* default behaviour in the future.
3598	*/
3599	list_for_each_entry(rdev, &regulator_list, list) {
3600	ops = rdev->desc->ops;
3601	c = rdev->constraints;
3602
3603	if (!ops->disable \|\| (c && c->always_on))
3604	continue;
3605
3606	mutex_lock(&rdev->mutex);
3607
3608	if (rdev->use_count)
3609	goto unlock;
3610
3611	/* If we can't read the status assume it's on. */
3612	if (ops->is_enabled)
3613	enabled = ops->is_enabled(rdev);
3614	else
3615	enabled = 1;
3616
3617	if (!enabled)
3618	goto unlock;
3619
3620	if (has_full_constraints) {
3621	/* We log since this may kill the system if it
3622	* goes wrong. */
3623	rdev_info(rdev, "disabling\n");
3624	ret = ops->disable(rdev);
3625	if (ret != 0) {
3626	rdev_err(rdev, "couldn't disable: %d\n", ret);
3627	}
3628	} else {
3629	/* The intention is that in future we will
3630	* assume that full constraints are provided
3631	* so warn even if we aren't going to do
3632	* anything here.
3633	*/
3634	rdev_warn(rdev, "incomplete constraints, leaving on\n");
3635	}
3636
3637	unlock:
3638	mutex_unlock(&rdev->mutex);
3639	}
3640
3641	mutex_unlock(&regulator_list_mutex);
3642
3643	return 0;
3644	}
3645	late_initcall(regulator_init_complete);
3646

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/drivers/regulator/core.c

interactive