[J-u-boot.git] / drivers / power / regulator / fan53555.c

// SPDX-License-Identifier:     GPL-2.0+
/*
 * (C) 2018 Theobroma Systems Design und Consulting GmbH
 */

#include <common.h>
#include <bitfield.h>
#include <errno.h>
#include <dm.h>
#include <fdtdec.h>
#include <i2c.h>
#include <log.h>
#include <asm/gpio.h>
#include <linux/bitops.h>
#include <power/fan53555.h>
#include <power/pmic.h>
#include <power/regulator.h>

/**
 * struct ic_types - definition of fan53555-family devices
 *
 * @die_id: Identifies the DIE_ID (lower nibble of the ID1 register)
 * @die_rev: Identifies the DIE_REV (lower nibble of the ID2 register)
 * @vsel_min: starting voltage (step 0) in uV
 * @vsel_step: increment of the voltage in uV
 *
 * The voltage ramp (i.e. minimum voltage and step) is selected from the
 * combination of 2 nibbles: DIE_ID and DIE_REV.
 *
 * See http://www.onsemi.com/pub/Collateral/FAN53555-D.pdf for details.
 */
static const struct {
	unsigned int vendor;
	u8 die_id;
	u8 die_rev;
	bool check_rev;
	u32 vsel_min;
	u32 vsel_step;
} ic_types[] = {
	/* Option 00 */
	{ FAN53555_VENDOR_FAIRCHILD, 0x0, 0x3, true,  600000, 10000 },
	/* Option 13 */
	{ FAN53555_VENDOR_FAIRCHILD, 0x0, 0xf, true,  800000, 10000 },
	/* Option 23 */
	{ FAN53555_VENDOR_FAIRCHILD, 0x0, 0xc, true,  600000, 12500 },
	/* Option 01 */
	{ FAN53555_VENDOR_FAIRCHILD, 0x1, 0x3, true,  600000, 10000 },
	/* Option 03 */
	{ FAN53555_VENDOR_FAIRCHILD, 0x3, 0x3, true,  600000, 10000 },
	/* Option 04 */
	{ FAN53555_VENDOR_FAIRCHILD, 0x4, 0xf, true,  603000, 12826 },
	/* Option 05 */
	{ FAN53555_VENDOR_FAIRCHILD, 0x5, 0x3, true,  600000, 10000 },
	/* Option 08 */
	{ FAN53555_VENDOR_FAIRCHILD, 0x8, 0x1, true,  600000, 10000 },
	/* Option 08 */
	{ FAN53555_VENDOR_FAIRCHILD, 0x8, 0xf, true,  600000, 10000 },
	/* Option 09 */
	{ FAN53555_VENDOR_FAIRCHILD, 0xc, 0xf, true,  603000, 12826 },
	/* SYL82X */
	{ FAN53555_VENDOR_SILERGY,   0x8, 0x0, false, 712500, 12500 },
	/* SYL83X */
	{ FAN53555_VENDOR_SILERGY,   0x9, 0x0, false, 712500, 12500 },
};

/* I2C-accessible byte-sized registers */
enum {
	/* Voltage setting */
	FAN53555_VSEL0 = 0x00,
	FAN53555_VSEL1,
	/* Control register */
	FAN53555_CONTROL,
	/* IC Type */
	FAN53555_ID1,
	/* IC mask version */
	FAN53555_ID2,
	/* Monitor register */
	FAN53555_MONITOR,
};

struct fan53555_platdata {
	/* Voltage setting register */
	unsigned int vol_reg;
	unsigned int sleep_reg;

};

struct fan53555_priv {
	/* IC Vendor */
	unsigned int vendor;
	/* IC Type and Rev */
	unsigned int die_id;
	unsigned int die_rev;
	/* Voltage range and step(linear) */
	unsigned int vsel_min;
	unsigned int vsel_step;
	/* Voltage slew rate limiting */
	unsigned int slew_rate;
	/* Sleep voltage cache */
	unsigned int sleep_vol_cache;
};

static int fan53555_regulator_ofdata_to_platdata(struct udevice *dev)
{
	struct fan53555_platdata *dev_pdata = dev_get_platdata(dev);
	struct dm_regulator_uclass_platdata *uc_pdata =
		dev_get_uclass_platdata(dev);
	u32 sleep_vsel;

	/* This is a buck regulator */
	uc_pdata->type = REGULATOR_TYPE_BUCK;

	sleep_vsel = dev_read_u32_default(dev, "fcs,suspend-voltage-selector",
					  FAN53555_VSEL1);

	/*
	 * Depending on the device-tree settings, the 'normal mode'
	 * voltage is either controlled by VSEL0 or VSEL1.
	 */
	switch (sleep_vsel) {
	case FAN53555_VSEL0:
		dev_pdata->sleep_reg = FAN53555_VSEL0;
		dev_pdata->vol_reg = FAN53555_VSEL1;
		break;
	case FAN53555_VSEL1:
		dev_pdata->sleep_reg = FAN53555_VSEL1;
		dev_pdata->vol_reg = FAN53555_VSEL0;
		break;
	default:
		pr_err("%s: invalid vsel id %d\n", dev->name, sleep_vsel);
		return -EINVAL;
	}

	return 0;
}

static int fan53555_regulator_get_value(struct udevice *dev)
{
	struct fan53555_platdata *pdata = dev_get_platdata(dev);
	struct fan53555_priv *priv = dev_get_priv(dev);
	int reg;
	int voltage;

	/* We only support a single voltage selector (i.e. 'normal' mode). */
	reg = pmic_reg_read(dev->parent, pdata->vol_reg);
	if (reg < 0)
		return reg;
	voltage = priv->vsel_min + (reg & 0x3f) * priv->vsel_step;

	debug("%s: %d uV\n", __func__, voltage);
	return voltage;
}

static int fan53555_regulator_set_value(struct udevice *dev, int uV)
{
	struct fan53555_platdata *pdata = dev_get_platdata(dev);
	struct fan53555_priv *priv = dev_get_priv(dev);
	u8 vol;

	vol = (uV - priv->vsel_min) / priv->vsel_step;
	debug("%s: uV=%d; writing volume %d: %02x\n",
	      __func__, uV, pdata->vol_reg, vol);

	return pmic_clrsetbits(dev->parent, pdata->vol_reg, GENMASK(6, 0), vol);
}

static int fan53555_voltages_setup(struct udevice *dev)
{
	struct fan53555_priv *priv = dev_get_priv(dev);
	int i;

	/* Init voltage range and step */
	for (i = 0; i < ARRAY_SIZE(ic_types); ++i) {
		if (ic_types[i].vendor != priv->vendor)
			continue;

		if (ic_types[i].die_id != priv->die_id)
			continue;

		if (ic_types[i].check_rev &&
		    ic_types[i].die_rev != priv->die_rev)
			continue;

		priv->vsel_min = ic_types[i].vsel_min;
		priv->vsel_step = ic_types[i].vsel_step;

		return 0;
	}

	pr_err("%s: %s: die id %d rev %d not supported!\n",
	       dev->name, __func__, priv->die_id, priv->die_rev);
	return -EINVAL;
}

enum {
	DIE_ID_SHIFT = 0,
	DIE_ID_WIDTH = 4,
	DIE_REV_SHIFT = 0,
	DIE_REV_WIDTH = 4,
};

static int fan53555_probe(struct udevice *dev)
{
	struct fan53555_priv *priv = dev_get_priv(dev);
	int ID1, ID2;

	debug("%s\n", __func__);

	/* read chip ID1 and ID2 (two registers, starting at ID1) */
	ID1 = pmic_reg_read(dev->parent, FAN53555_ID1);
	if (ID1 < 0)
		return ID1;

	ID2 = pmic_reg_read(dev->parent, FAN53555_ID2);
	if (ID2 < 0)
		return ID2;

	/* extract vendor, die_id and die_rev */
	priv->vendor = dev->driver_data;
	priv->die_id = ID1 & GENMASK(3, 0);
	priv->die_rev = ID2 & GENMASK(3, 0);

	if (fan53555_voltages_setup(dev) < 0)
		return -ENODATA;

	debug("%s: FAN53555 option %d rev %d detected\n",
	      __func__, priv->die_id, priv->die_rev);

	return 0;
}

static const struct dm_regulator_ops fan53555_regulator_ops = {
	.get_value	= fan53555_regulator_get_value,
	.set_value	= fan53555_regulator_set_value,
};

U_BOOT_DRIVER(fan53555_regulator) = {
	.name = "fan53555_regulator",
	.id = UCLASS_REGULATOR,
	.ops = &fan53555_regulator_ops,
	.ofdata_to_platdata = fan53555_regulator_ofdata_to_platdata,
	.platdata_auto_alloc_size = sizeof(struct fan53555_platdata),
	.priv_auto_alloc_size = sizeof(struct fan53555_priv),
	.probe = fan53555_probe,
};
Commit	Line	Data
dfb0a70a PT	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* (C) 2018 Theobroma Systems Design und Consulting GmbH
	4	*/
	5
	6	#include <common.h>
	7	#include <bitfield.h>
	8	#include <errno.h>
	9	#include <dm.h>
	10	#include <fdtdec.h>
	11	#include <i2c.h>
f7ae49fc	12	#include <log.h>
dfb0a70a	13	#include <asm/gpio.h>
cd93d625	14	#include <linux/bitops.h>
5ef1e02e	15	#include <power/fan53555.h>
dfb0a70a PT	16	#include <power/pmic.h>
	17	#include <power/regulator.h>
	18
	19	/**
	20	* struct ic_types - definition of fan53555-family devices
	21	*
	22	* @die_id: Identifies the DIE_ID (lower nibble of the ID1 register)
	23	* @die_rev: Identifies the DIE_REV (lower nibble of the ID2 register)
	24	* @vsel_min: starting voltage (step 0) in uV
	25	* @vsel_step: increment of the voltage in uV
	26	*
	27	* The voltage ramp (i.e. minimum voltage and step) is selected from the
	28	* combination of 2 nibbles: DIE_ID and DIE_REV.
	29	*
	30	* See http://www.onsemi.com/pub/Collateral/FAN53555-D.pdf for details.
	31	*/
	32	static const struct {
5ef1e02e	33	unsigned int vendor;
dfb0a70a PT	34	u8 die_id;
dfb0a70a PT	35	u8 die_rev;
5ef1e02e	36	bool check_rev;
dfb0a70a PT	37	u32 vsel_min;
	38	u32 vsel_step;
	39	} ic_types[] = {
5ef1e02e VK	40	/* Option 00 */
	41	{ FAN53555_VENDOR_FAIRCHILD, 0x0, 0x3, true, 600000, 10000 },
	42	/* Option 13 */
	43	{ FAN53555_VENDOR_FAIRCHILD, 0x0, 0xf, true, 800000, 10000 },
	44	/* Option 23 */
	45	{ FAN53555_VENDOR_FAIRCHILD, 0x0, 0xc, true, 600000, 12500 },
	46	/* Option 01 */
	47	{ FAN53555_VENDOR_FAIRCHILD, 0x1, 0x3, true, 600000, 10000 },
	48	/* Option 03 */
	49	{ FAN53555_VENDOR_FAIRCHILD, 0x3, 0x3, true, 600000, 10000 },
	50	/* Option 04 */
	51	{ FAN53555_VENDOR_FAIRCHILD, 0x4, 0xf, true, 603000, 12826 },
	52	/* Option 05 */
	53	{ FAN53555_VENDOR_FAIRCHILD, 0x5, 0x3, true, 600000, 10000 },
	54	/* Option 08 */
	55	{ FAN53555_VENDOR_FAIRCHILD, 0x8, 0x1, true, 600000, 10000 },
	56	/* Option 08 */
	57	{ FAN53555_VENDOR_FAIRCHILD, 0x8, 0xf, true, 600000, 10000 },
	58	/* Option 09 */
	59	{ FAN53555_VENDOR_FAIRCHILD, 0xc, 0xf, true, 603000, 12826 },
	60	/* SYL82X */
	61	{ FAN53555_VENDOR_SILERGY, 0x8, 0x0, false, 712500, 12500 },
	62	/* SYL83X */
	63	{ FAN53555_VENDOR_SILERGY, 0x9, 0x0, false, 712500, 12500 },
dfb0a70a PT	64	};
	65
	66	/* I2C-accessible byte-sized registers */
	67	enum {
	68	/* Voltage setting */
	69	FAN53555_VSEL0 = 0x00,
	70	FAN53555_VSEL1,
	71	/* Control register */
	72	FAN53555_CONTROL,
	73	/* IC Type */
	74	FAN53555_ID1,
	75	/* IC mask version */
	76	FAN53555_ID2,
	77	/* Monitor register */
	78	FAN53555_MONITOR,
	79	};
	80
	81	struct fan53555_platdata {
	82	/* Voltage setting register */
	83	unsigned int vol_reg;
	84	unsigned int sleep_reg;
	85
	86	};
	87
	88	struct fan53555_priv {
	89	/* IC Vendor */
	90	unsigned int vendor;
	91	/* IC Type and Rev */
	92	unsigned int die_id;
	93	unsigned int die_rev;
	94	/* Voltage range and step(linear) */
	95	unsigned int vsel_min;
	96	unsigned int vsel_step;
	97	/* Voltage slew rate limiting */
	98	unsigned int slew_rate;
	99	/* Sleep voltage cache */
	100	unsigned int sleep_vol_cache;
	101	};
	102
	103	static int fan53555_regulator_ofdata_to_platdata(struct udevice *dev)
	104	{
	105	struct fan53555_platdata *dev_pdata = dev_get_platdata(dev);
	106	struct dm_regulator_uclass_platdata *uc_pdata =
	107	dev_get_uclass_platdata(dev);
	108	u32 sleep_vsel;
	109
	110	/* This is a buck regulator */
	111	uc_pdata->type = REGULATOR_TYPE_BUCK;
	112
	113	sleep_vsel = dev_read_u32_default(dev, "fcs,suspend-voltage-selector",
	114	FAN53555_VSEL1);
	115
	116	/*
	117	* Depending on the device-tree settings, the 'normal mode'
	118	* voltage is either controlled by VSEL0 or VSEL1.
	119	*/
	120	switch (sleep_vsel) {
	121	case FAN53555_VSEL0:
	122	dev_pdata->sleep_reg = FAN53555_VSEL0;
	123	dev_pdata->vol_reg = FAN53555_VSEL1;
	124	break;
	125	case FAN53555_VSEL1:
	126	dev_pdata->sleep_reg = FAN53555_VSEL1;
	127	dev_pdata->vol_reg = FAN53555_VSEL0;
128	break;
129	default:
130	pr_err("%s: invalid vsel id %d\n", dev->name, sleep_vsel);
131	return -EINVAL;
132	}
133
134	return 0;
135	}
136
137	static int fan53555_regulator_get_value(struct udevice *dev)
138	{
139	struct fan53555_platdata *pdata = dev_get_platdata(dev);
140	struct fan53555_priv *priv = dev_get_priv(dev);
141	int reg;
142	int voltage;
143
144	/* We only support a single voltage selector (i.e. 'normal' mode). */
145	reg = pmic_reg_read(dev->parent, pdata->vol_reg);
146	if (reg < 0)
147	return reg;
148	voltage = priv->vsel_min + (reg & 0x3f) * priv->vsel_step;
149
150	debug("%s: %d uV\n", __func__, voltage);
151	return voltage;
152	}
153
154	static int fan53555_regulator_set_value(struct udevice *dev, int uV)
155	{
156	struct fan53555_platdata *pdata = dev_get_platdata(dev);
157	struct fan53555_priv *priv = dev_get_priv(dev);
158	u8 vol;
159
160	vol = (uV - priv->vsel_min) / priv->vsel_step;
161	debug("%s: uV=%d; writing volume %d: %02x\n",
162	__func__, uV, pdata->vol_reg, vol);
163
e82692ab	164	return pmic_clrsetbits(dev->parent, pdata->vol_reg, GENMASK(6, 0), vol);
dfb0a70a PT	165	}
	166
	167	static int fan53555_voltages_setup(struct udevice *dev)
	168	{
	169	struct fan53555_priv *priv = dev_get_priv(dev);
	170	int i;
	171
	172	/* Init voltage range and step */
	173	for (i = 0; i < ARRAY_SIZE(ic_types); ++i) {
5ef1e02e VK	174	if (ic_types[i].vendor != priv->vendor)
	175	continue;
	176
dfb0a70a PT	177	if (ic_types[i].die_id != priv->die_id)
	178	continue;
	179
5ef1e02e VK	180	if (ic_types[i].check_rev &&
5ef1e02e VK	181	ic_types[i].die_rev != priv->die_rev)
dfb0a70a PT	182	continue;
	183
	184	priv->vsel_min = ic_types[i].vsel_min;
	185	priv->vsel_step = ic_types[i].vsel_step;
	186
	187	return 0;
	188	}
	189
	190	pr_err("%s: %s: die id %d rev %d not supported!\n",
	191	dev->name, __func__, priv->die_id, priv->die_rev);
	192	return -EINVAL;
	193	}
	194
	195	enum {
	196	DIE_ID_SHIFT = 0,
	197	DIE_ID_WIDTH = 4,
	198	DIE_REV_SHIFT = 0,
	199	DIE_REV_WIDTH = 4,
	200	};
	201
	202	static int fan53555_probe(struct udevice *dev)
	203	{
	204	struct fan53555_priv *priv = dev_get_priv(dev);
	205	int ID1, ID2;
	206
	207	debug("%s\n", __func__);
	208
	209	/* read chip ID1 and ID2 (two registers, starting at ID1) */
	210	ID1 = pmic_reg_read(dev->parent, FAN53555_ID1);
	211	if (ID1 < 0)
	212	return ID1;
	213
	214	ID2 = pmic_reg_read(dev->parent, FAN53555_ID2);
	215	if (ID2 < 0)
	216	return ID2;
	217
	218	/* extract vendor, die_id and die_rev */
5ef1e02e	219	priv->vendor = dev->driver_data;
dfb0a70a PT	220	priv->die_id = ID1 & GENMASK(3, 0);
	221	priv->die_rev = ID2 & GENMASK(3, 0);
	222
	223	if (fan53555_voltages_setup(dev) < 0)
	224	return -ENODATA;
	225
	226	debug("%s: FAN53555 option %d rev %d detected\n",
	227	__func__, priv->die_id, priv->die_rev);
	228
	229	return 0;
	230	}
	231
	232	static const struct dm_regulator_ops fan53555_regulator_ops = {
	233	.get_value = fan53555_regulator_get_value,
	234	.set_value = fan53555_regulator_set_value,
	235	};
	236
	237	U_BOOT_DRIVER(fan53555_regulator) = {
	238	.name = "fan53555_regulator",
	239	.id = UCLASS_REGULATOR,
	240	.ops = &fan53555_regulator_ops,
	241	.ofdata_to_platdata = fan53555_regulator_ofdata_to_platdata,
	242	.platdata_auto_alloc_size = sizeof(struct fan53555_platdata),
	243	.priv_auto_alloc_size = sizeof(struct fan53555_priv),
	244	.probe = fan53555_probe,
	245	};