Merge remote-tracking branches 'regulator/topic/of', 'regulator/topic/pwm',...

Qualcomm SPMI Regulators

- compatible:

	Usage: required

	Value type: <string>

	Definition: must be one of:

			"qcom,pm8841-regulators"

			"qcom,pm8916-regulators"

			"qcom,pm8941-regulators"

- interrupts:

	Usage: optional

	Value type: <prop-encoded-array>

	Definition: List of OCP interrupts.

- interrupt-names:

	Usage: required if 'interrupts' property present

	Value type: <string-array>

	Definition: List of strings defining the names of the

		    interrupts in the 'interrupts' property 1-to-1.

		    Supported values are "ocp-<regulator_name>", where

		    <regulator_name> corresponds to a voltage switch

		    type regulator.

- vdd_s1-supply:

- vdd_s2-supply:

- vdd_s3-supply:

- vdd_s4-supply:

- vdd_s5-supply:

- vdd_s6-supply:

- vdd_s7-supply:

- vdd_s8-supply:

	Usage: optional (pm8841 only)

	Value type: <phandle>

	Definition: Reference to regulator supplying the input pin, as

		    described in the data sheet.

- vdd_s1-supply:

- vdd_s2-supply:

- vdd_s3-supply:

- vdd_s4-supply:

- vdd_l1_l3-supply:

- vdd_l2-supply:

- vdd_l4_l5_l6-supply:

- vdd_l7-supply:

- vdd_l8_l11_l14_l15_l16-supply:

- vdd_l9_l10_l12_l13_l17_l18-supply:

	Usage: optional (pm8916 only)

	Value type: <phandle>

	Definition: Reference to regulator supplying the input pin, as

		    described in the data sheet.

- vdd_s1-supply:

- vdd_s2-supply:

- vdd_s3-supply:

- vdd_l1_l3-supply:

- vdd_l2_lvs_1_2_3-supply:

- vdd_l4_l11-supply:

- vdd_l5_l7-supply:

- vdd_l6_l12_l14_l15-supply:

- vdd_l8_l16_l18_19-supply:

- vdd_l9_l10_l17_l22-supply:

- vdd_l13_l20_l23_l24-supply:

- vdd_l21-supply:

- vin_5vs-supply:

	Usage: optional (pm8941 only)

	Value type: <phandle>

	Definition: Reference to regulator supplying the input pin, as

		    described in the data sheet.

The regulator node houses sub-nodes for each regulator within the device. Each

sub-node is identified using the node's name, with valid values listed for each

of the PMICs below.

pm8841:

	s1, s2, s3, s4, s5, s6, s7, s8

pm8916:

	s1, s2, s3, s4, l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13,

	l14, l15, l16, l17, l18

pm8941:

	s1, s2, s3, l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13, l14,

	l15, l16, l17, l18, l19, l20, l21, l22, l23, l24, lvs1, lvs2, lvs3,

	mvs1, mvs2

The content of each sub-node is defined by the standard binding for regulators -

see regulator.txt - with additional custom properties described below:

- regulator-initial-mode:

	Usage: optional

	Value type: <u32>

	Descrption: 1 = Set initial mode to high power mode (HPM), also referred

		    to as NPM.  HPM consumes more ground current than LPM, but

		    it can source significantly higher load current. HPM is not

		    available on boost type regulators. For voltage switch type

		    regulators, HPM implies that over current protection and

		    soft start are active all the time. 0 = Set initial mode to

		    low power mode (LPM).

Example:

	regulators {

		compatible = "qcom,pm8941-regulators";

		vdd_l1_l3-supply = <&s1>;

		s1: s1 {

			regulator-min-microvolt = <1300000>;

			regulator-max-microvolt = <1400000>;

		};

		...

		l1: l1 {

			regulator-min-microvolt = <1225000>;

			regulator-max-microvolt = <1300000>;

		};

		....

	};

	  Qualcomm RPM as a module. The module will be named

	  "qcom_rpm-regulator".

config REGULATOR_QCOM_SPMI

	tristate "Qualcomm SPMI regulator driver"

	depends on SPMI || COMPILE_TEST

	help

	  If you say yes to this option, support will be included for the

	  regulators found in Qualcomm SPMI PMICs.

	  Say M here if you want to include support for the regulators on the

	  Qualcomm SPMI PMICs as a module. The module will be named

	  "qcom_spmi-regulator".

config REGULATOR_RC5T583

	tristate "RICOH RC5T583 Power regulators"

	depends on MFD_RC5T583

obj-$(CONFIG_REGULATOR_MC13XXX_CORE) +=  mc13xxx-regulator-core.o

obj-$(CONFIG_REGULATOR_MT6397)	+= mt6397-regulator.o

obj-$(CONFIG_REGULATOR_QCOM_RPM) += qcom_rpm-regulator.o

obj-$(CONFIG_REGULATOR_QCOM_SPMI) += qcom_spmi-regulator.o

obj-$(CONFIG_REGULATOR_PALMAS) += palmas-regulator.o

obj-$(CONFIG_REGULATOR_PFUZE100) += pfuze100-regulator.o

obj-$(CONFIG_REGULATOR_PWM) += pwm-regulator.o

		return NULL;

	}

	for_each_child_of_node(search, child) {

	for_each_available_child_of_node(search, child) {

		name = of_get_property(child, "regulator-compatible", NULL);

		if (!name)

			name = child->name;

#include <linux/pwm.h>

struct pwm_regulator_data {

	struct regulator_desc desc;

	struct pwm_voltages *duty_cycle_table;

	struct pwm_device *pwm;

	bool enabled;

	int state;

};

	unsigned int dutycycle;

};

static int pwm_regulator_get_voltage_sel(struct regulator_dev *dev)

static int pwm_regulator_get_voltage_sel(struct regulator_dev *rdev)

{

	struct pwm_regulator_data *drvdata = rdev_get_drvdata(dev);

	struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev);

	return drvdata->state;

}

static int pwm_regulator_set_voltage_sel(struct regulator_dev *dev,

static int pwm_regulator_set_voltage_sel(struct regulator_dev *rdev,

					 unsigned selector)

{

	struct pwm_regulator_data *drvdata = rdev_get_drvdata(dev);

	struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev);

	unsigned int pwm_reg_period;

	int dutycycle;

	int ret;

	ret = pwm_config(drvdata->pwm, dutycycle, pwm_reg_period);

	if (ret) {

		dev_err(&dev->dev, "Failed to configure PWM\n");

		dev_err(&rdev->dev, "Failed to configure PWM\n");

		return ret;

	}

	drvdata->state = selector;

	if (!drvdata->enabled) {

	ret = pwm_enable(drvdata->pwm);

	if (ret) {

			dev_err(&dev->dev, "Failed to enable PWM\n");

		dev_err(&rdev->dev, "Failed to enable PWM\n");

		return ret;

	}

		drvdata->enabled = true;

	}

	return 0;

}

static int pwm_regulator_list_voltage(struct regulator_dev *dev,

static int pwm_regulator_list_voltage(struct regulator_dev *rdev,

				      unsigned selector)

{

	struct pwm_regulator_data *drvdata = rdev_get_drvdata(dev);

	struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev);

	if (selector >= drvdata->desc.n_voltages)

	if (selector >= rdev->desc->n_voltages)

		return -EINVAL;

	return drvdata->duty_cycle_table[selector].uV;

	.map_voltage     = regulator_map_voltage_iterate,

};

static const struct regulator_desc pwm_regulator_desc = {

static struct regulator_desc pwm_regulator_desc = {

	.name		= "pwm-regulator",

	.ops		= &pwm_regulator_voltage_ops,

	.type		= REGULATOR_VOLTAGE,

	if (!drvdata)

		return -ENOMEM;

	memcpy(&drvdata->desc, &pwm_regulator_desc, sizeof(pwm_regulator_desc));

	/* determine the number of voltage-table */

	prop = of_find_property(np, "voltage-table", &length);

	if (!prop) {

		return -EINVAL;

	}

	drvdata->desc.n_voltages = length / sizeof(*drvdata->duty_cycle_table);

	pwm_regulator_desc.n_voltages = length / sizeof(*drvdata->duty_cycle_table);

	drvdata->duty_cycle_table = devm_kzalloc(&pdev->dev,

						 length, GFP_KERNEL);

	}

	config.init_data = of_get_regulator_init_data(&pdev->dev, np,

						      &drvdata->desc);

						      &pwm_regulator_desc);

	if (!config.init_data)

		return -ENOMEM;

	}

	regulator = devm_regulator_register(&pdev->dev,

					    &drvdata->desc, &config);

					    &pwm_regulator_desc, &config);

	if (IS_ERR(regulator)) {

		dev_err(&pdev->dev, "Failed to register regulator %s\n",

			drvdata->desc.name);

			pwm_regulator_desc.name);

		return PTR_ERR(regulator);

	}