/*
 * max15569-regulator.c -- max15569 regulator driver
 *
 * Copyright (c) 2013-2014, NVIDIA CORPORATION.  All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope 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, see <http://www.gnu.org/licenses/>.
 */

#include <linux/err.h>
#include <linux/i2c.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/machine.h>
#include <linux/regulator/max15569-regulator.h>
#include <linux/slab.h>

/* Register definitions */
#define MAX15569_VOUTMAX_REG			0x2
#define MAX15569_STATUS_REG			0x4
#define MAX15569_MASK_REG			0x5
#define MAX15569_SLEW_RATE_REG			0x6
#define MAX15569_SETVOUT_REG			0x7
#define MAX15569_IMON_REG			0x8

#define MAX15569_MAX_REG			0x9

#define MAX15569_MIN_VOLTAGE	500000
#define MAX15569_MAX_VOLTAGE	1520000
#define MAX15569_VOLTAGE_STEP	10000
#define MAX15569_MAX_SEL	0x7F
#define MAX15569_MAX_SLEW_RATE  44
#define MAX15569_MIN_SLEW_RATE  1

#define MAX15569_STATUS_VRHOT	0x20
#define MAX15569_STATUS_UV	0x10
#define MAX15569_STATUS_OV	0x08
#define MAX15569_STATUS_OC	0x4
#define MAX15569_STATUS_VMERR	0x2
#define MAX15569_STATUS_INT	0x1

struct {
	unsigned char soft_start_slew_rate;
	unsigned char regular_slew_rate;
} max15569_slewrate_table[] = {
	{-1,	-1 },
	{ 9,	9},
	{ 9,	9},
	{ 9,	9},
	{ 9,	9},
	{ 0x19,	0x19},
	{ 0x19,	0x19},
	{ 0x23,	0x23},
	{ 3,	3},
	{ 3,	3},
	{ 0x17,	0x1e},
	{ 0x17,	0x1e},
	{ 0x20,	0x20},
	{ 0x20,	0x20},
	{ 0x20,	0x20},
	{ 0x20,	0x20},
	{ 0x20,	0x20},
	{ 0x0, 0x0},
	{ 0x0, 0x0},
	{ 0x0, 0x0},
	{ 0x0, 0x0},
	{ 0x10, 0x10},
	{ 0x10,	0x10},
	{ 0x10,	0x10},
	{ 0x10,	0x10},
	{ 0x25,	0x25},
	{ 0x25,	0x25},
	{ 0x25,	0x25},
	{ 0x25,	0x25},
	{ 0x25,	0x25},
	{ 0x25,	0x25},
	{ 0x25,	0x25},
	{ 0x25,	0x25},
	{ 0x5,	0x5},
	{ 0x5,	0x5},
	{ 0x5,	0x5},
	{ 0x5,	0x5},
	{ 0x5,	0x5},
	{ 0x5,	0x5},
	{ 0x5,	0x5},
	{ 0x5,	0x5},
	{ 0x15,	0x15},
	{ 0x15,	0x15},
	{ 0x15,	0x15},
	{ 0x15,	0x15},
};

/* MAX15569 chip information */
struct max15569_chip {
	struct device *dev;
	struct regulator_desc desc;
	struct regulator_dev *rdev;
	struct regmap *regmap;

	bool output_enabled;
	unsigned int change_mv_per_us;
};

static int max15569_get_voltage_sel(struct regulator_dev *rdev)
{
	struct max15569_chip *max = rdev_get_drvdata(rdev);
	unsigned int data;
	int ret;
	unsigned int reg = MAX15569_SETVOUT_REG;

	ret = regmap_read(max->regmap, reg, &data);
	if (ret < 0) {
		dev_err(max->dev, "reg read failed, err %d\n", ret);
		return ret;
	}
	return data;
}

static int max15569_set_voltage(struct regulator_dev *rdev,
	     int min_uV, int max_uV, unsigned *selector)
{
	struct max15569_chip *max = rdev_get_drvdata(rdev);
	unsigned int reg = MAX15569_SETVOUT_REG;
	int vsel;
	int ret;

	if ((max_uV < min_uV) || (max_uV < MAX15569_MIN_VOLTAGE) ||
			(min_uV > MAX15569_MAX_VOLTAGE))
		return -EINVAL;

	vsel = DIV_ROUND_UP(min_uV - MAX15569_MIN_VOLTAGE,
			MAX15569_VOLTAGE_STEP) + 0x1;
	if (selector)
		*selector = vsel;

	ret = regmap_write(max->regmap, reg, vsel);
	if (ret < 0)
		dev_err(max->dev, "reg write failed, err %d\n", ret);
	return ret;
}

static int max15569_list_voltage(struct regulator_dev *rdev,
					unsigned selector)
{
	if (selector > MAX15569_MAX_SEL)
		return -EINVAL;

	return MAX15569_MIN_VOLTAGE + (selector - 0x1) * MAX15569_VOLTAGE_STEP;
}

static int max15569_set_voltage_time_sel(struct regulator_dev *rdev,
		unsigned int old_selector, unsigned int new_selector)
{
	struct max15569_chip *max = rdev_get_drvdata(rdev);
	int change_mv_per_us = max->change_mv_per_us;

	if (change_mv_per_us > MAX15569_MAX_SLEW_RATE)
		change_mv_per_us = MAX15569_MAX_SLEW_RATE;

	if (change_mv_per_us < MAX15569_MIN_SLEW_RATE)
		change_mv_per_us = MAX15569_MIN_SLEW_RATE;

	return max->output_enabled ?
		max15569_slewrate_table[max->change_mv_per_us].regular_slew_rate :
		max15569_slewrate_table[max->change_mv_per_us].soft_start_slew_rate;
}

static int max15569_set_control_mode(struct regulator_dev *rdev,
		unsigned int mode)
{
	if (mode != REGULATOR_CONTROL_MODE_I2C)
		return -EINVAL;

	return 0;
}

static unsigned int max15569_get_control_mode(struct regulator_dev *rdev)
{
	return REGULATOR_CONTROL_MODE_I2C;
}

static struct regulator_ops max15569_ops = {
	.get_voltage_sel	= max15569_get_voltage_sel,
	.set_voltage		= max15569_set_voltage,
	.list_voltage		= max15569_list_voltage,
	.set_voltage_time_sel	= max15569_set_voltage_time_sel,
	.set_control_mode	= max15569_set_control_mode,
	.get_control_mode	= max15569_get_control_mode,
};

static int max15569_init(struct max15569_chip *max15569,
	struct max15569_regulator_platform_data *pdata)
{
	int ret;
	int vsel;
	unsigned int status;

	max15569->output_enabled = true;

	/* Set slew rate */
	/* max15569->change_mv_per_us = min(44,max(1, pdata->slew_rate_mv_per_us)); */

	if (max15569->change_mv_per_us > 44)
		max15569->change_mv_per_us = 44;

	if (max15569->change_mv_per_us < 1)
		max15569->change_mv_per_us = 1;


	vsel = max15569_slewrate_table[max15569->change_mv_per_us].regular_slew_rate;

	ret = regmap_write(max15569->regmap, MAX15569_SLEW_RATE_REG, vsel);
	if (ret < 0) {
		dev_err(max15569->dev, "SLEW reg write failed, err %d\n", ret);
		return ret;
	}

	/* Set base voltage if passed from platform data*/
	if (pdata->base_voltage_uV) {
		vsel = DIV_ROUND_UP(pdata->base_voltage_uV -
				MAX15569_MIN_VOLTAGE, MAX15569_VOLTAGE_STEP) + 0x1;
		dev_err(max15569->dev, "Setting rail to vsel %x\n", vsel);
		ret = regmap_write(max15569->regmap, MAX15569_SETVOUT_REG, vsel);
		if (ret < 0) {
			dev_err(max15569->dev, "BASE reg write failed, err %d\n", ret);
			return ret;
		}
	}

	/* setup max voltage */
	if (pdata->max_voltage_uV) {
		vsel = DIV_ROUND_UP(pdata->max_voltage_uV -
			MAX15569_MIN_VOLTAGE, MAX15569_VOLTAGE_STEP) + 0x1;
		ret = regmap_write(max15569->regmap, MAX15569_VOUTMAX_REG, vsel);
		if (ret < 0) {
			dev_err(max15569->dev, "VMAX write failed, err %d\n", ret);
			return ret;
		}
	}

	ret = regmap_read(max15569->regmap, MAX15569_STATUS_REG, &status);
	if (ret < 0) {
		dev_err(max15569->dev, "STATUS reg read failed, err %d\n", ret);
		return ret;
	}

	if (status & MAX15569_STATUS_VRHOT)
		dev_err(max15569->dev, "VRHOT: regulator temperature beyond limit\n");

	if (status & MAX15569_STATUS_UV)
		dev_err(max15569->dev, "UV: regulator under-voltage condition\n");

	if (status & MAX15569_STATUS_OV)
		dev_err(max15569->dev, "UV: regulator over-voltage condition\n");

	if (status & MAX15569_STATUS_OC)
		dev_err(max15569->dev, "UV: regulator over-current condition\n");

	return 0;
}

static bool is_volatile_reg(struct device *dev, unsigned int reg)
{
	switch (reg) {
	case MAX15569_IMON_REG:
		return true;
	default:
		return false;
	}
}

static bool is_read_reg(struct device *dev, unsigned int reg)
{
	switch (reg) {
	case 0x02:
	case 0x4 ... 0x08:
		return true;
	default:
		return false;
	}
}

static bool is_write_reg(struct device *dev, unsigned int reg)
{
	switch (reg) {
	case 0x02:
	case 0x5 ... 0x7:
		return true;
	default:
		return false;
	}
}

static const struct regmap_config max15569_regmap_config = {
	.reg_bits		= 8,
	.val_bits		= 8,
	.writeable_reg		= is_write_reg,
	.readable_reg		= is_read_reg,
	.volatile_reg		= is_volatile_reg,
	.max_register		= MAX15569_MAX_REG - 1,
	.cache_type		= REGCACHE_RBTREE,
};

static int max15569_probe(struct i2c_client *client,
			const struct i2c_device_id *id)
{
	struct max15569_regulator_platform_data *pdata;
	struct regulator_dev *rdev;
	struct max15569_chip *max;
	struct regulator_config rconfig = { };
	int ret;

	pdata = client->dev.platform_data;
	if (!pdata) {
		dev_err(&client->dev, "No Platform data\n");
		return -EINVAL;
	}

	max = devm_kzalloc(&client->dev, sizeof(*max), GFP_KERNEL);
	if (!max) {
		dev_err(&client->dev, "Memory allocation failed\n");
		return -ENOMEM;
	}

	max->dev = &client->dev;
	max->desc.name = id->name;
	max->desc.id = 0;
	max->desc.ops = &max15569_ops;
	max->desc.type = REGULATOR_VOLTAGE;
	max->desc.owner = THIS_MODULE;
	max->regmap = devm_regmap_init_i2c(client, &max15569_regmap_config);
	if (IS_ERR(max->regmap)) {
		ret = PTR_ERR(max->regmap);
		dev_err(&client->dev, "regmap init failed, err %d\n", ret);
		return ret;
	}
	i2c_set_clientdata(client, max);

	ret = max15569_init(max, pdata);
	if (ret < 0) {
		dev_err(max->dev, "Init failed, err = %d\n", ret);
		return ret;
	}

	/* Register the regulators */
	rconfig.dev = &client->dev;
	rconfig.of_node = NULL;
	rconfig.init_data = pdata->reg_init_data;
	rconfig.driver_data = max;
	rdev = regulator_register(&max->desc, &rconfig);

	if (IS_ERR(rdev)) {
		dev_err(max->dev, "regulator register failed\n");
		return PTR_ERR(rdev);
	}

	max->rdev = rdev;
	return 0;
}

static int max15569_remove(struct i2c_client *client)
{
	struct max15569_chip *max = i2c_get_clientdata(client);

	regulator_unregister(max->rdev);
	return 0;
}

static const struct i2c_device_id max15569_id[] = {
	{.name = "max15569",},
	{},
};

MODULE_DEVICE_TABLE(i2c, max15569_id);

static struct i2c_driver max15569_i2c_driver = {
	.driver = {
		.name = "max15569",
		.owner = THIS_MODULE,
	},
	.probe = max15569_probe,
	.remove = max15569_remove,
	.id_table = max15569_id,
};

static int __init max15569_drv_init(void)
{
	return i2c_add_driver(&max15569_i2c_driver);
}
subsys_initcall(max15569_drv_init);

static void __exit max15569_drv_cleanup(void)
{
	i2c_del_driver(&max15569_i2c_driver);
}
module_exit(max15569_drv_cleanup);

MODULE_AUTHOR("NVIDIA Corporation");
MODULE_DESCRIPTION("MAX15569 voltage regulator driver");
MODULE_LICENSE("GPL v2");