Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 39a9f9a8 authored by Subbaraman Narayanamurthy's avatar Subbaraman Narayanamurthy Committed by Gerrit - the friendly Code Review server
Browse files

msm: qpnp-power-on: add regulator support for PON device 



There is a requirement for configuring certain spare register
bits of PON peripheral. Since there is a chance for multiple
clients to configure these bits, a regulator device can handle
such configuration easily. Add support for it.

Regulator configuration requires an address inside PON peripheral
and a bit position which needs to be controlled to be specified
in the device tree subnode.

CRs-Fixed: 840571
Change-Id: I62d0c3f49e777103e102229353faaf2e8ee1fad6
Signed-off-by: default avatarSubbaraman Narayanamurthy <subbaram@codeaurora.org>
parent b91d6eb9

Documentation/devicetree/bindings/platform/msm/qpnp-power-on.txt

+21 −2
Original line number Diff line number Diff line
@@ -66,12 +66,25 @@ Optional properties: 
All the below properties are in the sub-node section (properties of the child

node).



Sub-node required properties:

Sub-nodes (if defined) should belong to either a PON configuration or a

regulator configuration.



Regulator sub-node required properties:

- regulator-name		Regulator name for the PON regulator that

				is being configured.

- qcom,pon-spare-reg-addr	Register offset from the base address of the PON

				peripheral that needs to be configured for the

				regulator being controlled.

- qcom,pon-spare-reg-bit	Bit position in the specified register that

				needs to be configured for the regulator being

				controlled.



PON sub-node required properties:

- qcom,pon-type			The type of PON/RESET source. The driver

				currently supports KPDPWR(0), RESIN(1) and

				CBLPWR(2) pon/reset sources.



Sub-node optional properties:

PON sub-node optional properties:

- qcom,pull-up			The initial state of the reset pin under

				consideration.

				0 = No pull-up
@@ -152,4 +165,10 @@ Example: 
		compatible = "qcom,qpnp-power-on";

		reg = <0x800 0x100>;

		qcom,secondary-pon-reset;



		pon_perph_reg: qcom,pon_perph_reg {

			regulator-name = "pon_spare_reg";

			qcom,pon-spare-reg-addr = <0x8c>;

			qcom,pon-spare-reg-bit = <1>;

		};

	};

drivers/platform/msm/qpnp-power-on.c

+186 −20
Original line number Diff line number Diff line
@@ -25,6 +25,9 @@ 
#include <linux/mutex.h>

#include <linux/input.h>

#include <linux/log2.h>

#include <linux/regulator/driver.h>

#include <linux/regulator/machine.h>

#include <linux/regulator/of_regulator.h>

#include <linux/qpnp/power-on.h>



#define CREATE_MASK(NUM_BITS, POS) \
@@ -151,19 +154,31 @@ struct qpnp_pon_config { 
	bool config_reset;

};



struct pon_regulator {

	struct qpnp_pon		*pon;

	struct regulator_dev	*rdev;

	struct regulator_desc	rdesc;

	u32			addr;

	u32			bit;

	bool			enabled;

};



struct qpnp_pon {

	struct spmi_device	*spmi;

	struct input_dev	*pon_input;

	struct qpnp_pon_config	*pon_cfg;

	struct pon_regulator	*pon_reg_cfg;

	struct list_head	list;

	int num_pon_config;

	u16 base;

	struct delayed_work	bark_work;

	u32 dbc;

	struct dentry		*debugfs;

	int			pon_trigger_reason;

	int			pon_power_off_reason;

	int			num_pon_reg;

	int			num_pon_config;

	int			reg_count;

	u32			dbc;

	u32			uvlo;

	struct dentry *debugfs;

	u16			base;

	u8			warm_reset_reason1;

	u8			warm_reset_reason2;

	bool			is_spon;
@@ -1090,7 +1105,9 @@ static int qpnp_pon_config_init(struct qpnp_pon *pon) 
	}



	/* iterate through the list of pon configs */

	while ((pp = of_get_next_child(pon->spmi->dev.of_node, pp))) {

	for_each_available_child_of_node(pon->spmi->dev.of_node, pp) {

		if (!of_find_property(pp, "qcom,pon-type", NULL))

			continue;



		cfg = &pon->pon_cfg[i++];
@@ -1433,6 +1450,137 @@ free_input_dev: 
	return rc;

}



static int pon_spare_regulator_enable(struct regulator_dev *rdev)

{

	int rc = 0;

	u8 value;

	struct pon_regulator *pon_reg = rdev_get_drvdata(rdev);



	pr_debug("reg %s enable addr: %x bit: %d\n", rdev->desc->name,

		pon_reg->addr, pon_reg->bit);



	value = BIT(pon_reg->bit) & 0xFF;

	rc = qpnp_pon_masked_write(pon_reg->pon, pon_reg->pon->base +

				pon_reg->addr, value, value);

	if (rc)

		dev_err(&pon_reg->pon->spmi->dev, "Unable to write to %x\n",

			pon_reg->pon->base + pon_reg->addr);

	else

		pon_reg->enabled = true;

	return rc;

}



static int pon_spare_regulator_disable(struct regulator_dev *rdev)

{

	int rc = 0;

	u8 mask;

	struct pon_regulator *pon_reg = rdev_get_drvdata(rdev);



	pr_debug("reg %s disable addr: %x bit: %d\n", rdev->desc->name,

		pon_reg->addr, pon_reg->bit);



	mask = BIT(pon_reg->bit) & 0xFF;

	rc = qpnp_pon_masked_write(pon_reg->pon, pon_reg->pon->base +

				pon_reg->addr, mask, 0);

	if (rc)

		dev_err(&pon_reg->pon->spmi->dev, "Unable to write to %x\n",

			pon_reg->pon->base + pon_reg->addr);

	else

		pon_reg->enabled = false;

	return rc;

}



static int pon_spare_regulator_is_enable(struct regulator_dev *rdev)

{

	struct pon_regulator *pon_reg = rdev_get_drvdata(rdev);



	return pon_reg->enabled;

}



struct regulator_ops pon_spare_reg_ops = {

	.enable		= pon_spare_regulator_enable,

	.disable	= pon_spare_regulator_disable,

	.is_enabled	= pon_spare_regulator_is_enable,

};



static int pon_regulator_init(struct qpnp_pon *pon)

{

	int rc = 0, i = 0;

	struct regulator_init_data *init_data;

	struct regulator_config reg_cfg = {};

	struct device_node *node = NULL;

	struct device *dev = &pon->spmi->dev;

	struct pon_regulator *pon_reg;



	if (!pon->num_pon_reg)

		return 0;



	pon->pon_reg_cfg = devm_kcalloc(dev, pon->num_pon_reg,

					sizeof(*(pon->pon_reg_cfg)),

					GFP_KERNEL);



	if (!pon->pon_reg_cfg)

		return -ENOMEM;



	for_each_available_child_of_node(dev->of_node, node) {

		if (!of_find_property(node, "regulator-name", NULL))

			continue;



		pon_reg = &pon->pon_reg_cfg[i++];

		pon_reg->pon = pon;



		rc = of_property_read_u32(node, "qcom,pon-spare-reg-addr",

			&pon_reg->addr);

		if (rc) {

			dev_err(dev, "Unable to read address for regulator, rc=%d\n",

				rc);

			return rc;

		}



		rc = of_property_read_u32(node, "qcom,pon-spare-reg-bit",

			&pon_reg->bit);

		if (rc) {

			dev_err(dev, "Unable to read bit for regulator, rc=%d\n",

				rc);

			return rc;

		}



		init_data = of_get_regulator_init_data(dev, node);

		if (!init_data) {

			dev_err(dev, "regulator init data is missing\n");

			return -EINVAL;

		}

		init_data->constraints.valid_ops_mask

			|= REGULATOR_CHANGE_STATUS;



		if (!init_data->constraints.name) {

			dev_err(dev, "regulator-name is missing\n");

			return -EINVAL;

		}



		pon_reg->rdesc.owner = THIS_MODULE;

		pon_reg->rdesc.type = REGULATOR_VOLTAGE;

		pon_reg->rdesc.ops = &pon_spare_reg_ops;

		pon_reg->rdesc.name = init_data->constraints.name;



		reg_cfg.dev = dev;

		reg_cfg.init_data = init_data;

		reg_cfg.driver_data = pon_reg;

		reg_cfg.of_node = node;



		pon_reg->rdev = regulator_register(&pon_reg->rdesc, &reg_cfg);

		if (IS_ERR(pon_reg->rdev)) {

			rc = PTR_ERR(pon_reg->rdev);

			pon_reg->rdev = NULL;

			if (rc != -EPROBE_DEFER)

				dev_err(dev, "regulator_register failed, rc=%d\n",

					rc);

			return rc;

		}

	}

	return rc;

}



static bool dload_on_uvlo;



static int qpnp_pon_debugfs_uvlo_dload_get(char *buf,
@@ -1569,7 +1717,7 @@ static int qpnp_pon_probe(struct spmi_device *spmi) 
{

	struct qpnp_pon *pon;

	struct resource *pon_resource;

	struct device_node *itr = NULL;

	struct device_node *node = NULL;

	u32 delay = 0, s3_debounce = 0;

	int rc, sys_reset, index;

	u8 pon_sts = 0, buf[2];
@@ -1603,8 +1751,26 @@ static int qpnp_pon_probe(struct spmi_device *spmi) 
	pon->base = pon_resource->start;



	/* get the total number of pon configurations */

	while ((itr = of_get_next_child(spmi->dev.of_node, itr)))

	for_each_available_child_of_node(spmi->dev.of_node, node) {

		if (of_find_property(node, "regulator-name", NULL)) {

			pon->num_pon_reg++;

		} else if (of_find_property(node, "qcom,pon-type", NULL)) {

			pon->num_pon_config++;

		} else {

			pr_err("Unknown sub-node\n");

			return -EINVAL;

		}

	}



	pr_debug("PON@SID %d: num_pon_config: %d num_pon_reg: %d\n",

		pon->spmi->sid, pon->num_pon_config, pon->num_pon_reg);



	rc = pon_regulator_init(pon);

	if (rc) {

		dev_err(&pon->spmi->dev, "Error in pon_regulator_init rc: %d\n",

			rc);

		return rc;

	}



	if (!pon->num_pon_config)

		/* No PON config., do not register the driver */