Commit 202f4f53 authored by MyungJoo Ham's avatar MyungJoo Ham Committed by Liam Girdwood
Browse files

MAX8952 PMIC Driver Initial Release 



MAX8952 PMIC is used to provide voltage output between 770mV - 1400mV
with DVS support. In this initial release, users can set voltages for
four DVS modes, RAMP delay values, and SYNC frequency.
Controlling FPWM/SYNC_MODE/Pull-Down/Ramp Modes and reading CHIP_ID
is not supported in this release.

If GPIO of EN is not valid in platform data, the driver assumes that it
is always-on. If GPIO of VID0 or VID1 is invalid, the driver pulls down
VID0 and VID1 to fix DVS mode as 0 and disables DVS support.

We assume that V_OUT is capable to provide every voltage from 770mV to
1.40V in 10mV steps although the data sheet has some ambiguity on it.

Signed-off-by: default avatarMyungJoo Ham <myungjoo.ham@samsung.com>
Signed-off-by: default avatarKyungmin Park <kyungmin.park@samsung.com>
Acked-by: default avatarMark Brown <broonie@opensource.wolfsonmicro.com>
--
v2:
	- Style correction
	- Can accept platform_data with invalid GPIOs
	- Removed unnecessary features
	- Improved error handling
Signed-off-by: default avatarLiam Girdwood <lrg@slimlogic.co.uk>
parent 2d3b07c0

drivers/regulator/Kconfig

+8 −0
Original line number Diff line number Diff line
@@ -100,6 +100,14 @@ config REGULATOR_MAX8925 
	help

	  Say y here to support the voltage regulaltor of Maxim MAX8925 PMIC.



config REGULATOR_MAX8952

	tristate "Maxim MAX8952 Power Management IC"

	depends on I2C

	help

	  This driver controls a Maxim 8952 voltage output regulator

	  via I2C bus. Maxim 8952 has one voltage output and supports 4 DVS

	  modes ranging from 0.77V to 1.40V by 0.01V steps.



config REGULATOR_MAX8998

	tristate "Maxim 8998 voltage regulator"

	depends on MFD_MAX8998

drivers/regulator/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ obj-$(CONFIG_REGULATOR_TWL4030) += twl-regulator.o 
obj-$(CONFIG_REGULATOR_MAX8649)	+= max8649.o

obj-$(CONFIG_REGULATOR_MAX8660) += max8660.o

obj-$(CONFIG_REGULATOR_MAX8925) += max8925-regulator.o

obj-$(CONFIG_REGULATOR_MAX8952) += max8952.o

obj-$(CONFIG_REGULATOR_MAX8998) += max8998.o

obj-$(CONFIG_REGULATOR_WM831X) += wm831x-dcdc.o

obj-$(CONFIG_REGULATOR_WM831X) += wm831x-isink.o

drivers/regulator/max8952.c

0 → 100644
+360 −0
Original line number Diff line number Diff line 
/*

 * max8952.c - Voltage and current regulation for the Maxim 8952

 *

 * Copyright (C) 2010 Samsung Electronics

 * MyungJoo Ham <myungjoo.ham@samsung.com>

 *

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

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * 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.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */



#include <linux/module.h>

#include <linux/init.h>

#include <linux/i2c.h>

#include <linux/err.h>

#include <linux/platform_device.h>

#include <linux/regulator/driver.h>

#include <linux/regulator/max8952.h>

#include <linux/mutex.h>

#include <linux/gpio.h>

#include <linux/io.h>

#include <linux/slab.h>



/* Registers */

enum {

	MAX8952_REG_MODE0,

	MAX8952_REG_MODE1,

	MAX8952_REG_MODE2,

	MAX8952_REG_MODE3,

	MAX8952_REG_CONTROL,

	MAX8952_REG_SYNC,

	MAX8952_REG_RAMP,

	MAX8952_REG_CHIP_ID1,

	MAX8952_REG_CHIP_ID2,

};



struct max8952_data {

	struct i2c_client	*client;

	struct device		*dev;

	struct mutex		mutex;

	struct max8952_platform_data *pdata;

	struct regulator_dev	*rdev;



	bool vid0;

	bool vid1;

	bool en;

};



static int max8952_read_reg(struct max8952_data *max8952, u8 reg)

{

	int ret = i2c_smbus_read_byte_data(max8952->client, reg);

	if (ret > 0)

		ret &= 0xff;



	return ret;

}



static int max8952_write_reg(struct max8952_data *max8952,

		u8 reg, u8 value)

{

	return i2c_smbus_write_byte_data(max8952->client, reg, value);

}



static int max8952_voltage(struct max8952_data *max8952, u8 mode)

{

	return (max8952->pdata->dvs_mode[mode] * 10 + 770) * 1000;

}



static int max8952_list_voltage(struct regulator_dev *rdev,

		unsigned int selector)

{

	struct max8952_data *max8952 = rdev_get_drvdata(rdev);



	if (rdev_get_id(rdev) != 0)

		return -EINVAL;



	return max8952_voltage(max8952, selector);

}



static int max8952_is_enabled(struct regulator_dev *rdev)

{

	struct max8952_data *max8952 = rdev_get_drvdata(rdev);

	return max8952->en;

}



static int max8952_enable(struct regulator_dev *rdev)

{

	struct max8952_data *max8952 = rdev_get_drvdata(rdev);



	/* If not valid, assume "ALWAYS_HIGH" */

	if (gpio_is_valid(max8952->pdata->gpio_en))

		gpio_set_value(max8952->pdata->gpio_en, 1);



	max8952->en = true;

	return 0;

}



static int max8952_disable(struct regulator_dev *rdev)

{

	struct max8952_data *max8952 = rdev_get_drvdata(rdev);



	/* If not valid, assume "ALWAYS_HIGH" -> not permitted */

	if (gpio_is_valid(max8952->pdata->gpio_en))

		gpio_set_value(max8952->pdata->gpio_en, 0);

	else

		return -EPERM;



	max8952->en = false;

	return 0;

}



static int max8952_get_voltage(struct regulator_dev *rdev)

{

	struct max8952_data *max8952 = rdev_get_drvdata(rdev);

	u8 vid = 0;



	if (max8952->vid0)

		vid += 1;

	if (max8952->vid1)

		vid += 2;



	return max8952_voltage(max8952, vid);

}



static int max8952_set_voltage(struct regulator_dev *rdev,

				int min_uV, int max_uV)

{

	struct max8952_data *max8952 = rdev_get_drvdata(rdev);

	u8 vid = -1, i;



	if (!gpio_is_valid(max8952->pdata->gpio_vid0) ||

			!gpio_is_valid(max8952->pdata->gpio_vid0)) {

		/* DVS not supported */

		return -EPERM;

	}



	for (i = 0; i < MAX8952_NUM_DVS_MODE; i++) {

		int volt = max8952_voltage(max8952, i);



		/* Set the voltage as low as possible within the range */

		if (volt <= max_uV && volt >= min_uV)

			if (vid == -1 || max8952_voltage(max8952, vid) > volt)

				vid = i;

	}



	if (vid >= 0 && vid < MAX8952_NUM_DVS_MODE) {

		max8952->vid0 = (vid % 2 == 1);

		max8952->vid1 = (((vid >> 1) % 2) == 1);

		gpio_set_value(max8952->pdata->gpio_vid0, max8952->vid0);

		gpio_set_value(max8952->pdata->gpio_vid1, max8952->vid1);

	} else

		return -EINVAL;



	return 0;

}



static struct regulator_ops max8952_ops = {

	.list_voltage		= max8952_list_voltage,

	.is_enabled		= max8952_is_enabled,

	.enable			= max8952_enable,

	.disable		= max8952_disable,

	.get_voltage		= max8952_get_voltage,

	.set_voltage		= max8952_set_voltage,

	.set_suspend_disable	= max8952_disable,

};



static struct regulator_desc regulator = {

	.name		= "MAX8952_VOUT",

	.id		= 0,

	.n_voltages	= MAX8952_NUM_DVS_MODE,

	.ops		= &max8952_ops,

	.type		= REGULATOR_VOLTAGE,

	.owner		= THIS_MODULE,

};



static int __devinit max8952_pmic_probe(struct i2c_client *client,

		const struct i2c_device_id *i2c_id)

{

	struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);

	struct max8952_platform_data *pdata = client->dev.platform_data;

	struct max8952_data *max8952;



	int ret = 0, err = 0;



	if (!pdata) {

		dev_err(&client->dev, "Require the platform data\n");

		return -EINVAL;

	}



	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))

		return -EIO;



	max8952 = kzalloc(sizeof(struct max8952_data), GFP_KERNEL);

	if (!max8952)

		return -ENOMEM;



	max8952->client = client;

	max8952->dev = &client->dev;

	max8952->pdata = pdata;

	mutex_init(&max8952->mutex);



	max8952->rdev = regulator_register(&regulator, max8952->dev,

			&pdata->reg_data, max8952);



	ret = IS_ERR(max8952->rdev);

	if (ret)

		dev_err(max8952->dev, "regulator init failed (%d)\n", ret);



	max8952->en = !!(pdata->reg_data.constraints.boot_on);

	max8952->vid0 = (pdata->default_mode % 2) == 1;

	max8952->vid1 = ((pdata->default_mode >> 1) % 2) == 1;



	if (gpio_is_valid(pdata->gpio_en)) {

		if (!gpio_request(pdata->gpio_en, "MAX8952 EN"))

			gpio_direction_output(pdata->gpio_en, max8952->en);

		else

			err = 1;

	} else

		err = 2;



	if (err) {

		dev_info(max8952->dev, "EN gpio invalid: assume that EN"

				"is always High\n");

		max8952->en = 1;

		pdata->gpio_en = -1; /* Mark invalid */

	}



	err = 0;



	if (gpio_is_valid(pdata->gpio_vid0) &&

			gpio_is_valid(pdata->gpio_vid1)) {

		if (!gpio_request(pdata->gpio_vid0, "MAX8952 VID0"))

			gpio_direction_output(pdata->gpio_vid0,

					(pdata->default_mode) % 2);

		else

			err = 1;



		if (!gpio_request(pdata->gpio_vid1, "MAX8952 VID1"))

			gpio_direction_output(pdata->gpio_vid1,

				(pdata->default_mode >> 1) % 2);

		else {

			if (!err)

				gpio_free(pdata->gpio_vid0);

			err = 2;

		}



	} else

		err = 3;



	if (err) {

		dev_warn(max8952->dev, "VID0/1 gpio invalid: "

				"DVS not avilable.\n");

		max8952->vid0 = 0;

		max8952->vid1 = 0;

		/* Mark invalid */

		pdata->gpio_vid0 = -1;

		pdata->gpio_vid1 = -1;



		/* Disable Pulldown of EN only */

		max8952_write_reg(max8952, MAX8952_REG_CONTROL, 0x60);



		dev_err(max8952->dev, "DVS modes disabled because VID0 and VID1"

				" do not have proper controls.\n");

	} else {

		/*

		 * Disable Pulldown on EN, VID0, VID1 to reduce

		 * leakage current of MAX8952 assuming that MAX8952

		 * is turned on (EN==1). Note that without having VID0/1

		 * properly connected, turning pulldown off can be

		 * problematic. Thus, turn this off only when they are

		 * controllable by GPIO.

		 */

		max8952_write_reg(max8952, MAX8952_REG_CONTROL, 0x0);

	}



	max8952_write_reg(max8952, MAX8952_REG_MODE0,

			(max8952_read_reg(max8952,

					  MAX8952_REG_MODE0) & 0xC0) |

			(pdata->dvs_mode[0] & 0x3F));

	max8952_write_reg(max8952, MAX8952_REG_MODE1,

			(max8952_read_reg(max8952,

					  MAX8952_REG_MODE1) & 0xC0) |

			(pdata->dvs_mode[1] & 0x3F));

	max8952_write_reg(max8952, MAX8952_REG_MODE2,

			(max8952_read_reg(max8952,

					  MAX8952_REG_MODE2) & 0xC0) |

			(pdata->dvs_mode[2] & 0x3F));

	max8952_write_reg(max8952, MAX8952_REG_MODE3,

			(max8952_read_reg(max8952,

					  MAX8952_REG_MODE3) & 0xC0) |

			(pdata->dvs_mode[3] & 0x3F));



	max8952_write_reg(max8952, MAX8952_REG_SYNC,

			(max8952_read_reg(max8952, MAX8952_REG_SYNC) & 0x3F) |

			((pdata->sync_freq & 0x3) << 6));

	max8952_write_reg(max8952, MAX8952_REG_RAMP,

			(max8952_read_reg(max8952, MAX8952_REG_RAMP) & 0x1F) |

			((pdata->ramp_speed & 0x7) << 5));



	i2c_set_clientdata(client, max8952);



	return ret;

}



static int __devexit max8952_pmic_remove(struct i2c_client *client)

{

	struct max8952_data *max8952 = i2c_get_clientdata(client);

	struct max8952_platform_data *pdata = max8952->pdata;

	struct regulator_dev *rdev = max8952->rdev;



	regulator_unregister(rdev);



	gpio_free(pdata->gpio_vid0);

	gpio_free(pdata->gpio_vid1);

	gpio_free(pdata->gpio_en);



	kfree(max8952);

	return 0;

}



static const struct i2c_device_id max8952_ids[] = {

	{ "max8952", 0 },

	{ },

};

MODULE_DEVICE_TABLE(i2c, max8952_ids);



static struct i2c_driver max8952_pmic_driver = {

	.probe		= max8952_pmic_probe,

	.remove		= __devexit_p(max8952_pmic_remove),

	.driver		= {

		.name	= "max8952",

	},

	.id_table	= max8952_ids,

};



static int __init max8952_pmic_init(void)

{

	return i2c_add_driver(&max8952_pmic_driver);

}

subsys_initcall(max8952_pmic_init);



static void __exit max8952_pmic_exit(void)

{

	i2c_del_driver(&max8952_pmic_driver);

}

module_exit(max8952_pmic_exit);



MODULE_DESCRIPTION("MAXIM 8952 voltage regulator driver");

MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>");

MODULE_LICENSE("GPL");

include/linux/regulator/max8952.h

0 → 100644
+135 −0
Original line number Diff line number Diff line 
/*

 * max8952.h - Voltage regulation for the Maxim 8952

 *

 *  Copyright (C) 2010 Samsung Electrnoics

 *  MyungJoo Ham <myungjoo.ham@samsung.com>

 *

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

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * 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.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */



#ifndef REGULATOR_MAX8952

#define REGULATOR_MAX8952



#include <linux/regulator/machine.h>



enum {

	MAX8952_DVS_MODE0,

	MAX8952_DVS_MODE1,

	MAX8952_DVS_MODE2,

	MAX8952_DVS_MODE3,

};



enum {

	MAX8952_DVS_770mV = 0,

	MAX8952_DVS_780mV,

	MAX8952_DVS_790mV,

	MAX8952_DVS_800mV,

	MAX8952_DVS_810mV,

	MAX8952_DVS_820mV,

	MAX8952_DVS_830mV,

	MAX8952_DVS_840mV,

	MAX8952_DVS_850mV,

	MAX8952_DVS_860mV,

	MAX8952_DVS_870mV,

	MAX8952_DVS_880mV,

	MAX8952_DVS_890mV,

	MAX8952_DVS_900mV,

	MAX8952_DVS_910mV,

	MAX8952_DVS_920mV,

	MAX8952_DVS_930mV,

	MAX8952_DVS_940mV,

	MAX8952_DVS_950mV,

	MAX8952_DVS_960mV,

	MAX8952_DVS_970mV,

	MAX8952_DVS_980mV,

	MAX8952_DVS_990mV,

	MAX8952_DVS_1000mV,

	MAX8952_DVS_1010mV,

	MAX8952_DVS_1020mV,

	MAX8952_DVS_1030mV,

	MAX8952_DVS_1040mV,

	MAX8952_DVS_1050mV,

	MAX8952_DVS_1060mV,

	MAX8952_DVS_1070mV,

	MAX8952_DVS_1080mV,

	MAX8952_DVS_1090mV,

	MAX8952_DVS_1100mV,

	MAX8952_DVS_1110mV,

	MAX8952_DVS_1120mV,

	MAX8952_DVS_1130mV,

	MAX8952_DVS_1140mV,

	MAX8952_DVS_1150mV,

	MAX8952_DVS_1160mV,

	MAX8952_DVS_1170mV,

	MAX8952_DVS_1180mV,

	MAX8952_DVS_1190mV,

	MAX8952_DVS_1200mV,

	MAX8952_DVS_1210mV,

	MAX8952_DVS_1220mV,

	MAX8952_DVS_1230mV,

	MAX8952_DVS_1240mV,

	MAX8952_DVS_1250mV,

	MAX8952_DVS_1260mV,

	MAX8952_DVS_1270mV,

	MAX8952_DVS_1280mV,

	MAX8952_DVS_1290mV,

	MAX8952_DVS_1300mV,

	MAX8952_DVS_1310mV,

	MAX8952_DVS_1320mV,

	MAX8952_DVS_1330mV,

	MAX8952_DVS_1340mV,

	MAX8952_DVS_1350mV,

	MAX8952_DVS_1360mV,

	MAX8952_DVS_1370mV,

	MAX8952_DVS_1380mV,

	MAX8952_DVS_1390mV,

	MAX8952_DVS_1400mV,

};



enum {

	MAX8952_SYNC_FREQ_26MHZ, /* Default */

	MAX8952_SYNC_FREQ_13MHZ,

	MAX8952_SYNC_FREQ_19_2MHZ,

};



enum {

	MAX8952_RAMP_32mV_us = 0, /* Default */

	MAX8952_RAMP_16mV_us,

	MAX8952_RAMP_8mV_us,

	MAX8952_RAMP_4mV_us,

	MAX8952_RAMP_2mV_us,

	MAX8952_RAMP_1mV_us,

	MAX8952_RAMP_0_5mV_us,

	MAX8952_RAMP_0_25mV_us,

};



#define MAX8952_NUM_DVS_MODE	4



struct max8952_platform_data {

	int gpio_vid0;

	int gpio_vid1;

	int gpio_en;



	u8 default_mode;

	u8 dvs_mode[MAX8952_NUM_DVS_MODE]; /* MAX8952_DVS_MODEx_XXXXmV */



	u8 sync_freq;

	u8 ramp_speed;



	struct regulator_init_data reg_data;

};





#endif /* REGULATOR_MAX8952 */

CRA Git | Maintained and supported by SUSTech CRA and CCSE