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

Commit 660dbf1c authored by Anirudh Ghayal's avatar Anirudh Ghayal Committed by Kiran Gunda
Browse files

drivers: regulator: Add snapshot of OnSemi NCP6335D regulator 



This is snapshot of the OnSemi NCP6335D driver as of msm-3.10
'commit 156ba1726643 ("regulator: onsemi-ncp6335d: Add i2c retry logic")'.

Change-Id: I4cf0acd272fcf498462d4397385cd62f144eadf8
Signed-off-by: default avatarKiran Gunda <kgunda@codeaurora.org>
parent f1a10f15

Documentation/devicetree/bindings/regulator/onsemi-ncp6335d.txt

0 → 100644
+72 −0
Original line number Diff line number Diff line 
ON Semiconductor NCP6335d regulator



NCP6335d is able to deliver up to 5.0 A, with programmable output voltage from

0.6 V to 1.87 V in 10mV steps, with synchronous rectification and automatic PWM/

PFM transitions, enable pins and power good/fail signaling.



The NCP6335d interface is via I2C bus.



Required Properties:

- compatible:			Must be "onnn,ncp6335d-regulator".

- reg:				The device 8-bit I2C address.

- regulator-min-microvolt:	Minimum voltage in microvolts supported by this

				regulator.

- regulator-max-microvolt:	Maximum voltage in microvolts supported by this

				regulator.

- onnn,min-setpoint:		Minimum setpoint voltage in microvolts supported

				by this regulator.

- onnn,step-size:		The step size of the regulator, in uV.

- onnn,min-slew-ns:		Minimum time in ns needed to change voltage by

				one step size. This value corresponds to DVS

				mode bit of 00b in command register.

- onnn,max-slew-ns:		Maximum time in ns needed to change voltage by

				one step size. This value corresponds to DVS

				mode bit of 11b in command register.

- onnn,vsel:			Working vsel register. Supported value are 0

				or 1.

- onnn,slew-ns:			Time in ns needed to change voltage by one step

				size. Supported value are 333, 666, 1333, 2666.



Optional Properties:

- onnn,discharge-enable:	Present: discharge enabled.

				Not Present: discharge disabled.

- onnn,restore-reg:		Present: Restore vsel register from backup register.

				Not Present: No restore.

- onnn,vsel-gpio:		Present: GPIO connects to the VSEL pin and set the

				VSEL pin according to device tree flag.

				Not Present: No GPIO is connected to vsel pin.

- pinctrl-names:		The state name of the VSEL pin configuration.

				Only support: "default"

- pinctrl-0:			The phandles of the pin configuration node in

				pinctrl for VSEL pin.

				For details of pinctrl properties, please refer to:

				"Documentation/devicetree/bindings/pinctrl/pinctrl-bindings.txt"

- onnn,sleep-enable:		Present: Forced in sleep mode when EN and VSEL

				pins are low.

				Not Present: Low quiescent current mode when EN and VSEL

				pins are low.

- onnn,mode:			A string which specifies the initial mode to use for the regulator.

				Supported values are "pwm" and "auto". PWM mode is more

				robust, but draws more current than auto mode. If this propery

				is not specified, then the regulator will be in the hardware default mode.



Example:

	i2c_0 {

		ncp6335d-regulator@1c {

			compatible = "onnn,ncp6335d-regulator";

			reg = <0x1c>;

			onnn,vsel = <0>;

			onnn,slew-rate-ns = <2666>;

			onnn,discharge-enable;

			onnn,step-size = <10000>;

			onnn,min-slew-ns = <333>;

			onnn,max-slew-ns = <2666>;

			pintrl-names = "default";

			pinctrl-0 = <&ext_buck_vsel_default>;



			regulator-min-microvolt = <1050000>;

			regulator-max-microvolt = <1350000>;

			onnn,min-setpoint = <600000>;

			onnn,vsel-gpio = <&msmgpio 2 1>;

		};

	};

drivers/regulator/Kconfig

+9 −0
Original line number Diff line number Diff line
@@ -472,6 +472,15 @@ config REGULATOR_MT6397 
	  This driver supports the control of different power rails of device

	  through regulator interface.



config REGULATOR_ONSEMI_NCP6335D

	tristate "OnSemi NCP6335D regulator support"

	depends on I2C

	help

	 This driver supports the OnSemi NCP6335D switching voltage regulator

	 (buck converter). The regulator is controlled using an I2C interface

	 and supports a programmable voltage range from 0.6V to 1.4V in steps

	 of 6.25mV.



config REGULATOR_PALMAS

	tristate "TI Palmas PMIC Regulators"

	depends on MFD_PALMAS

drivers/regulator/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -65,6 +65,7 @@ obj-$(CONFIG_REGULATOR_MT6397) += mt6397-regulator.o 
obj-$(CONFIG_REGULATOR_QCOM_RPM) += qcom_rpm-regulator.o

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

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

obj-$(CONFIG_REGULATOR_ONSEMI_NCP6335D) += onsemi-ncp6335d.o

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

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

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

drivers/regulator/onsemi-ncp6335d.c

0 → 100644
+763 −0
Original line number Diff line number Diff line 
/* Copyright (c) 2012-2014, The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and

 * only version 2 as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 */



#include <linux/module.h>

#include <linux/err.h>

#include <linux/gpio.h>

#include <linux/kernel.h>

#include <linux/delay.h>

#include <linux/i2c.h>

#include <linux/log2.h>

#include <linux/regulator/driver.h>

#include <linux/regulator/machine.h>

#include <linux/regulator/of_regulator.h>

#include <linux/of.h>

#include <linux/of_gpio.h>

#include <linux/regmap.h>

#include <linux/debugfs.h>

#include <linux/regulator/onsemi-ncp6335d.h>

#include <linux/string.h>



/* registers */

#define REG_NCP6335D_PID		0x03

#define REG_NCP6335D_PROGVSEL1		0x10

#define REG_NCP6335D_PROGVSEL0		0x11

#define REG_NCP6335D_PGOOD		0x12

#define REG_NCP6335D_TIMING		0x13

#define REG_NCP6335D_COMMAND		0x14



/* constraints */

#define NCP6335D_MIN_VOLTAGE_UV		600000

#define NCP6335D_STEP_VOLTAGE_UV	6250

#define NCP6335D_VOLTAGE_STEPS		128

#define NCP6335D_MIN_SLEW_NS		166

#define NCP6335D_MAX_SLEW_NS		1333



/* bits */

#define NCP6335D_ENABLE			BIT(7)

#define NCP6335D_DVS_PWM_MODE		BIT(5)

#define NCP6335D_PWM_MODE1		BIT(6)

#define NCP6335D_PWM_MODE0		BIT(7)

#define NCP6335D_PGOOD_DISCHG		BIT(4)

#define NCP6335D_SLEEP_MODE		BIT(4)



#define NCP6335D_VOUT_SEL_MASK		0x7F

#define NCP6335D_SLEW_MASK		0x18

#define NCP6335D_SLEW_SHIFT		0x3



struct ncp6335d_info {

	struct regulator_dev *regulator;

	struct regulator_init_data *init_data;

	struct regmap *regmap;

	struct device *dev;

	unsigned int vsel_reg;

	unsigned int vsel_backup_reg;

	unsigned int mode_bit;

	int curr_voltage;

	int slew_rate;



	unsigned int step_size;

	unsigned int min_voltage;

	unsigned int min_slew_ns;

	unsigned int max_slew_ns;

	unsigned int peek_poke_address;



	struct dentry *debug_root;

};



static int delay_array[] = {10, 20, 30, 40, 50};



static int ncp6335x_read(struct ncp6335d_info *dd, unsigned int reg,

						unsigned int *val)

{

	int i = 0, rc = 0;



	rc = regmap_read(dd->regmap, reg, val);

	for (i = 0; rc && i < ARRAY_SIZE(delay_array); i++) {

		pr_debug("Failed reading reg=%u - retry(%d)\n", reg, i);

		msleep(delay_array[i]);

		rc = regmap_read(dd->regmap, reg, val);

	}



	if (rc)

		pr_err("Failed reading reg=%u rc=%d\n", reg, rc);



	return rc;

}



static int ncp6335x_write(struct ncp6335d_info *dd, unsigned int reg,

						unsigned int val)

{

	int i = 0, rc = 0;



	rc = regmap_write(dd->regmap, reg, val);

	for (i = 0; rc && i < ARRAY_SIZE(delay_array); i++) {

		pr_debug("Failed writing reg=%u - retry(%d)\n", reg, i);

		msleep(delay_array[i]);

		rc = regmap_write(dd->regmap, reg, val);

	}



	if (rc)

		pr_err("Failed writing reg=%u rc=%d\n", reg, rc);



	return rc;

}



static int ncp6335x_update_bits(struct ncp6335d_info *dd, unsigned int reg,

					unsigned int mask, unsigned int val)

{

	int i = 0, rc = 0;



	rc = regmap_update_bits(dd->regmap, reg, mask, val);

	for (i = 0; rc && i < ARRAY_SIZE(delay_array); i++) {

		pr_debug("Failed updating reg=%u- retry(%d)\n", reg, i);

		msleep(delay_array[i]);

		rc = regmap_update_bits(dd->regmap, reg, mask, val);

	}



	if (rc)

		pr_err("Failed updating reg=%u rc=%d\n", reg, rc);



	return rc;

}



static void dump_registers(struct ncp6335d_info *dd,

			unsigned int reg, const char *func)

{

	unsigned int val = 0;



	ncp6335x_read(dd, reg, &val);

	dev_dbg(dd->dev, "%s: NCP6335D: Reg = %x, Val = %x\n", func, reg, val);

}



static void ncp633d_slew_delay(struct ncp6335d_info *dd,

					int prev_uV, int new_uV)

{

	u8 val;

	int delay;



	val = abs(prev_uV - new_uV) / dd->step_size;

	delay = ((val * dd->slew_rate) / 1000) + 1;



	dev_dbg(dd->dev, "Slew Delay = %d\n", delay);



	udelay(delay);

}



static int ncp6335d_enable(struct regulator_dev *rdev)

{

	int rc;

	struct ncp6335d_info *dd = rdev_get_drvdata(rdev);



	rc = ncp6335x_update_bits(dd, dd->vsel_reg,

			NCP6335D_ENABLE, NCP6335D_ENABLE);

	if (rc)

		dev_err(dd->dev, "Unable to enable regualtor rc(%d)", rc);



	dump_registers(dd, dd->vsel_reg, __func__);



	return rc;

}



static int ncp6335d_disable(struct regulator_dev *rdev)

{

	int rc;

	struct ncp6335d_info *dd = rdev_get_drvdata(rdev);



	rc = ncp6335x_update_bits(dd, dd->vsel_reg,

					NCP6335D_ENABLE, 0);

	if (rc)

		dev_err(dd->dev, "Unable to disable regualtor rc(%d)", rc);



	dump_registers(dd, dd->vsel_reg, __func__);



	return rc;

}



static int ncp6335d_get_voltage(struct regulator_dev *rdev)

{

	unsigned int val;

	int rc;

	struct ncp6335d_info *dd = rdev_get_drvdata(rdev);



	rc = ncp6335x_read(dd, dd->vsel_reg, &val);

	if (rc) {

		dev_err(dd->dev, "Unable to get volatge rc(%d)", rc);

		return rc;

	}

	dd->curr_voltage = ((val & NCP6335D_VOUT_SEL_MASK) * dd->step_size) +

				dd->min_voltage;



	dump_registers(dd, dd->vsel_reg, __func__);



	return dd->curr_voltage;

}



static int ncp6335d_set_voltage(struct regulator_dev *rdev,

			int min_uV, int max_uV, unsigned *selector)

{

	int rc, set_val, new_uV;

	struct ncp6335d_info *dd = rdev_get_drvdata(rdev);



	set_val = DIV_ROUND_UP(min_uV - dd->min_voltage, dd->step_size);

	new_uV = (set_val * dd->step_size) + dd->min_voltage;

	if (new_uV > max_uV) {

		dev_err(dd->dev, "Unable to set volatge (%d %d)\n",

							min_uV, max_uV);

		return -EINVAL;

	}



	rc = ncp6335x_update_bits(dd, dd->vsel_reg,

		NCP6335D_VOUT_SEL_MASK, (set_val & NCP6335D_VOUT_SEL_MASK));

	if (rc) {

		dev_err(dd->dev, "Unable to set volatge (%d %d)\n",

							min_uV, max_uV);

	} else {

		ncp633d_slew_delay(dd, dd->curr_voltage, new_uV);

		dd->curr_voltage = new_uV;

	}



	dump_registers(dd, dd->vsel_reg, __func__);



	return rc;

}



static int ncp6335d_list_voltage(struct regulator_dev *rdev,

					unsigned selector)

{

	struct ncp6335d_info *dd = rdev_get_drvdata(rdev);



	if (selector >= NCP6335D_VOLTAGE_STEPS)

		return 0;



	return selector * dd->step_size + dd->min_voltage;

}



static int ncp6335d_set_mode(struct regulator_dev *rdev,

					unsigned int mode)

{

	int rc;

	struct ncp6335d_info *dd = rdev_get_drvdata(rdev);



	/* only FAST and NORMAL mode types are supported */

	if (mode != REGULATOR_MODE_FAST && mode != REGULATOR_MODE_NORMAL) {

		dev_err(dd->dev, "Mode %d not supported\n", mode);

		return -EINVAL;

	}



	rc = ncp6335x_update_bits(dd, REG_NCP6335D_COMMAND, dd->mode_bit,

			(mode == REGULATOR_MODE_FAST) ? dd->mode_bit : 0);

	if (rc) {

		dev_err(dd->dev, "Unable to set operating mode rc(%d)", rc);

		return rc;

	}



	rc = ncp6335x_update_bits(dd, REG_NCP6335D_COMMAND,

					NCP6335D_DVS_PWM_MODE,

					(mode == REGULATOR_MODE_FAST) ?

					NCP6335D_DVS_PWM_MODE : 0);

	if (rc)

		dev_err(dd->dev, "Unable to set DVS trans. mode rc(%d)", rc);



	dump_registers(dd, REG_NCP6335D_COMMAND, __func__);



	return rc;

}



static unsigned int ncp6335d_get_mode(struct regulator_dev *rdev)

{

	unsigned int val;

	int rc;

	struct ncp6335d_info *dd = rdev_get_drvdata(rdev);



	rc = ncp6335x_read(dd, REG_NCP6335D_COMMAND, &val);

	if (rc) {

		dev_err(dd->dev, "Unable to get regulator mode rc(%d)\n", rc);

		return rc;

	}



	dump_registers(dd, REG_NCP6335D_COMMAND, __func__);



	if (val & dd->mode_bit)

		return REGULATOR_MODE_FAST;



	return REGULATOR_MODE_NORMAL;

}



static struct regulator_ops ncp6335d_ops = {

	.set_voltage = ncp6335d_set_voltage,

	.get_voltage = ncp6335d_get_voltage,

	.list_voltage = ncp6335d_list_voltage,

	.enable = ncp6335d_enable,

	.disable = ncp6335d_disable,

	.set_mode = ncp6335d_set_mode,

	.get_mode = ncp6335d_get_mode,

};



static struct regulator_desc rdesc = {

	.name = "ncp6335d",

	.owner = THIS_MODULE,

	.n_voltages = NCP6335D_VOLTAGE_STEPS,

	.ops = &ncp6335d_ops,

};



static int ncp6335d_restore_working_reg(struct device_node *node,

					struct ncp6335d_info *dd)

{

	int ret;

	unsigned int val;



	/* Restore register from back up register */

	ret = ncp6335x_read(dd, dd->vsel_backup_reg, &val);

	if (ret < 0) {

		dev_err(dd->dev, "Failed to get backup data from reg %d, ret = %d\n",

			dd->vsel_backup_reg, ret);

		return ret;

	}



	ret = ncp6335x_update_bits(dd, dd->vsel_reg,

					NCP6335D_VOUT_SEL_MASK, val);

	if (ret < 0) {

		dev_err(dd->dev, "Failed to update working reg %d, ret = %d\n",

			dd->vsel_reg,  ret);

		return ret;

	}



	return ret;

}



static int ncp6335d_parse_gpio(struct device_node *node,

					struct ncp6335d_info *dd)

{

	int ret = 0, gpio;

	enum of_gpio_flags flags;



	if (!of_find_property(node, "onnn,vsel-gpio", NULL))

		return ret;



	/* Get GPIO connected to vsel and set its output */

	gpio = of_get_named_gpio_flags(node,

			"onnn,vsel-gpio", 0, &flags);

	if (!gpio_is_valid(gpio)) {

		if (gpio != -EPROBE_DEFER)

			dev_err(dd->dev, "Could not get vsel, ret = %d\n",

				gpio);

		return gpio;

	}



	ret = devm_gpio_request(dd->dev, gpio, "ncp6335d_vsel");

	if (ret) {

		dev_err(dd->dev, "Failed to obtain gpio %d ret = %d\n",

				gpio, ret);

			return ret;

	}



	ret = gpio_direction_output(gpio, flags & OF_GPIO_ACTIVE_LOW ? 0 : 1);

	if (ret) {

		dev_err(dd->dev, "Failed to set GPIO %d to: %s, ret = %d",

				gpio, flags & OF_GPIO_ACTIVE_LOW ?

				"GPIO_LOW" : "GPIO_HIGH", ret);

		return ret;

	}



	return ret;

}



static int ncp6335d_init(struct i2c_client *client, struct ncp6335d_info *dd,

			const struct ncp6335d_platform_data *pdata)

{

	int rc;

	unsigned int val;



	switch (pdata->default_vsel) {

	case NCP6335D_VSEL0:

		dd->vsel_reg = REG_NCP6335D_PROGVSEL0;

		dd->vsel_backup_reg = REG_NCP6335D_PROGVSEL1;

		dd->mode_bit = NCP6335D_PWM_MODE0;

	break;

	case NCP6335D_VSEL1:

		dd->vsel_reg = REG_NCP6335D_PROGVSEL1;

		dd->vsel_backup_reg = REG_NCP6335D_PROGVSEL0;

		dd->mode_bit = NCP6335D_PWM_MODE1;

	break;

	default:

		dev_err(dd->dev, "Invalid VSEL ID %d\n", pdata->default_vsel);

		return -EINVAL;

	}



	if (of_property_read_bool(client->dev.of_node, "onnn,restore-reg")) {

		rc = ncp6335d_restore_working_reg(client->dev.of_node, dd);

		if (rc)

			return rc;

	}



	rc = ncp6335d_parse_gpio(client->dev.of_node, dd);

	if (rc)

		return rc;



	/* get the current programmed voltage */

	rc = ncp6335x_read(dd, dd->vsel_reg, &val);

	if (rc) {

		dev_err(dd->dev, "Unable to get volatge rc(%d)", rc);

		return rc;

	}

	dd->curr_voltage = ((val & NCP6335D_VOUT_SEL_MASK) *

				dd->step_size) + dd->min_voltage;



	/* set discharge */

	rc = ncp6335x_update_bits(dd, REG_NCP6335D_PGOOD,

					NCP6335D_PGOOD_DISCHG,

					(pdata->discharge_enable ?

					NCP6335D_PGOOD_DISCHG : 0));

	if (rc) {

		dev_err(dd->dev, "Unable to set Active Discharge rc(%d)\n", rc);

		return -EINVAL;

	}



	/* set slew rate */

	if (pdata->slew_rate_ns < dd->min_slew_ns ||

			pdata->slew_rate_ns > dd->max_slew_ns) {

		dev_err(dd->dev, "Invalid slew rate %d\n", pdata->slew_rate_ns);

		return -EINVAL;

	}



	dd->slew_rate = pdata->slew_rate_ns;

	val = DIV_ROUND_UP(pdata->slew_rate_ns, dd->min_slew_ns);

	val = ilog2(val);



	rc = ncp6335x_update_bits(dd, REG_NCP6335D_TIMING,

			NCP6335D_SLEW_MASK, val << NCP6335D_SLEW_SHIFT);

	if (rc)

		dev_err(dd->dev, "Unable to set slew rate rc(%d)\n", rc);



	/* Set Sleep mode bit */

	rc = ncp6335x_update_bits(dd, REG_NCP6335D_COMMAND,

				NCP6335D_SLEEP_MODE, pdata->sleep_enable ?

						NCP6335D_SLEEP_MODE : 0);

	if (rc)

		dev_err(dd->dev, "Unable to set sleep mode (%d)\n", rc);



	dump_registers(dd, REG_NCP6335D_COMMAND, __func__);

	dump_registers(dd, REG_NCP6335D_PROGVSEL0, __func__);

	dump_registers(dd, REG_NCP6335D_TIMING, __func__);

	dump_registers(dd, REG_NCP6335D_PGOOD, __func__);



	return rc;

}



static struct regmap_config ncp6335d_regmap_config = {

	.reg_bits = 8,

	.val_bits = 8,

};



static int ncp6335d_parse_dt(struct i2c_client *client,

				struct ncp6335d_info *dd)

{

	int rc;



	rc = of_property_read_u32(client->dev.of_node,

			"onnn,step-size", &dd->step_size);

	if (rc < 0) {

		dev_err(&client->dev, "step size missing: rc = %d.\n", rc);

		return rc;

	}



	rc = of_property_read_u32(client->dev.of_node,

			"onnn,min-slew-ns", &dd->min_slew_ns);

	if (rc < 0) {

		dev_err(&client->dev, "min slew us missing: rc = %d.\n", rc);

		return rc;

	}



	rc = of_property_read_u32(client->dev.of_node,

			"onnn,max-slew-ns", &dd->max_slew_ns);

	if (rc < 0) {

		dev_err(&client->dev, "max slew us missing: rc = %d.\n", rc);

		return rc;

	}



	rc = of_property_read_u32(client->dev.of_node,

			"onnn,min-setpoint", &dd->min_voltage);

	if (rc < 0) {

		dev_err(&client->dev, "min set point missing: rc = %d.\n", rc);

		return rc;

	}



	return rc;

}



static struct ncp6335d_platform_data *

	ncp6335d_get_of_platform_data(struct i2c_client *client)

{

	struct ncp6335d_platform_data *pdata = NULL;

	struct regulator_init_data *init_data;

	const char *mode_name;

	int rc;



	init_data = of_get_regulator_init_data(&client->dev,

				client->dev.of_node);

	if (!init_data) {

		dev_err(&client->dev, "regulator init data is missing\n");

		return pdata;

	}



	pdata = devm_kzalloc(&client->dev,

			sizeof(struct ncp6335d_platform_data), GFP_KERNEL);

	if (!pdata) {

		dev_err(&client->dev, "ncp6335d_platform_data allocation failed.\n");

		return pdata;

	}



	rc = of_property_read_u32(client->dev.of_node,

			"onnn,vsel", &pdata->default_vsel);

	if (rc < 0) {

		dev_err(&client->dev, "onnn,vsel property missing: rc = %d.\n",

			rc);

		return NULL;

	}



	rc = of_property_read_u32(client->dev.of_node,

			"onnn,slew-ns", &pdata->slew_rate_ns);

	if (rc < 0) {

		dev_err(&client->dev, "onnn,slew-ns property missing: rc = %d.\n",

			rc);

		return NULL;

	}



	pdata->discharge_enable = of_property_read_bool(client->dev.of_node,

						"onnn,discharge-enable");



	pdata->sleep_enable = of_property_read_bool(client->dev.of_node,

						"onnn,sleep-enable");



	pdata->init_data = init_data;



	init_data->constraints.input_uV = init_data->constraints.max_uV;

	init_data->constraints.valid_ops_mask =

				REGULATOR_CHANGE_VOLTAGE |

				REGULATOR_CHANGE_STATUS |

				REGULATOR_CHANGE_MODE;

	init_data->constraints.valid_modes_mask =

				REGULATOR_MODE_NORMAL |

				REGULATOR_MODE_FAST;



	rc = of_property_read_string(client->dev.of_node, "onnn,mode",

					&mode_name);

	if (!rc) {

		if (strcmp("pwm", mode_name) == 0) {

			init_data->constraints.initial_mode =

							REGULATOR_MODE_FAST;

		} else if (strcmp("auto", mode_name) == 0) {

			init_data->constraints.initial_mode =

							REGULATOR_MODE_NORMAL;

		} else {

			dev_err(&client->dev, "onnn,mode, unknown regulator mode: %s\n",

				mode_name);

			return NULL;

		}

	}



	return pdata;

}



static int get_reg(void *data, u64 *val)

{

	struct ncp6335d_info *dd = data;

	int rc;

	unsigned int temp = 0;



	rc = ncp6335x_read(dd, dd->peek_poke_address, &temp);

	if (rc < 0)

		dev_err(dd->dev, "Couldn't read reg %x rc = %d\n",

				dd->peek_poke_address, rc);

	else

		*val = temp;



	return rc;

}



static int set_reg(void *data, u64 val)

{

	struct ncp6335d_info *dd = data;

	int rc;

	unsigned int temp = 0;



	temp = (unsigned int) val;

	rc = ncp6335x_write(dd, dd->peek_poke_address, temp);

	if (rc < 0)

		dev_err(dd->dev, "Couldn't write 0x%02x to 0x%02x rc= %d\n",

			dd->peek_poke_address, temp, rc);



	return rc;

}

DEFINE_SIMPLE_ATTRIBUTE(poke_poke_debug_ops, get_reg, set_reg, "0x%02llx\n");



static int ncp6335d_regulator_probe(struct i2c_client *client,

					const struct i2c_device_id *id)

{

	int rc;

	unsigned int val = 0;

	struct ncp6335d_info *dd;

	const struct ncp6335d_platform_data *pdata;

	struct regulator_config config = { };



	if (client->dev.of_node)

		pdata = ncp6335d_get_of_platform_data(client);

	else

		pdata = client->dev.platform_data;



	if (!pdata) {

		dev_err(&client->dev, "Platform data not specified\n");

		return -EINVAL;

	}



	dd = devm_kzalloc(&client->dev, sizeof(*dd), GFP_KERNEL);

	if (!dd) {

		dev_err(&client->dev, "Unable to allocate memory\n");

		return -ENOMEM;

	}



	if (client->dev.of_node) {

		rc = ncp6335d_parse_dt(client, dd);

		if (rc)

			return rc;

	} else {

		dd->step_size	= NCP6335D_STEP_VOLTAGE_UV;

		dd->min_voltage	= NCP6335D_MIN_VOLTAGE_UV;

		dd->min_slew_ns	= NCP6335D_MIN_SLEW_NS;

		dd->max_slew_ns	= NCP6335D_MAX_SLEW_NS;

	}



	dd->regmap = devm_regmap_init_i2c(client, &ncp6335d_regmap_config);

	if (IS_ERR(dd->regmap)) {

		dev_err(&client->dev, "Error allocating regmap\n");

		return PTR_ERR(dd->regmap);

	}



	rc = ncp6335x_read(dd, REG_NCP6335D_PID, &val);

	if (rc) {

		dev_err(&client->dev, "Unable to identify NCP6335D, rc(%d)\n",

									rc);

		return rc;

	}

	dev_info(&client->dev, "Detected Regulator NCP6335D PID = %d\n", val);



	dd->init_data = pdata->init_data;

	dd->dev = &client->dev;

	i2c_set_clientdata(client, dd);



	rc = ncp6335d_init(client, dd, pdata);

	if (rc) {

		dev_err(&client->dev, "Unable to intialize the regulator\n");

		return -EINVAL;

	}



	config.dev = &client->dev;

	config.init_data = dd->init_data;

	config.regmap = dd->regmap;

	config.driver_data = dd;

	config.of_node = client->dev.of_node;



	dd->regulator = regulator_register(&rdesc, &config);



	if (IS_ERR(dd->regulator)) {

		dev_err(&client->dev, "Unable to register regulator rc(%ld)",

						PTR_ERR(dd->regulator));



		return PTR_ERR(dd->regulator);

	}



	dd->debug_root = debugfs_create_dir("ncp6335x", NULL);

	if (!dd->debug_root)

		dev_err(&client->dev, "Couldn't create debug dir\n");



	if (dd->debug_root) {

		struct dentry *ent;



		ent = debugfs_create_x32("address", S_IFREG | S_IWUSR | S_IRUGO,

					  dd->debug_root,

					  &(dd->peek_poke_address));

		if (!ent)

			dev_err(&client->dev, "Couldn't create address debug file rc = %d\n",

									rc);



		ent = debugfs_create_file("data", S_IFREG | S_IWUSR | S_IRUGO,

					  dd->debug_root, dd,

					  &poke_poke_debug_ops);

		if (!ent)

			dev_err(&client->dev, "Couldn't create data debug file rc = %d\n",

									rc);

	}



	return 0;

}



static int ncp6335d_regulator_remove(struct i2c_client *client)

{

	struct ncp6335d_info *dd = i2c_get_clientdata(client);



	regulator_unregister(dd->regulator);



	debugfs_remove_recursive(dd->debug_root);



	return 0;

}



static struct of_device_id ncp6335d_match_table[] = {

	{ .compatible = "onnn,ncp6335d-regulator", },

	{},

};

MODULE_DEVICE_TABLE(of, ncp6335d_match_table);



static const struct i2c_device_id ncp6335d_id[] = {

	{"ncp6335d", -1},

	{ },

};



static struct i2c_driver ncp6335d_regulator_driver = {

	.driver = {

		.name = "ncp6335d-regulator",

		.owner = THIS_MODULE,

		.of_match_table = ncp6335d_match_table,

	},

	.probe = ncp6335d_regulator_probe,

	.remove = ncp6335d_regulator_remove,

	.id_table = ncp6335d_id,

};



/**

 * ncp6335d_regulator_init() - initialized ncp6335d regulator driver

 * This function registers the ncp6335d regulator platform driver.

 *

 * Returns 0 on success or errno on failure.

 */

int __init ncp6335d_regulator_init(void)

{

	static bool initialized;



	if (initialized)

		return 0;

	else

		initialized = true;



	return i2c_add_driver(&ncp6335d_regulator_driver);

}

EXPORT_SYMBOL(ncp6335d_regulator_init);

arch_initcall(ncp6335d_regulator_init);



static void __exit ncp6335d_regulator_exit(void)

{

	i2c_del_driver(&ncp6335d_regulator_driver);

}

module_exit(ncp6335d_regulator_exit);

MODULE_DESCRIPTION("OnSemi-NCP6335D regulator driver");

MODULE_LICENSE("GPL v2");

include/linux/regulator/onsemi-ncp6335d.h

0 → 100644
+35 −0
Original line number Diff line number Diff line 
/* Copyright (c) 2012-2014, The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and

 * only version 2 as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 */



#ifndef __NCP6335D_H__

#define __NCP6335D_H__



enum {

	NCP6335D_VSEL0,

	NCP6335D_VSEL1,

};



struct ncp6335d_platform_data {

	struct regulator_init_data *init_data;

	int default_vsel;

	int slew_rate_ns;

	int discharge_enable;

	bool sleep_enable;

};



#ifdef CONFIG_REGULATOR_ONSEMI_NCP6335D

int __init ncp6335d_regulator_init(void);

#else

static inline int __init ncp6335d_regulator_init(void) { return 0; }

#endif



#endif