Unverified Commit 498ab2fd authored by Nisha Kumari's avatar Nisha Kumari Committed by Mark Brown
Browse files

regulator: qcom: Add labibb driver 



Qualcomm platforms have LAB(LCD AMOLED Boost)/IBB(Inverting Buck Boost)
regulators, labibb for short, which are used as power supply for
LCD Mode displays.

This patch adds labibb regulator driver for pmi8998 PMIC, found on
SDM845 platforms.

  [sumits: reworked the driver design as per upstream review]

Signed-off-by: default avatarNisha Kumari <nishakumari@codeaurora.org>
Signed-off-by: default avatarSumit Semwal <sumit.semwal@linaro.org>
Link: https://lore.kernel.org/r/20200622124110.20971-5-sumit.semwal@linaro.org


Signed-off-by: default avatarMark Brown <broonie@kernel.org>
parent f7d7ad42

drivers/regulator/Kconfig

+10 −0
Original line number Diff line number Diff line
@@ -1223,5 +1223,15 @@ config REGULATOR_WM8994 
	  This driver provides support for the voltage regulators on the

	  WM8994 CODEC.



config REGULATOR_QCOM_LABIBB

	tristate "QCOM LAB/IBB regulator support"

	depends on SPMI || COMPILE_TEST

	help

	  This driver supports Qualcomm's LAB/IBB regulators present on the

	  Qualcomm's PMIC chip pmi8998. QCOM LAB and IBB are SPMI

	  based PMIC implementations. LAB can be used as positive

	  boost regulator and IBB can be used as a negative boost regulator

	  for LCD display panel.



endif

drivers/regulator/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -90,6 +90,7 @@ obj-$(CONFIG_REGULATOR_MT6323) += mt6323-regulator.o 
obj-$(CONFIG_REGULATOR_MT6358)	+= mt6358-regulator.o

obj-$(CONFIG_REGULATOR_MT6380)	+= mt6380-regulator.o

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

obj-$(CONFIG_REGULATOR_QCOM_LABIBB) += qcom-labibb-regulator.o

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

obj-$(CONFIG_REGULATOR_QCOM_RPMH) += qcom-rpmh-regulator.o

obj-$(CONFIG_REGULATOR_QCOM_SMD_RPM) += qcom_smd-regulator.o

drivers/regulator/qcom-labibb-regulator.c

0 → 100644
+175 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-only

// Copyright (c) 2020, The Linux Foundation. All rights reserved.



#include <linux/module.h>

#include <linux/of_irq.h>

#include <linux/of.h>

#include <linux/of_device.h>

#include <linux/platform_device.h>

#include <linux/regmap.h>

#include <linux/regulator/driver.h>

#include <linux/regulator/of_regulator.h>



#define REG_PERPH_TYPE                  0x04



#define QCOM_LAB_TYPE			0x24

#define QCOM_IBB_TYPE			0x20



#define PMI8998_LAB_REG_BASE		0xde00

#define PMI8998_IBB_REG_BASE		0xdc00



#define REG_LABIBB_STATUS1		0x08

#define REG_LABIBB_ENABLE_CTL		0x46

#define LABIBB_STATUS1_VREG_OK_BIT	BIT(7)

#define LABIBB_CONTROL_ENABLE		BIT(7)



#define LAB_ENABLE_CTL_MASK		BIT(7)

#define IBB_ENABLE_CTL_MASK		(BIT(7) | BIT(6))



#define LABIBB_OFF_ON_DELAY		1000

#define LAB_ENABLE_TIME			(LABIBB_OFF_ON_DELAY * 2)

#define IBB_ENABLE_TIME			(LABIBB_OFF_ON_DELAY * 10)

#define LABIBB_POLL_ENABLED_TIME	1000



struct labibb_regulator {

	struct regulator_desc		desc;

	struct device			*dev;

	struct regmap			*regmap;

	struct regulator_dev		*rdev;

	u16				base;

	u8				type;

};



struct labibb_regulator_data {

	const char			*name;

	u8				type;

	u16				base;

	struct regulator_desc		*desc;

};



static struct regulator_ops qcom_labibb_ops = {

	.enable			= regulator_enable_regmap,

	.disable		= regulator_disable_regmap,

	.is_enabled		= regulator_is_enabled_regmap,

};



static struct regulator_desc pmi8998_lab_desc = {

	.enable_mask		= LAB_ENABLE_CTL_MASK,

	.enable_reg		= (PMI8998_LAB_REG_BASE + REG_LABIBB_ENABLE_CTL),

	.enable_val		= LABIBB_CONTROL_ENABLE,

	.enable_time		= LAB_ENABLE_TIME,

	.poll_enabled_time	= LABIBB_POLL_ENABLED_TIME,

	.off_on_delay		= LABIBB_OFF_ON_DELAY,

	.owner			= THIS_MODULE,

	.type			= REGULATOR_VOLTAGE,

	.ops			= &qcom_labibb_ops,

};



static struct regulator_desc pmi8998_ibb_desc = {

	.enable_mask		= IBB_ENABLE_CTL_MASK,

	.enable_reg		= (PMI8998_IBB_REG_BASE + REG_LABIBB_ENABLE_CTL),

	.enable_val		= LABIBB_CONTROL_ENABLE,

	.enable_time		= IBB_ENABLE_TIME,

	.poll_enabled_time	= LABIBB_POLL_ENABLED_TIME,

	.off_on_delay		= LABIBB_OFF_ON_DELAY,

	.owner			= THIS_MODULE,

	.type			= REGULATOR_VOLTAGE,

	.ops			= &qcom_labibb_ops,

};



static const struct labibb_regulator_data pmi8998_labibb_data[] = {

	{"lab", QCOM_LAB_TYPE, PMI8998_LAB_REG_BASE, &pmi8998_lab_desc},

	{"ibb", QCOM_IBB_TYPE, PMI8998_IBB_REG_BASE, &pmi8998_ibb_desc},

	{ },

};



static const struct of_device_id qcom_labibb_match[] = {

	{ .compatible = "qcom,pmi8998-lab-ibb", .data = &pmi8998_labibb_data},

	{ },

};

MODULE_DEVICE_TABLE(of, qcom_labibb_match);



static int qcom_labibb_regulator_probe(struct platform_device *pdev)

{

	struct labibb_regulator *vreg;

	struct device *dev = &pdev->dev;

	struct regulator_config cfg = {};



	const struct of_device_id *match;

	const struct labibb_regulator_data *reg_data;

	struct regmap *reg_regmap;

	unsigned int type;

	int ret;



	reg_regmap = dev_get_regmap(pdev->dev.parent, NULL);

	if (!reg_regmap) {

		dev_err(&pdev->dev, "Couldn't get parent's regmap\n");

		return -ENODEV;

	}



	match = of_match_device(qcom_labibb_match, &pdev->dev);

	if (!match)

		return -ENODEV;



	for (reg_data = match->data; reg_data->name; reg_data++) {



		/* Validate if the type of regulator is indeed

		 * what's mentioned in DT.

		 */

		ret = regmap_read(reg_regmap, reg_data->base + REG_PERPH_TYPE,

				  &type);

		if (ret < 0) {

			dev_err(dev,

				"Peripheral type read failed ret=%d\n",

				ret);

			return -EINVAL;

		}



		if (WARN_ON((type != QCOM_LAB_TYPE) && (type != QCOM_IBB_TYPE)) ||

		    WARN_ON(type != reg_data->type))

			return -EINVAL;



		vreg  = devm_kzalloc(&pdev->dev, sizeof(*vreg),

					   GFP_KERNEL);

		if (!vreg)

			return -ENOMEM;



		vreg->regmap = reg_regmap;

		vreg->dev = dev;

		vreg->base = reg_data->base;

		vreg->type = reg_data->type;



		memcpy(&vreg->desc, reg_data->desc, sizeof(vreg->desc));

		vreg->desc.of_match = reg_data->name;

		vreg->desc.name = reg_data->name;



		cfg.dev = vreg->dev;

		cfg.driver_data = vreg;

		cfg.regmap = vreg->regmap;



		vreg->rdev = devm_regulator_register(vreg->dev, &vreg->desc,

							&cfg);



		if (IS_ERR(vreg->rdev)) {

			dev_err(dev, "qcom_labibb: error registering %s : %d\n",

					reg_data->name, ret);

			return PTR_ERR(vreg->rdev);

		}

	}



	return 0;

}



static struct platform_driver qcom_labibb_regulator_driver = {

	.driver	= {

		.name = "qcom-lab-ibb-regulator",

		.of_match_table	= qcom_labibb_match,

	},

	.probe = qcom_labibb_regulator_probe,

};

module_platform_driver(qcom_labibb_regulator_driver);



MODULE_DESCRIPTION("Qualcomm labibb driver");

MODULE_AUTHOR("Nisha Kumari <nishakumari@codeaurora.org>");

MODULE_AUTHOR("Sumit Semwal <sumit.semwal@linaro.org>");

MODULE_LICENSE("GPL v2");

CRA Git | Maintained and supported by SUSTech CRA and CCSE