1	// SPDX-License-Identifier: GPL-2.0-or-later
2	//
3	// core.c -- Voltage/Current Regulator framework.
4	//
5	// Copyright 2007, 2008 Wolfson Microelectronics PLC.
6	// Copyright 2008 SlimLogic Ltd.
7	//
8	// Author: Liam Girdwood <lrg@slimlogic.co.uk>
9
10	#include <linux/kernel.h>
11	#include <linux/init.h>
12	#include <linux/debugfs.h>
13	#include <linux/device.h>
14	#include <linux/slab.h>
15	#include <linux/async.h>
16	#include <linux/err.h>
17	#include <linux/mutex.h>
18	#include <linux/suspend.h>
19	#include <linux/delay.h>
20	#include <linux/gpio/consumer.h>
21	#include <linux/of.h>
22	#include <linux/reboot.h>
23	#include <linux/regmap.h>
24	#include <linux/regulator/of_regulator.h>
25	#include <linux/regulator/consumer.h>
26	#include <linux/regulator/coupler.h>
27	#include <linux/regulator/driver.h>
28	#include <linux/regulator/machine.h>
29	#include <linux/module.h>
30
31	#define CREATE_TRACE_POINTS
32	#include <trace/events/regulator.h>
33
34	#include "dummy.h"
35	#include "internal.h"
36	#include "regnl.h"
37
38	static DEFINE_WW_CLASS(regulator_ww_class);
39	static DEFINE_MUTEX(regulator_nesting_mutex);
40	static DEFINE_MUTEX(regulator_list_mutex);
41	static LIST_HEAD(regulator_map_list);
42	static LIST_HEAD(regulator_ena_gpio_list);
43	static LIST_HEAD(regulator_supply_alias_list);
44	static LIST_HEAD(regulator_coupler_list);
45	static bool has_full_constraints;
46
47	static struct dentry *debugfs_root;
48
49	/*
50	* struct regulator_map
51	*
52	* Used to provide symbolic supply names to devices.
53	*/
54	struct regulator_map {
55	struct list_head list;
56	const char *dev_name; /* The dev_name() for the consumer */
57	const char *supply;
58	struct regulator_dev *regulator;
59	};
60
61	/*
62	* struct regulator_enable_gpio
63	*
64	* Management for shared enable GPIO pin
65	*/
66	struct regulator_enable_gpio {
67	struct list_head list;
68	struct gpio_desc *gpiod;
69	u32 enable_count; /* a number of enabled shared GPIO */
70	u32 request_count; /* a number of requested shared GPIO */
71	};
72
73	/*
74	* struct regulator_supply_alias
75	*
76	* Used to map lookups for a supply onto an alternative device.
77	*/
78	struct regulator_supply_alias {
79	struct list_head list;
80	struct device *src_dev;
81	const char *src_supply;
82	struct device *alias_dev;
83	const char *alias_supply;
84	};
85
86	static int _regulator_is_enabled(struct regulator_dev *rdev);
87	static int _regulator_disable(struct regulator *regulator);
88	static int _regulator_get_error_flags(struct regulator_dev *rdev, unsigned int *flags);
89	static int _regulator_get_current_limit(struct regulator_dev *rdev);
90	static unsigned int _regulator_get_mode(struct regulator_dev *rdev);
91	static int _notifier_call_chain(struct regulator_dev *rdev,
92	unsigned long event, void *data);
93	static int _regulator_do_set_voltage(struct regulator_dev *rdev,
94	int min_uV, int max_uV);
95	static int regulator_balance_voltage(struct regulator_dev *rdev,
96	suspend_state_t state);
97	static struct regulator *create_regulator(struct regulator_dev *rdev,
98	struct device *dev,
99	const char *supply_name);
100	static void destroy_regulator(struct regulator *regulator);
101	static void _regulator_put(struct regulator *regulator);
102
103	const char *rdev_get_name(struct regulator_dev *rdev)
104	{
105	if (rdev->constraints && rdev->constraints->name)
106	return rdev->constraints->name;
107	else if (rdev->desc->name)
108	return rdev->desc->name;
109	else
110	return "";
111	}
112	EXPORT_SYMBOL_GPL(rdev_get_name);
113
114	static bool have_full_constraints(void)
115	{
116	return has_full_constraints || of_have_populated_dt();
117	}
118
119	static bool regulator_ops_is_valid(struct regulator_dev *rdev, int ops)
120	{
121	if (!rdev->constraints) {
122	rdev_err(rdev, "no constraints\n");
123	return false;
124	}
125
126	if (rdev->constraints->valid_ops_mask & ops)
127	return true;
128
129	return false;
130	}
131
132	/**
133	* regulator_lock_nested - lock a single regulator
134	* @rdev: regulator source
135	* @ww_ctx: w/w mutex acquire context
136	*
137	* This function can be called many times by one task on
138	* a single regulator and its mutex will be locked only
139	* once. If a task, which is calling this function is other
140	* than the one, which initially locked the mutex, it will
141	* wait on mutex.
142	*/
143	static inline int regulator_lock_nested(struct regulator_dev *rdev,
144	struct ww_acquire_ctx *ww_ctx)
145	{
146	bool lock = false;
147	int ret = 0;
148
149	mutex_lock(&regulator_nesting_mutex);
150
151	if (!ww_mutex_trylock(lock: &rdev->mutex, ctx: ww_ctx)) {
152	if (rdev->mutex_owner == current)
153	rdev->ref_cnt++;
154	else
155	lock = true;
156
157	if (lock) {
158	mutex_unlock(lock: &regulator_nesting_mutex);
159	ret = ww_mutex_lock(lock: &rdev->mutex, ctx: ww_ctx);
160	mutex_lock(&regulator_nesting_mutex);
161	}
162	} else {
163	lock = true;
164	}
165
166	if (lock && ret != -EDEADLK) {
167	rdev->ref_cnt++;
168	rdev->mutex_owner = current;
169	}
170
171	mutex_unlock(lock: &regulator_nesting_mutex);
172
173	return ret;
174	}
175
176	/**
177	* regulator_lock - lock a single regulator
178	* @rdev: regulator source
179	*
180	* This function can be called many times by one task on
181	* a single regulator and its mutex will be locked only
182	* once. If a task, which is calling this function is other
183	* than the one, which initially locked the mutex, it will
184	* wait on mutex.
185	*/
186	static void regulator_lock(struct regulator_dev *rdev)
187	{
188	regulator_lock_nested(rdev, NULL);
189	}
190
191	/**
192	* regulator_unlock - unlock a single regulator
193	* @rdev: regulator_source
194	*
195	* This function unlocks the mutex when the
196	* reference counter reaches 0.
197	*/
198	static void regulator_unlock(struct regulator_dev *rdev)
199	{
200	mutex_lock(&regulator_nesting_mutex);
201
202	if (--rdev->ref_cnt == 0) {
203	rdev->mutex_owner = NULL;
204	ww_mutex_unlock(lock: &rdev->mutex);
205	}
206
207	WARN_ON_ONCE(rdev->ref_cnt < 0);
208
209	mutex_unlock(lock: &regulator_nesting_mutex);
210	}
211
212	/**
213	* regulator_lock_two - lock two regulators
214	* @rdev1: first regulator
215	* @rdev2: second regulator
216	* @ww_ctx: w/w mutex acquire context
217	*
218	* Locks both rdevs using the regulator_ww_class.
219	*/
220	static void regulator_lock_two(struct regulator_dev *rdev1,
221	struct regulator_dev *rdev2,
222	struct ww_acquire_ctx *ww_ctx)
223	{
224	struct regulator_dev *held, *contended;
225	int ret;
226
227	ww_acquire_init(ctx: ww_ctx, ww_class: &regulator_ww_class);
228
229	/* Try to just grab both of them */
230	ret = regulator_lock_nested(rdev: rdev1, ww_ctx);
231	WARN_ON(ret);
232	ret = regulator_lock_nested(rdev: rdev2, ww_ctx);
233	if (ret != -EDEADLOCK) {
234	WARN_ON(ret);
235	goto exit;
236	}
237
238	held = rdev1;
239	contended = rdev2;
240	while (true) {
241	regulator_unlock(rdev: held);
242
243	ww_mutex_lock_slow(lock: &contended->mutex, ctx: ww_ctx);
244	contended->ref_cnt++;
245	contended->mutex_owner = current;
246	swap(held, contended);
247	ret = regulator_lock_nested(rdev: contended, ww_ctx);
248
249	if (ret != -EDEADLOCK) {
250	WARN_ON(ret);
251	break;
252	}
253	}
254
255	exit:
256	ww_acquire_done(ctx: ww_ctx);
257	}
258
259	/**
260	* regulator_unlock_two - unlock two regulators
261	* @rdev1: first regulator
262	* @rdev2: second regulator
263	* @ww_ctx: w/w mutex acquire context
264	*
265	* The inverse of regulator_lock_two().
266	*/
267
268	static void regulator_unlock_two(struct regulator_dev *rdev1,
269	struct regulator_dev *rdev2,
270	struct ww_acquire_ctx *ww_ctx)
271	{
272	regulator_unlock(rdev: rdev2);
273	regulator_unlock(rdev: rdev1);
274	ww_acquire_fini(ctx: ww_ctx);
275	}
276
277	static bool regulator_supply_is_couple(struct regulator_dev *rdev)
278	{
279	struct regulator_dev *c_rdev;
280	int i;
281
282	for (i = 1; i < rdev->coupling_desc.n_coupled; i++) {
283	c_rdev = rdev->coupling_desc.coupled_rdevs[i];
284
285	if (rdev->supply->rdev == c_rdev)
286	return true;
287	}
288
289	return false;
290	}
291
292	static void regulator_unlock_recursive(struct regulator_dev *rdev,
293	unsigned int n_coupled)
294	{
295	struct regulator_dev *c_rdev, *supply_rdev;
296	int i, supply_n_coupled;
297
298	for (i = n_coupled; i > 0; i--) {
299	c_rdev = rdev->coupling_desc.coupled_rdevs[i - 1];
300
301	if (!c_rdev)
302	continue;
303
304	if (c_rdev->supply && !regulator_supply_is_couple(rdev: c_rdev)) {
305	supply_rdev = c_rdev->supply->rdev;
306	supply_n_coupled = supply_rdev->coupling_desc.n_coupled;
307
308	regulator_unlock_recursive(rdev: supply_rdev,
309	n_coupled: supply_n_coupled);
310	}
311
312	regulator_unlock(rdev: c_rdev);
313	}
314	}
315
316	static int regulator_lock_recursive(struct regulator_dev *rdev,
317	struct regulator_dev **new_contended_rdev,
318	struct regulator_dev **old_contended_rdev,
319	struct ww_acquire_ctx *ww_ctx)
320	{
321	struct regulator_dev *c_rdev;
322	int i, err;
323
324	for (i = 0; i < rdev->coupling_desc.n_coupled; i++) {
325	c_rdev = rdev->coupling_desc.coupled_rdevs[i];
326
327	if (!c_rdev)
328	continue;
329
330	if (c_rdev != *old_contended_rdev) {
331	err = regulator_lock_nested(rdev: c_rdev, ww_ctx);
332	if (err) {
333	if (err == -EDEADLK) {
334	*new_contended_rdev = c_rdev;
335	goto err_unlock;
336	}
337
338	/* shouldn't happen */
339	WARN_ON_ONCE(err != -EALREADY);
340	}
341	} else {
342	*old_contended_rdev = NULL;
343	}
344
345	if (c_rdev->supply && !regulator_supply_is_couple(rdev: c_rdev)) {
346	err = regulator_lock_recursive(rdev: c_rdev->supply->rdev,
347	new_contended_rdev,
348	old_contended_rdev,
349	ww_ctx);
350	if (err) {
351	regulator_unlock(rdev: c_rdev);
352	goto err_unlock;
353	}
354	}
355	}
356
357	return 0;
358
359	err_unlock:
360	regulator_unlock_recursive(rdev, n_coupled: i);
361
362	return err;
363	}
364
365	/**
366	* regulator_unlock_dependent - unlock regulator's suppliers and coupled
367	* regulators
368	* @rdev: regulator source
369	* @ww_ctx: w/w mutex acquire context
370	*
371	* Unlock all regulators related with rdev by coupling or supplying.
372	*/
373	static void regulator_unlock_dependent(struct regulator_dev *rdev,
374	struct ww_acquire_ctx *ww_ctx)
375	{
376	regulator_unlock_recursive(rdev, n_coupled: rdev->coupling_desc.n_coupled);
377	ww_acquire_fini(ctx: ww_ctx);
378	}
379
380	/**
381	* regulator_lock_dependent - lock regulator's suppliers and coupled regulators
382	* @rdev: regulator source
383	* @ww_ctx: w/w mutex acquire context
384	*
385	* This function as a wrapper on regulator_lock_recursive(), which locks
386	* all regulators related with rdev by coupling or supplying.
387	*/
388	static void regulator_lock_dependent(struct regulator_dev *rdev,
389	struct ww_acquire_ctx *ww_ctx)
390	{
391	struct regulator_dev *new_contended_rdev = NULL;
392	struct regulator_dev *old_contended_rdev = NULL;
393	int err;
394
395	mutex_lock(&regulator_list_mutex);
396
397	ww_acquire_init(ctx: ww_ctx, ww_class: &regulator_ww_class);
398
399	do {
400	if (new_contended_rdev) {
401	ww_mutex_lock_slow(lock: &new_contended_rdev->mutex, ctx: ww_ctx);
402	old_contended_rdev = new_contended_rdev;
403	old_contended_rdev->ref_cnt++;
404	old_contended_rdev->mutex_owner = current;
405	}
406
407	err = regulator_lock_recursive(rdev,
408	new_contended_rdev: &new_contended_rdev,
409	old_contended_rdev: &old_contended_rdev,
410	ww_ctx);
411
412	if (old_contended_rdev)
413	regulator_unlock(rdev: old_contended_rdev);
414
415	} while (err == -EDEADLK);
416
417	ww_acquire_done(ctx: ww_ctx);
418
419	mutex_unlock(lock: &regulator_list_mutex);
420	}
421
422	/**
423	* of_get_child_regulator - get a child regulator device node
424	* based on supply name
425	* @parent: Parent device node
426	* @prop_name: Combination regulator supply name and "-supply"
427	*
428	* Traverse all child nodes.
429	* Extract the child regulator device node corresponding to the supply name.
430	* returns the device node corresponding to the regulator if found, else
431	* returns NULL.
432	*/
433	static struct device_node *of_get_child_regulator(struct device_node *parent,
434	const char *prop_name)
435	{
436	struct device_node *regnode = NULL;
437	struct device_node *child = NULL;
438
439	for_each_child_of_node(parent, child) {
440	regnode = of_parse_phandle(np: child, phandle_name: prop_name, index: 0);
441
442	if (!regnode) {
443	regnode = of_get_child_regulator(parent: child, prop_name);
444	if (regnode)
445	goto err_node_put;
446	} else {
447	goto err_node_put;
448	}
449	}
450	return NULL;
451
452	err_node_put:
453	of_node_put(node: child);
454	return regnode;
455	}
456
457	/**
458	* of_get_regulator - get a regulator device node based on supply name
459	* @dev: Device pointer for the consumer (of regulator) device
460	* @supply: regulator supply name
461	*
462	* Extract the regulator device node corresponding to the supply name.
463	* returns the device node corresponding to the regulator if found, else
464	* returns NULL.
465	*/
466	static struct device_node *of_get_regulator(struct device *dev, const char *supply)
467	{
468	struct device_node *regnode = NULL;
469	char prop_name[64]; /* 64 is max size of property name */
470
471	dev_dbg(dev, "Looking up %s-supply from device tree\n", supply);
472
473	snprintf(buf: prop_name, size: 64, fmt: "%s-supply", supply);
474	regnode = of_parse_phandle(np: dev->of_node, phandle_name: prop_name, index: 0);
475
476	if (!regnode) {
477	regnode = of_get_child_regulator(parent: dev->of_node, prop_name);
478	if (regnode)
479	return regnode;
480
481	dev_dbg(dev, "Looking up %s property in node %pOF failed\n",
482	prop_name, dev->of_node);
483	return NULL;
484	}
485	return regnode;
486	}
487
488	/* Platform voltage constraint check */
489	int regulator_check_voltage(struct regulator_dev *rdev,
490	int *min_uV, int *max_uV)
491	{
492	BUG_ON(*min_uV > *max_uV);
493
494	if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_VOLTAGE)) {
495	rdev_err(rdev, "voltage operation not allowed\n");
496	return -EPERM;
497	}
498
499	if (*max_uV > rdev->constraints->max_uV)
500	*max_uV = rdev->constraints->max_uV;
501	if (*min_uV < rdev->constraints->min_uV)
502	*min_uV = rdev->constraints->min_uV;
503
504	if (*min_uV > *max_uV) {
505	rdev_err(rdev, "unsupportable voltage range: %d-%duV\n",
506	*min_uV, *max_uV);
507	return -EINVAL;
508	}
509
510	return 0;
511	}
512
513	/* return 0 if the state is valid */
514	static int regulator_check_states(suspend_state_t state)
515	{
516	return (state > PM_SUSPEND_MAX || state == PM_SUSPEND_TO_IDLE);
517	}
518
519	/* Make sure we select a voltage that suits the needs of all
520	* regulator consumers
521	*/
522	int regulator_check_consumers(struct regulator_dev *rdev,
523	int *min_uV, int *max_uV,
524	suspend_state_t state)
525	{
526	struct regulator *regulator;
527	struct regulator_voltage *voltage;
528
529	list_for_each_entry(regulator, &rdev->consumer_list, list) {
530	voltage = &regulator->voltage[state];
531	/*
532	* Assume consumers that didn't say anything are OK
533	* with anything in the constraint range.
534	*/
535	if (!voltage->min_uV && !voltage->max_uV)
536	continue;
537
538	if (*max_uV > voltage->max_uV)
539	*max_uV = voltage->max_uV;
540	if (*min_uV < voltage->min_uV)
541	*min_uV = voltage->min_uV;
542	}
543
544	if (*min_uV > *max_uV) {
545	rdev_err(rdev, "Restricting voltage, %u-%uuV\n",
546	*min_uV, *max_uV);
547	return -EINVAL;
548	}
549
550	return 0;
551	}
552
553	/* current constraint check */
554	static int regulator_check_current_limit(struct regulator_dev *rdev,
555	int *min_uA, int *max_uA)
556	{
557	BUG_ON(*min_uA > *max_uA);
558
559	if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_CURRENT)) {
560	rdev_err(rdev, "current operation not allowed\n");
561	return -EPERM;
562	}
563
564	if (*max_uA > rdev->constraints->max_uA)
565	*max_uA = rdev->constraints->max_uA;
566	if (*min_uA < rdev->constraints->min_uA)
567	*min_uA = rdev->constraints->min_uA;
568
569	if (*min_uA > *max_uA) {
570	rdev_err(rdev, "unsupportable current range: %d-%duA\n",
571	*min_uA, *max_uA);
572	return -EINVAL;
573	}
574
575	return 0;
576	}
577
578	/* operating mode constraint check */
579	static int regulator_mode_constrain(struct regulator_dev *rdev,
580	unsigned int *mode)
581	{
582	switch (*mode) {
583	case REGULATOR_MODE_FAST:
584	case REGULATOR_MODE_NORMAL:
585	case REGULATOR_MODE_IDLE:
586	case REGULATOR_MODE_STANDBY:
587	break;
588	default:
589	rdev_err(rdev, "invalid mode %x specified\n", *mode);
590	return -EINVAL;
591	}
592
593	if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_MODE)) {
594	rdev_err(rdev, "mode operation not allowed\n");
595	return -EPERM;
596	}
597
598	/* The modes are bitmasks, the most power hungry modes having
599	* the lowest values. If the requested mode isn't supported
600	* try higher modes.
601	*/
602	while (*mode) {
603	if (rdev->constraints->valid_modes_mask & *mode)
604	return 0;
605	*mode /= 2;
606	}
607
608	return -EINVAL;
609	}
610
611	static inline struct regulator_state *
612	regulator_get_suspend_state(struct regulator_dev *rdev, suspend_state_t state)
613	{
614	if (rdev->constraints == NULL)
615	return NULL;
616
617	switch (state) {
618	case PM_SUSPEND_STANDBY:
619	return &rdev->constraints->state_standby;
620	case PM_SUSPEND_MEM:
621	return &rdev->constraints->state_mem;
622	case PM_SUSPEND_MAX:
623	return &rdev->constraints->state_disk;
624	default:
625	return NULL;
626	}
627	}
628
629	static const struct regulator_state *
630	regulator_get_suspend_state_check(struct regulator_dev *rdev, suspend_state_t state)
631	{
632	const struct regulator_state *rstate;
633
634	rstate = regulator_get_suspend_state(rdev, state);
635	if (rstate == NULL)
636	return NULL;
637
638	/* If we have no suspend mode configuration don't set anything;
639	* only warn if the driver implements set_suspend_voltage or
640	* set_suspend_mode callback.
641	*/
642	if (rstate->enabled != ENABLE_IN_SUSPEND &&
643	rstate->enabled != DISABLE_IN_SUSPEND) {
644	if (rdev->desc->ops->set_suspend_voltage ||
645	rdev->desc->ops->set_suspend_mode)
646	rdev_warn(rdev, "No configuration\n");
647	return NULL;
648	}
649
650	return rstate;
651	}
652
653	static ssize_t microvolts_show(struct device *dev,
654	struct device_attribute *attr, char *buf)
655	{
656	struct regulator_dev *rdev = dev_get_drvdata(dev);
657	int uV;
658
659	regulator_lock(rdev);
660	uV = regulator_get_voltage_rdev(rdev);
661	regulator_unlock(rdev);
662
663	if (uV < 0)
664	return uV;
665	return sprintf(buf, fmt: "%d\n", uV);
666	}
667	static DEVICE_ATTR_RO(microvolts);
668
669	static ssize_t microamps_show(struct device *dev,
670	struct device_attribute *attr, char *buf)
671	{
672	struct regulator_dev *rdev = dev_get_drvdata(dev);
673
674	return sprintf(buf, fmt: "%d\n", _regulator_get_current_limit(rdev));
675	}
676	static DEVICE_ATTR_RO(microamps);
677
678	static ssize_t name_show(struct device *dev, struct device_attribute *attr,
679	char *buf)
680	{
681	struct regulator_dev *rdev = dev_get_drvdata(dev);
682
683	return sprintf(buf, fmt: "%s\n", rdev_get_name(rdev));
684	}
685	static DEVICE_ATTR_RO(name);
686
687	static const char *regulator_opmode_to_str(int mode)
688	{
689	switch (mode) {
690	case REGULATOR_MODE_FAST:
691	return "fast";
692	case REGULATOR_MODE_NORMAL:
693	return "normal";
694	case REGULATOR_MODE_IDLE:
695	return "idle";
696	case REGULATOR_MODE_STANDBY:
697	return "standby";
698	}
699	return "unknown";
700	}
701
702	static ssize_t regulator_print_opmode(char *buf, int mode)
703	{
704	return sprintf(buf, fmt: "%s\n", regulator_opmode_to_str(mode));
705	}
706
707	static ssize_t opmode_show(struct device *dev,
708	struct device_attribute *attr, char *buf)
709	{
710	struct regulator_dev *rdev = dev_get_drvdata(dev);
711
712	return regulator_print_opmode(buf, mode: _regulator_get_mode(rdev));
713	}
714	static DEVICE_ATTR_RO(opmode);
715
716	static ssize_t regulator_print_state(char *buf, int state)
717	{
718	if (state > 0)
719	return sprintf(buf, fmt: "enabled\n");
720	else if (state == 0)
721	return sprintf(buf, fmt: "disabled\n");
722	else
723	return sprintf(buf, fmt: "unknown\n");
724	}
725
726	static ssize_t state_show(struct device *dev,
727	struct device_attribute *attr, char *buf)
728	{
729	struct regulator_dev *rdev = dev_get_drvdata(dev);
730	ssize_t ret;
731
732	regulator_lock(rdev);
733	ret = regulator_print_state(buf, state: _regulator_is_enabled(rdev));
734	regulator_unlock(rdev);
735
736	return ret;
737	}
738	static DEVICE_ATTR_RO(state);
739
740	static ssize_t status_show(struct device *dev,
741	struct device_attribute *attr, char *buf)
742	{
743	struct regulator_dev *rdev = dev_get_drvdata(dev);
744	int status;
745	char *label;
746
747	status = rdev->desc->ops->get_status(rdev);
748	if (status < 0)
749	return status;
750
751	switch (status) {
752	case REGULATOR_STATUS_OFF:
753	label = "off";
754	break;
755	case REGULATOR_STATUS_ON:
756	label = "on";
757	break;
758	case REGULATOR_STATUS_ERROR:
759	label = "error";
760	break;
761	case REGULATOR_STATUS_FAST:
762	label = "fast";
763	break;
764	case REGULATOR_STATUS_NORMAL:
765	label = "normal";
766	break;
767	case REGULATOR_STATUS_IDLE:
768	label = "idle";
769	break;
770	case REGULATOR_STATUS_STANDBY:
771	label = "standby";
772	break;
773	case REGULATOR_STATUS_BYPASS:
774	label = "bypass";
775	break;
776	case REGULATOR_STATUS_UNDEFINED:
777	label = "undefined";
778	break;
779	default:
780	return -ERANGE;
781	}
782
783	return sprintf(buf, fmt: "%s\n", label);
784	}
785	static DEVICE_ATTR_RO(status);
786
787	static ssize_t min_microamps_show(struct device *dev,
788	struct device_attribute *attr, char *buf)
789	{
790	struct regulator_dev *rdev = dev_get_drvdata(dev);
791
792	if (!rdev->constraints)
793	return sprintf(buf, fmt: "constraint not defined\n");
794
795	return sprintf(buf, fmt: "%d\n", rdev->constraints->min_uA);
796	}
797	static DEVICE_ATTR_RO(min_microamps);
798
799	static ssize_t max_microamps_show(struct device *dev,
800	struct device_attribute *attr, char *buf)
801	{
802	struct regulator_dev *rdev = dev_get_drvdata(dev);
803
804	if (!rdev->constraints)
805	return sprintf(buf, fmt: "constraint not defined\n");
806
807	return sprintf(buf, fmt: "%d\n", rdev->constraints->max_uA);
808	}
809	static DEVICE_ATTR_RO(max_microamps);
810
811	static ssize_t min_microvolts_show(struct device *dev,
812	struct device_attribute *attr, char *buf)
813	{
814	struct regulator_dev *rdev = dev_get_drvdata(dev);
815
816	if (!rdev->constraints)
817	return sprintf(buf, fmt: "constraint not defined\n");
818
819	return sprintf(buf, fmt: "%d\n", rdev->constraints->min_uV);
820	}
821	static DEVICE_ATTR_RO(min_microvolts);
822
823	static ssize_t max_microvolts_show(struct device *dev,
824	struct device_attribute *attr, char *buf)
825	{
826	struct regulator_dev *rdev = dev_get_drvdata(dev);
827
828	if (!rdev->constraints)
829	return sprintf(buf, fmt: "constraint not defined\n");
830
831	return sprintf(buf, fmt: "%d\n", rdev->constraints->max_uV);
832	}
833	static DEVICE_ATTR_RO(max_microvolts);
834
835	static ssize_t requested_microamps_show(struct device *dev,
836	struct device_attribute *attr, char *buf)
837	{
838	struct regulator_dev *rdev = dev_get_drvdata(dev);
839	struct regulator *regulator;
840	int uA = 0;
841
842	regulator_lock(rdev);
843	list_for_each_entry(regulator, &rdev->consumer_list, list) {
844	if (regulator->enable_count)
845	uA += regulator->uA_load;
846	}
847	regulator_unlock(rdev);
848	return sprintf(buf, fmt: "%d\n", uA);
849	}
850	static DEVICE_ATTR_RO(requested_microamps);
851
852	static ssize_t num_users_show(struct device *dev, struct device_attribute *attr,
853	char *buf)
854	{
855	struct regulator_dev *rdev = dev_get_drvdata(dev);
856	return sprintf(buf, fmt: "%d\n", rdev->use_count);
857	}
858	static DEVICE_ATTR_RO(num_users);
859
860	static ssize_t type_show(struct device *dev, struct device_attribute *attr,
861	char *buf)
862	{
863	struct regulator_dev *rdev = dev_get_drvdata(dev);
864
865	switch (rdev->desc->type) {
866	case REGULATOR_VOLTAGE:
867	return sprintf(buf, fmt: "voltage\n");
868	case REGULATOR_CURRENT:
869	return sprintf(buf, fmt: "current\n");
870	}
871	return sprintf(buf, fmt: "unknown\n");
872	}
873	static DEVICE_ATTR_RO(type);
874
875	static ssize_t suspend_mem_microvolts_show(struct device *dev,
876	struct device_attribute *attr, char *buf)
877	{
878	struct regulator_dev *rdev = dev_get_drvdata(dev);
879
880	return sprintf(buf, fmt: "%d\n", rdev->constraints->state_mem.uV);
881	}
882	static DEVICE_ATTR_RO(suspend_mem_microvolts);
883
884	static ssize_t suspend_disk_microvolts_show(struct device *dev,
885	struct device_attribute *attr, char *buf)
886	{
887	struct regulator_dev *rdev = dev_get_drvdata(dev);
888
889	return sprintf(buf, fmt: "%d\n", rdev->constraints->state_disk.uV);
890	}
891	static DEVICE_ATTR_RO(suspend_disk_microvolts);
892
893	static ssize_t suspend_standby_microvolts_show(struct device *dev,
894	struct device_attribute *attr, char *buf)
895	{
896	struct regulator_dev *rdev = dev_get_drvdata(dev);
897
898	return sprintf(buf, fmt: "%d\n", rdev->constraints->state_standby.uV);
899	}
900	static DEVICE_ATTR_RO(suspend_standby_microvolts);
901
902	static ssize_t suspend_mem_mode_show(struct device *dev,
903	struct device_attribute *attr, char *buf)
904	{
905	struct regulator_dev *rdev = dev_get_drvdata(dev);
906
907	return regulator_print_opmode(buf,
908	mode: rdev->constraints->state_mem.mode);
909	}
910	static DEVICE_ATTR_RO(suspend_mem_mode);
911
912	static ssize_t suspend_disk_mode_show(struct device *dev,
913	struct device_attribute *attr, char *buf)
914	{
915	struct regulator_dev *rdev = dev_get_drvdata(dev);
916
917	return regulator_print_opmode(buf,
918	mode: rdev->constraints->state_disk.mode);
919	}
920	static DEVICE_ATTR_RO(suspend_disk_mode);
921
922	static ssize_t suspend_standby_mode_show(struct device *dev,
923	struct device_attribute *attr, char *buf)
924	{
925	struct regulator_dev *rdev = dev_get_drvdata(dev);
926
927	return regulator_print_opmode(buf,
928	mode: rdev->constraints->state_standby.mode);
929	}
930	static DEVICE_ATTR_RO(suspend_standby_mode);
931
932	static ssize_t suspend_mem_state_show(struct device *dev,
933	struct device_attribute *attr, char *buf)
934	{
935	struct regulator_dev *rdev = dev_get_drvdata(dev);
936
937	return regulator_print_state(buf,
938	state: rdev->constraints->state_mem.enabled);
939	}
940	static DEVICE_ATTR_RO(suspend_mem_state);
941
942	static ssize_t suspend_disk_state_show(struct device *dev,
943	struct device_attribute *attr, char *buf)
944	{
945	struct regulator_dev *rdev = dev_get_drvdata(dev);
946
947	return regulator_print_state(buf,
948	state: rdev->constraints->state_disk.enabled);
949	}
950	static DEVICE_ATTR_RO(suspend_disk_state);
951
952	static ssize_t suspend_standby_state_show(struct device *dev,
953	struct device_attribute *attr, char *buf)
954	{
955	struct regulator_dev *rdev = dev_get_drvdata(dev);
956
957	return regulator_print_state(buf,
958	state: rdev->constraints->state_standby.enabled);
959	}
960	static DEVICE_ATTR_RO(suspend_standby_state);
961
962	static ssize_t bypass_show(struct device *dev,
963	struct device_attribute *attr, char *buf)
964	{
965	struct regulator_dev *rdev = dev_get_drvdata(dev);
966	const char *report;
967	bool bypass;
968	int ret;
969
970	ret = rdev->desc->ops->get_bypass(rdev, &bypass);
971
972	if (ret != 0)
973	report = "unknown";
974	else if (bypass)
975	report = "enabled";
976	else
977	report = "disabled";
978
979	return sprintf(buf, fmt: "%s\n", report);
980	}
981	static DEVICE_ATTR_RO(bypass);
982
983	#define REGULATOR_ERROR_ATTR(name, bit) \
984	static ssize_t name##_show(struct device *dev, struct device_attribute *attr, \
985	char *buf) \
986	{ \
987	int ret; \
988	unsigned int flags; \
989	struct regulator_dev *rdev = dev_get_drvdata(dev); \
990	ret = _regulator_get_error_flags(rdev, &flags); \
991	if (ret) \
992	return ret; \
993	return sysfs_emit(buf, "%d\n", !!(flags & (bit))); \
994	} \
995	static DEVICE_ATTR_RO(name)
996
997	REGULATOR_ERROR_ATTR(under_voltage, REGULATOR_ERROR_UNDER_VOLTAGE);
998	REGULATOR_ERROR_ATTR(over_current, REGULATOR_ERROR_OVER_CURRENT);
999	REGULATOR_ERROR_ATTR(regulation_out, REGULATOR_ERROR_REGULATION_OUT);
1000	REGULATOR_ERROR_ATTR(fail, REGULATOR_ERROR_FAIL);
1001	REGULATOR_ERROR_ATTR(over_temp, REGULATOR_ERROR_OVER_TEMP);
1002	REGULATOR_ERROR_ATTR(under_voltage_warn, REGULATOR_ERROR_UNDER_VOLTAGE_WARN);
1003	REGULATOR_ERROR_ATTR(over_current_warn, REGULATOR_ERROR_OVER_CURRENT_WARN);
1004	REGULATOR_ERROR_ATTR(over_voltage_warn, REGULATOR_ERROR_OVER_VOLTAGE_WARN);
1005	REGULATOR_ERROR_ATTR(over_temp_warn, REGULATOR_ERROR_OVER_TEMP_WARN);
1006
1007	/* Calculate the new optimum regulator operating mode based on the new total
1008	* consumer load. All locks held by caller
1009	*/
1010	static int drms_uA_update(struct regulator_dev *rdev)
1011	{
1012	struct regulator *sibling;
1013	int current_uA = 0, output_uV, input_uV, err;
1014	unsigned int mode;
1015
1016	/*
1017	* first check to see if we can set modes at all, otherwise just
1018	* tell the consumer everything is OK.
1019	*/
1020	if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_DRMS)) {
1021	rdev_dbg(rdev, "DRMS operation not allowed\n");
1022	return 0;
1023	}
1024
1025	if (!rdev->desc->ops->get_optimum_mode &&
1026	!rdev->desc->ops->set_load)
1027	return 0;
1028
1029	if (!rdev->desc->ops->set_mode &&
1030	!rdev->desc->ops->set_load)
1031	return -EINVAL;
1032
1033	/* calc total requested load */
1034	list_for_each_entry(sibling, &rdev->consumer_list, list) {
1035	if (sibling->enable_count)
1036	current_uA += sibling->uA_load;
1037	}
1038
1039	current_uA += rdev->constraints->system_load;
1040
1041	if (rdev->desc->ops->set_load) {
1042	/* set the optimum mode for our new total regulator load */
1043	err = rdev->desc->ops->set_load(rdev, current_uA);
1044	if (err < 0)
1045	rdev_err(rdev, "failed to set load %d: %pe\n",
1046	current_uA, ERR_PTR(err));
1047	} else {
1048	/*
1049	* Unfortunately in some cases the constraints->valid_ops has
1050	* REGULATOR_CHANGE_DRMS but there are no valid modes listed.
1051	* That's not really legit but we won't consider it a fatal
1052	* error here. We'll treat it as if REGULATOR_CHANGE_DRMS
1053	* wasn't set.
1054	*/
1055	if (!rdev->constraints->valid_modes_mask) {
1056	rdev_dbg(rdev, "Can change modes; but no valid mode\n");
1057	return 0;
1058	}
1059
1060	/* get output voltage */
1061	output_uV = regulator_get_voltage_rdev(rdev);
1062
1063	/*
1064	* Don't return an error; if regulator driver cares about
1065	* output_uV then it's up to the driver to validate.
1066	*/
1067	if (output_uV <= 0)
1068	rdev_dbg(rdev, "invalid output voltage found\n");
1069
1070	/* get input voltage */
1071	input_uV = 0;
1072	if (rdev->supply)
1073	input_uV = regulator_get_voltage_rdev(rdev: rdev->supply->rdev);
1074	if (input_uV <= 0)
1075	input_uV = rdev->constraints->input_uV;
1076
1077	/*
1078	* Don't return an error; if regulator driver cares about
1079	* input_uV then it's up to the driver to validate.
1080	*/
1081	if (input_uV <= 0)
1082	rdev_dbg(rdev, "invalid input voltage found\n");
1083
1084	/* now get the optimum mode for our new total regulator load */
1085	mode = rdev->desc->ops->get_optimum_mode(rdev, input_uV,
1086	output_uV, current_uA);
1087
1088	/* check the new mode is allowed */
1089	err = regulator_mode_constrain(rdev, mode: &mode);
1090	if (err < 0) {
1091	rdev_err(rdev, "failed to get optimum mode @ %d uA %d -> %d uV: %pe\n",
1092	current_uA, input_uV, output_uV, ERR_PTR(err));
1093	return err;
1094	}
1095
1096	err = rdev->desc->ops->set_mode(rdev, mode);
1097	if (err < 0)
1098	rdev_err(rdev, "failed to set optimum mode %x: %pe\n",
1099	mode, ERR_PTR(err));
1100	}
1101
1102	return err;
1103	}
1104
1105	static int __suspend_set_state(struct regulator_dev *rdev,
1106	const struct regulator_state *rstate)
1107	{
1108	int ret = 0;
1109
1110	if (rstate->enabled == ENABLE_IN_SUSPEND &&
1111	rdev->desc->ops->set_suspend_enable)
1112	ret = rdev->desc->ops->set_suspend_enable(rdev);
1113	else if (rstate->enabled == DISABLE_IN_SUSPEND &&
1114	rdev->desc->ops->set_suspend_disable)
1115	ret = rdev->desc->ops->set_suspend_disable(rdev);
1116	else /* OK if set_suspend_enable or set_suspend_disable is NULL */
1117	ret = 0;
1118
1119	if (ret < 0) {
1120	rdev_err(rdev, "failed to enabled/disable: %pe\n", ERR_PTR(ret));
1121	return ret;
1122	}
1123
1124	if (rdev->desc->ops->set_suspend_voltage && rstate->uV > 0) {
1125	ret = rdev->desc->ops->set_suspend_voltage(rdev, rstate->uV);
1126	if (ret < 0) {
1127	rdev_err(rdev, "failed to set voltage: %pe\n", ERR_PTR(ret));
1128	return ret;
1129	}
1130	}
1131
1132	if (rdev->desc->ops->set_suspend_mode && rstate->mode > 0) {
1133	ret = rdev->desc->ops->set_suspend_mode(rdev, rstate->mode);
1134	if (ret < 0) {
1135	rdev_err(rdev, "failed to set mode: %pe\n", ERR_PTR(ret));
1136	return ret;
1137	}
1138	}
1139
1140	return ret;
1141	}
1142
1143	static int suspend_set_initial_state(struct regulator_dev *rdev)
1144	{
1145	const struct regulator_state *rstate;
1146
1147	rstate = regulator_get_suspend_state_check(rdev,
1148	state: rdev->constraints->initial_state);
1149	if (!rstate)
1150	return 0;
1151
1152	return __suspend_set_state(rdev, rstate);
1153	}
1154
1155	#if defined(DEBUG) || defined(CONFIG_DYNAMIC_DEBUG)
1156	static void print_constraints_debug(struct regulator_dev *rdev)
1157	{
1158	struct regulation_constraints *constraints = rdev->constraints;
1159	char buf[160] = "";
1160	size_t len = sizeof(buf) - 1;
1161	int count = 0;
1162	int ret;
1163
1164	if (constraints->min_uV && constraints->max_uV) {
1165	if (constraints->min_uV == constraints->max_uV)
1166	count += scnprintf(buf: buf + count, size: len - count, fmt: "%d mV ",
1167	constraints->min_uV / 1000);
1168	else
1169	count += scnprintf(buf: buf + count, size: len - count,
1170	fmt: "%d <--> %d mV ",
1171	constraints->min_uV / 1000,
1172	constraints->max_uV / 1000);
1173	}
1174
1175	if (!constraints->min_uV ||
1176	constraints->min_uV != constraints->max_uV) {
1177	ret = regulator_get_voltage_rdev(rdev);
1178	if (ret > 0)
1179	count += scnprintf(buf: buf + count, size: len - count,
1180	fmt: "at %d mV ", ret / 1000);
1181	}
1182
1183	if (constraints->uV_offset)
1184	count += scnprintf(buf: buf + count, size: len - count, fmt: "%dmV offset ",
1185	constraints->uV_offset / 1000);
1186
1187	if (constraints->min_uA && constraints->max_uA) {
1188	if (constraints->min_uA == constraints->max_uA)
1189	count += scnprintf(buf: buf + count, size: len - count, fmt: "%d mA ",
1190	constraints->min_uA / 1000);
1191	else
1192	count += scnprintf(buf: buf + count, size: len - count,
1193	fmt: "%d <--> %d mA ",
1194	constraints->min_uA / 1000,
1195	constraints->max_uA / 1000);
1196	}
1197
1198	if (!constraints->min_uA ||
1199	constraints->min_uA != constraints->max_uA) {
1200	ret = _regulator_get_current_limit(rdev);
1201	if (ret > 0)
1202	count += scnprintf(buf: buf + count, size: len - count,
1203	fmt: "at %d mA ", ret / 1000);
1204	}
1205
1206	if (constraints->valid_modes_mask & REGULATOR_MODE_FAST)
1207	count += scnprintf(buf: buf + count, size: len - count, fmt: "fast ");
1208	if (constraints->valid_modes_mask & REGULATOR_MODE_NORMAL)
1209	count += scnprintf(buf: buf + count, size: len - count, fmt: "normal ");
1210	if (constraints->valid_modes_mask & REGULATOR_MODE_IDLE)
1211	count += scnprintf(buf: buf + count, size: len - count, fmt: "idle ");
1212	if (constraints->valid_modes_mask & REGULATOR_MODE_STANDBY)
1213	count += scnprintf(buf: buf + count, size: len - count, fmt: "standby ");
1214
1215	if (!count)
1216	count = scnprintf(buf, size: len, fmt: "no parameters");
1217	else
1218	--count;
1219
1220	count += scnprintf(buf: buf + count, size: len - count, fmt: ", %s",
1221	_regulator_is_enabled(rdev) ? "enabled" : "disabled");
1222
1223	rdev_dbg(rdev, "%s\n", buf);
1224	}
1225	#else /* !DEBUG && !CONFIG_DYNAMIC_DEBUG */
1226	static inline void print_constraints_debug(struct regulator_dev *rdev) {}
1227	#endif /* !DEBUG && !CONFIG_DYNAMIC_DEBUG */
1228
1229	static void print_constraints(struct regulator_dev *rdev)
1230	{
1231	struct regulation_constraints *constraints = rdev->constraints;
1232
1233	print_constraints_debug(rdev);
1234
1235	if ((constraints->min_uV != constraints->max_uV) &&
1236	!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_VOLTAGE))
1237	rdev_warn(rdev,
1238	"Voltage range but no REGULATOR_CHANGE_VOLTAGE\n");
1239	}
1240
1241	static int machine_constraints_voltage(struct regulator_dev *rdev,
1242	struct regulation_constraints *constraints)
1243	{
1244	const struct regulator_ops *ops = rdev->desc->ops;
1245	int ret;
1246
1247	/* do we need to apply the constraint voltage */
1248	if (rdev->constraints->apply_uV &&
1249	rdev->constraints->min_uV && rdev->constraints->max_uV) {
1250	int target_min, target_max;
1251	int current_uV = regulator_get_voltage_rdev(rdev);
1252
1253	if (current_uV == -ENOTRECOVERABLE) {
1254	/* This regulator can't be read and must be initialized */
1255	rdev_info(rdev, "Setting %d-%duV\n",
1256	rdev->constraints->min_uV,
1257	rdev->constraints->max_uV);
1258	_regulator_do_set_voltage(rdev,
1259	min_uV: rdev->constraints->min_uV,
1260	max_uV: rdev->constraints->max_uV);
1261	current_uV = regulator_get_voltage_rdev(rdev);
1262	}
1263
1264	if (current_uV < 0) {
1265	if (current_uV != -EPROBE_DEFER)
1266	rdev_err(rdev,
1267	"failed to get the current voltage: %pe\n",
1268	ERR_PTR(current_uV));
1269	return current_uV;
1270	}
1271
1272	/*
1273	* If we're below the minimum voltage move up to the
1274	* minimum voltage, if we're above the maximum voltage
1275	* then move down to the maximum.
1276	*/
1277	target_min = current_uV;
1278	target_max = current_uV;
1279
1280	if (current_uV < rdev->constraints->min_uV) {
1281	target_min = rdev->constraints->min_uV;
1282	target_max = rdev->constraints->min_uV;
1283	}
1284
1285	if (current_uV > rdev->constraints->max_uV) {
1286	target_min = rdev->constraints->max_uV;
1287	target_max = rdev->constraints->max_uV;
1288	}
1289
1290	if (target_min != current_uV || target_max != current_uV) {
1291	rdev_info(rdev, "Bringing %duV into %d-%duV\n",
1292	current_uV, target_min, target_max);
1293	ret = _regulator_do_set_voltage(
1294	rdev, min_uV: target_min, max_uV: target_max);
1295	if (ret < 0) {
1296	rdev_err(rdev,
1297	"failed to apply %d-%duV constraint: %pe\n",
1298	target_min, target_max, ERR_PTR(ret));
1299	return ret;
1300	}
1301	}
1302	}
1303
1304	/* constrain machine-level voltage specs to fit
1305	* the actual range supported by this regulator.
1306	*/
1307	if (ops->list_voltage && rdev->desc->n_voltages) {
1308	int count = rdev->desc->n_voltages;
1309	int i;
1310	int min_uV = INT_MAX;
1311	int max_uV = INT_MIN;
1312	int cmin = constraints->min_uV;
1313	int cmax = constraints->max_uV;
1314
1315	/* it's safe to autoconfigure fixed-voltage supplies
1316	* and the constraints are used by list_voltage.
1317	*/
1318	if (count == 1 && !cmin) {
1319	cmin = 1;
1320	cmax = INT_MAX;
1321	constraints->min_uV = cmin;
1322	constraints->max_uV = cmax;
1323	}
1324
1325	/* voltage constraints are optional */
1326	if ((cmin == 0) && (cmax == 0))
1327	return 0;
1328
1329	/* else require explicit machine-level constraints */
1330	if (cmin <= 0 || cmax <= 0 || cmax < cmin) {
1331	rdev_err(rdev, "invalid voltage constraints\n");
1332	return -EINVAL;
1333	}
1334
1335	/* no need to loop voltages if range is continuous */
1336	if (rdev->desc->continuous_voltage_range)
1337	return 0;
1338
1339	/* initial: [cmin..cmax] valid, [min_uV..max_uV] not */
1340	for (i = 0; i < count; i++) {
1341	int value;
1342
1343	value = ops->list_voltage(rdev, i);
1344	if (value <= 0)
1345	continue;
1346
1347	/* maybe adjust [min_uV..max_uV] */
1348	if (value >= cmin && value < min_uV)
1349	min_uV = value;
1350	if (value <= cmax && value > max_uV)
1351	max_uV = value;
1352	}
1353
1354	/* final: [min_uV..max_uV] valid iff constraints valid */
1355	if (max_uV < min_uV) {
1356	rdev_err(rdev,
1357	"unsupportable voltage constraints %u-%uuV\n",
1358	min_uV, max_uV);
1359	return -EINVAL;
1360	}
1361
1362	/* use regulator's subset of machine constraints */
1363	if (constraints->min_uV < min_uV) {
1364	rdev_dbg(rdev, "override min_uV, %d -> %d\n",
1365	constraints->min_uV, min_uV);
1366	constraints->min_uV = min_uV;
1367	}
1368	if (constraints->max_uV > max_uV) {
1369	rdev_dbg(rdev, "override max_uV, %d -> %d\n",
1370	constraints->max_uV, max_uV);
1371	constraints->max_uV = max_uV;
1372	}
1373	}
1374
1375	return 0;
1376	}
1377
1378	static int machine_constraints_current(struct regulator_dev *rdev,
1379	struct regulation_constraints *constraints)
1380	{
1381	const struct regulator_ops *ops = rdev->desc->ops;
1382	int ret;
1383
1384	if (!constraints->min_uA && !constraints->max_uA)
1385	return 0;
1386
1387	if (constraints->min_uA > constraints->max_uA) {
1388	rdev_err(rdev, "Invalid current constraints\n");
1389	return -EINVAL;
1390	}
1391
1392	if (!ops->set_current_limit || !ops->get_current_limit) {
1393	rdev_warn(rdev, "Operation of current configuration missing\n");
1394	return 0;
1395	}
1396
1397	/* Set regulator current in constraints range */
1398	ret = ops->set_current_limit(rdev, constraints->min_uA,
1399	constraints->max_uA);
1400	if (ret < 0) {
1401	rdev_err(rdev, "Failed to set current constraint, %d\n", ret);
1402	return ret;
1403	}
1404
1405	return 0;
1406	}
1407
1408	static int _regulator_do_enable(struct regulator_dev *rdev);
1409
1410	static int notif_set_limit(struct regulator_dev *rdev,
1411	int (*set)(struct regulator_dev *, int, int, bool),
1412	int limit, int severity)
1413	{
1414	bool enable;
1415
1416	if (limit == REGULATOR_NOTIF_LIMIT_DISABLE) {
1417	enable = false;
1418	limit = 0;
1419	} else {
1420	enable = true;
1421	}
1422
1423	if (limit == REGULATOR_NOTIF_LIMIT_ENABLE)
1424	limit = 0;
1425
1426	return set(rdev, limit, severity, enable);
1427	}
1428
1429	static int handle_notify_limits(struct regulator_dev *rdev,
1430	int (*set)(struct regulator_dev *, int, int, bool),
1431	struct notification_limit *limits)
1432	{
1433	int ret = 0;
1434
1435	if (!set)
1436	return -EOPNOTSUPP;
1437
1438	if (limits->prot)
1439	ret = notif_set_limit(rdev, set, limit: limits->prot,
1440	severity: REGULATOR_SEVERITY_PROT);
1441	if (ret)
1442	return ret;
1443
1444	if (limits->err)
1445	ret = notif_set_limit(rdev, set, limit: limits->err,
1446	severity: REGULATOR_SEVERITY_ERR);
1447	if (ret)
1448	return ret;
1449
1450	if (limits->warn)
1451	ret = notif_set_limit(rdev, set, limit: limits->warn,
1452	severity: REGULATOR_SEVERITY_WARN);
1453
1454	return ret;
1455	}
1456	/**
1457	* set_machine_constraints - sets regulator constraints
1458	* @rdev: regulator source
1459	*
1460	* Allows platform initialisation code to define and constrain
1461	* regulator circuits e.g. valid voltage/current ranges, etc. NOTE:
1462	* Constraints *must* be set by platform code in order for some
1463	* regulator operations to proceed i.e. set_voltage, set_current_limit,
1464	* set_mode.
1465	*/
1466	static int set_machine_constraints(struct regulator_dev *rdev)
1467	{
1468	int ret = 0;
1469	const struct regulator_ops *ops = rdev->desc->ops;
1470
1471	ret = machine_constraints_voltage(rdev, constraints: rdev->constraints);
1472	if (ret != 0)
1473	return ret;
1474
1475	ret = machine_constraints_current(rdev, constraints: rdev->constraints);
1476	if (ret != 0)
1477	return ret;
1478
1479	if (rdev->constraints->ilim_uA && ops->set_input_current_limit) {
1480	ret = ops->set_input_current_limit(rdev,
1481	rdev->constraints->ilim_uA);
1482	if (ret < 0) {
1483	rdev_err(rdev, "failed to set input limit: %pe\n", ERR_PTR(ret));
1484	return ret;
1485	}
1486	}
1487
1488	/* do we need to setup our suspend state */
1489	if (rdev->constraints->initial_state) {
1490	ret = suspend_set_initial_state(rdev);
1491	if (ret < 0) {
1492	rdev_err(rdev, "failed to set suspend state: %pe\n", ERR_PTR(ret));
1493	return ret;
1494	}
1495	}
1496
1497	if (rdev->constraints->initial_mode) {
1498	if (!ops->set_mode) {
1499	rdev_err(rdev, "no set_mode operation\n");
1500	return -EINVAL;
1501	}
1502
1503	ret = ops->set_mode(rdev, rdev->constraints->initial_mode);
1504	if (ret < 0) {
1505	rdev_err(rdev, "failed to set initial mode: %pe\n", ERR_PTR(ret));
1506	return ret;
1507	}
1508	} else if (rdev->constraints->system_load) {
1509	/*
1510	* We'll only apply the initial system load if an
1511	* initial mode wasn't specified.
1512	*/
1513	drms_uA_update(rdev);
1514	}
1515
1516	if ((rdev->constraints->ramp_delay || rdev->constraints->ramp_disable)
1517	&& ops->set_ramp_delay) {
1518	ret = ops->set_ramp_delay(rdev, rdev->constraints->ramp_delay);
1519	if (ret < 0) {
1520	rdev_err(rdev, "failed to set ramp_delay: %pe\n", ERR_PTR(ret));
1521	return ret;
1522	}
1523	}
1524
1525	if (rdev->constraints->pull_down && ops->set_pull_down) {
1526	ret = ops->set_pull_down(rdev);
1527	if (ret < 0) {
1528	rdev_err(rdev, "failed to set pull down: %pe\n", ERR_PTR(ret));
1529	return ret;
1530	}
1531	}
1532
1533	if (rdev->constraints->soft_start && ops->set_soft_start) {
1534	ret = ops->set_soft_start(rdev);
1535	if (ret < 0) {
1536	rdev_err(rdev, "failed to set soft start: %pe\n", ERR_PTR(ret));
1537	return ret;
1538	}
1539	}
1540
1541	/*
1542	* Existing logic does not warn if over_current_protection is given as
1543	* a constraint but driver does not support that. I think we should
1544	* warn about this type of issues as it is possible someone changes
1545	* PMIC on board to another type - and the another PMIC's driver does
1546	* not support setting protection. Board composer may happily believe
1547	* the DT limits are respected - especially if the new PMIC HW also
1548	* supports protection but the driver does not. I won't change the logic
1549	* without hearing more experienced opinion on this though.
1550	*
1551	* If warning is seen as a good idea then we can merge handling the
1552	* over-curret protection and detection and get rid of this special
1553	* handling.
1554	*/
1555	if (rdev->constraints->over_current_protection
1556	&& ops->set_over_current_protection) {
1557	int lim = rdev->constraints->over_curr_limits.prot;
1558
1559	ret = ops->set_over_current_protection(rdev, lim,
1560	REGULATOR_SEVERITY_PROT,
1561	true);
1562	if (ret < 0) {
1563	rdev_err(rdev, "failed to set over current protection: %pe\n",
1564	ERR_PTR(ret));
1565	return ret;
1566	}
1567	}
1568
1569	if (rdev->constraints->over_current_detection)
1570	ret = handle_notify_limits(rdev,
1571	set: ops->set_over_current_protection,
1572	limits: &rdev->constraints->over_curr_limits);
1573	if (ret) {
1574	if (ret != -EOPNOTSUPP) {
1575	rdev_err(rdev, "failed to set over current limits: %pe\n",
1576	ERR_PTR(ret));
1577	return ret;
1578	}
1579	rdev_warn(rdev,
1580	"IC does not support requested over-current limits\n");
1581	}
1582
1583	if (rdev->constraints->over_voltage_detection)
1584	ret = handle_notify_limits(rdev,
1585	set: ops->set_over_voltage_protection,
1586	limits: &rdev->constraints->over_voltage_limits);
1587	if (ret) {
1588	if (ret != -EOPNOTSUPP) {
1589	rdev_err(rdev, "failed to set over voltage limits %pe\n",
1590	ERR_PTR(ret));
1591	return ret;
1592	}
1593	rdev_warn(rdev,
1594	"IC does not support requested over voltage limits\n");
1595	}
1596
1597	if (rdev->constraints->under_voltage_detection)
1598	ret = handle_notify_limits(rdev,
1599	set: ops->set_under_voltage_protection,
1600	limits: &rdev->constraints->under_voltage_limits);
1601	if (ret) {
1602	if (ret != -EOPNOTSUPP) {
1603	rdev_err(rdev, "failed to set under voltage limits %pe\n",
1604	ERR_PTR(ret));
1605	return ret;
1606	}
1607	rdev_warn(rdev,
1608	"IC does not support requested under voltage limits\n");
1609	}
1610
1611	if (rdev->constraints->over_temp_detection)
1612	ret = handle_notify_limits(rdev,
1613	set: ops->set_thermal_protection,
1614	limits: &rdev->constraints->temp_limits);
1615	if (ret) {
1616	if (ret != -EOPNOTSUPP) {
1617	rdev_err(rdev, "failed to set temperature limits %pe\n",
1618	ERR_PTR(ret));
1619	return ret;
1620	}
1621	rdev_warn(rdev,
1622	"IC does not support requested temperature limits\n");
1623	}
1624
1625	if (rdev->constraints->active_discharge && ops->set_active_discharge) {
1626	bool ad_state = (rdev->constraints->active_discharge ==
1627	REGULATOR_ACTIVE_DISCHARGE_ENABLE) ? true : false;
1628
1629	ret = ops->set_active_discharge(rdev, ad_state);
1630	if (ret < 0) {
1631	rdev_err(rdev, "failed to set active discharge: %pe\n", ERR_PTR(ret));
1632	return ret;
1633	}
1634	}
1635
1636	/*
1637	* If there is no mechanism for controlling the regulator then
1638	* flag it as always_on so we don't end up duplicating checks
1639	* for this so much. Note that we could control the state of
1640	* a supply to control the output on a regulator that has no
1641	* direct control.
1642	*/
1643	if (!rdev->ena_pin && !ops->enable) {
1644	if (rdev->supply_name && !rdev->supply)
1645	return -EPROBE_DEFER;
1646
1647	if (rdev->supply)
1648	rdev->constraints->always_on =
1649	rdev->supply->rdev->constraints->always_on;
1650	else
1651	rdev->constraints->always_on = true;
1652	}
1653
1654	/* If the constraints say the regulator should be on at this point
1655	* and we have control then make sure it is enabled.
1656	*/
1657	if (rdev->constraints->always_on || rdev->constraints->boot_on) {
1658	/* If we want to enable this regulator, make sure that we know
1659	* the supplying regulator.
1660	*/
1661	if (rdev->supply_name && !rdev->supply)
1662	return -EPROBE_DEFER;
1663
1664	/* If supplying regulator has already been enabled,
1665	* it's not intended to have use_count increment
1666	* when rdev is only boot-on.
1667	*/
1668	if (rdev->supply &&
1669	(rdev->constraints->always_on ||
1670	!regulator_is_enabled(regulator: rdev->supply))) {
1671	ret = regulator_enable(regulator: rdev->supply);
1672	if (ret < 0) {
1673	_regulator_put(regulator: rdev->supply);
1674	rdev->supply = NULL;
1675	return ret;
1676	}
1677	}
1678
1679	ret = _regulator_do_enable(rdev);
1680	if (ret < 0 && ret != -EINVAL) {
1681	rdev_err(rdev, "failed to enable: %pe\n", ERR_PTR(ret));
1682	return ret;
1683	}
1684
1685	if (rdev->constraints->always_on)
1686	rdev->use_count++;
1687	} else if (rdev->desc->off_on_delay) {
1688	rdev->last_off = ktime_get();
1689	}
1690
1691	print_constraints(rdev);
1692	return 0;
1693	}
1694
1695	/**
1696	* set_supply - set regulator supply regulator
1697	* @rdev: regulator (locked)
1698	* @supply_rdev: supply regulator (locked))
1699	*
1700	* Called by platform initialisation code to set the supply regulator for this
1701	* regulator. This ensures that a regulators supply will also be enabled by the
1702	* core if it's child is enabled.
1703	*/
1704	static int set_supply(struct regulator_dev *rdev,
1705	struct regulator_dev *supply_rdev)
1706	{
1707	int err;
1708
1709	rdev_dbg(rdev, "supplied by %s\n", rdev_get_name(supply_rdev));
1710
1711	if (!try_module_get(module: supply_rdev->owner))
1712	return -ENODEV;
1713
1714	rdev->supply = create_regulator(rdev: supply_rdev, dev: &rdev->dev, supply_name: "SUPPLY");
1715	if (rdev->supply == NULL) {
1716	module_put(module: supply_rdev->owner);
1717	err = -ENOMEM;
1718	return err;
1719	}
1720	supply_rdev->open_count++;
1721
1722	return 0;
1723	}
1724
1725	/**
1726	* set_consumer_device_supply - Bind a regulator to a symbolic supply
1727	* @rdev: regulator source
1728	* @consumer_dev_name: dev_name() string for device supply applies to
1729	* @supply: symbolic name for supply
1730	*
1731	* Allows platform initialisation code to map physical regulator
1732	* sources to symbolic names for supplies for use by devices. Devices
1733	* should use these symbolic names to request regulators, avoiding the
1734	* need to provide board-specific regulator names as platform data.
1735	*/
1736	static int set_consumer_device_supply(struct regulator_dev *rdev,
1737	const char *consumer_dev_name,
1738	const char *supply)
1739	{
1740	struct regulator_map *node, *new_node;
1741	int has_dev;
1742
1743	if (supply == NULL)
1744	return -EINVAL;
1745
1746	if (consumer_dev_name != NULL)
1747	has_dev = 1;
1748	else
1749	has_dev = 0;
1750
1751	new_node = kzalloc(size: sizeof(struct regulator_map), GFP_KERNEL);
1752	if (new_node == NULL)
1753	return -ENOMEM;
1754
1755	new_node->regulator = rdev;
1756	new_node->supply = supply;
1757
1758	if (has_dev) {
1759	new_node->dev_name = kstrdup(s: consumer_dev_name, GFP_KERNEL);
1760	if (new_node->dev_name == NULL) {
1761	kfree(objp: new_node);
1762	return -ENOMEM;
1763	}
1764	}
1765
1766	mutex_lock(&regulator_list_mutex);
1767	list_for_each_entry(node, &regulator_map_list, list) {
1768	if (node->dev_name && consumer_dev_name) {
1769	if (strcmp(node->dev_name, consumer_dev_name) != 0)
1770	continue;
1771	} else if (node->dev_name || consumer_dev_name) {
1772	continue;
1773	}
1774
1775	if (strcmp(node->supply, supply) != 0)
1776	continue;
1777
1778	pr_debug("%s: %s/%s is '%s' supply; fail %s/%s\n",
1779	consumer_dev_name,
1780	dev_name(&node->regulator->dev),
1781	node->regulator->desc->name,
1782	supply,
1783	dev_name(&rdev->dev), rdev_get_name(rdev));
1784	goto fail;
1785	}
1786
1787	list_add(new: &new_node->list, head: &regulator_map_list);
1788	mutex_unlock(lock: &regulator_list_mutex);
1789
1790	return 0;
1791
1792	fail:
1793	mutex_unlock(lock: &regulator_list_mutex);
1794	kfree(objp: new_node->dev_name);
1795	kfree(objp: new_node);
1796	return -EBUSY;
1797	}
1798
1799	static void unset_regulator_supplies(struct regulator_dev *rdev)
1800	{
1801	struct regulator_map *node, *n;
1802
1803	list_for_each_entry_safe(node, n, &regulator_map_list, list) {
1804	if (rdev == node->regulator) {
1805	list_del(entry: &node->list);
1806	kfree(objp: node->dev_name);
1807	kfree(objp: node);
1808	}
1809	}
1810	}
1811
1812	#ifdef CONFIG_DEBUG_FS
1813	static ssize_t constraint_flags_read_file(struct file *file,
1814	char __user *user_buf,
1815	size_t count, loff_t *ppos)
1816	{
1817	const struct regulator *regulator = file->private_data;
1818	const struct regulation_constraints *c = regulator->rdev->constraints;
1819	char *buf;
1820	ssize_t ret;
1821
1822	if (!c)
1823	return 0;
1824
1825	buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
1826	if (!buf)
1827	return -ENOMEM;
1828
1829	ret = snprintf(buf, PAGE_SIZE,
1830	fmt: "always_on: %u\n"
1831	"boot_on: %u\n"
1832	"apply_uV: %u\n"
1833	"ramp_disable: %u\n"
1834	"soft_start: %u\n"
1835	"pull_down: %u\n"
1836	"over_current_protection: %u\n",
1837	c->always_on,
1838	c->boot_on,
1839	c->apply_uV,
1840	c->ramp_disable,
1841	c->soft_start,
1842	c->pull_down,
1843	c->over_current_protection);
1844
1845	ret = simple_read_from_buffer(to: user_buf, count, ppos, from: buf, available: ret);
1846	kfree(objp: buf);
1847
1848	return ret;
1849	}
1850
1851	#endif
1852
1853	static const struct file_operations constraint_flags_fops = {
1854	#ifdef CONFIG_DEBUG_FS
1855	.open = simple_open,
1856	.read = constraint_flags_read_file,
1857	.llseek = default_llseek,
1858	#endif
1859	};
1860
1861	#define REG_STR_SIZE 64
1862
1863	static struct regulator *create_regulator(struct regulator_dev *rdev,
1864	struct device *dev,
1865	const char *supply_name)
1866	{
1867	struct regulator *regulator;
1868	int err = 0;
1869
1870	lockdep_assert_held_once(&rdev->mutex.base);
1871
1872	if (dev) {
1873	char buf[REG_STR_SIZE];
1874	int size;
1875
1876	size = snprintf(buf, REG_STR_SIZE, fmt: "%s-%s",
1877	dev->kobj.name, supply_name);
1878	if (size >= REG_STR_SIZE)
1879	return NULL;
1880
1881	supply_name = kstrdup(s: buf, GFP_KERNEL);
1882	if (supply_name == NULL)
1883	return NULL;
1884	} else {
1885	supply_name = kstrdup_const(s: supply_name, GFP_KERNEL);
1886	if (supply_name == NULL)
1887	return NULL;
1888	}
1889
1890	regulator = kzalloc(size: sizeof(*regulator), GFP_KERNEL);
1891	if (regulator == NULL) {
1892	kfree_const(x: supply_name);
1893	return NULL;
1894	}
1895
1896	regulator->rdev = rdev;
1897	regulator->supply_name = supply_name;
1898
1899	list_add(new: &regulator->list, head: &rdev->consumer_list);
1900
1901	if (dev) {
1902	regulator->dev = dev;
1903
1904	/* Add a link to the device sysfs entry */
1905	err = sysfs_create_link_nowarn(kobj: &rdev->dev.kobj, target: &dev->kobj,
1906	name: supply_name);
1907	if (err) {
1908	rdev_dbg(rdev, "could not add device link %s: %pe\n",
1909	dev->kobj.name, ERR_PTR(err));
1910	/* non-fatal */
1911	}
1912	}
1913
1914	if (err != -EEXIST)
1915	regulator->debugfs = debugfs_create_dir(name: supply_name, parent: rdev->debugfs);
1916	if (IS_ERR(ptr: regulator->debugfs))
1917	rdev_dbg(rdev, "Failed to create debugfs directory\n");
1918
1919	debugfs_create_u32(name: "uA_load", mode: 0444, parent: regulator->debugfs,
1920	value: &regulator->uA_load);
1921	debugfs_create_u32(name: "min_uV", mode: 0444, parent: regulator->debugfs,
1922	value: &regulator->voltage[PM_SUSPEND_ON].min_uV);
1923	debugfs_create_u32(name: "max_uV", mode: 0444, parent: regulator->debugfs,
1924	value: &regulator->voltage[PM_SUSPEND_ON].max_uV);
1925	debugfs_create_file(name: "constraint_flags", mode: 0444, parent: regulator->debugfs,
1926	data: regulator, fops: &constraint_flags_fops);
1927
1928	/*
1929	* Check now if the regulator is an always on regulator - if
1930	* it is then we don't need to do nearly so much work for
1931	* enable/disable calls.
1932	*/
1933	if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_STATUS) &&
1934	_regulator_is_enabled(rdev))
1935	regulator->always_on = true;
1936
1937	return regulator;
1938	}
1939
1940	static int _regulator_get_enable_time(struct regulator_dev *rdev)
1941	{
1942	if (rdev->constraints && rdev->constraints->enable_time)
1943	return rdev->constraints->enable_time;
1944	if (rdev->desc->ops->enable_time)
1945	return rdev->desc->ops->enable_time(rdev);
1946	return rdev->desc->enable_time;
1947	}
1948
1949	static struct regulator_supply_alias *regulator_find_supply_alias(
1950	struct device *dev, const char *supply)
1951	{
1952	struct regulator_supply_alias *map;
1953
1954	list_for_each_entry(map, &regulator_supply_alias_list, list)
1955	if (map->src_dev == dev && strcmp(map->src_supply, supply) == 0)
1956	return map;
1957
1958	return NULL;
1959	}
1960
1961	static void regulator_supply_alias(struct device **dev, const char **supply)
1962	{
1963	struct regulator_supply_alias *map;
1964
1965	map = regulator_find_supply_alias(dev: *dev, supply: *supply);
1966	if (map) {
1967	dev_dbg(*dev, "Mapping supply %s to %s,%s\n",
1968	*supply, map->alias_supply,
1969	dev_name(map->alias_dev));
1970	*dev = map->alias_dev;
1971	*supply = map->alias_supply;
1972	}
1973	}
1974
1975	static int regulator_match(struct device *dev, const void *data)
1976	{
1977	struct regulator_dev *r = dev_to_rdev(dev);
1978
1979	return strcmp(rdev_get_name(r), data) == 0;
1980	}
1981
1982	static struct regulator_dev *regulator_lookup_by_name(const char *name)
1983	{
1984	struct device *dev;
1985
1986	dev = class_find_device(class: &regulator_class, NULL, data: name, match: regulator_match);
1987
1988	return dev ? dev_to_rdev(dev) : NULL;
1989	}
1990
1991	/**
1992	* regulator_dev_lookup - lookup a regulator device.
1993	* @dev: device for regulator "consumer".
1994	* @supply: Supply name or regulator ID.
1995	*
1996	* If successful, returns a struct regulator_dev that corresponds to the name
1997	* @supply and with the embedded struct device refcount incremented by one.
1998	* The refcount must be dropped by calling put_device().
1999	* On failure one of the following ERR-PTR-encoded values is returned:
2000	* -ENODEV if lookup fails permanently, -EPROBE_DEFER if lookup could succeed
2001	* in the future.
2002	*/
2003	static struct regulator_dev *regulator_dev_lookup(struct device *dev,
2004	const char *supply)
2005	{
2006	struct regulator_dev *r = NULL;
2007	struct device_node *node;
2008	struct regulator_map *map;
2009	const char *devname = NULL;
2010
2011	regulator_supply_alias(dev: &dev, supply: &supply);
2012
2013	/* first do a dt based lookup */
2014	if (dev && dev->of_node) {
2015	node = of_get_regulator(dev, supply);
2016	if (node) {
2017	r = of_find_regulator_by_node(np: node);
2018	of_node_put(node);
2019	if (r)
2020	return r;
2021
2022	/*
2023	* We have a node, but there is no device.
2024	* assume it has not registered yet.
2025	*/
2026	return ERR_PTR(error: -EPROBE_DEFER);
2027	}
2028	}
2029
2030	/* if not found, try doing it non-dt way */
2031	if (dev)
2032	devname = dev_name(dev);
2033
2034	mutex_lock(&regulator_list_mutex);
2035	list_for_each_entry(map, &regulator_map_list, list) {
2036	/* If the mapping has a device set up it must match */
2037	if (map->dev_name &&
2038	(!devname || strcmp(map->dev_name, devname)))
2039	continue;
2040
2041	if (strcmp(map->supply, supply) == 0 &&
2042	get_device(dev: &map->regulator->dev)) {
2043	r = map->regulator;
2044	break;
2045	}
2046	}
2047	mutex_unlock(lock: &regulator_list_mutex);
2048
2049	if (r)
2050	return r;
2051
2052	r = regulator_lookup_by_name(name: supply);
2053	if (r)
2054	return r;
2055
2056	return ERR_PTR(error: -ENODEV);
2057	}
2058
2059	static int regulator_resolve_supply(struct regulator_dev *rdev)
2060	{
2061	struct regulator_dev *r;
2062	struct device *dev = rdev->dev.parent;
2063	struct ww_acquire_ctx ww_ctx;
2064	int ret = 0;
2065
2066	/* No supply to resolve? */
2067	if (!rdev->supply_name)
2068	return 0;
2069
2070	/* Supply already resolved? (fast-path without locking contention) */
2071	if (rdev->supply)
2072	return 0;
2073
2074	r = regulator_dev_lookup(dev, supply: rdev->supply_name);
2075	if (IS_ERR(ptr: r)) {
2076	ret = PTR_ERR(ptr: r);
2077
2078	/* Did the lookup explicitly defer for us? */
2079	if (ret == -EPROBE_DEFER)
2080	goto out;
2081
2082	if (have_full_constraints()) {
2083	r = dummy_regulator_rdev;
2084	get_device(dev: &r->dev);
2085	} else {
2086	dev_err(dev, "Failed to resolve %s-supply for %s\n",
2087	rdev->supply_name, rdev->desc->name);
2088	ret = -EPROBE_DEFER;
2089	goto out;
2090	}
2091	}
2092
2093	if (r == rdev) {
2094	dev_err(dev, "Supply for %s (%s) resolved to itself\n",
2095	rdev->desc->name, rdev->supply_name);
2096	if (!have_full_constraints()) {
2097	ret = -EINVAL;
2098	goto out;
2099	}
2100	r = dummy_regulator_rdev;
2101	get_device(dev: &r->dev);
2102	}
2103
2104	/*
2105	* If the supply's parent device is not the same as the
2106	* regulator's parent device, then ensure the parent device
2107	* is bound before we resolve the supply, in case the parent
2108	* device get probe deferred and unregisters the supply.
2109	*/
2110	if (r->dev.parent && r->dev.parent != rdev->dev.parent) {
2111	if (!device_is_bound(dev: r->dev.parent)) {
2112	put_device(dev: &r->dev);
2113	ret = -EPROBE_DEFER;
2114	goto out;
2115	}
2116	}
2117
2118	/* Recursively resolve the supply of the supply */
2119	ret = regulator_resolve_supply(rdev: r);
2120	if (ret < 0) {
2121	put_device(dev: &r->dev);
2122	goto out;
2123	}
2124
2125	/*
2126	* Recheck rdev->supply with rdev->mutex lock held to avoid a race
2127	* between rdev->supply null check and setting rdev->supply in
2128	* set_supply() from concurrent tasks.
2129	*/
2130	regulator_lock_two(rdev1: rdev, rdev2: r, ww_ctx: &ww_ctx);
2131
2132	/* Supply just resolved by a concurrent task? */
2133	if (rdev->supply) {
2134	regulator_unlock_two(rdev1: rdev, rdev2: r, ww_ctx: &ww_ctx);
2135	put_device(dev: &r->dev);
2136	goto out;
2137	}
2138
2139	ret = set_supply(rdev, supply_rdev: r);
2140	if (ret < 0) {
2141	regulator_unlock_two(rdev1: rdev, rdev2: r, ww_ctx: &ww_ctx);
2142	put_device(dev: &r->dev);
2143	goto out;
2144	}
2145
2146	regulator_unlock_two(rdev1: rdev, rdev2: r, ww_ctx: &ww_ctx);
2147
2148	/*
2149	* In set_machine_constraints() we may have turned this regulator on
2150	* but we couldn't propagate to the supply if it hadn't been resolved
2151	* yet. Do it now.
2152	*/
2153	if (rdev->use_count) {
2154	ret = regulator_enable(regulator: rdev->supply);
2155	if (ret < 0) {
2156	_regulator_put(regulator: rdev->supply);
2157	rdev->supply = NULL;
2158	goto out;
2159	}
2160	}
2161
2162	out:
2163	return ret;
2164	}
2165
2166	/* Internal regulator request function */
2167	struct regulator *_regulator_get(struct device *dev, const char *id,
2168	enum regulator_get_type get_type)
2169	{
2170	struct regulator_dev *rdev;
2171	struct regulator *regulator;
2172	struct device_link *link;
2173	int ret;
2174
2175	if (get_type >= MAX_GET_TYPE) {
2176	dev_err(dev, "invalid type %d in %s\n", get_type, __func__);
2177	return ERR_PTR(error: -EINVAL);
2178	}
2179
2180	if (id == NULL) {
2181	pr_err("get() with no identifier\n");
2182	return ERR_PTR(error: -EINVAL);
2183	}
2184
2185	rdev = regulator_dev_lookup(dev, supply: id);
2186	if (IS_ERR(ptr: rdev)) {
2187	ret = PTR_ERR(ptr: rdev);
2188
2189	/*
2190	* If regulator_dev_lookup() fails with error other
2191	* than -ENODEV our job here is done, we simply return it.
2192	*/
2193	if (ret != -ENODEV)
2194	return ERR_PTR(error: ret);
2195
2196	if (!have_full_constraints()) {
2197	dev_warn(dev,
2198	"incomplete constraints, dummy supplies not allowed\n");
2199	return ERR_PTR(error: -ENODEV);
2200	}
2201
2202	switch (get_type) {
2203	case NORMAL_GET:
2204	/*
2205	* Assume that a regulator is physically present and
2206	* enabled, even if it isn't hooked up, and just
2207	* provide a dummy.
2208	*/
2209	dev_warn(dev, "supply %s not found, using dummy regulator\n", id);
2210	rdev = dummy_regulator_rdev;
2211	get_device(dev: &rdev->dev);
2212	break;
2213
2214	case EXCLUSIVE_GET:
2215	dev_warn(dev,
2216	"dummy supplies not allowed for exclusive requests\n");
2217	fallthrough;
2218
2219	default:
2220	return ERR_PTR(error: -ENODEV);
2221	}
2222	}
2223
2224	if (rdev->exclusive) {
2225	regulator = ERR_PTR(error: -EPERM);
2226	put_device(dev: &rdev->dev);
2227	return regulator;
2228	}
2229
2230	if (get_type == EXCLUSIVE_GET && rdev->open_count) {
2231	regulator = ERR_PTR(error: -EBUSY);
2232	put_device(dev: &rdev->dev);
2233	return regulator;
2234	}
2235
2236	mutex_lock(&regulator_list_mutex);
2237	ret = (rdev->coupling_desc.n_resolved != rdev->coupling_desc.n_coupled);
2238	mutex_unlock(lock: &regulator_list_mutex);
2239
2240	if (ret != 0) {
2241	regulator = ERR_PTR(error: -EPROBE_DEFER);
2242	put_device(dev: &rdev->dev);
2243	return regulator;
2244	}
2245
2246	ret = regulator_resolve_supply(rdev);
2247	if (ret < 0) {
2248	regulator = ERR_PTR(error: ret);
2249	put_device(dev: &rdev->dev);
2250	return regulator;
2251	}
2252
2253	if (!try_module_get(module: rdev->owner)) {
2254	regulator = ERR_PTR(error: -EPROBE_DEFER);
2255	put_device(dev: &rdev->dev);
2256	return regulator;
2257	}
2258
2259	regulator_lock(rdev);
2260	regulator = create_regulator(rdev, dev, supply_name: id);
2261	regulator_unlock(rdev);
2262	if (regulator == NULL) {
2263	regulator = ERR_PTR(error: -ENOMEM);
2264	module_put(module: rdev->owner);
2265	put_device(dev: &rdev->dev);
2266	return regulator;
2267	}
2268
2269	rdev->open_count++;
2270	if (get_type == EXCLUSIVE_GET) {
2271	rdev->exclusive = 1;
2272
2273	ret = _regulator_is_enabled(rdev);
2274	if (ret > 0) {
2275	rdev->use_count = 1;
2276	regulator->enable_count = 1;
2277
2278	/* Propagate the regulator state to its supply */
2279	if (rdev->supply) {
2280	ret = regulator_enable(regulator: rdev->supply);
2281	if (ret < 0) {
2282	destroy_regulator(regulator);
2283	module_put(module: rdev->owner);
2284	put_device(dev: &rdev->dev);
2285	return ERR_PTR(error: ret);
2286	}
2287	}
2288	} else {
2289	rdev->use_count = 0;
2290	regulator->enable_count = 0;
2291	}
2292	}
2293
2294	link = device_link_add(consumer: dev, supplier: &rdev->dev, DL_FLAG_STATELESS);
2295	if (!IS_ERR_OR_NULL(ptr: link))
2296	regulator->device_link = true;
2297
2298	return regulator;
2299	}
2300
2301	/**
2302	* regulator_get - lookup and obtain a reference to a regulator.
2303	* @dev: device for regulator "consumer"
2304	* @id: Supply name or regulator ID.
2305	*
2306	* Returns a struct regulator corresponding to the regulator producer,
2307	* or IS_ERR() condition containing errno.
2308	*
2309	* Use of supply names configured via set_consumer_device_supply() is
2310	* strongly encouraged. It is recommended that the supply name used
2311	* should match the name used for the supply and/or the relevant
2312	* device pins in the datasheet.
2313	*/
2314	struct regulator *regulator_get(struct device *dev, const char *id)
2315	{
2316	return _regulator_get(dev, id, get_type: NORMAL_GET);
2317	}
2318	EXPORT_SYMBOL_GPL(regulator_get);
2319
2320	/**
2321	* regulator_get_exclusive - obtain exclusive access to a regulator.
2322	* @dev: device for regulator "consumer"
2323	* @id: Supply name or regulator ID.
2324	*
2325	* Returns a struct regulator corresponding to the regulator producer,
2326	* or IS_ERR() condition containing errno. Other consumers will be
2327	* unable to obtain this regulator while this reference is held and the
2328	* use count for the regulator will be initialised to reflect the current
2329	* state of the regulator.
2330	*
2331	* This is intended for use by consumers which cannot tolerate shared
2332	* use of the regulator such as those which need to force the
2333	* regulator off for correct operation of the hardware they are
2334	* controlling.
2335	*
2336	* Use of supply names configured via set_consumer_device_supply() is
2337	* strongly encouraged. It is recommended that the supply name used
2338	* should match the name used for the supply and/or the relevant
2339	* device pins in the datasheet.
2340	*/
2341	struct regulator *regulator_get_exclusive(struct device *dev, const char *id)
2342	{
2343	return _regulator_get(dev, id, get_type: EXCLUSIVE_GET);
2344	}
2345	EXPORT_SYMBOL_GPL(regulator_get_exclusive);
2346
2347	/**
2348	* regulator_get_optional - obtain optional access to a regulator.
2349	* @dev: device for regulator "consumer"
2350	* @id: Supply name or regulator ID.
2351	*
2352	* Returns a struct regulator corresponding to the regulator producer,
2353	* or IS_ERR() condition containing errno.
2354	*
2355	* This is intended for use by consumers for devices which can have
2356	* some supplies unconnected in normal use, such as some MMC devices.
2357	* It can allow the regulator core to provide stub supplies for other
2358	* supplies requested using normal regulator_get() calls without
2359	* disrupting the operation of drivers that can handle absent
2360	* supplies.
2361	*
2362	* Use of supply names configured via set_consumer_device_supply() is
2363	* strongly encouraged. It is recommended that the supply name used
2364	* should match the name used for the supply and/or the relevant
2365	* device pins in the datasheet.
2366	*/
2367	struct regulator *regulator_get_optional(struct device *dev, const char *id)
2368	{
2369	return _regulator_get(dev, id, get_type: OPTIONAL_GET);
2370	}
2371	EXPORT_SYMBOL_GPL(regulator_get_optional);
2372
2373	static void destroy_regulator(struct regulator *regulator)
2374	{
2375	struct regulator_dev *rdev = regulator->rdev;
2376
2377	debugfs_remove_recursive(dentry: regulator->debugfs);
2378
2379	if (regulator->dev) {
2380	if (regulator->device_link)
2381	device_link_remove(consumer: regulator->dev, supplier: &rdev->dev);
2382
2383	/* remove any sysfs entries */
2384	sysfs_remove_link(kobj: &rdev->dev.kobj, name: regulator->supply_name);
2385	}
2386
2387	regulator_lock(rdev);
2388	list_del(entry: &regulator->list);
2389
2390	rdev->open_count--;
2391	rdev->exclusive = 0;
2392	regulator_unlock(rdev);
2393
2394	kfree_const(x: regulator->supply_name);
2395	kfree(objp: regulator);
2396	}
2397
2398	/* regulator_list_mutex lock held by regulator_put() */
2399	static void _regulator_put(struct regulator *regulator)
2400	{
2401	struct regulator_dev *rdev;
2402
2403	if (IS_ERR_OR_NULL(ptr: regulator))
2404	return;
2405
2406	lockdep_assert_held_once(&regulator_list_mutex);
2407
2408	/* Docs say you must disable before calling regulator_put() */
2409	WARN_ON(regulator->enable_count);
2410
2411	rdev = regulator->rdev;
2412
2413	destroy_regulator(regulator);
2414
2415	module_put(module: rdev->owner);
2416	put_device(dev: &rdev->dev);
2417	}
2418
2419	/**
2420	* regulator_put - "free" the regulator source
2421	* @regulator: regulator source
2422	*
2423	* Note: drivers must ensure that all regulator_enable calls made on this
2424	* regulator source are balanced by regulator_disable calls prior to calling
2425	* this function.
2426	*/
2427	void regulator_put(struct regulator *regulator)
2428	{
2429	mutex_lock(&regulator_list_mutex);
2430	_regulator_put(regulator);
2431	mutex_unlock(lock: &regulator_list_mutex);
2432	}
2433	EXPORT_SYMBOL_GPL(regulator_put);
2434
2435	/**
2436	* regulator_register_supply_alias - Provide device alias for supply lookup
2437	*
2438	* @dev: device that will be given as the regulator "consumer"
2439	* @id: Supply name or regulator ID
2440	* @alias_dev: device that should be used to lookup the supply
2441	* @alias_id: Supply name or regulator ID that should be used to lookup the
2442	* supply
2443	*
2444	* All lookups for id on dev will instead be conducted for alias_id on
2445	* alias_dev.
2446	*/
2447	int regulator_register_supply_alias(struct device *dev, const char *id,
2448	struct device *alias_dev,
2449	const char *alias_id)
2450	{
2451	struct regulator_supply_alias *map;
2452
2453	map = regulator_find_supply_alias(dev, supply: id);
2454	if (map)
2455	return -EEXIST;
2456
2457	map = kzalloc(size: sizeof(struct regulator_supply_alias), GFP_KERNEL);
2458	if (!map)
2459	return -ENOMEM;
2460
2461	map->src_dev = dev;
2462	map->src_supply = id;
2463	map->alias_dev = alias_dev;
2464	map->alias_supply = alias_id;
2465
2466	list_add(new: &map->list, head: &regulator_supply_alias_list);
2467
2468	pr_info("Adding alias for supply %s,%s -> %s,%s\n",
2469	id, dev_name(dev), alias_id, dev_name(alias_dev));
2470
2471	return 0;
2472	}
2473	EXPORT_SYMBOL_GPL(regulator_register_supply_alias);
2474
2475	/**
2476	* regulator_unregister_supply_alias - Remove device alias
2477	*
2478	* @dev: device that will be given as the regulator "consumer"
2479	* @id: Supply name or regulator ID
2480	*
2481	* Remove a lookup alias if one exists for id on dev.
2482	*/
2483	void regulator_unregister_supply_alias(struct device *dev, const char *id)
2484	{
2485	struct regulator_supply_alias *map;
2486
2487	map = regulator_find_supply_alias(dev, supply: id);
2488	if (map) {
2489	list_del(entry: &map->list);
2490	kfree(objp: map);
2491	}
2492	}
2493	EXPORT_SYMBOL_GPL(regulator_unregister_supply_alias);
2494
2495	/**
2496	* regulator_bulk_register_supply_alias - register multiple aliases
2497	*
2498	* @dev: device that will be given as the regulator "consumer"
2499	* @id: List of supply names or regulator IDs
2500	* @alias_dev: device that should be used to lookup the supply
2501	* @alias_id: List of supply names or regulator IDs that should be used to
2502	* lookup the supply
2503	* @num_id: Number of aliases to register
2504	*
2505	* @return 0 on success, an errno on failure.
2506	*
2507	* This helper function allows drivers to register several supply
2508	* aliases in one operation. If any of the aliases cannot be
2509	* registered any aliases that were registered will be removed
2510	* before returning to the caller.
2511	*/
2512	int regulator_bulk_register_supply_alias(struct device *dev,
2513	const char *const *id,
2514	struct device *alias_dev,
2515	const char *const *alias_id,
2516	int num_id)
2517	{
2518	int i;
2519	int ret;
2520
2521	for (i = 0; i < num_id; ++i) {
2522	ret = regulator_register_supply_alias(dev, id[i], alias_dev,
2523	alias_id[i]);
2524	if (ret < 0)
2525	goto err;
2526	}
2527
2528	return 0;
2529
2530	err:
2531	dev_err(dev,
2532	"Failed to create supply alias %s,%s -> %s,%s\n",
2533	id[i], dev_name(dev), alias_id[i], dev_name(alias_dev));
2534
2535	while (--i >= 0)
2536	regulator_unregister_supply_alias(dev, id[i]);
2537
2538	return ret;
2539	}
2540	EXPORT_SYMBOL_GPL(regulator_bulk_register_supply_alias);
2541
2542	/**
2543	* regulator_bulk_unregister_supply_alias - unregister multiple aliases
2544	*
2545	* @dev: device that will be given as the regulator "consumer"
2546	* @id: List of supply names or regulator IDs
2547	* @num_id: Number of aliases to unregister
2548	*
2549	* This helper function allows drivers to unregister several supply
2550	* aliases in one operation.
2551	*/
2552	void regulator_bulk_unregister_supply_alias(struct device *dev,
2553	const char *const *id,
2554	int num_id)
2555	{
2556	int i;
2557
2558	for (i = 0; i < num_id; ++i)
2559	regulator_unregister_supply_alias(dev, id[i]);
2560	}
2561	EXPORT_SYMBOL_GPL(regulator_bulk_unregister_supply_alias);
2562
2563
2564	/* Manage enable GPIO list. Same GPIO pin can be shared among regulators */
2565	static int regulator_ena_gpio_request(struct regulator_dev *rdev,
2566	const struct regulator_config *config)
2567	{
2568	struct regulator_enable_gpio *pin, *new_pin;
2569	struct gpio_desc *gpiod;
2570
2571	gpiod = config->ena_gpiod;
2572	new_pin = kzalloc(size: sizeof(*new_pin), GFP_KERNEL);
2573
2574	mutex_lock(&regulator_list_mutex);
2575
2576	list_for_each_entry(pin, &regulator_ena_gpio_list, list) {
2577	if (pin->gpiod == gpiod) {
2578	rdev_dbg(rdev, "GPIO is already used\n");
2579	goto update_ena_gpio_to_rdev;
2580	}
2581	}
2582
2583	if (new_pin == NULL) {
2584	mutex_unlock(lock: &regulator_list_mutex);
2585	return -ENOMEM;
2586	}
2587
2588	pin = new_pin;
2589	new_pin = NULL;
2590
2591	pin->gpiod = gpiod;
2592	list_add(new: &pin->list, head: &regulator_ena_gpio_list);
2593
2594	update_ena_gpio_to_rdev:
2595	pin->request_count++;
2596	rdev->ena_pin = pin;
2597
2598	mutex_unlock(lock: &regulator_list_mutex);
2599	kfree(objp: new_pin);
2600
2601	return 0;
2602	}
2603
2604	static void regulator_ena_gpio_free(struct regulator_dev *rdev)
2605	{
2606	struct regulator_enable_gpio *pin, *n;
2607
2608	if (!rdev->ena_pin)
2609	return;
2610
2611	/* Free the GPIO only in case of no use */
2612	list_for_each_entry_safe(pin, n, &regulator_ena_gpio_list, list) {
2613	if (pin != rdev->ena_pin)
2614	continue;
2615
2616	if (--pin->request_count)
2617	break;
2618
2619	gpiod_put(desc: pin->gpiod);
2620	list_del(entry: &pin->list);
2621	kfree(objp: pin);
2622	break;
2623	}
2624
2625	rdev->ena_pin = NULL;
2626	}
2627
2628	/**
2629	* regulator_ena_gpio_ctrl - balance enable_count of each GPIO and actual GPIO pin control
2630	* @rdev: regulator_dev structure
2631	* @enable: enable GPIO at initial use?
2632	*
2633	* GPIO is enabled in case of initial use. (enable_count is 0)
2634	* GPIO is disabled when it is not shared any more. (enable_count <= 1)
2635	*/
2636	static int regulator_ena_gpio_ctrl(struct regulator_dev *rdev, bool enable)
2637	{
2638	struct regulator_enable_gpio *pin = rdev->ena_pin;
2639
2640	if (!pin)
2641	return -EINVAL;
2642
2643	if (enable) {
2644	/* Enable GPIO at initial use */
2645	if (pin->enable_count == 0)
2646	gpiod_set_value_cansleep(desc: pin->gpiod, value: 1);
2647
2648	pin->enable_count++;
2649	} else {
2650	if (pin->enable_count > 1) {
2651	pin->enable_count--;
2652	return 0;
2653	}
2654
2655	/* Disable GPIO if not used */
2656	if (pin->enable_count <= 1) {
2657	gpiod_set_value_cansleep(desc: pin->gpiod, value: 0);
2658	pin->enable_count = 0;
2659	}
2660	}
2661
2662	return 0;
2663	}
2664
2665	/**
2666	* _regulator_delay_helper - a delay helper function
2667	* @delay: time to delay in microseconds
2668	*
2669	* Delay for the requested amount of time as per the guidelines in:
2670	*
2671	* Documentation/timers/timers-howto.rst
2672	*
2673	* The assumption here is that these regulator operations will never used in
2674	* atomic context and therefore sleeping functions can be used.
2675	*/
2676	static void _regulator_delay_helper(unsigned int delay)
2677	{
2678	unsigned int ms = delay / 1000;
2679	unsigned int us = delay % 1000;
2680
2681	if (ms > 0) {
2682	/*
2683	* For small enough values, handle super-millisecond
2684	* delays in the usleep_range() call below.
2685	*/
2686	if (ms < 20)
2687	us += ms * 1000;
2688	else
2689	msleep(msecs: ms);
2690	}
2691
2692	/*
2693	* Give the scheduler some room to coalesce with any other
2694	* wakeup sources. For delays shorter than 10 us, don't even
2695	* bother setting up high-resolution timers and just busy-
2696	* loop.
2697	*/
2698	if (us >= 10)
2699	usleep_range(min: us, max: us + 100);
2700	else
2701	udelay(us);
2702	}
2703
2704	/**
2705	* _regulator_check_status_enabled
2706	*
2707	* A helper function to check if the regulator status can be interpreted
2708	* as 'regulator is enabled'.
2709	* @rdev: the regulator device to check
2710	*
2711	* Return:
2712	* * 1 - if status shows regulator is in enabled state
2713	* * 0 - if not enabled state
2714	* * Error Value - as received from ops->get_status()
2715	*/
2716	static inline int _regulator_check_status_enabled(struct regulator_dev *rdev)
2717	{
2718	int ret = rdev->desc->ops->get_status(rdev);
2719
2720	if (ret < 0) {
2721	rdev_info(rdev, "get_status returned error: %d\n", ret);
2722	return ret;
2723	}
2724
2725	switch (ret) {
2726	case REGULATOR_STATUS_OFF:
2727	case REGULATOR_STATUS_ERROR:
2728	case REGULATOR_STATUS_UNDEFINED:
2729	return 0;
2730	default:
2731	return 1;
2732	}
2733	}
2734
2735	static int _regulator_do_enable(struct regulator_dev *rdev)
2736	{
2737	int ret, delay;
2738
2739	/* Query before enabling in case configuration dependent. */
2740	ret = _regulator_get_enable_time(rdev);
2741	if (ret >= 0) {
2742	delay = ret;
2743	} else {
2744	rdev_warn(rdev, "enable_time() failed: %pe\n", ERR_PTR(ret));
2745	delay = 0;
2746	}
2747
2748	trace_regulator_enable(name: rdev_get_name(rdev));
2749
2750	if (rdev->desc->off_on_delay) {
2751	/* if needed, keep a distance of off_on_delay from last time
2752	* this regulator was disabled.
2753	*/
2754	ktime_t end = ktime_add_us(kt: rdev->last_off, usec: rdev->desc->off_on_delay);
2755	s64 remaining = ktime_us_delta(later: end, earlier: ktime_get_boottime());
2756
2757	if (remaining > 0)
2758	_regulator_delay_helper(delay: remaining);
2759	}
2760
2761	if (rdev->ena_pin) {
2762	if (!rdev->ena_gpio_state) {
2763	ret = regulator_ena_gpio_ctrl(rdev, enable: true);
2764	if (ret < 0)
2765	return ret;
2766	rdev->ena_gpio_state = 1;
2767	}
2768	} else if (rdev->desc->ops->enable) {
2769	ret = rdev->desc->ops->enable(rdev);
2770	if (ret < 0)
2771	return ret;
2772	} else {
2773	return -EINVAL;
2774	}
2775
2776	/* Allow the regulator to ramp; it would be useful to extend
2777	* this for bulk operations so that the regulators can ramp
2778	* together.
2779	*/
2780	trace_regulator_enable_delay(name: rdev_get_name(rdev));
2781
2782	/* If poll_enabled_time is set, poll upto the delay calculated
2783	* above, delaying poll_enabled_time uS to check if the regulator
2784	* actually got enabled.
2785	* If the regulator isn't enabled after our delay helper has expired,
2786	* return -ETIMEDOUT.
2787	*/
2788	if (rdev->desc->poll_enabled_time) {
2789	int time_remaining = delay;
2790
2791	while (time_remaining > 0) {
2792	_regulator_delay_helper(delay: rdev->desc->poll_enabled_time);
2793
2794	if (rdev->desc->ops->get_status) {
2795	ret = _regulator_check_status_enabled(rdev);
2796	if (ret < 0)
2797	return ret;
2798	else if (ret)
2799	break;
2800	} else if (rdev->desc->ops->is_enabled(rdev))
2801	break;
2802
2803	time_remaining -= rdev->desc->poll_enabled_time;
2804	}
2805
2806	if (time_remaining <= 0) {
2807	rdev_err(rdev, "Enabled check timed out\n");
2808	return -ETIMEDOUT;
2809	}
2810	} else {
2811	_regulator_delay_helper(delay);
2812	}
2813
2814	trace_regulator_enable_complete(name: rdev_get_name(rdev));
2815
2816	return 0;
2817	}
2818
2819	/**
2820	* _regulator_handle_consumer_enable - handle that a consumer enabled
2821	* @regulator: regulator source
2822	*
2823	* Some things on a regulator consumer (like the contribution towards total
2824	* load on the regulator) only have an effect when the consumer wants the
2825	* regulator enabled. Explained in example with two consumers of the same
2826	* regulator:
2827	* consumer A: set_load(100); => total load = 0
2828	* consumer A: regulator_enable(); => total load = 100
2829	* consumer B: set_load(1000); => total load = 100
2830	* consumer B: regulator_enable(); => total load = 1100
2831	* consumer A: regulator_disable(); => total_load = 1000
2832	*
2833	* This function (together with _regulator_handle_consumer_disable) is
2834	* responsible for keeping track of the refcount for a given regulator consumer
2835	* and applying / unapplying these things.
2836	*
2837	* Returns 0 upon no error; -error upon error.
2838	*/
2839	static int _regulator_handle_consumer_enable(struct regulator *regulator)
2840	{
2841	int ret;
2842	struct regulator_dev *rdev = regulator->rdev;
2843
2844	lockdep_assert_held_once(&rdev->mutex.base);
2845
2846	regulator->enable_count++;
2847	if (regulator->uA_load && regulator->enable_count == 1) {
2848	ret = drms_uA_update(rdev);
2849	if (ret)
2850	regulator->enable_count--;
2851	return ret;
2852	}
2853
2854	return 0;
2855	}
2856
2857	/**
2858	* _regulator_handle_consumer_disable - handle that a consumer disabled
2859	* @regulator: regulator source
2860	*
2861	* The opposite of _regulator_handle_consumer_enable().
2862	*
2863	* Returns 0 upon no error; -error upon error.
2864	*/
2865	static int _regulator_handle_consumer_disable(struct regulator *regulator)
2866	{
2867	struct regulator_dev *rdev = regulator->rdev;
2868
2869	lockdep_assert_held_once(&rdev->mutex.base);
2870
2871	if (!regulator->enable_count) {
2872	rdev_err(rdev, "Underflow of regulator enable count\n");
2873	return -EINVAL;
2874	}
2875
2876	regulator->enable_count--;
2877	if (regulator->uA_load && regulator->enable_count == 0)
2878	return drms_uA_update(rdev);
2879
2880	return 0;
2881	}
2882
2883	/* locks held by regulator_enable() */
2884	static int _regulator_enable(struct regulator *regulator)
2885	{
2886	struct regulator_dev *rdev = regulator->rdev;
2887	int ret;
2888
2889	lockdep_assert_held_once(&rdev->mutex.base);
2890
2891	if (rdev->use_count == 0 && rdev->supply) {
2892	ret = _regulator_enable(regulator: rdev->supply);
2893	if (ret < 0)
2894	return ret;
2895	}
2896
2897	/* balance only if there are regulators coupled */
2898	if (rdev->coupling_desc.n_coupled > 1) {
2899	ret = regulator_balance_voltage(rdev, PM_SUSPEND_ON);
2900	if (ret < 0)
2901	goto err_disable_supply;
2902	}
2903
2904	ret = _regulator_handle_consumer_enable(regulator);
2905	if (ret < 0)
2906	goto err_disable_supply;
2907
2908	if (rdev->use_count == 0) {
2909	/*
2910	* The regulator may already be enabled if it's not switchable
2911	* or was left on
2912	*/
2913	ret = _regulator_is_enabled(rdev);
2914	if (ret == -EINVAL || ret == 0) {
2915	if (!regulator_ops_is_valid(rdev,
2916	REGULATOR_CHANGE_STATUS)) {
2917	ret = -EPERM;
2918	goto err_consumer_disable;
2919	}
2920
2921	ret = _regulator_do_enable(rdev);
2922	if (ret < 0)
2923	goto err_consumer_disable;
2924
2925	_notifier_call_chain(rdev, REGULATOR_EVENT_ENABLE,
2926	NULL);
2927	} else if (ret < 0) {
2928	rdev_err(rdev, "is_enabled() failed: %pe\n", ERR_PTR(ret));
2929	goto err_consumer_disable;
2930	}
2931	/* Fallthrough on positive return values - already enabled */
2932	}
2933
2934	if (regulator->enable_count == 1)
2935	rdev->use_count++;
2936
2937	return 0;
2938
2939	err_consumer_disable:
2940	_regulator_handle_consumer_disable(regulator);
2941
2942	err_disable_supply:
2943	if (rdev->use_count == 0 && rdev->supply)
2944	_regulator_disable(regulator: rdev->supply);
2945
2946	return ret;
2947	}
2948
2949	/**
2950	* regulator_enable - enable regulator output
2951	* @regulator: regulator source
2952	*
2953	* Request that the regulator be enabled with the regulator output at
2954	* the predefined voltage or current value. Calls to regulator_enable()
2955	* must be balanced with calls to regulator_disable().
2956	*
2957	* NOTE: the output value can be set by other drivers, boot loader or may be
2958	* hardwired in the regulator.
2959	*/
2960	int regulator_enable(struct regulator *regulator)
2961	{
2962	struct regulator_dev *rdev = regulator->rdev;
2963	struct ww_acquire_ctx ww_ctx;
2964	int ret;
2965
2966	regulator_lock_dependent(rdev, ww_ctx: &ww_ctx);
2967	ret = _regulator_enable(regulator);
2968	regulator_unlock_dependent(rdev, ww_ctx: &ww_ctx);
2969
2970	return ret;
2971	}
2972	EXPORT_SYMBOL_GPL(regulator_enable);
2973
2974	static int _regulator_do_disable(struct regulator_dev *rdev)
2975	{
2976	int ret;
2977
2978	trace_regulator_disable(name: rdev_get_name(rdev));
2979
2980	if (rdev->ena_pin) {
2981	if (rdev->ena_gpio_state) {
2982	ret = regulator_ena_gpio_ctrl(rdev, enable: false);
2983	if (ret < 0)
2984	return ret;
2985	rdev->ena_gpio_state = 0;
2986	}
2987
2988	} else if (rdev->desc->ops->disable) {
2989	ret = rdev->desc->ops->disable(rdev);
2990	if (ret != 0)
2991	return ret;
2992	}
2993
2994	if (rdev->desc->off_on_delay)
2995	rdev->last_off = ktime_get_boottime();
2996
2997	trace_regulator_disable_complete(name: rdev_get_name(rdev));
2998
2999	return 0;
3000	}
3001
3002	/* locks held by regulator_disable() */
3003	static int _regulator_disable(struct regulator *regulator)
3004	{
3005	struct regulator_dev *rdev = regulator->rdev;
3006	int ret = 0;
3007
3008	lockdep_assert_held_once(&rdev->mutex.base);
3009
3010	if (WARN(regulator->enable_count == 0,
3011	"unbalanced disables for %s\n", rdev_get_name(rdev)))
3012	return -EIO;
3013
3014	if (regulator->enable_count == 1) {
3015	/* disabling last enable_count from this regulator */
3016	/* are we the last user and permitted to disable ? */
3017	if (rdev->use_count == 1 &&
3018	(rdev->constraints && !rdev->constraints->always_on)) {
3019
3020	/* we are last user */
3021	if (regulator_ops_is_valid(rdev, REGULATOR_CHANGE_STATUS)) {
3022	ret = _notifier_call_chain(rdev,
3023	REGULATOR_EVENT_PRE_DISABLE,
3024	NULL);
3025	if (ret & NOTIFY_STOP_MASK)
3026	return -EINVAL;
3027
3028	ret = _regulator_do_disable(rdev);
3029	if (ret < 0) {
3030	rdev_err(rdev, "failed to disable: %pe\n", ERR_PTR(ret));
3031	_notifier_call_chain(rdev,
3032	REGULATOR_EVENT_ABORT_DISABLE,
3033	NULL);
3034	return ret;
3035	}
3036	_notifier_call_chain(rdev, REGULATOR_EVENT_DISABLE,
3037	NULL);
3038	}
3039
3040	rdev->use_count = 0;
3041	} else if (rdev->use_count > 1) {
3042	rdev->use_count--;
3043	}
3044	}
3045
3046	if (ret == 0)
3047	ret = _regulator_handle_consumer_disable(regulator);
3048
3049	if (ret == 0 && rdev->coupling_desc.n_coupled > 1)
3050	ret = regulator_balance_voltage(rdev, PM_SUSPEND_ON);
3051
3052	if (ret == 0 && rdev->use_count == 0 && rdev->supply)
3053	ret = _regulator_disable(regulator: rdev->supply);
3054
3055	return ret;
3056	}
3057
3058	/**
3059	* regulator_disable - disable regulator output
3060	* @regulator: regulator source
3061	*
3062	* Disable the regulator output voltage or current. Calls to
3063	* regulator_enable() must be balanced with calls to
3064	* regulator_disable().
3065	*
3066	* NOTE: this will only disable the regulator output if no other consumer
3067	* devices have it enabled, the regulator device supports disabling and
3068	* machine constraints permit this operation.
3069	*/
3070	int regulator_disable(struct regulator *regulator)
3071	{
3072	struct regulator_dev *rdev = regulator->rdev;
3073	struct ww_acquire_ctx ww_ctx;
3074	int ret;
3075
3076	regulator_lock_dependent(rdev, ww_ctx: &ww_ctx);
3077	ret = _regulator_disable(regulator);
3078	regulator_unlock_dependent(rdev, ww_ctx: &ww_ctx);
3079
3080	return ret;
3081	}
3082	EXPORT_SYMBOL_GPL(regulator_disable);
3083
3084	/* locks held by regulator_force_disable() */
3085	static int _regulator_force_disable(struct regulator_dev *rdev)
3086	{
3087	int ret = 0;
3088
3089	lockdep_assert_held_once(&rdev->mutex.base);
3090
3091	ret = _notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
3092	REGULATOR_EVENT_PRE_DISABLE, NULL);
3093	if (ret & NOTIFY_STOP_MASK)
3094	return -EINVAL;
3095
3096	ret = _regulator_do_disable(rdev);
3097	if (ret < 0) {
3098	rdev_err(rdev, "failed to force disable: %pe\n", ERR_PTR(ret));
3099	_notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
3100	REGULATOR_EVENT_ABORT_DISABLE, NULL);
3101	return ret;
3102	}
3103
3104	_notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
3105	REGULATOR_EVENT_DISABLE, NULL);
3106
3107	return 0;
3108	}
3109
3110	/**
3111	* regulator_force_disable - force disable regulator output
3112	* @regulator: regulator source
3113	*
3114	* Forcibly disable the regulator output voltage or current.
3115	* NOTE: this *will* disable the regulator output even if other consumer
3116	* devices have it enabled. This should be used for situations when device
3117	* damage will likely occur if the regulator is not disabled (e.g. over temp).
3118	*/
3119	int regulator_force_disable(struct regulator *regulator)
3120	{
3121	struct regulator_dev *rdev = regulator->rdev;
3122	struct ww_acquire_ctx ww_ctx;
3123	int ret;
3124
3125	regulator_lock_dependent(rdev, ww_ctx: &ww_ctx);
3126
3127	ret = _regulator_force_disable(rdev: regulator->rdev);
3128
3129	if (rdev->coupling_desc.n_coupled > 1)
3130	regulator_balance_voltage(rdev, PM_SUSPEND_ON);
3131
3132	if (regulator->uA_load) {
3133	regulator->uA_load = 0;
3134	ret = drms_uA_update(rdev);
3135	}
3136
3137	if (rdev->use_count != 0 && rdev->supply)
3138	_regulator_disable(regulator: rdev->supply);
3139
3140	regulator_unlock_dependent(rdev, ww_ctx: &ww_ctx);
3141
3142	return ret;
3143	}
3144	EXPORT_SYMBOL_GPL(regulator_force_disable);
3145
3146	static void regulator_disable_work(struct work_struct *work)
3147	{
3148	struct regulator_dev *rdev = container_of(work, struct regulator_dev,
3149	disable_work.work);
3150	struct ww_acquire_ctx ww_ctx;
3151	int count, i, ret;
3152	struct regulator *regulator;
3153	int total_count = 0;
3154
3155	regulator_lock_dependent(rdev, ww_ctx: &ww_ctx);
3156
3157	/*
3158	* Workqueue functions queue the new work instance while the previous
3159	* work instance is being processed. Cancel the queued work instance
3160	* as the work instance under processing does the job of the queued
3161	* work instance.
3162	*/
3163	cancel_delayed_work(dwork: &rdev->disable_work);
3164
3165	list_for_each_entry(regulator, &rdev->consumer_list, list) {
3166	count = regulator->deferred_disables;
3167
3168	if (!count)
3169	continue;
3170
3171	total_count += count;
3172	regulator->deferred_disables = 0;
3173
3174	for (i = 0; i < count; i++) {
3175	ret = _regulator_disable(regulator);
3176	if (ret != 0)
3177	rdev_err(rdev, "Deferred disable failed: %pe\n",
3178	ERR_PTR(ret));
3179	}
3180	}
3181	WARN_ON(!total_count);
3182
3183	if (rdev->coupling_desc.n_coupled > 1)
3184	regulator_balance_voltage(rdev, PM_SUSPEND_ON);
3185
3186	regulator_unlock_dependent(rdev, ww_ctx: &ww_ctx);
3187	}
3188
3189	/**
3190	* regulator_disable_deferred - disable regulator output with delay
3191	* @regulator: regulator source
3192	* @ms: milliseconds until the regulator is disabled
3193	*
3194	* Execute regulator_disable() on the regulator after a delay. This
3195	* is intended for use with devices that require some time to quiesce.
3196	*
3197	* NOTE: this will only disable the regulator output if no other consumer
3198	* devices have it enabled, the regulator device supports disabling and
3199	* machine constraints permit this operation.
3200	*/
3201	int regulator_disable_deferred(struct regulator *regulator, int ms)
3202	{
3203	struct regulator_dev *rdev = regulator->rdev;
3204
3205	if (!ms)
3206	return regulator_disable(regulator);
3207
3208	regulator_lock(rdev);
3209	regulator->deferred_disables++;
3210	mod_delayed_work(wq: system_power_efficient_wq, dwork: &rdev->disable_work,
3211	delay: msecs_to_jiffies(m: ms));
3212	regulator_unlock(rdev);
3213
3214	return 0;
3215	}
3216	EXPORT_SYMBOL_GPL(regulator_disable_deferred);
3217
3218	static int _regulator_is_enabled(struct regulator_dev *rdev)
3219	{
3220	/* A GPIO control always takes precedence */
3221	if (rdev->ena_pin)
3222	return rdev->ena_gpio_state;
3223
3224	/* If we don't know then assume that the regulator is always on */
3225	if (!rdev->desc->ops->is_enabled)
3226	return 1;
3227
3228	return rdev->desc->ops->is_enabled(rdev);
3229	}
3230
3231	static int _regulator_list_voltage(struct regulator_dev *rdev,
3232	unsigned selector, int lock)
3233	{
3234	const struct regulator_ops *ops = rdev->desc->ops;
3235	int ret;
3236
3237	if (rdev->desc->fixed_uV && rdev->desc->n_voltages == 1 && !selector)
3238	return rdev->desc->fixed_uV;
3239
3240	if (ops->list_voltage) {
3241	if (selector >= rdev->desc->n_voltages)
3242	return -EINVAL;
3243	if (selector < rdev->desc->linear_min_sel)
3244	return 0;
3245	if (lock)
3246	regulator_lock(rdev);
3247	ret = ops->list_voltage(rdev, selector);
3248	if (lock)
3249	regulator_unlock(rdev);
3250	} else if (rdev->is_switch && rdev->supply) {
3251	ret = _regulator_list_voltage(rdev: rdev->supply->rdev,
3252	selector, lock);
3253	} else {
3254	return -EINVAL;
3255	}
3256
3257	if (ret > 0) {
3258	if (ret < rdev->constraints->min_uV)
3259	ret = 0;
3260	else if (ret > rdev->constraints->max_uV)
3261	ret = 0;
3262	}
3263
3264	return ret;
3265	}
3266
3267	/**
3268	* regulator_is_enabled - is the regulator output enabled
3269	* @regulator: regulator source
3270	*
3271	* Returns positive if the regulator driver backing the source/client
3272	* has requested that the device be enabled, zero if it hasn't, else a
3273	* negative errno code.
3274	*
3275	* Note that the device backing this regulator handle can have multiple
3276	* users, so it might be enabled even if regulator_enable() was never
3277	* called for this particular source.
3278	*/
3279	int regulator_is_enabled(struct regulator *regulator)
3280	{
3281	int ret;
3282
3283	if (regulator->always_on)
3284	return 1;
3285
3286	regulator_lock(rdev: regulator->rdev);
3287	ret = _regulator_is_enabled(rdev: regulator->rdev);
3288	regulator_unlock(rdev: regulator->rdev);
3289
3290	return ret;
3291	}
3292	EXPORT_SYMBOL_GPL(regulator_is_enabled);
3293
3294	/**
3295	* regulator_count_voltages - count regulator_list_voltage() selectors
3296	* @regulator: regulator source
3297	*
3298	* Returns number of selectors, or negative errno. Selectors are
3299	* numbered starting at zero, and typically correspond to bitfields
3300	* in hardware registers.
3301	*/
3302	int regulator_count_voltages(struct regulator *regulator)
3303	{
3304	struct regulator_dev *rdev = regulator->rdev;
3305
3306	if (rdev->desc->n_voltages)
3307	return rdev->desc->n_voltages;
3308
3309	if (!rdev->is_switch || !rdev->supply)
3310	return -EINVAL;
3311
3312	return regulator_count_voltages(regulator: rdev->supply);
3313	}
3314	EXPORT_SYMBOL_GPL(regulator_count_voltages);
3315
3316	/**
3317	* regulator_list_voltage - enumerate supported voltages
3318	* @regulator: regulator source
3319	* @selector: identify voltage to list
3320	* Context: can sleep
3321	*
3322	* Returns a voltage that can be passed to @regulator_set_voltage(),
3323	* zero if this selector code can't be used on this system, or a
3324	* negative errno.
3325	*/
3326	int regulator_list_voltage(struct regulator *regulator, unsigned selector)
3327	{
3328	return _regulator_list_voltage(rdev: regulator->rdev, selector, lock: 1);
3329	}
3330	EXPORT_SYMBOL_GPL(regulator_list_voltage);
3331
3332	/**
3333	* regulator_get_regmap - get the regulator's register map
3334	* @regulator: regulator source
3335	*
3336	* Returns the register map for the given regulator, or an ERR_PTR value
3337	* if the regulator doesn't use regmap.
3338	*/
3339	struct regmap *regulator_get_regmap(struct regulator *regulator)
3340	{
3341	struct regmap *map = regulator->rdev->regmap;
3342
3343	return map ? map : ERR_PTR(error: -EOPNOTSUPP);
3344	}
3345
3346	/**
3347	* regulator_get_hardware_vsel_register - get the HW voltage selector register
3348	* @regulator: regulator source
3349	* @vsel_reg: voltage selector register, output parameter
3350	* @vsel_mask: mask for voltage selector bitfield, output parameter
3351	*
3352	* Returns the hardware register offset and bitmask used for setting the
3353	* regulator voltage. This might be useful when configuring voltage-scaling
3354	* hardware or firmware that can make I2C requests behind the kernel's back,
3355	* for example.
3356	*
3357	* On success, the output parameters @vsel_reg and @vsel_mask are filled in
3358	* and 0 is returned, otherwise a negative errno is returned.
3359	*/
3360	int regulator_get_hardware_vsel_register(struct regulator *regulator,
3361	unsigned *vsel_reg,
3362	unsigned *vsel_mask)
3363	{
3364	struct regulator_dev *rdev = regulator->rdev;
3365	const struct regulator_ops *ops = rdev->desc->ops;
3366
3367	if (ops->set_voltage_sel != regulator_set_voltage_sel_regmap)
3368	return -EOPNOTSUPP;
3369
3370	*vsel_reg = rdev->desc->vsel_reg;
3371	*vsel_mask = rdev->desc->vsel_mask;
3372
3373	return 0;
3374	}
3375	EXPORT_SYMBOL_GPL(regulator_get_hardware_vsel_register);
3376
3377	/**
3378	* regulator_list_hardware_vsel - get the HW-specific register value for a selector
3379	* @regulator: regulator source
3380	* @selector: identify voltage to list
3381	*
3382	* Converts the selector to a hardware-specific voltage selector that can be
3383	* directly written to the regulator registers. The address of the voltage
3384	* register can be determined by calling @regulator_get_hardware_vsel_register.
3385	*
3386	* On error a negative errno is returned.
3387	*/
3388	int regulator_list_hardware_vsel(struct regulator *regulator,
3389	unsigned selector)
3390	{
3391	struct regulator_dev *rdev = regulator->rdev;
3392	const struct regulator_ops *ops = rdev->desc->ops;
3393
3394	if (selector >= rdev->desc->n_voltages)
3395	return -EINVAL;
3396	if (selector < rdev->desc->linear_min_sel)
3397	return 0;
3398	if (ops->set_voltage_sel != regulator_set_voltage_sel_regmap)
3399	return -EOPNOTSUPP;
3400
3401	return selector;
3402	}
3403	EXPORT_SYMBOL_GPL(regulator_list_hardware_vsel);
3404
3405	/**
3406	* regulator_get_linear_step - return the voltage step size between VSEL values
3407	* @regulator: regulator source
3408	*
3409	* Returns the voltage step size between VSEL values for linear
3410	* regulators, or return 0 if the regulator isn't a linear regulator.
3411	*/
3412	unsigned int regulator_get_linear_step(struct regulator *regulator)
3413	{
3414	struct regulator_dev *rdev = regulator->rdev;
3415
3416	return rdev->desc->uV_step;
3417	}
3418	EXPORT_SYMBOL_GPL(regulator_get_linear_step);
3419
3420	/**
3421	* regulator_is_supported_voltage - check if a voltage range can be supported
3422	*
3423	* @regulator: Regulator to check.
3424	* @min_uV: Minimum required voltage in uV.
3425	* @max_uV: Maximum required voltage in uV.
3426	*
3427	* Returns a boolean.
3428	*/
3429	int regulator_is_supported_voltage(struct regulator *regulator,
3430	int min_uV, int max_uV)
3431	{
3432	struct regulator_dev *rdev = regulator->rdev;
3433	int i, voltages, ret;
3434
3435	/* If we can't change voltage check the current voltage */
3436	if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_VOLTAGE)) {
3437	ret = regulator_get_voltage(regulator);
3438	if (ret >= 0)
3439	return min_uV <= ret && ret <= max_uV;
3440	else
3441	return ret;
3442	}
3443
3444	/* Any voltage within constrains range is fine? */
3445	if (rdev->desc->continuous_voltage_range)
3446	return min_uV >= rdev->constraints->min_uV &&
3447	max_uV <= rdev->constraints->max_uV;
3448
3449	ret = regulator_count_voltages(regulator);
3450	if (ret < 0)
3451	return 0;
3452	voltages = ret;
3453
3454	for (i = 0; i < voltages; i++) {
3455	ret = regulator_list_voltage(regulator, i);
3456
3457	if (ret >= min_uV && ret <= max_uV)
3458	return 1;
3459	}
3460
3461	return 0;
3462	}
3463	EXPORT_SYMBOL_GPL(regulator_is_supported_voltage);
3464
3465	static int regulator_map_voltage(struct regulator_dev *rdev, int min_uV,
3466	int max_uV)
3467	{
3468	const struct regulator_desc *desc = rdev->desc;
3469
3470	if (desc->ops->map_voltage)
3471	return desc->ops->map_voltage(rdev, min_uV, max_uV);
3472
3473	if (desc->ops->list_voltage == regulator_list_voltage_linear)
3474	return regulator_map_voltage_linear(rdev, min_uV, max_uV);
3475
3476	if (desc->ops->list_voltage == regulator_list_voltage_linear_range)
3477	return regulator_map_voltage_linear_range(rdev, min_uV, max_uV);
3478
3479	if (desc->ops->list_voltage ==
3480	regulator_list_voltage_pickable_linear_range)
3481	return regulator_map_voltage_pickable_linear_range(rdev,
3482	min_uV, max_uV);
3483
3484	return regulator_map_voltage_iterate(rdev, min_uV, max_uV);
3485	}
3486
3487	static int _regulator_call_set_voltage(struct regulator_dev *rdev,
3488	int min_uV, int max_uV,
3489	unsigned *selector)
3490	{
3491	struct pre_voltage_change_data data;
3492	int ret;
3493
3494	data.old_uV = regulator_get_voltage_rdev(rdev);
3495	data.min_uV = min_uV;
3496	data.max_uV = max_uV;
3497	ret = _notifier_call_chain(rdev, REGULATOR_EVENT_PRE_VOLTAGE_CHANGE,
3498	data: &data);
3499	if (ret & NOTIFY_STOP_MASK)
3500	return -EINVAL;
3501
3502	ret = rdev->desc->ops->set_voltage(rdev, min_uV, max_uV, selector);
3503	if (ret >= 0)
3504	return ret;
3505
3506	_notifier_call_chain(rdev, REGULATOR_EVENT_ABORT_VOLTAGE_CHANGE,
3507	data: (void *)data.old_uV);
3508
3509	return ret;
3510	}
3511
3512	static int _regulator_call_set_voltage_sel(struct regulator_dev *rdev,
3513	int uV, unsigned selector)
3514	{
3515	struct pre_voltage_change_data data;
3516	int ret;
3517
3518	data.old_uV = regulator_get_voltage_rdev(rdev);
3519	data.min_uV = uV;
3520	data.max_uV = uV;
3521	ret = _notifier_call_chain(rdev, REGULATOR_EVENT_PRE_VOLTAGE_CHANGE,
3522	data: &data);
3523	if (ret & NOTIFY_STOP_MASK)
3524	return -EINVAL;
3525
3526	ret = rdev->desc->ops->set_voltage_sel(rdev, selector);
3527	if (ret >= 0)
3528	return ret;
3529
3530	_notifier_call_chain(rdev, REGULATOR_EVENT_ABORT_VOLTAGE_CHANGE,
3531	data: (void *)data.old_uV);
3532
3533	return ret;
3534	}
3535
3536	static int _regulator_set_voltage_sel_step(struct regulator_dev *rdev,
3537	int uV, int new_selector)
3538	{
3539	const struct regulator_ops *ops = rdev->desc->ops;
3540	int diff, old_sel, curr_sel, ret;
3541
3542	/* Stepping is only needed if the regulator is enabled. */
3543	if (!_regulator_is_enabled(rdev))
3544	goto final_set;
3545
3546	if (!ops->get_voltage_sel)
3547	return -EINVAL;
3548
3549	old_sel = ops->get_voltage_sel(rdev);
3550	if (old_sel < 0)
3551	return old_sel;
3552
3553	diff = new_selector - old_sel;
3554	if (diff == 0)
3555	return 0; /* No change needed. */
3556
3557	if (diff > 0) {
3558	/* Stepping up. */
3559	for (curr_sel = old_sel + rdev->desc->vsel_step;
3560	curr_sel < new_selector;
3561	curr_sel += rdev->desc->vsel_step) {
3562	/*
3563	* Call the callback directly instead of using
3564	* _regulator_call_set_voltage_sel() as we don't
3565	* want to notify anyone yet. Same in the branch
3566	* below.
3567	*/
3568	ret = ops->set_voltage_sel(rdev, curr_sel);
3569	if (ret)
3570	goto try_revert;
3571	}
3572	} else {
3573	/* Stepping down. */
3574	for (curr_sel = old_sel - rdev->desc->vsel_step;
3575	curr_sel > new_selector;
3576	curr_sel -= rdev->desc->vsel_step) {
3577	ret = ops->set_voltage_sel(rdev, curr_sel);
3578	if (ret)
3579	goto try_revert;
3580	}
3581	}
3582
3583	final_set:
3584	/* The final selector will trigger the notifiers. */
3585	return _regulator_call_set_voltage_sel(rdev, uV, selector: new_selector);
3586
3587	try_revert:
3588	/*
3589	* At least try to return to the previous voltage if setting a new
3590	* one failed.
3591	*/
3592	(void)ops->set_voltage_sel(rdev, old_sel);
3593	return ret;
3594	}
3595
3596	static int _regulator_set_voltage_time(struct regulator_dev *rdev,
3597	int old_uV, int new_uV)
3598	{
3599	unsigned int ramp_delay = 0;
3600
3601	if (rdev->constraints->ramp_delay)
3602	ramp_delay = rdev->constraints->ramp_delay;
3603	else if (rdev->desc->ramp_delay)
3604	ramp_delay = rdev->desc->ramp_delay;
3605	else if (rdev->constraints->settling_time)
3606	return rdev->constraints->settling_time;
3607	else if (rdev->constraints->settling_time_up &&
3608	(new_uV > old_uV))
3609	return rdev->constraints->settling_time_up;
3610	else if (rdev->constraints->settling_time_down &&
3611	(new_uV < old_uV))
3612	return rdev->constraints->settling_time_down;
3613
3614	if (ramp_delay == 0)
3615	return 0;
3616
3617	return DIV_ROUND_UP(abs(new_uV - old_uV), ramp_delay);
3618	}
3619
3620	static int _regulator_do_set_voltage(struct regulator_dev *rdev,
3621	int min_uV, int max_uV)
3622	{
3623	int ret;
3624	int delay = 0;
3625	int best_val = 0;
3626	unsigned int selector;
3627	int old_selector = -1;
3628	const struct regulator_ops *ops = rdev->desc->ops;
3629	int old_uV = regulator_get_voltage_rdev(rdev);
3630
3631	trace_regulator_set_voltage(name: rdev_get_name(rdev), min: min_uV, max: max_uV);
3632
3633	min_uV += rdev->constraints->uV_offset;
3634	max_uV += rdev->constraints->uV_offset;
3635
3636	/*
3637	* If we can't obtain the old selector there is not enough
3638	* info to call set_voltage_time_sel().
3639	*/
3640	if (_regulator_is_enabled(rdev) &&
3641	ops->set_voltage_time_sel && ops->get_voltage_sel) {
3642	old_selector = ops->get_voltage_sel(rdev);
3643	if (old_selector < 0)
3644	return old_selector;
3645	}
3646
3647	if (ops->set_voltage) {
3648	ret = _regulator_call_set_voltage(rdev, min_uV, max_uV,
3649	selector: &selector);
3650
3651	if (ret >= 0) {
3652	if (ops->list_voltage)
3653	best_val = ops->list_voltage(rdev,
3654	selector);
3655	else
3656	best_val = regulator_get_voltage_rdev(rdev);
3657	}
3658
3659	} else if (ops->set_voltage_sel) {
3660	ret = regulator_map_voltage(rdev, min_uV, max_uV);
3661	if (ret >= 0) {
3662	best_val = ops->list_voltage(rdev, ret);
3663	if (min_uV <= best_val && max_uV >= best_val) {
3664	selector = ret;
3665	if (old_selector == selector)
3666	ret = 0;
3667	else if (rdev->desc->vsel_step)
3668	ret = _regulator_set_voltage_sel_step(
3669	rdev, uV: best_val, new_selector: selector);
3670	else
3671	ret = _regulator_call_set_voltage_sel(
3672	rdev, uV: best_val, selector);
3673	} else {
3674	ret = -EINVAL;
3675	}
3676	}
3677	} else {
3678	ret = -EINVAL;
3679	}
3680
3681	if (ret)
3682	goto out;
3683
3684	if (ops->set_voltage_time_sel) {
3685	/*
3686	* Call set_voltage_time_sel if successfully obtained
3687	* old_selector
3688	*/
3689	if (old_selector >= 0 && old_selector != selector)
3690	delay = ops->set_voltage_time_sel(rdev, old_selector,
3691	selector);
3692	} else {
3693	if (old_uV != best_val) {
3694	if (ops->set_voltage_time)
3695	delay = ops->set_voltage_time(rdev, old_uV,
3696	best_val);
3697	else
3698	delay = _regulator_set_voltage_time(rdev,
3699	old_uV,
3700	new_uV: best_val);
3701	}
3702	}
3703
3704	if (delay < 0) {
3705	rdev_warn(rdev, "failed to get delay: %pe\n", ERR_PTR(delay));
3706	delay = 0;
3707	}
3708
3709	/* Insert any necessary delays */
3710	_regulator_delay_helper(delay);
3711
3712	if (best_val >= 0) {
3713	unsigned long data = best_val;
3714
3715	_notifier_call_chain(rdev, REGULATOR_EVENT_VOLTAGE_CHANGE,
3716	data: (void *)data);
3717	}
3718
3719	out:
3720	trace_regulator_set_voltage_complete(name: rdev_get_name(rdev), value: best_val);
3721
3722	return ret;
3723	}
3724
3725	static int _regulator_do_set_suspend_voltage(struct regulator_dev *rdev,
3726	int min_uV, int max_uV, suspend_state_t state)
3727	{
3728	struct regulator_state *rstate;
3729	int uV, sel;
3730
3731	rstate = regulator_get_suspend_state(rdev, state);
3732	if (rstate == NULL)
3733	return -EINVAL;
3734
3735	if (min_uV < rstate->min_uV)
3736	min_uV = rstate->min_uV;
3737	if (max_uV > rstate->max_uV)
3738	max_uV = rstate->max_uV;
3739
3740	sel = regulator_map_voltage(rdev, min_uV, max_uV);
3741	if (sel < 0)
3742	return sel;
3743
3744	uV = rdev->desc->ops->list_voltage(rdev, sel);
3745	if (uV >= min_uV && uV <= max_uV)
3746	rstate->uV = uV;
3747
3748	return 0;
3749	}
3750
3751	static int regulator_set_voltage_unlocked(struct regulator *regulator,
3752	int min_uV, int max_uV,
3753	suspend_state_t state)
3754	{
3755	struct regulator_dev *rdev = regulator->rdev;
3756	struct regulator_voltage *voltage = &regulator->voltage[state];
3757	int ret = 0;
3758	int old_min_uV, old_max_uV;
3759	int current_uV;
3760
3761	/* If we're setting the same range as last time the change
3762	* should be a noop (some cpufreq implementations use the same
3763	* voltage for multiple frequencies, for example).
3764	*/
3765	if (voltage->min_uV == min_uV && voltage->max_uV == max_uV)
3766	goto out;
3767
3768	/* If we're trying to set a range that overlaps the current voltage,
3769	* return successfully even though the regulator does not support
3770	* changing the voltage.
3771	*/
3772	if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_VOLTAGE)) {
3773	current_uV = regulator_get_voltage_rdev(rdev);
3774	if (min_uV <= current_uV && current_uV <= max_uV) {
3775	voltage->min_uV = min_uV;
3776	voltage->max_uV = max_uV;
3777	goto out;
3778	}
3779	}
3780
3781	/* sanity check */
3782	if (!rdev->desc->ops->set_voltage &&
3783	!rdev->desc->ops->set_voltage_sel) {
3784	ret = -EINVAL;
3785	goto out;
3786	}
3787
3788	/* constraints check */
3789	ret = regulator_check_voltage(rdev, min_uV: &min_uV, max_uV: &max_uV);
3790	if (ret < 0)
3791	goto out;
3792
3793	/* restore original values in case of error */
3794	old_min_uV = voltage->min_uV;
3795	old_max_uV = voltage->max_uV;
3796	voltage->min_uV = min_uV;
3797	voltage->max_uV = max_uV;
3798
3799	/* for not coupled regulators this will just set the voltage */
3800	ret = regulator_balance_voltage(rdev, state);
3801	if (ret < 0) {
3802	voltage->min_uV = old_min_uV;
3803	voltage->max_uV = old_max_uV;
3804	}
3805
3806	out:
3807	return ret;
3808	}
3809
3810	int regulator_set_voltage_rdev(struct regulator_dev *rdev, int min_uV,
3811	int max_uV, suspend_state_t state)
3812	{
3813	int best_supply_uV = 0;
3814	int supply_change_uV = 0;
3815	int ret;
3816
3817	if (rdev->supply &&
3818	regulator_ops_is_valid(rdev: rdev->supply->rdev,
3819	REGULATOR_CHANGE_VOLTAGE) &&
3820	(rdev->desc->min_dropout_uV || !(rdev->desc->ops->get_voltage ||
3821	rdev->desc->ops->get_voltage_sel))) {
3822	int current_supply_uV;
3823	int selector;
3824
3825	selector = regulator_map_voltage(rdev, min_uV, max_uV);
3826	if (selector < 0) {
3827	ret = selector;
3828	goto out;
3829	}
3830
3831	best_supply_uV = _regulator_list_voltage(rdev, selector, lock: 0);
3832	if (best_supply_uV < 0) {
3833	ret = best_supply_uV;
3834	goto out;
3835	}
3836
3837	best_supply_uV += rdev->desc->min_dropout_uV;
3838
3839	current_supply_uV = regulator_get_voltage_rdev(rdev: rdev->supply->rdev);
3840	if (current_supply_uV < 0) {
3841	ret = current_supply_uV;
3842	goto out;
3843	}
3844
3845	supply_change_uV = best_supply_uV - current_supply_uV;
3846	}
3847
3848	if (supply_change_uV > 0) {
3849	ret = regulator_set_voltage_unlocked(regulator: rdev->supply,
3850	min_uV: best_supply_uV, INT_MAX, state);
3851	if (ret) {
3852	dev_err(&rdev->dev, "Failed to increase supply voltage: %pe\n",
3853	ERR_PTR(ret));
3854	goto out;
3855	}
3856	}
3857
3858	if (state == PM_SUSPEND_ON)
3859	ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
3860	else
3861	ret = _regulator_do_set_suspend_voltage(rdev, min_uV,
3862	max_uV, state);
3863	if (ret < 0)
3864	goto out;
3865
3866	if (supply_change_uV < 0) {
3867	ret = regulator_set_voltage_unlocked(regulator: rdev->supply,
3868	min_uV: best_supply_uV, INT_MAX, state);
3869	if (ret)
3870	dev_warn(&rdev->dev, "Failed to decrease supply voltage: %pe\n",
3871	ERR_PTR(ret));
3872	/* No need to fail here */
3873	ret = 0;
3874	}
3875
3876	out:
3877	return ret;
3878	}
3879	EXPORT_SYMBOL_GPL(regulator_set_voltage_rdev);
3880
3881	static int regulator_limit_voltage_step(struct regulator_dev *rdev,
3882	int *current_uV, int *min_uV)
3883	{
3884	struct regulation_constraints *constraints = rdev->constraints;
3885
3886	/* Limit voltage change only if necessary */
3887	if (!constraints->max_uV_step || !_regulator_is_enabled(rdev))
3888	return 1;
3889
3890	if (*current_uV < 0) {
3891	*current_uV = regulator_get_voltage_rdev(rdev);
3892
3893	if (*current_uV < 0)
3894	return *current_uV;
3895	}
3896
3897	if (abs(*current_uV - *min_uV) <= constraints->max_uV_step)
3898	return 1;
3899
3900	/* Clamp target voltage within the given step */
3901	if (*current_uV < *min_uV)
3902	*min_uV = min(*current_uV + constraints->max_uV_step,
3903	*min_uV);
3904	else
3905	*min_uV = max(*current_uV - constraints->max_uV_step,
3906	*min_uV);
3907
3908	return 0;
3909	}
3910
3911	static int regulator_get_optimal_voltage(struct regulator_dev *rdev,
3912	int *current_uV,
3913	int *min_uV, int *max_uV,
3914	suspend_state_t state,
3915	int n_coupled)
3916	{
3917	struct coupling_desc *c_desc = &rdev->coupling_desc;
3918	struct regulator_dev **c_rdevs = c_desc->coupled_rdevs;
3919	struct regulation_constraints *constraints = rdev->constraints;
3920	int desired_min_uV = 0, desired_max_uV = INT_MAX;
3921	int max_current_uV = 0, min_current_uV = INT_MAX;
3922	int highest_min_uV = 0, target_uV, possible_uV;
3923	int i, ret, max_spread;
3924	bool done;
3925
3926	*current_uV = -1;
3927
3928	/*
3929	* If there are no coupled regulators, simply set the voltage
3930	* demanded by consumers.
3931	*/
3932	if (n_coupled == 1) {
3933	/*
3934	* If consumers don't provide any demands, set voltage
3935	* to min_uV
3936	*/
3937	desired_min_uV = constraints->min_uV;
3938	desired_max_uV = constraints->max_uV;
3939
3940	ret = regulator_check_consumers(rdev,
3941	min_uV: &desired_min_uV,
3942	max_uV: &desired_max_uV, state);
3943	if (ret < 0)
3944	return ret;
3945
3946	done = true;
3947
3948	goto finish;
3949	}
3950
3951	/* Find highest min desired voltage */
3952	for (i = 0; i < n_coupled; i++) {
3953	int tmp_min = 0;
3954	int tmp_max = INT_MAX;
3955
3956	lockdep_assert_held_once(&c_rdevs[i]->mutex.base);
3957
3958	ret = regulator_check_consumers(rdev: c_rdevs[i],
3959	min_uV: &tmp_min,
3960	max_uV: &tmp_max, state);
3961	if (ret < 0)
3962	return ret;
3963
3964	ret = regulator_check_voltage(rdev: c_rdevs[i], min_uV: &tmp_min, max_uV: &tmp_max);
3965	if (ret < 0)
3966	return ret;
3967
3968	highest_min_uV = max(highest_min_uV, tmp_min);
3969
3970	if (i == 0) {
3971	desired_min_uV = tmp_min;
3972	desired_max_uV = tmp_max;
3973	}
3974	}
3975
3976	max_spread = constraints->max_spread[0];
3977
3978	/*
3979	* Let target_uV be equal to the desired one if possible.
3980	* If not, set it to minimum voltage, allowed by other coupled
3981	* regulators.
3982	*/
3983	target_uV = max(desired_min_uV, highest_min_uV - max_spread);
3984
3985	/*
3986	* Find min and max voltages, which currently aren't violating
3987	* max_spread.
3988	*/
3989	for (i = 1; i < n_coupled; i++) {
3990	int tmp_act;
3991
3992	if (!_regulator_is_enabled(rdev: c_rdevs[i]))
3993	continue;
3994
3995	tmp_act = regulator_get_voltage_rdev(rdev: c_rdevs[i]);
3996	if (tmp_act < 0)
3997	return tmp_act;
3998
3999	min_current_uV = min(tmp_act, min_current_uV);
4000	max_current_uV = max(tmp_act, max_current_uV);
4001	}
4002
4003	/* There aren't any other regulators enabled */
4004	if (max_current_uV == 0) {
4005	possible_uV = target_uV;
4006	} else {
4007	/*
4008	* Correct target voltage, so as it currently isn't
4009	* violating max_spread
4010	*/
4011	possible_uV = max(target_uV, max_current_uV - max_spread);
4012	possible_uV = min(possible_uV, min_current_uV + max_spread);
4013	}
4014
4015	if (possible_uV > desired_max_uV)
4016	return -EINVAL;
4017
4018	done = (possible_uV == target_uV);
4019	desired_min_uV = possible_uV;
4020
4021	finish:
4022	/* Apply max_uV_step constraint if necessary */
4023	if (state == PM_SUSPEND_ON) {
4024	ret = regulator_limit_voltage_step(rdev, current_uV,
4025	min_uV: &desired_min_uV);
4026	if (ret < 0)
4027	return ret;
4028
4029	if (ret == 0)
4030	done = false;
4031	}
4032
4033	/* Set current_uV if wasn't done earlier in the code and if necessary */
4034	if (n_coupled > 1 && *current_uV == -1) {
4035
4036	if (_regulator_is_enabled(rdev)) {
4037	ret = regulator_get_voltage_rdev(rdev);
4038	if (ret < 0)
4039	return ret;
4040
4041	*current_uV = ret;
4042	} else {
4043	*current_uV = desired_min_uV;
4044	}
4045	}
4046
4047	*min_uV = desired_min_uV;
4048	*max_uV = desired_max_uV;
4049
4050	return done;
4051	}
4052
4053	int regulator_do_balance_voltage(struct regulator_dev *rdev,
4054	suspend_state_t state, bool skip_coupled)
4055	{
4056	struct regulator_dev **c_rdevs;
4057	struct regulator_dev *best_rdev;
4058	struct coupling_desc *c_desc = &rdev->coupling_desc;
4059	int i, ret, n_coupled, best_min_uV, best_max_uV, best_c_rdev;
4060	unsigned int delta, best_delta;
4061	unsigned long c_rdev_done = 0;
4062	bool best_c_rdev_done;
4063
4064	c_rdevs = c_desc->coupled_rdevs;
4065	n_coupled = skip_coupled ? 1 : c_desc->n_coupled;
4066
4067	/*
4068	* Find the best possible voltage change on each loop. Leave the loop
4069	* if there isn't any possible change.
4070	*/
4071	do {
4072	best_c_rdev_done = false;
4073	best_delta = 0;
4074	best_min_uV = 0;
4075	best_max_uV = 0;
4076	best_c_rdev = 0;
4077	best_rdev = NULL;
4078
4079	/*
4080	* Find highest difference between optimal voltage
4081	* and current voltage.
4082	*/
4083	for (i = 0; i < n_coupled; i++) {
4084	/*
4085	* optimal_uV is the best voltage that can be set for
4086	* i-th regulator at the moment without violating
4087	* max_spread constraint in order to balance
4088	* the coupled voltages.
4089	*/
4090	int optimal_uV = 0, optimal_max_uV = 0, current_uV = 0;
4091
4092	if (test_bit(i, &c_rdev_done))
4093	continue;
4094
4095	ret = regulator_get_optimal_voltage(rdev: c_rdevs[i],
4096	current_uV: &current_uV,
4097	min_uV: &optimal_uV,
4098	max_uV: &optimal_max_uV,
4099	state, n_coupled);
4100	if (ret < 0)
4101	goto out;
4102
4103	delta = abs(optimal_uV - current_uV);
4104
4105	if (delta && best_delta <= delta) {
4106	best_c_rdev_done = ret;
4107	best_delta = delta;
4108	best_rdev = c_rdevs[i];
4109	best_min_uV = optimal_uV;
4110	best_max_uV = optimal_max_uV;
4111	best_c_rdev = i;
4112	}
4113	}
4114
4115	/* Nothing to change, return successfully */
4116	if (!best_rdev) {
4117	ret = 0;
4118	goto out;
4119	}
4120
4121	ret = regulator_set_voltage_rdev(best_rdev, best_min_uV,
4122	best_max_uV, state);
4123
4124	if (ret < 0)
4125	goto out;
4126
4127	if (best_c_rdev_done)
4128	set_bit(nr: best_c_rdev, addr: &c_rdev_done);
4129
4130	} while (n_coupled > 1);
4131
4132	out:
4133	return ret;
4134	}
4135
4136	static int regulator_balance_voltage(struct regulator_dev *rdev,
4137	suspend_state_t state)
4138	{
4139	struct coupling_desc *c_desc = &rdev->coupling_desc;
4140	struct regulator_coupler *coupler = c_desc->coupler;
4141	bool skip_coupled = false;
4142
4143	/*
4144	* If system is in a state other than PM_SUSPEND_ON, don't check
4145	* other coupled regulators.
4146	*/
4147	if (state != PM_SUSPEND_ON)
4148	skip_coupled = true;
4149
4150	if (c_desc->n_resolved < c_desc->n_coupled) {
4151	rdev_err(rdev, "Not all coupled regulators registered\n");
4152	return -EPERM;
4153	}
4154
4155	/* Invoke custom balancer for customized couplers */
4156	if (coupler && coupler->balance_voltage)
4157	return coupler->balance_voltage(coupler, rdev, state);
4158
4159	return regulator_do_balance_voltage(rdev, state, skip_coupled);
4160	}
4161
4162	/**
4163	* regulator_set_voltage - set regulator output voltage
4164	* @regulator: regulator source
4165	* @min_uV: Minimum required voltage in uV
4166	* @max_uV: Maximum acceptable voltage in uV
4167	*
4168	* Sets a voltage regulator to the desired output voltage. This can be set
4169	* during any regulator state. IOW, regulator can be disabled or enabled.
4170	*
4171	* If the regulator is enabled then the voltage will change to the new value
4172	* immediately otherwise if the regulator is disabled the regulator will
4173	* output at the new voltage when enabled.
4174	*
4175	* NOTE: If the regulator is shared between several devices then the lowest
4176	* request voltage that meets the system constraints will be used.
4177	* Regulator system constraints must be set for this regulator before
4178	* calling this function otherwise this call will fail.
4179	*/
4180	int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV)
4181	{
4182	struct ww_acquire_ctx ww_ctx;
4183	int ret;
4184
4185	regulator_lock_dependent(rdev: regulator->rdev, ww_ctx: &ww_ctx);
4186
4187	ret = regulator_set_voltage_unlocked(regulator, min_uV, max_uV,
4188	PM_SUSPEND_ON);
4189
4190	regulator_unlock_dependent(rdev: regulator->rdev, ww_ctx: &ww_ctx);
4191
4192	return ret;
4193	}
4194	EXPORT_SYMBOL_GPL(regulator_set_voltage);
4195
4196	static inline int regulator_suspend_toggle(struct regulator_dev *rdev,
4197	suspend_state_t state, bool en)
4198	{
4199	struct regulator_state *rstate;
4200
4201	rstate = regulator_get_suspend_state(rdev, state);
4202	if (rstate == NULL)
4203	return -EINVAL;
4204
4205	if (!rstate->changeable)
4206	return -EPERM;
4207
4208	rstate->enabled = (en) ? ENABLE_IN_SUSPEND : DISABLE_IN_SUSPEND;
4209
4210	return 0;
4211	}
4212
4213	int regulator_suspend_enable(struct regulator_dev *rdev,
4214	suspend_state_t state)
4215	{
4216	return regulator_suspend_toggle(rdev, state, en: true);
4217	}
4218	EXPORT_SYMBOL_GPL(regulator_suspend_enable);
4219
4220	int regulator_suspend_disable(struct regulator_dev *rdev,
4221	suspend_state_t state)
4222	{
4223	struct regulator *regulator;
4224	struct regulator_voltage *voltage;
4225
4226	/*
4227	* if any consumer wants this regulator device keeping on in
4228	* suspend states, don't set it as disabled.
4229	*/
4230	list_for_each_entry(regulator, &rdev->consumer_list, list) {
4231	voltage = &regulator->voltage[state];
4232	if (voltage->min_uV || voltage->max_uV)
4233	return 0;
4234	}
4235
4236	return regulator_suspend_toggle(rdev, state, en: false);
4237	}
4238	EXPORT_SYMBOL_GPL(regulator_suspend_disable);
4239
4240	static int _regulator_set_suspend_voltage(struct regulator *regulator,
4241	int min_uV, int max_uV,
4242	suspend_state_t state)
4243	{
4244	struct regulator_dev *rdev = regulator->rdev;
4245	struct regulator_state *rstate;
4246
4247	rstate = regulator_get_suspend_state(rdev, state);
4248	if (rstate == NULL)
4249	return -EINVAL;
4250
4251	if (rstate->min_uV == rstate->max_uV) {
4252	rdev_err(rdev, "The suspend voltage can't be changed!\n");
4253	return -EPERM;
4254	}
4255
4256	return regulator_set_voltage_unlocked(regulator, min_uV, max_uV, state);
4257	}
4258
4259	int regulator_set_suspend_voltage(struct regulator *regulator, int min_uV,
4260	int max_uV, suspend_state_t state)
4261	{
4262	struct ww_acquire_ctx ww_ctx;
4263	int ret;
4264
4265	/* PM_SUSPEND_ON is handled by regulator_set_voltage() */
4266	if (regulator_check_states(state) || state == PM_SUSPEND_ON)
4267	return -EINVAL;
4268
4269	regulator_lock_dependent(rdev: regulator->rdev, ww_ctx: &ww_ctx);
4270
4271	ret = _regulator_set_suspend_voltage(regulator, min_uV,
4272	max_uV, state);
4273
4274	regulator_unlock_dependent(rdev: regulator->rdev, ww_ctx: &ww_ctx);
4275
4276	return ret;
4277	}
4278	EXPORT_SYMBOL_GPL(regulator_set_suspend_voltage);
4279
4280	/**
4281	* regulator_set_voltage_time - get raise/fall time
4282	* @regulator: regulator source
4283	* @old_uV: starting voltage in microvolts
4284	* @new_uV: target voltage in microvolts
4285	*
4286	* Provided with the starting and ending voltage, this function attempts to
4287	* calculate the time in microseconds required to rise or fall to this new
4288	* voltage.
4289	*/
4290	int regulator_set_voltage_time(struct regulator *regulator,
4291	int old_uV, int new_uV)
4292	{
4293	struct regulator_dev *rdev = regulator->rdev;
4294	const struct regulator_ops *ops = rdev->desc->ops;
4295	int old_sel = -1;
4296	int new_sel = -1;
4297	int voltage;
4298	int i;
4299
4300	if (ops->set_voltage_time)
4301	return ops->set_voltage_time(rdev, old_uV, new_uV);
4302	else if (!ops->set_voltage_time_sel)
4303	return _regulator_set_voltage_time(rdev, old_uV, new_uV);
4304
4305	/* Currently requires operations to do this */
4306	if (!ops->list_voltage || !rdev->desc->n_voltages)
4307	return -EINVAL;
4308
4309	for (i = 0; i < rdev->desc->n_voltages; i++) {
4310	/* We only look for exact voltage matches here */
4311	if (i < rdev->desc->linear_min_sel)
4312	continue;
4313
4314	if (old_sel >= 0 && new_sel >= 0)
4315	break;
4316
4317	voltage = regulator_list_voltage(regulator, i);
4318	if (voltage < 0)
4319	return -EINVAL;
4320	if (voltage == 0)
4321	continue;
4322	if (voltage == old_uV)
4323	old_sel = i;
4324	if (voltage == new_uV)
4325	new_sel = i;
4326	}
4327
4328	if (old_sel < 0 || new_sel < 0)
4329	return -EINVAL;
4330
4331	return ops->set_voltage_time_sel(rdev, old_sel, new_sel);
4332	}
4333	EXPORT_SYMBOL_GPL(regulator_set_voltage_time);
4334
4335	/**
4336	* regulator_set_voltage_time_sel - get raise/fall time
4337	* @rdev: regulator source device
4338	* @old_selector: selector for starting voltage
4339	* @new_selector: selector for target voltage
4340	*
4341	* Provided with the starting and target voltage selectors, this function
4342	* returns time in microseconds required to rise or fall to this new voltage
4343	*
4344	* Drivers providing ramp_delay in regulation_constraints can use this as their
4345	* set_voltage_time_sel() operation.
4346	*/
4347	int regulator_set_voltage_time_sel(struct regulator_dev *rdev,
4348	unsigned int old_selector,
4349	unsigned int new_selector)
4350	{
4351	int old_volt, new_volt;
4352
4353	/* sanity check */
4354	if (!rdev->desc->ops->list_voltage)
4355	return -EINVAL;
4356
4357	old_volt = rdev->desc->ops->list_voltage(rdev, old_selector);
4358	new_volt = rdev->desc->ops->list_voltage(rdev, new_selector);
4359
4360	if (rdev->desc->ops->set_voltage_time)
4361	return rdev->desc->ops->set_voltage_time(rdev, old_volt,
4362	new_volt);
4363	else
4364	return _regulator_set_voltage_time(rdev, old_uV: old_volt, new_uV: new_volt);
4365	}
4366	EXPORT_SYMBOL_GPL(regulator_set_voltage_time_sel);
4367
4368	int regulator_sync_voltage_rdev(struct regulator_dev *rdev)
4369	{
4370	int ret;
4371
4372	regulator_lock(rdev);
4373
4374	if (!rdev->desc->ops->set_voltage &&
4375	!rdev->desc->ops->set_voltage_sel) {
4376	ret = -EINVAL;
4377	goto out;
4378	}
4379
4380	/* balance only, if regulator is coupled */
4381	if (rdev->coupling_desc.n_coupled > 1)
4382	ret = regulator_balance_voltage(rdev, PM_SUSPEND_ON);
4383	else
4384	ret = -EOPNOTSUPP;
4385
4386	out:
4387	regulator_unlock(rdev);
4388	return ret;
4389	}
4390
4391	/**
4392	* regulator_sync_voltage - re-apply last regulator output voltage
4393	* @regulator: regulator source
4394	*
4395	* Re-apply the last configured voltage. This is intended to be used
4396	* where some external control source the consumer is cooperating with
4397	* has caused the configured voltage to change.
4398	*/
4399	int regulator_sync_voltage(struct regulator *regulator)
4400	{
4401	struct regulator_dev *rdev = regulator->rdev;
4402	struct regulator_voltage *voltage = &regulator->voltage[PM_SUSPEND_ON];
4403	int ret, min_uV, max_uV;
4404
4405	if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_VOLTAGE))
4406	return 0;
4407
4408	regulator_lock(rdev);
4409
4410	if (!rdev->desc->ops->set_voltage &&
4411	!rdev->desc->ops->set_voltage_sel) {
4412	ret = -EINVAL;
4413	goto out;
4414	}
4415
4416	/* This is only going to work if we've had a voltage configured. */
4417	if (!voltage->min_uV && !voltage->max_uV) {
4418	ret = -EINVAL;
4419	goto out;
4420	}
4421
4422	min_uV = voltage->min_uV;
4423	max_uV = voltage->max_uV;
4424
4425	/* This should be a paranoia check... */
4426	ret = regulator_check_voltage(rdev, min_uV: &min_uV, max_uV: &max_uV);
4427	if (ret < 0)
4428	goto out;
4429
4430	ret = regulator_check_consumers(rdev, min_uV: &min_uV, max_uV: &max_uV, state: 0);
4431	if (ret < 0)
4432	goto out;
4433
4434	/* balance only, if regulator is coupled */
4435	if (rdev->coupling_desc.n_coupled > 1)
4436	ret = regulator_balance_voltage(rdev, PM_SUSPEND_ON);
4437	else
4438	ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
4439
4440	out:
4441	regulator_unlock(rdev);
4442	return ret;
4443	}
4444	EXPORT_SYMBOL_GPL(regulator_sync_voltage);
4445
4446	int regulator_get_voltage_rdev(struct regulator_dev *rdev)
4447	{
4448	int sel, ret;
4449	bool bypassed;
4450
4451	if (rdev->desc->ops->get_bypass) {
4452	ret = rdev->desc->ops->get_bypass(rdev, &bypassed);
4453	if (ret < 0)
4454	return ret;
4455	if (bypassed) {
4456	/* if bypassed the regulator must have a supply */
4457	if (!rdev->supply) {
4458	rdev_err(rdev,
4459	"bypassed regulator has no supply!\n");
4460	return -EPROBE_DEFER;
4461	}
4462
4463	return regulator_get_voltage_rdev(rdev: rdev->supply->rdev);
4464	}
4465	}
4466
4467	if (rdev->desc->ops->get_voltage_sel) {
4468	sel = rdev->desc->ops->get_voltage_sel(rdev);
4469	if (sel < 0)
4470	return sel;
4471	ret = rdev->desc->ops->list_voltage(rdev, sel);
4472	} else if (rdev->desc->ops->get_voltage) {
4473	ret = rdev->desc->ops->get_voltage(rdev);
4474	} else if (rdev->desc->ops->list_voltage) {
4475	ret = rdev->desc->ops->list_voltage(rdev, 0);
4476	} else if (rdev->desc->fixed_uV && (rdev->desc->n_voltages == 1)) {
4477	ret = rdev->desc->fixed_uV;
4478	} else if (rdev->supply) {
4479	ret = regulator_get_voltage_rdev(rdev: rdev->supply->rdev);
4480	} else if (rdev->supply_name) {
4481	return -EPROBE_DEFER;
4482	} else {
4483	return -EINVAL;
4484	}
4485
4486	if (ret < 0)
4487	return ret;
4488	return ret - rdev->constraints->uV_offset;
4489	}
4490	EXPORT_SYMBOL_GPL(regulator_get_voltage_rdev);
4491
4492	/**
4493	* regulator_get_voltage - get regulator output voltage
4494	* @regulator: regulator source
4495	*
4496	* This returns the current regulator voltage in uV.
4497	*
4498	* NOTE: If the regulator is disabled it will return the voltage value. This
4499	* function should not be used to determine regulator state.
4500	*/
4501	int regulator_get_voltage(struct regulator *regulator)
4502	{
4503	struct ww_acquire_ctx ww_ctx;
4504	int ret;
4505
4506	regulator_lock_dependent(rdev: regulator->rdev, ww_ctx: &ww_ctx);
4507	ret = regulator_get_voltage_rdev(regulator->rdev);
4508	regulator_unlock_dependent(rdev: regulator->rdev, ww_ctx: &ww_ctx);
4509
4510	return ret;
4511	}
4512	EXPORT_SYMBOL_GPL(regulator_get_voltage);
4513
4514	/**
4515	* regulator_set_current_limit - set regulator output current limit
4516	* @regulator: regulator source
4517	* @min_uA: Minimum supported current in uA
4518	* @max_uA: Maximum supported current in uA
4519	*
4520	* Sets current sink to the desired output current. This can be set during
4521	* any regulator state. IOW, regulator can be disabled or enabled.
4522	*
4523	* If the regulator is enabled then the current will change to the new value
4524	* immediately otherwise if the regulator is disabled the regulator will
4525	* output at the new current when enabled.
4526	*
4527	* NOTE: Regulator system constraints must be set for this regulator before
4528	* calling this function otherwise this call will fail.
4529	*/
4530	int regulator_set_current_limit(struct regulator *regulator,
4531	int min_uA, int max_uA)
4532	{
4533	struct regulator_dev *rdev = regulator->rdev;
4534	int ret;
4535
4536	regulator_lock(rdev);
4537
4538	/* sanity check */
4539	if (!rdev->desc->ops->set_current_limit) {
4540	ret = -EINVAL;
4541	goto out;
4542	}
4543
4544	/* constraints check */
4545	ret = regulator_check_current_limit(rdev, min_uA: &min_uA, max_uA: &max_uA);
4546	if (ret < 0)
4547	goto out;
4548
4549	ret = rdev->desc->ops->set_current_limit(rdev, min_uA, max_uA);
4550	out:
4551	regulator_unlock(rdev);
4552	return ret;
4553	}
4554	EXPORT_SYMBOL_GPL(regulator_set_current_limit);
4555
4556	static int _regulator_get_current_limit_unlocked(struct regulator_dev *rdev)
4557	{
4558	/* sanity check */
4559	if (!rdev->desc->ops->get_current_limit)
4560	return -EINVAL;
4561
4562	return rdev->desc->ops->get_current_limit(rdev);
4563	}
4564
4565	static int _regulator_get_current_limit(struct regulator_dev *rdev)
4566	{
4567	int ret;
4568
4569	regulator_lock(rdev);
4570	ret = _regulator_get_current_limit_unlocked(rdev);
4571	regulator_unlock(rdev);
4572
4573	return ret;
4574	}
4575
4576	/**
4577	* regulator_get_current_limit - get regulator output current
4578	* @regulator: regulator source
4579	*
4580	* This returns the current supplied by the specified current sink in uA.
4581	*
4582	* NOTE: If the regulator is disabled it will return the current value. This
4583	* function should not be used to determine regulator state.
4584	*/
4585	int regulator_get_current_limit(struct regulator *regulator)
4586	{
4587	return _regulator_get_current_limit(rdev: regulator->rdev);
4588	}
4589	EXPORT_SYMBOL_GPL(regulator_get_current_limit);
4590
4591	/**
4592	* regulator_set_mode - set regulator operating mode
4593	* @regulator: regulator source
4594	* @mode: operating mode - one of the REGULATOR_MODE constants
4595	*
4596	* Set regulator operating mode to increase regulator efficiency or improve
4597	* regulation performance.
4598	*
4599	* NOTE: Regulator system constraints must be set for this regulator before
4600	* calling this function otherwise this call will fail.
4601	*/
4602	int regulator_set_mode(struct regulator *regulator, unsigned int mode)
4603	{
4604	struct regulator_dev *rdev = regulator->rdev;
4605	int ret;
4606	int regulator_curr_mode;
4607
4608	regulator_lock(rdev);
4609
4610	/* sanity check */
4611	if (!rdev->desc->ops->set_mode) {
4612	ret = -EINVAL;
4613	goto out;
4614	}
4615
4616	/* return if the same mode is requested */
4617	if (rdev->desc->ops->get_mode) {
4618	regulator_curr_mode = rdev->desc->ops->get_mode(rdev);
4619	if (regulator_curr_mode == mode) {
4620	ret = 0;
4621	goto out;
4622	}
4623	}
4624
4625	/* constraints check */
4626	ret = regulator_mode_constrain(rdev, mode: &mode);
4627	if (ret < 0)
4628	goto out;
4629
4630	ret = rdev->desc->ops->set_mode(rdev, mode);
4631	out:
4632	regulator_unlock(rdev);
4633	return ret;
4634	}
4635	EXPORT_SYMBOL_GPL(regulator_set_mode);
4636
4637	static unsigned int _regulator_get_mode_unlocked(struct regulator_dev *rdev)
4638	{
4639	/* sanity check */
4640	if (!rdev->desc->ops->get_mode)
4641	return -EINVAL;
4642
4643	return rdev->desc->ops->get_mode(rdev);
4644	}
4645
4646	static unsigned int _regulator_get_mode(struct regulator_dev *rdev)
4647	{
4648	int ret;
4649
4650	regulator_lock(rdev);
4651	ret = _regulator_get_mode_unlocked(rdev);
4652	regulator_unlock(rdev);
4653
4654	return ret;
4655	}
4656
4657	/**
4658	* regulator_get_mode - get regulator operating mode
4659	* @regulator: regulator source
4660	*
4661	* Get the current regulator operating mode.
4662	*/
4663	unsigned int regulator_get_mode(struct regulator *regulator)
4664	{
4665	return _regulator_get_mode(rdev: regulator->rdev);
4666	}
4667	EXPORT_SYMBOL_GPL(regulator_get_mode);
4668
4669	static int rdev_get_cached_err_flags(struct regulator_dev *rdev)
4670	{
4671	int ret = 0;
4672
4673	if (rdev->use_cached_err) {
4674	spin_lock(lock: &rdev->err_lock);
4675	ret = rdev->cached_err;
4676	spin_unlock(lock: &rdev->err_lock);
4677	}
4678	return ret;
4679	}
4680
4681	static int _regulator_get_error_flags(struct regulator_dev *rdev,
4682	unsigned int *flags)
4683	{
4684	int cached_flags, ret = 0;
4685
4686	regulator_lock(rdev);
4687
4688	cached_flags = rdev_get_cached_err_flags(rdev);
4689
4690	if (rdev->desc->ops->get_error_flags)
4691	ret = rdev->desc->ops->get_error_flags(rdev, flags);
4692	else if (!rdev->use_cached_err)
4693	ret = -EINVAL;
4694
4695	*flags |= cached_flags;
4696
4697	regulator_unlock(rdev);
4698
4699	return ret;
4700	}
4701
4702	/**
4703	* regulator_get_error_flags - get regulator error information
4704	* @regulator: regulator source
4705	* @flags: pointer to store error flags
4706	*
4707	* Get the current regulator error information.
4708	*/
4709	int regulator_get_error_flags(struct regulator *regulator,
4710	unsigned int *flags)
4711	{
4712	return _regulator_get_error_flags(rdev: regulator->rdev, flags);
4713	}
4714	EXPORT_SYMBOL_GPL(regulator_get_error_flags);
4715
4716	/**
4717	* regulator_set_load - set regulator load
4718	* @regulator: regulator source
4719	* @uA_load: load current
4720	*
4721	* Notifies the regulator core of a new device load. This is then used by
4722	* DRMS (if enabled by constraints) to set the most efficient regulator
4723	* operating mode for the new regulator loading.
4724	*
4725	* Consumer devices notify their supply regulator of the maximum power
4726	* they will require (can be taken from device datasheet in the power
4727	* consumption tables) when they change operational status and hence power
4728	* state. Examples of operational state changes that can affect power
4729	* consumption are :-
4730	*
4731	* o Device is opened / closed.
4732	* o Device I/O is about to begin or has just finished.
4733	* o Device is idling in between work.
4734	*
4735	* This information is also exported via sysfs to userspace.
4736	*
4737	* DRMS will sum the total requested load on the regulator and change
4738	* to the most efficient operating mode if platform constraints allow.
4739	*
4740	* NOTE: when a regulator consumer requests to have a regulator
4741	* disabled then any load that consumer requested no longer counts
4742	* toward the total requested load. If the regulator is re-enabled
4743	* then the previously requested load will start counting again.
4744	*
4745	* If a regulator is an always-on regulator then an individual consumer's
4746	* load will still be removed if that consumer is fully disabled.
4747	*
4748	* On error a negative errno is returned.
4749	*/
4750	int regulator_set_load(struct regulator *regulator, int uA_load)
4751	{
4752	struct regulator_dev *rdev = regulator->rdev;
4753	int old_uA_load;
4754	int ret = 0;
4755
4756	regulator_lock(rdev);
4757	old_uA_load = regulator->uA_load;
4758	regulator->uA_load = uA_load;
4759	if (regulator->enable_count && old_uA_load != uA_load) {
4760	ret = drms_uA_update(rdev);
4761	if (ret < 0)
4762	regulator->uA_load = old_uA_load;
4763	}
4764	regulator_unlock(rdev);
4765
4766	return ret;
4767	}
4768	EXPORT_SYMBOL_GPL(regulator_set_load);
4769
4770	/**
4771	* regulator_allow_bypass - allow the regulator to go into bypass mode
4772	*
4773	* @regulator: Regulator to configure
4774	* @enable: enable or disable bypass mode
4775	*
4776	* Allow the regulator to go into bypass mode if all other consumers
4777	* for the regulator also enable bypass mode and the machine
4778	* constraints allow this. Bypass mode means that the regulator is
4779	* simply passing the input directly to the output with no regulation.
4780	*/
4781	int regulator_allow_bypass(struct regulator *regulator, bool enable)
4782	{
4783	struct regulator_dev *rdev = regulator->rdev;
4784	const char *name = rdev_get_name(rdev);
4785	int ret = 0;
4786
4787	if (!rdev->desc->ops->set_bypass)
4788	return 0;
4789
4790	if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_BYPASS))
4791	return 0;
4792
4793	regulator_lock(rdev);
4794
4795	if (enable && !regulator->bypass) {
4796	rdev->bypass_count++;
4797
4798	if (rdev->bypass_count == rdev->open_count) {
4799	trace_regulator_bypass_enable(name);
4800
4801	ret = rdev->desc->ops->set_bypass(rdev, enable);
4802	if (ret != 0)
4803	rdev->bypass_count--;
4804	else
4805	trace_regulator_bypass_enable_complete(name);
4806	}
4807
4808	} else if (!enable && regulator->bypass) {
4809	rdev->bypass_count--;
4810
4811	if (rdev->bypass_count != rdev->open_count) {
4812	trace_regulator_bypass_disable(name);
4813
4814	ret = rdev->desc->ops->set_bypass(rdev, enable);
4815	if (ret != 0)
4816	rdev->bypass_count++;
4817	else
4818	trace_regulator_bypass_disable_complete(name);
4819	}
4820	}
4821
4822	if (ret == 0)
4823	regulator->bypass = enable;
4824
4825	regulator_unlock(rdev);
4826
4827	return ret;
4828	}
4829	EXPORT_SYMBOL_GPL(regulator_allow_bypass);
4830
4831	/**
4832	* regulator_register_notifier - register regulator event notifier
4833	* @regulator: regulator source
4834	* @nb: notifier block
4835	*
4836	* Register notifier block to receive regulator events.
4837	*/
4838	int regulator_register_notifier(struct regulator *regulator,
4839	struct notifier_block *nb)
4840	{
4841	return blocking_notifier_chain_register(nh: &regulator->rdev->notifier,
4842	nb);
4843	}
4844	EXPORT_SYMBOL_GPL(regulator_register_notifier);
4845
4846	/**
4847	* regulator_unregister_notifier - unregister regulator event notifier
4848	* @regulator: regulator source
4849	* @nb: notifier block
4850	*
4851	* Unregister regulator event notifier block.
4852	*/
4853	int regulator_unregister_notifier(struct regulator *regulator,
4854	struct notifier_block *nb)
4855	{
4856	return blocking_notifier_chain_unregister(nh: &regulator->rdev->notifier,
4857	nb);
4858	}
4859	EXPORT_SYMBOL_GPL(regulator_unregister_notifier);
4860
4861	/* notify regulator consumers and downstream regulator consumers.
4862	* Note mutex must be held by caller.
4863	*/
4864	static int _notifier_call_chain(struct regulator_dev *rdev,
4865	unsigned long event, void *data)
4866	{
4867	/* call rdev chain first */
4868	int ret = blocking_notifier_call_chain(nh: &rdev->notifier, val: event, v: data);
4869
4870	if (IS_REACHABLE(CONFIG_REGULATOR_NETLINK_EVENTS)) {
4871	struct device *parent = rdev->dev.parent;
4872	const char *rname = rdev_get_name(rdev);
4873	char name[32];
4874
4875	/* Avoid duplicate debugfs directory names */
4876	if (parent && rname == rdev->desc->name) {
4877	snprintf(buf: name, size: sizeof(name), fmt: "%s-%s", dev_name(dev: parent),
4878	rname);
4879	rname = name;
4880	}
4881	reg_generate_netlink_event(reg_name: rname, event);
4882	}
4883
4884	return ret;
4885	}
4886
4887	int _regulator_bulk_get(struct device *dev, int num_consumers,
4888	struct regulator_bulk_data *consumers, enum regulator_get_type get_type)
4889	{
4890	int i;
4891	int ret;
4892
4893	for (i = 0; i < num_consumers; i++)
4894	consumers[i].consumer = NULL;
4895
4896	for (i = 0; i < num_consumers; i++) {
4897	consumers[i].consumer = _regulator_get(dev,
4898	id: consumers[i].supply, get_type);
4899	if (IS_ERR(ptr: consumers[i].consumer)) {
4900	ret = dev_err_probe(dev, err: PTR_ERR(ptr: consumers[i].consumer),
4901	fmt: "Failed to get supply '%s'",
4902	consumers[i].supply);
4903	consumers[i].consumer = NULL;
4904	goto err;
4905	}
4906
4907	if (consumers[i].init_load_uA > 0) {
4908	ret = regulator_set_load(consumers[i].consumer,
4909	consumers[i].init_load_uA);
4910	if (ret) {
4911	i++;
4912	goto err;
4913	}
4914	}
4915	}
4916
4917	return 0;
4918
4919	err:
4920	while (--i >= 0)
4921	regulator_put(consumers[i].consumer);
4922
4923	return ret;
4924	}
4925
4926	/**
4927	* regulator_bulk_get - get multiple regulator consumers
4928	*
4929	* @dev: Device to supply
4930	* @num_consumers: Number of consumers to register
4931	* @consumers: Configuration of consumers; clients are stored here.
4932	*
4933	* @return 0 on success, an errno on failure.
4934	*
4935	* This helper function allows drivers to get several regulator
4936	* consumers in one operation. If any of the regulators cannot be
4937	* acquired then any regulators that were allocated will be freed
4938	* before returning to the caller.
4939	*/
4940	int regulator_bulk_get(struct device *dev, int num_consumers,
4941	struct regulator_bulk_data *consumers)
4942	{
4943	return _regulator_bulk_get(dev, num_consumers, consumers, get_type: NORMAL_GET);
4944	}
4945	EXPORT_SYMBOL_GPL(regulator_bulk_get);
4946
4947	static void regulator_bulk_enable_async(void *data, async_cookie_t cookie)
4948	{
4949	struct regulator_bulk_data *bulk = data;
4950
4951	bulk->ret = regulator_enable(bulk->consumer);
4952	}
4953
4954	/**
4955	* regulator_bulk_enable - enable multiple regulator consumers
4956	*
4957	* @num_consumers: Number of consumers
4958	* @consumers: Consumer data; clients are stored here.
4959	* @return 0 on success, an errno on failure
4960	*
4961	* This convenience API allows consumers to enable multiple regulator
4962	* clients in a single API call. If any consumers cannot be enabled
4963	* then any others that were enabled will be disabled again prior to
4964	* return.
4965	*/
4966	int regulator_bulk_enable(int num_consumers,
4967	struct regulator_bulk_data *consumers)
4968	{
4969	ASYNC_DOMAIN_EXCLUSIVE(async_domain);
4970	int i;
4971	int ret = 0;
4972
4973	for (i = 0; i < num_consumers; i++) {
4974	async_schedule_domain(func: regulator_bulk_enable_async,
4975	data: &consumers[i], domain: &async_domain);
4976	}
4977
4978	async_synchronize_full_domain(domain: &async_domain);
4979
4980	/* If any consumer failed we need to unwind any that succeeded */
4981	for (i = 0; i < num_consumers; i++) {
4982	if (consumers[i].ret != 0) {
4983	ret = consumers[i].ret;
4984	goto err;
4985	}
4986	}
4987
4988	return 0;
4989
4990	err:
4991	for (i = 0; i < num_consumers; i++) {
4992	if (consumers[i].ret < 0)
4993	pr_err("Failed to enable %s: %pe\n", consumers[i].supply,
4994	ERR_PTR(consumers[i].ret));
4995	else
4996	regulator_disable(consumers[i].consumer);
4997	}
4998
4999	return ret;
5000	}
5001	EXPORT_SYMBOL_GPL(regulator_bulk_enable);
5002
5003	/**
5004	* regulator_bulk_disable - disable multiple regulator consumers
5005	*
5006	* @num_consumers: Number of consumers
5007	* @consumers: Consumer data; clients are stored here.
5008	* @return 0 on success, an errno on failure
5009	*
5010	* This convenience API allows consumers to disable multiple regulator
5011	* clients in a single API call. If any consumers cannot be disabled
5012	* then any others that were disabled will be enabled again prior to
5013	* return.
5014	*/
5015	int regulator_bulk_disable(int num_consumers,
5016	struct regulator_bulk_data *consumers)
5017	{
5018	int i;
5019	int ret, r;
5020
5021	for (i = num_consumers - 1; i >= 0; --i) {
5022	ret = regulator_disable(consumers[i].consumer);
5023	if (ret != 0)
5024	goto err;
5025	}
5026
5027	return 0;
5028
5029	err:
5030	pr_err("Failed to disable %s: %pe\n", consumers[i].supply, ERR_PTR(ret));
5031	for (++i; i < num_consumers; ++i) {
5032	r = regulator_enable(consumers[i].consumer);
5033	if (r != 0)
5034	pr_err("Failed to re-enable %s: %pe\n",
5035	consumers[i].supply, ERR_PTR(r));
5036	}
5037
5038	return ret;
5039	}
5040	EXPORT_SYMBOL_GPL(regulator_bulk_disable);
5041
5042	/**
5043	* regulator_bulk_force_disable - force disable multiple regulator consumers
5044	*
5045	* @num_consumers: Number of consumers
5046	* @consumers: Consumer data; clients are stored here.
5047	* @return 0 on success, an errno on failure
5048	*
5049	* This convenience API allows consumers to forcibly disable multiple regulator
5050	* clients in a single API call.
5051	* NOTE: This should be used for situations when device damage will
5052	* likely occur if the regulators are not disabled (e.g. over temp).
5053	* Although regulator_force_disable function call for some consumers can
5054	* return error numbers, the function is called for all consumers.
5055	*/
5056	int regulator_bulk_force_disable(int num_consumers,
5057	struct regulator_bulk_data *consumers)
5058	{
5059	int i;
5060	int ret = 0;
5061
5062	for (i = 0; i < num_consumers; i++) {
5063	consumers[i].ret =
5064	regulator_force_disable(consumers[i].consumer);
5065
5066	/* Store first error for reporting */
5067	if (consumers[i].ret && !ret)
5068	ret = consumers[i].ret;
5069	}
5070
5071	return ret;
5072	}
5073	EXPORT_SYMBOL_GPL(regulator_bulk_force_disable);
5074
5075	/**
5076	* regulator_bulk_free - free multiple regulator consumers
5077	*
5078	* @num_consumers: Number of consumers
5079	* @consumers: Consumer data; clients are stored here.
5080	*
5081	* This convenience API allows consumers to free multiple regulator
5082	* clients in a single API call.
5083	*/
5084	void regulator_bulk_free(int num_consumers,
5085	struct regulator_bulk_data *consumers)
5086	{
5087	int i;
5088
5089	for (i = 0; i < num_consumers; i++) {
5090	regulator_put(consumers[i].consumer);
5091	consumers[i].consumer = NULL;
5092	}
5093	}
5094	EXPORT_SYMBOL_GPL(regulator_bulk_free);
5095
5096	/**
5097	* regulator_handle_critical - Handle events for system-critical regulators.
5098	* @rdev: The regulator device.
5099	* @event: The event being handled.
5100	*
5101	* This function handles critical events such as under-voltage, over-current,
5102	* and unknown errors for regulators deemed system-critical. On detecting such
5103	* events, it triggers a hardware protection shutdown with a defined timeout.
5104	*/
5105	static void regulator_handle_critical(struct regulator_dev *rdev,
5106	unsigned long event)
5107	{
5108	const char *reason = NULL;
5109
5110	if (!rdev->constraints->system_critical)
5111	return;
5112
5113	switch (event) {
5114	case REGULATOR_EVENT_UNDER_VOLTAGE:
5115	reason = "System critical regulator: voltage drop detected";
5116	break;
5117	case REGULATOR_EVENT_OVER_CURRENT:
5118	reason = "System critical regulator: over-current detected";
5119	break;
5120	case REGULATOR_EVENT_FAIL:
5121	reason = "System critical regulator: unknown error";
5122	}
5123
5124	if (!reason)
5125	return;
5126
5127	hw_protection_shutdown(reason,
5128	ms_until_forced: rdev->constraints->uv_less_critical_window_ms);
5129	}
5130
5131	/**
5132	* regulator_notifier_call_chain - call regulator event notifier
5133	* @rdev: regulator source
5134	* @event: notifier block
5135	* @data: callback-specific data.
5136	*
5137	* Called by regulator drivers to notify clients a regulator event has
5138	* occurred.
5139	*/
5140	int regulator_notifier_call_chain(struct regulator_dev *rdev,
5141	unsigned long event, void *data)
5142	{
5143	regulator_handle_critical(rdev, event);
5144
5145	_notifier_call_chain(rdev, event, data);
5146	return NOTIFY_DONE;
5147
5148	}
5149	EXPORT_SYMBOL_GPL(regulator_notifier_call_chain);
5150
5151	/**
5152	* regulator_mode_to_status - convert a regulator mode into a status
5153	*
5154	* @mode: Mode to convert
5155	*
5156	* Convert a regulator mode into a status.
5157	*/
5158	int regulator_mode_to_status(unsigned int mode)
5159	{
5160	switch (mode) {
5161	case REGULATOR_MODE_FAST:
5162	return REGULATOR_STATUS_FAST;
5163	case REGULATOR_MODE_NORMAL:
5164	return REGULATOR_STATUS_NORMAL;
5165	case REGULATOR_MODE_IDLE:
5166	return REGULATOR_STATUS_IDLE;
5167	case REGULATOR_MODE_STANDBY:
5168	return REGULATOR_STATUS_STANDBY;
5169	default:
5170	return REGULATOR_STATUS_UNDEFINED;
5171	}
5172	}
5173	EXPORT_SYMBOL_GPL(regulator_mode_to_status);
5174
5175	static struct attribute *regulator_dev_attrs[] = {
5176	&dev_attr_name.attr,
5177	&dev_attr_num_users.attr,
5178	&dev_attr_type.attr,
5179	&dev_attr_microvolts.attr,
5180	&dev_attr_microamps.attr,
5181	&dev_attr_opmode.attr,
5182	&dev_attr_state.attr,
5183	&dev_attr_status.attr,
5184	&dev_attr_bypass.attr,
5185	&dev_attr_requested_microamps.attr,
5186	&dev_attr_min_microvolts.attr,
5187	&dev_attr_max_microvolts.attr,
5188	&dev_attr_min_microamps.attr,
5189	&dev_attr_max_microamps.attr,
5190	&dev_attr_under_voltage.attr,
5191	&dev_attr_over_current.attr,
5192	&dev_attr_regulation_out.attr,
5193	&dev_attr_fail.attr,
5194	&dev_attr_over_temp.attr,
5195	&dev_attr_under_voltage_warn.attr,
5196	&dev_attr_over_current_warn.attr,
5197	&dev_attr_over_voltage_warn.attr,
5198	&dev_attr_over_temp_warn.attr,
5199	&dev_attr_suspend_standby_state.attr,
5200	&dev_attr_suspend_mem_state.attr,
5201	&dev_attr_suspend_disk_state.attr,
5202	&dev_attr_suspend_standby_microvolts.attr,
5203	&dev_attr_suspend_mem_microvolts.attr,
5204	&dev_attr_suspend_disk_microvolts.attr,
5205	&dev_attr_suspend_standby_mode.attr,
5206	&dev_attr_suspend_mem_mode.attr,
5207	&dev_attr_suspend_disk_mode.attr,
5208	NULL
5209	};
5210
5211	/*
5212	* To avoid cluttering sysfs (and memory) with useless state, only
5213	* create attributes that can be meaningfully displayed.
5214	*/
5215	static umode_t regulator_attr_is_visible(struct kobject *kobj,
5216	struct attribute *attr, int idx)
5217	{
5218	struct device *dev = kobj_to_dev(kobj);
5219	struct regulator_dev *rdev = dev_to_rdev(dev);
5220	const struct regulator_ops *ops = rdev->desc->ops;
5221	umode_t mode = attr->mode;
5222
5223	/* these three are always present */
5224	if (attr == &dev_attr_name.attr ||
5225	attr == &dev_attr_num_users.attr ||
5226	attr == &dev_attr_type.attr)
5227	return mode;
5228
5229	/* some attributes need specific methods to be displayed */
5230	if (attr == &dev_attr_microvolts.attr) {
5231	if ((ops->get_voltage && ops->get_voltage(rdev) >= 0) ||
5232	(ops->get_voltage_sel && ops->get_voltage_sel(rdev) >= 0) ||
5233	(ops->list_voltage && ops->list_voltage(rdev, 0) >= 0) ||
5234	(rdev->desc->fixed_uV && rdev->desc->n_voltages == 1))
5235	return mode;
5236	return 0;
5237	}
5238
5239	if (attr == &dev_attr_microamps.attr)
5240	return ops->get_current_limit ? mode : 0;
5241
5242	if (attr == &dev_attr_opmode.attr)
5243	return ops->get_mode ? mode : 0;
5244
5245	if (attr == &dev_attr_state.attr)
5246	return (rdev->ena_pin || ops->is_enabled) ? mode : 0;
5247
5248	if (attr == &dev_attr_status.attr)
5249	return ops->get_status ? mode : 0;
5250
5251	if (attr == &dev_attr_bypass.attr)
5252	return ops->get_bypass ? mode : 0;
5253
5254	if (attr == &dev_attr_under_voltage.attr ||
5255	attr == &dev_attr_over_current.attr ||
5256	attr == &dev_attr_regulation_out.attr ||
5257	attr == &dev_attr_fail.attr ||
5258	attr == &dev_attr_over_temp.attr ||
5259	attr == &dev_attr_under_voltage_warn.attr ||
5260	attr == &dev_attr_over_current_warn.attr ||
5261	attr == &dev_attr_over_voltage_warn.attr ||
5262	attr == &dev_attr_over_temp_warn.attr)
5263	return ops->get_error_flags ? mode : 0;
5264
5265	/* constraints need specific supporting methods */
5266	if (attr == &dev_attr_min_microvolts.attr ||
5267	attr == &dev_attr_max_microvolts.attr)
5268	return (ops->set_voltage || ops->set_voltage_sel) ? mode : 0;
5269
5270	if (attr == &dev_attr_min_microamps.attr ||
5271	attr == &dev_attr_max_microamps.attr)
5272	return ops->set_current_limit ? mode : 0;
5273
5274	if (attr == &dev_attr_suspend_standby_state.attr ||
5275	attr == &dev_attr_suspend_mem_state.attr ||
5276	attr == &dev_attr_suspend_disk_state.attr)
5277	return mode;
5278
5279	if (attr == &dev_attr_suspend_standby_microvolts.attr ||
5280	attr == &dev_attr_suspend_mem_microvolts.attr ||
5281	attr == &dev_attr_suspend_disk_microvolts.attr)
5282	return ops->set_suspend_voltage ? mode : 0;
5283
5284	if (attr == &dev_attr_suspend_standby_mode.attr ||
5285	attr == &dev_attr_suspend_mem_mode.attr ||
5286	attr == &dev_attr_suspend_disk_mode.attr)
5287	return ops->set_suspend_mode ? mode : 0;
5288
5289	return mode;
5290	}
5291
5292	static const struct attribute_group regulator_dev_group = {
5293	.attrs = regulator_dev_attrs,
5294	.is_visible = regulator_attr_is_visible,
5295	};
5296
5297	static const struct attribute_group *regulator_dev_groups[] = {
5298	&regulator_dev_group,
5299	NULL
5300	};
5301
5302	static void regulator_dev_release(struct device *dev)
5303	{
5304	struct regulator_dev *rdev = dev_get_drvdata(dev);
5305
5306	debugfs_remove_recursive(dentry: rdev->debugfs);
5307	kfree(objp: rdev->constraints);
5308	of_node_put(node: rdev->dev.of_node);
5309	kfree(objp: rdev);
5310	}
5311
5312	static void rdev_init_debugfs(struct regulator_dev *rdev)
5313	{
5314	struct device *parent = rdev->dev.parent;
5315	const char *rname = rdev_get_name(rdev);
5316	char name[NAME_MAX];
5317
5318	/* Avoid duplicate debugfs directory names */
5319	if (parent && rname == rdev->desc->name) {
5320	snprintf(buf: name, size: sizeof(name), fmt: "%s-%s", dev_name(dev: parent),
5321	rname);
5322	rname = name;
5323	}
5324
5325	rdev->debugfs = debugfs_create_dir(name: rname, parent: debugfs_root);
5326	if (IS_ERR(ptr: rdev->debugfs))
5327	rdev_dbg(rdev, "Failed to create debugfs directory\n");
5328
5329	debugfs_create_u32(name: "use_count", mode: 0444, parent: rdev->debugfs,
5330	value: &rdev->use_count);
5331	debugfs_create_u32(name: "open_count", mode: 0444, parent: rdev->debugfs,
5332	value: &rdev->open_count);
5333	debugfs_create_u32(name: "bypass_count", mode: 0444, parent: rdev->debugfs,
5334	value: &rdev->bypass_count);
5335	}
5336
5337	static int regulator_register_resolve_supply(struct device *dev, void *data)
5338	{
5339	struct regulator_dev *rdev = dev_to_rdev(dev);
5340
5341	if (regulator_resolve_supply(rdev))
5342	rdev_dbg(rdev, "unable to resolve supply\n");
5343
5344	return 0;
5345	}
5346
5347	int regulator_coupler_register(struct regulator_coupler *coupler)
5348	{
5349	mutex_lock(&regulator_list_mutex);
5350	list_add_tail(new: &coupler->list, head: &regulator_coupler_list);
5351	mutex_unlock(lock: &regulator_list_mutex);
5352
5353	return 0;
5354	}
5355
5356	static struct regulator_coupler *
5357	regulator_find_coupler(struct regulator_dev *rdev)
5358	{
5359	struct regulator_coupler *coupler;
5360	int err;
5361
5362	/*
5363	* Note that regulators are appended to the list and the generic
5364	* coupler is registered first, hence it will be attached at last
5365	* if nobody cared.
5366	*/
5367	list_for_each_entry_reverse(coupler, &regulator_coupler_list, list) {
5368	err = coupler->attach_regulator(coupler, rdev);
5369	if (!err) {
5370	if (!coupler->balance_voltage &&
5371	rdev->coupling_desc.n_coupled > 2)
5372	goto err_unsupported;
5373
5374	return coupler;
5375	}
5376
5377	if (err < 0)
5378	return ERR_PTR(error: err);
5379
5380	if (err == 1)
5381	continue;
5382
5383	break;
5384	}
5385
5386	return ERR_PTR(error: -EINVAL);
5387
5388	err_unsupported:
5389	if (coupler->detach_regulator)
5390	coupler->detach_regulator(coupler, rdev);
5391
5392	rdev_err(rdev,
5393	"Voltage balancing for multiple regulator couples is unimplemented\n");
5394
5395	return ERR_PTR(error: -EPERM);
5396	}
5397
5398	static void regulator_resolve_coupling(struct regulator_dev *rdev)
5399	{
5400	struct regulator_coupler *coupler = rdev->coupling_desc.coupler;
5401	struct coupling_desc *c_desc = &rdev->coupling_desc;
5402	int n_coupled = c_desc->n_coupled;
5403	struct regulator_dev *c_rdev;
5404	int i;
5405
5406	for (i = 1; i < n_coupled; i++) {
5407	/* already resolved */
5408	if (c_desc->coupled_rdevs[i])
5409	continue;
5410
5411	c_rdev = of_parse_coupled_regulator(rdev, index: i - 1);
5412
5413	if (!c_rdev)
5414	continue;
5415
5416	if (c_rdev->coupling_desc.coupler != coupler) {
5417	rdev_err(rdev, "coupler mismatch with %s\n",
5418	rdev_get_name(c_rdev));
5419	return;
5420	}
5421
5422	c_desc->coupled_rdevs[i] = c_rdev;
5423	c_desc->n_resolved++;
5424
5425	regulator_resolve_coupling(rdev: c_rdev);
5426	}
5427	}
5428
5429	static void regulator_remove_coupling(struct regulator_dev *rdev)
5430	{
5431	struct regulator_coupler *coupler = rdev->coupling_desc.coupler;
5432	struct coupling_desc *__c_desc, *c_desc = &rdev->coupling_desc;
5433	struct regulator_dev *__c_rdev, *c_rdev;
5434	unsigned int __n_coupled, n_coupled;
5435	int i, k;
5436	int err;
5437
5438	n_coupled = c_desc->n_coupled;
5439
5440	for (i = 1; i < n_coupled; i++) {
5441	c_rdev = c_desc->coupled_rdevs[i];
5442
5443	if (!c_rdev)
5444	continue;
5445
5446	regulator_lock(rdev: c_rdev);
5447
5448	__c_desc = &c_rdev->coupling_desc;
5449	__n_coupled = __c_desc->n_coupled;
5450
5451	for (k = 1; k < __n_coupled; k++) {
5452	__c_rdev = __c_desc->coupled_rdevs[k];
5453
5454	if (__c_rdev == rdev) {
5455	__c_desc->coupled_rdevs[k] = NULL;
5456	__c_desc->n_resolved--;
5457	break;
5458	}
5459	}
5460
5461	regulator_unlock(rdev: c_rdev);
5462
5463	c_desc->coupled_rdevs[i] = NULL;
5464	c_desc->n_resolved--;
5465	}
5466
5467	if (coupler && coupler->detach_regulator) {
5468	err = coupler->detach_regulator(coupler, rdev);
5469	if (err)
5470	rdev_err(rdev, "failed to detach from coupler: %pe\n",
5471	ERR_PTR(err));
5472	}
5473
5474	kfree(objp: rdev->coupling_desc.coupled_rdevs);
5475	rdev->coupling_desc.coupled_rdevs = NULL;
5476	}
5477
5478	static int regulator_init_coupling(struct regulator_dev *rdev)
5479	{
5480	struct regulator_dev **coupled;
5481	int err, n_phandles;
5482
5483	if (!IS_ENABLED(CONFIG_OF))
5484	n_phandles = 0;
5485	else
5486	n_phandles = of_get_n_coupled(rdev);
5487
5488	coupled = kcalloc(n: n_phandles + 1, size: sizeof(*coupled), GFP_KERNEL);
5489	if (!coupled)
5490	return -ENOMEM;
5491
5492	rdev->coupling_desc.coupled_rdevs = coupled;
5493
5494	/*
5495	* Every regulator should always have coupling descriptor filled with
5496	* at least pointer to itself.
5497	*/
5498	rdev->coupling_desc.coupled_rdevs[0] = rdev;
5499	rdev->coupling_desc.n_coupled = n_phandles + 1;
5500	rdev->coupling_desc.n_resolved++;
5501
5502	/* regulator isn't coupled */
5503	if (n_phandles == 0)
5504	return 0;
5505
5506	if (!of_check_coupling_data(rdev))
5507	return -EPERM;
5508
5509	mutex_lock(&regulator_list_mutex);
5510	rdev->coupling_desc.coupler = regulator_find_coupler(rdev);
5511	mutex_unlock(lock: &regulator_list_mutex);
5512
5513	if (IS_ERR(ptr: rdev->coupling_desc.coupler)) {
5514	err = PTR_ERR(ptr: rdev->coupling_desc.coupler);
5515	rdev_err(rdev, "failed to get coupler: %pe\n", ERR_PTR(err));
5516	return err;
5517	}
5518
5519	return 0;
5520	}
5521
5522	static int generic_coupler_attach(struct regulator_coupler *coupler,
5523	struct regulator_dev *rdev)
5524	{
5525	if (rdev->coupling_desc.n_coupled > 2) {
5526	rdev_err(rdev,
5527	"Voltage balancing for multiple regulator couples is unimplemented\n");
5528	return -EPERM;
5529	}
5530
5531	if (!rdev->constraints->always_on) {
5532	rdev_err(rdev,
5533	"Coupling of a non always-on regulator is unimplemented\n");
5534	return -ENOTSUPP;
5535	}
5536
5537	return 0;
5538	}
5539
5540	static struct regulator_coupler generic_regulator_coupler = {
5541	.attach_regulator = generic_coupler_attach,
5542	};
5543
5544	/**
5545	* regulator_register - register regulator
5546	* @dev: the device that drive the regulator
5547	* @regulator_desc: regulator to register
5548	* @cfg: runtime configuration for regulator
5549	*
5550	* Called by regulator drivers to register a regulator.
5551	* Returns a valid pointer to struct regulator_dev on success
5552	* or an ERR_PTR() on error.
5553	*/
5554	struct regulator_dev *
5555	regulator_register(struct device *dev,
5556	const struct regulator_desc *regulator_desc,
5557	const struct regulator_config *cfg)
5558	{
5559	const struct regulator_init_data *init_data;
5560	struct regulator_config *config = NULL;
5561	static atomic_t regulator_no = ATOMIC_INIT(-1);
5562	struct regulator_dev *rdev;
5563	bool dangling_cfg_gpiod = false;
5564	bool dangling_of_gpiod = false;
5565	int ret, i;
5566	bool resolved_early = false;
5567
5568	if (cfg == NULL)
5569	return ERR_PTR(error: -EINVAL);
5570	if (cfg->ena_gpiod)
5571	dangling_cfg_gpiod = true;
5572	if (regulator_desc == NULL) {
5573	ret = -EINVAL;
5574	goto rinse;
5575	}
5576
5577	WARN_ON(!dev || !cfg->dev);
5578
5579	if (regulator_desc->name == NULL || regulator_desc->ops == NULL) {
5580	ret = -EINVAL;
5581	goto rinse;
5582	}
5583
5584	if (regulator_desc->type != REGULATOR_VOLTAGE &&
5585	regulator_desc->type != REGULATOR_CURRENT) {
5586	ret = -EINVAL;
5587	goto rinse;
5588	}
5589
5590	/* Only one of each should be implemented */
5591	WARN_ON(regulator_desc->ops->get_voltage &&
5592	regulator_desc->ops->get_voltage_sel);
5593	WARN_ON(regulator_desc->ops->set_voltage &&
5594	regulator_desc->ops->set_voltage_sel);
5595
5596	/* If we're using selectors we must implement list_voltage. */
5597	if (regulator_desc->ops->get_voltage_sel &&
5598	!regulator_desc->ops->list_voltage) {
5599	ret = -EINVAL;
5600	goto rinse;
5601	}
5602	if (regulator_desc->ops->set_voltage_sel &&
5603	!regulator_desc->ops->list_voltage) {
5604	ret = -EINVAL;
5605	goto rinse;
5606	}
5607
5608	rdev = kzalloc(size: sizeof(struct regulator_dev), GFP_KERNEL);
5609	if (rdev == NULL) {
5610	ret = -ENOMEM;
5611	goto rinse;
5612	}
5613	device_initialize(dev: &rdev->dev);
5614	dev_set_drvdata(dev: &rdev->dev, data: rdev);
5615	rdev->dev.class = &regulator_class;
5616	spin_lock_init(&rdev->err_lock);
5617
5618	/*
5619	* Duplicate the config so the driver could override it after
5620	* parsing init data.
5621	*/
5622	config = kmemdup(p: cfg, size: sizeof(*cfg), GFP_KERNEL);
5623	if (config == NULL) {
5624	ret = -ENOMEM;
5625	goto clean;
5626	}
5627
5628	init_data = regulator_of_get_init_data(dev, desc: regulator_desc, config,
5629	node: &rdev->dev.of_node);
5630
5631	/*
5632	* Sometimes not all resources are probed already so we need to take
5633	* that into account. This happens most the time if the ena_gpiod comes
5634	* from a gpio extender or something else.
5635	*/
5636	if (PTR_ERR(ptr: init_data) == -EPROBE_DEFER) {
5637	ret = -EPROBE_DEFER;
5638	goto clean;
5639	}
5640
5641	/*
5642	* We need to keep track of any GPIO descriptor coming from the
5643	* device tree until we have handled it over to the core. If the
5644	* config that was passed in to this function DOES NOT contain
5645	* a descriptor, and the config after this call DOES contain
5646	* a descriptor, we definitely got one from parsing the device
5647	* tree.
5648	*/
5649	if (!cfg->ena_gpiod && config->ena_gpiod)
5650	dangling_of_gpiod = true;
5651	if (!init_data) {
5652	init_data = config->init_data;
5653	rdev->dev.of_node = of_node_get(node: config->of_node);
5654	}
5655
5656	ww_mutex_init(lock: &rdev->mutex, ww_class: &regulator_ww_class);
5657	rdev->reg_data = config->driver_data;
5658	rdev->owner = regulator_desc->owner;
5659	rdev->desc = regulator_desc;
5660	if (config->regmap)
5661	rdev->regmap = config->regmap;
5662	else if (dev_get_regmap(dev, NULL))
5663	rdev->regmap = dev_get_regmap(dev, NULL);
5664	else if (dev->parent)
5665	rdev->regmap = dev_get_regmap(dev: dev->parent, NULL);
5666	INIT_LIST_HEAD(list: &rdev->consumer_list);
5667	INIT_LIST_HEAD(list: &rdev->list);
5668	BLOCKING_INIT_NOTIFIER_HEAD(&rdev->notifier);
5669	INIT_DELAYED_WORK(&rdev->disable_work, regulator_disable_work);
5670
5671	if (init_data && init_data->supply_regulator)
5672	rdev->supply_name = init_data->supply_regulator;
5673	else if (regulator_desc->supply_name)
5674	rdev->supply_name = regulator_desc->supply_name;
5675
5676	/* register with sysfs */
5677	rdev->dev.parent = config->dev;
5678	dev_set_name(dev: &rdev->dev, name: "regulator.%lu",
5679	(unsigned long) atomic_inc_return(v: &regulator_no));
5680
5681	/* set regulator constraints */
5682	if (init_data)
5683	rdev->constraints = kmemdup(p: &init_data->constraints,
5684	size: sizeof(*rdev->constraints),
5685	GFP_KERNEL);
5686	else
5687	rdev->constraints = kzalloc(size: sizeof(*rdev->constraints),
5688	GFP_KERNEL);
5689	if (!rdev->constraints) {
5690	ret = -ENOMEM;
5691	goto wash;
5692	}
5693
5694	if ((rdev->supply_name && !rdev->supply) &&
5695	(rdev->constraints->always_on ||
5696	rdev->constraints->boot_on)) {
5697	ret = regulator_resolve_supply(rdev);
5698	if (ret)
5699	rdev_dbg(rdev, "unable to resolve supply early: %pe\n",
5700	ERR_PTR(ret));
5701
5702	resolved_early = true;
5703	}
5704
5705	/* perform any regulator specific init */
5706	if (init_data && init_data->regulator_init) {
5707	ret = init_data->regulator_init(rdev->reg_data);
5708	if (ret < 0)
5709	goto wash;
5710	}
5711
5712	if (config->ena_gpiod) {
5713	ret = regulator_ena_gpio_request(rdev, config);
5714	if (ret != 0) {
5715	rdev_err(rdev, "Failed to request enable GPIO: %pe\n",
5716	ERR_PTR(ret));
5717	goto wash;
5718	}
5719	/* The regulator core took over the GPIO descriptor */
5720	dangling_cfg_gpiod = false;
5721	dangling_of_gpiod = false;
5722	}
5723
5724	ret = set_machine_constraints(rdev);
5725	if (ret == -EPROBE_DEFER && !resolved_early) {
5726	/* Regulator might be in bypass mode and so needs its supply
5727	* to set the constraints
5728	*/
5729	/* FIXME: this currently triggers a chicken-and-egg problem
5730	* when creating -SUPPLY symlink in sysfs to a regulator
5731	* that is just being created
5732	*/
5733	rdev_dbg(rdev, "will resolve supply early: %s\n",
5734	rdev->supply_name);
5735	ret = regulator_resolve_supply(rdev);
5736	if (!ret)
5737	ret = set_machine_constraints(rdev);
5738	else
5739	rdev_dbg(rdev, "unable to resolve supply early: %pe\n",
5740	ERR_PTR(ret));
5741	}
5742	if (ret < 0)
5743	goto wash;
5744
5745	ret = regulator_init_coupling(rdev);
5746	if (ret < 0)
5747	goto wash;
5748
5749	/* add consumers devices */
5750	if (init_data) {
5751	for (i = 0; i < init_data->num_consumer_supplies; i++) {
5752	ret = set_consumer_device_supply(rdev,
5753	consumer_dev_name: init_data->consumer_supplies[i].dev_name,
5754	supply: init_data->consumer_supplies[i].supply);
5755	if (ret < 0) {
5756	dev_err(dev, "Failed to set supply %s\n",
5757	init_data->consumer_supplies[i].supply);
5758	goto unset_supplies;
5759	}
5760	}
5761	}
5762
5763	if (!rdev->desc->ops->get_voltage &&
5764	!rdev->desc->ops->list_voltage &&
5765	!rdev->desc->fixed_uV)
5766	rdev->is_switch = true;
5767
5768	ret = device_add(dev: &rdev->dev);
5769	if (ret != 0)
5770	goto unset_supplies;
5771
5772	rdev_init_debugfs(rdev);
5773
5774	/* try to resolve regulators coupling since a new one was registered */
5775	mutex_lock(&regulator_list_mutex);
5776	regulator_resolve_coupling(rdev);
5777	mutex_unlock(lock: &regulator_list_mutex);
5778
5779	/* try to resolve regulators supply since a new one was registered */
5780	class_for_each_device(class: &regulator_class, NULL, NULL,
5781	fn: regulator_register_resolve_supply);
5782	kfree(objp: config);
5783	return rdev;
5784
5785	unset_supplies:
5786	mutex_lock(&regulator_list_mutex);
5787	unset_regulator_supplies(rdev);
5788	regulator_remove_coupling(rdev);
5789	mutex_unlock(lock: &regulator_list_mutex);
5790	wash:
5791	regulator_put(rdev->supply);
5792	kfree(objp: rdev->coupling_desc.coupled_rdevs);
5793	mutex_lock(&regulator_list_mutex);
5794	regulator_ena_gpio_free(rdev);
5795	mutex_unlock(lock: &regulator_list_mutex);
5796	clean:
5797	if (dangling_of_gpiod)
5798	gpiod_put(desc: config->ena_gpiod);
5799	kfree(objp: config);
5800	put_device(dev: &rdev->dev);
5801	rinse:
5802	if (dangling_cfg_gpiod)
5803	gpiod_put(desc: cfg->ena_gpiod);
5804	return ERR_PTR(error: ret);
5805	}
5806	EXPORT_SYMBOL_GPL(regulator_register);
5807
5808	/**
5809	* regulator_unregister - unregister regulator
5810	* @rdev: regulator to unregister
5811	*
5812	* Called by regulator drivers to unregister a regulator.
5813	*/
5814	void regulator_unregister(struct regulator_dev *rdev)
5815	{
5816	if (rdev == NULL)
5817	return;
5818
5819	if (rdev->supply) {
5820	while (rdev->use_count--)
5821	regulator_disable(rdev->supply);
5822	regulator_put(rdev->supply);
5823	}
5824
5825	flush_work(work: &rdev->disable_work.work);
5826
5827	mutex_lock(&regulator_list_mutex);
5828
5829	WARN_ON(rdev->open_count);
5830	regulator_remove_coupling(rdev);
5831	unset_regulator_supplies(rdev);
5832	list_del(entry: &rdev->list);
5833	regulator_ena_gpio_free(rdev);
5834	device_unregister(dev: &rdev->dev);
5835
5836	mutex_unlock(lock: &regulator_list_mutex);
5837	}
5838	EXPORT_SYMBOL_GPL(regulator_unregister);
5839
5840	#ifdef CONFIG_SUSPEND
5841	/**
5842	* regulator_suspend - prepare regulators for system wide suspend
5843	* @dev: ``&struct device`` pointer that is passed to _regulator_suspend()
5844	*
5845	* Configure each regulator with it's suspend operating parameters for state.
5846	*/
5847	static int regulator_suspend(struct device *dev)
5848	{
5849	struct regulator_dev *rdev = dev_to_rdev(dev);
5850	suspend_state_t state = pm_suspend_target_state;
5851	int ret;
5852	const struct regulator_state *rstate;
5853
5854	rstate = regulator_get_suspend_state_check(rdev, state);
5855	if (!rstate)
5856	return 0;
5857
5858	regulator_lock(rdev);
5859	ret = __suspend_set_state(rdev, rstate);
5860	regulator_unlock(rdev);
5861
5862	return ret;
5863	}
5864
5865	static int regulator_resume(struct device *dev)
5866	{
5867	suspend_state_t state = pm_suspend_target_state;
5868	struct regulator_dev *rdev = dev_to_rdev(dev);
5869	struct regulator_state *rstate;
5870	int ret = 0;
5871
5872	rstate = regulator_get_suspend_state(rdev, state);
5873	if (rstate == NULL)
5874	return 0;
5875
5876	/* Avoid grabbing the lock if we don't need to */
5877	if (!rdev->desc->ops->resume)
5878	return 0;
5879
5880	regulator_lock(rdev);
5881
5882	if (rstate->enabled == ENABLE_IN_SUSPEND ||
5883	rstate->enabled == DISABLE_IN_SUSPEND)
5884	ret = rdev->desc->ops->resume(rdev);
5885
5886	regulator_unlock(rdev);
5887
5888	return ret;
5889	}
5890	#else /* !CONFIG_SUSPEND */
5891
5892	#define regulator_suspend NULL
5893	#define regulator_resume NULL
5894
5895	#endif /* !CONFIG_SUSPEND */
5896
5897	#ifdef CONFIG_PM
5898	static const struct dev_pm_ops __maybe_unused regulator_pm_ops = {
5899	.suspend = regulator_suspend,
5900	.resume = regulator_resume,
5901	};
5902	#endif
5903
5904	const struct class regulator_class = {
5905	.name = "regulator",
5906	.dev_release = regulator_dev_release,
5907	.dev_groups = regulator_dev_groups,
5908	#ifdef CONFIG_PM
5909	.pm = &regulator_pm_ops,
5910	#endif
5911	};
5912	/**
5913	* regulator_has_full_constraints - the system has fully specified constraints
5914	*
5915	* Calling this function will cause the regulator API to disable all
5916	* regulators which have a zero use count and don't have an always_on
5917	* constraint in a late_initcall.
5918	*
5919	* The intention is that this will become the default behaviour in a
5920	* future kernel release so users are encouraged to use this facility
5921	* now.
5922	*/
5923	void regulator_has_full_constraints(void)
5924	{
5925	has_full_constraints = 1;
5926	}
5927	EXPORT_SYMBOL_GPL(regulator_has_full_constraints);
5928
5929	/**
5930	* rdev_get_drvdata - get rdev regulator driver data
5931	* @rdev: regulator
5932	*
5933	* Get rdev regulator driver private data. This call can be used in the
5934	* regulator driver context.
5935	*/
5936	void *rdev_get_drvdata(struct regulator_dev *rdev)
5937	{
5938	return rdev->reg_data;
5939	}
5940	EXPORT_SYMBOL_GPL(rdev_get_drvdata);
5941
5942	/**
5943	* regulator_get_drvdata - get regulator driver data
5944	* @regulator: regulator
5945	*
5946	* Get regulator driver private data. This call can be used in the consumer
5947	* driver context when non API regulator specific functions need to be called.
5948	*/
5949	void *regulator_get_drvdata(struct regulator *regulator)
5950	{
5951	return regulator->rdev->reg_data;
5952	}
5953	EXPORT_SYMBOL_GPL(regulator_get_drvdata);
5954
5955	/**
5956	* regulator_set_drvdata - set regulator driver data
5957	* @regulator: regulator
5958	* @data: data
5959	*/
5960	void regulator_set_drvdata(struct regulator *regulator, void *data)
5961	{
5962	regulator->rdev->reg_data = data;
5963	}
5964	EXPORT_SYMBOL_GPL(regulator_set_drvdata);
5965
5966	/**
5967	* rdev_get_id - get regulator ID
5968	* @rdev: regulator
5969	*/
5970	int rdev_get_id(struct regulator_dev *rdev)
5971	{
5972	return rdev->desc->id;
5973	}
5974	EXPORT_SYMBOL_GPL(rdev_get_id);
5975
5976	struct device *rdev_get_dev(struct regulator_dev *rdev)
5977	{
5978	return &rdev->dev;
5979	}
5980	EXPORT_SYMBOL_GPL(rdev_get_dev);
5981
5982	struct regmap *rdev_get_regmap(struct regulator_dev *rdev)
5983	{
5984	return rdev->regmap;
5985	}
5986	EXPORT_SYMBOL_GPL(rdev_get_regmap);
5987
5988	void *regulator_get_init_drvdata(struct regulator_init_data *reg_init_data)
5989	{
5990	return reg_init_data->driver_data;
5991	}
5992	EXPORT_SYMBOL_GPL(regulator_get_init_drvdata);
5993
5994	#ifdef CONFIG_DEBUG_FS
5995	static int supply_map_show(struct seq_file *sf, void *data)
5996	{
5997	struct regulator_map *map;
5998
5999	list_for_each_entry(map, &regulator_map_list, list) {
6000	seq_printf(m: sf, fmt: "%s -> %s.%s\n",
6001	rdev_get_name(map->regulator), map->dev_name,
6002	map->supply);
6003	}
6004
6005	return 0;
6006	}
6007	DEFINE_SHOW_ATTRIBUTE(supply_map);
6008
6009	struct summary_data {
6010	struct seq_file *s;
6011	struct regulator_dev *parent;
6012	int level;
6013	};
6014
6015	static void regulator_summary_show_subtree(struct seq_file *s,
6016	struct regulator_dev *rdev,
6017	int level);
6018
6019	static int regulator_summary_show_children(struct device *dev, void *data)
6020	{
6021	struct regulator_dev *rdev = dev_to_rdev(dev);
6022	struct summary_data *summary_data = data;
6023
6024	if (rdev->supply && rdev->supply->rdev == summary_data->parent)
6025	regulator_summary_show_subtree(s: summary_data->s, rdev,
6026	level: summary_data->level + 1);
6027
6028	return 0;
6029	}
6030
6031	static void regulator_summary_show_subtree(struct seq_file *s,
6032	struct regulator_dev *rdev,
6033	int level)
6034	{
6035	struct regulation_constraints *c;
6036	struct regulator *consumer;
6037	struct summary_data summary_data;
6038	unsigned int opmode;
6039
6040	if (!rdev)
6041	return;
6042
6043	opmode = _regulator_get_mode_unlocked(rdev);
6044	seq_printf(m: s, fmt: "%*s%-*s %3d %4d %6d %7s ",
6045	level * 3 + 1, "",
6046	30 - level * 3, rdev_get_name(rdev),
6047	rdev->use_count, rdev->open_count, rdev->bypass_count,
6048	regulator_opmode_to_str(mode: opmode));
6049
6050	seq_printf(m: s, fmt: "%5dmV ", regulator_get_voltage_rdev(rdev) / 1000);
6051	seq_printf(m: s, fmt: "%5dmA ",
6052	_regulator_get_current_limit_unlocked(rdev) / 1000);
6053
6054	c = rdev->constraints;
6055	if (c) {
6056	switch (rdev->desc->type) {
6057	case REGULATOR_VOLTAGE:
6058	seq_printf(m: s, fmt: "%5dmV %5dmV ",
6059	c->min_uV / 1000, c->max_uV / 1000);
6060	break;
6061	case REGULATOR_CURRENT:
6062	seq_printf(m: s, fmt: "%5dmA %5dmA ",
6063	c->min_uA / 1000, c->max_uA / 1000);
6064	break;
6065	}
6066	}
6067
6068	seq_puts(m: s, s: "\n");
6069
6070	list_for_each_entry(consumer, &rdev->consumer_list, list) {
6071	if (consumer->dev && consumer->dev->class == &regulator_class)
6072	continue;
6073
6074	seq_printf(m: s, fmt: "%*s%-*s ",
6075	(level + 1) * 3 + 1, "",
6076	30 - (level + 1) * 3,
6077	consumer->supply_name ? consumer->supply_name :
6078	consumer->dev ? dev_name(dev: consumer->dev) : "deviceless");
6079
6080	switch (rdev->desc->type) {
6081	case REGULATOR_VOLTAGE:
6082	seq_printf(m: s, fmt: "%3d %33dmA%c%5dmV %5dmV",
6083	consumer->enable_count,
6084	consumer->uA_load / 1000,
6085	consumer->uA_load && !consumer->enable_count ?
6086	'*' : ' ',
6087	consumer->voltage[PM_SUSPEND_ON].min_uV / 1000,
6088	consumer->voltage[PM_SUSPEND_ON].max_uV / 1000);
6089	break;
6090	case REGULATOR_CURRENT:
6091	break;
6092	}
6093
6094	seq_puts(m: s, s: "\n");
6095	}
6096
6097	summary_data.s = s;
6098	summary_data.level = level;
6099	summary_data.parent = rdev;
6100
6101	class_for_each_device(class: &regulator_class, NULL, data: &summary_data,
6102	fn: regulator_summary_show_children);
6103	}
6104
6105	struct summary_lock_data {
6106	struct ww_acquire_ctx *ww_ctx;
6107	struct regulator_dev **new_contended_rdev;
6108	struct regulator_dev **old_contended_rdev;
6109	};
6110
6111	static int regulator_summary_lock_one(struct device *dev, void *data)
6112	{
6113	struct regulator_dev *rdev = dev_to_rdev(dev);
6114	struct summary_lock_data *lock_data = data;
6115	int ret = 0;
6116
6117	if (rdev != *lock_data->old_contended_rdev) {
6118	ret = regulator_lock_nested(rdev, ww_ctx: lock_data->ww_ctx);
6119
6120	if (ret == -EDEADLK)
6121	*lock_data->new_contended_rdev = rdev;
6122	else
6123	WARN_ON_ONCE(ret);
6124	} else {
6125	*lock_data->old_contended_rdev = NULL;
6126	}
6127
6128	return ret;
6129	}
6130
6131	static int regulator_summary_unlock_one(struct device *dev, void *data)
6132	{
6133	struct regulator_dev *rdev = dev_to_rdev(dev);
6134	struct summary_lock_data *lock_data = data;
6135
6136	if (lock_data) {
6137	if (rdev == *lock_data->new_contended_rdev)
6138	return -EDEADLK;
6139	}
6140
6141	regulator_unlock(rdev);
6142
6143	return 0;
6144	}
6145
6146	static int regulator_summary_lock_all(struct ww_acquire_ctx *ww_ctx,
6147	struct regulator_dev **new_contended_rdev,
6148	struct regulator_dev **old_contended_rdev)
6149	{
6150	struct summary_lock_data lock_data;
6151	int ret;
6152
6153	lock_data.ww_ctx = ww_ctx;
6154	lock_data.new_contended_rdev = new_contended_rdev;
6155	lock_data.old_contended_rdev = old_contended_rdev;
6156
6157	ret = class_for_each_device(class: &regulator_class, NULL, data: &lock_data,
6158	fn: regulator_summary_lock_one);
6159	if (ret)
6160	class_for_each_device(class: &regulator_class, NULL, data: &lock_data,
6161	fn: regulator_summary_unlock_one);
6162
6163	return ret;
6164	}
6165
6166	static void regulator_summary_lock(struct ww_acquire_ctx *ww_ctx)
6167	{
6168	struct regulator_dev *new_contended_rdev = NULL;
6169	struct regulator_dev *old_contended_rdev = NULL;
6170	int err;
6171
6172	mutex_lock(&regulator_list_mutex);
6173
6174	ww_acquire_init(ctx: ww_ctx, ww_class: &regulator_ww_class);
6175
6176	do {
6177	if (new_contended_rdev) {
6178	ww_mutex_lock_slow(lock: &new_contended_rdev->mutex, ctx: ww_ctx);
6179	old_contended_rdev = new_contended_rdev;
6180	old_contended_rdev->ref_cnt++;
6181	old_contended_rdev->mutex_owner = current;
6182	}
6183
6184	err = regulator_summary_lock_all(ww_ctx,
6185	new_contended_rdev: &new_contended_rdev,
6186	old_contended_rdev: &old_contended_rdev);
6187
6188	if (old_contended_rdev)
6189	regulator_unlock(rdev: old_contended_rdev);
6190
6191	} while (err == -EDEADLK);
6192
6193	ww_acquire_done(ctx: ww_ctx);
6194	}
6195
6196	static void regulator_summary_unlock(struct ww_acquire_ctx *ww_ctx)
6197	{
6198	class_for_each_device(class: &regulator_class, NULL, NULL,
6199	fn: regulator_summary_unlock_one);
6200	ww_acquire_fini(ctx: ww_ctx);
6201
6202	mutex_unlock(lock: &regulator_list_mutex);
6203	}
6204
6205	static int regulator_summary_show_roots(struct device *dev, void *data)
6206	{
6207	struct regulator_dev *rdev = dev_to_rdev(dev);
6208	struct seq_file *s = data;
6209
6210	if (!rdev->supply)
6211	regulator_summary_show_subtree(s, rdev, level: 0);
6212
6213	return 0;
6214	}
6215
6216	static int regulator_summary_show(struct seq_file *s, void *data)
6217	{
6218	struct ww_acquire_ctx ww_ctx;
6219
6220	seq_puts(m: s, s: " regulator use open bypass opmode voltage current min max\n");
6221	seq_puts(m: s, s: "---------------------------------------------------------------------------------------\n");
6222
6223	regulator_summary_lock(ww_ctx: &ww_ctx);
6224
6225	class_for_each_device(class: &regulator_class, NULL, data: s,
6226	fn: regulator_summary_show_roots);
6227
6228	regulator_summary_unlock(ww_ctx: &ww_ctx);
6229
6230	return 0;
6231	}
6232	DEFINE_SHOW_ATTRIBUTE(regulator_summary);
6233	#endif /* CONFIG_DEBUG_FS */
6234
6235	static int __init regulator_init(void)
6236	{
6237	int ret;
6238
6239	ret = class_register(class: &regulator_class);
6240
6241	debugfs_root = debugfs_create_dir(name: "regulator", NULL);
6242	if (IS_ERR(ptr: debugfs_root))
6243	pr_debug("regulator: Failed to create debugfs directory\n");
6244
6245	#ifdef CONFIG_DEBUG_FS
6246	debugfs_create_file(name: "supply_map", mode: 0444, parent: debugfs_root, NULL,
6247	fops: &supply_map_fops);
6248
6249	debugfs_create_file(name: "regulator_summary", mode: 0444, parent: debugfs_root,
6250	NULL, fops: &regulator_summary_fops);
6251	#endif
6252	regulator_dummy_init();
6253
6254	regulator_coupler_register(coupler: &generic_regulator_coupler);
6255
6256	return ret;
6257	}
6258
6259	/* init early to allow our consumers to complete system booting */
6260	core_initcall(regulator_init);
6261
6262	static int regulator_late_cleanup(struct device *dev, void *data)
6263	{
6264	struct regulator_dev *rdev = dev_to_rdev(dev);
6265	struct regulation_constraints *c = rdev->constraints;
6266	int ret;
6267
6268	if (c && c->always_on)
6269	return 0;
6270
6271	if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_STATUS))
6272	return 0;
6273
6274	regulator_lock(rdev);
6275
6276	if (rdev->use_count)
6277	goto unlock;
6278
6279	/* If reading the status failed, assume that it's off. */
6280	if (_regulator_is_enabled(rdev) <= 0)
6281	goto unlock;
6282
6283	if (have_full_constraints()) {
6284	/* We log since this may kill the system if it goes
6285	* wrong.
6286	*/
6287	rdev_info(rdev, "disabling\n");
6288	ret = _regulator_do_disable(rdev);
6289	if (ret != 0)
6290	rdev_err(rdev, "couldn't disable: %pe\n", ERR_PTR(ret));
6291	} else {
6292	/* The intention is that in future we will
6293	* assume that full constraints are provided
6294	* so warn even if we aren't going to do
6295	* anything here.
6296	*/
6297	rdev_warn(rdev, "incomplete constraints, leaving on\n");
6298	}
6299
6300	unlock:
6301	regulator_unlock(rdev);
6302
6303	return 0;
6304	}
6305
6306	static bool regulator_ignore_unused;
6307	static int __init regulator_ignore_unused_setup(char *__unused)
6308	{
6309	regulator_ignore_unused = true;
6310	return 1;
6311	}
6312	__setup("regulator_ignore_unused", regulator_ignore_unused_setup);
6313
6314	static void regulator_init_complete_work_function(struct work_struct *work)
6315	{
6316	/*
6317	* Regulators may had failed to resolve their input supplies
6318	* when were registered, either because the input supply was
6319	* not registered yet or because its parent device was not
6320	* bound yet. So attempt to resolve the input supplies for
6321	* pending regulators before trying to disable unused ones.
6322	*/
6323	class_for_each_device(class: &regulator_class, NULL, NULL,
6324	fn: regulator_register_resolve_supply);
6325
6326	/*
6327	* For debugging purposes, it may be useful to prevent unused
6328	* regulators from being disabled.
6329	*/
6330	if (regulator_ignore_unused) {
6331	pr_warn("regulator: Not disabling unused regulators\n");
6332	return;
6333	}
6334
6335	/* If we have a full configuration then disable any regulators
6336	* we have permission to change the status for and which are
6337	* not in use or always_on. This is effectively the default
6338	* for DT and ACPI as they have full constraints.
6339	*/
6340	class_for_each_device(class: &regulator_class, NULL, NULL,
6341	fn: regulator_late_cleanup);
6342	}
6343
6344	static DECLARE_DELAYED_WORK(regulator_init_complete_work,
6345	regulator_init_complete_work_function);
6346
6347	static int __init regulator_init_complete(void)
6348	{
6349	/*
6350	* Since DT doesn't provide an idiomatic mechanism for
6351	* enabling full constraints and since it's much more natural
6352	* with DT to provide them just assume that a DT enabled
6353	* system has full constraints.
6354	*/
6355	if (of_have_populated_dt())
6356	has_full_constraints = true;
6357
6358	/*
6359	* We punt completion for an arbitrary amount of time since
6360	* systems like distros will load many drivers from userspace
6361	* so consumers might not always be ready yet, this is
6362	* particularly an issue with laptops where this might bounce
6363	* the display off then on. Ideally we'd get a notification
6364	* from userspace when this happens but we don't so just wait
6365	* a bit and hope we waited long enough. It'd be better if
6366	* we'd only do this on systems that need it, and a kernel
6367	* command line option might be useful.
6368	*/
6369	schedule_delayed_work(dwork: &regulator_init_complete_work,
6370	delay: msecs_to_jiffies(m: 30000));
6371
6372	return 0;
6373	}
6374	late_initcall_sync(regulator_init_complete);
6375