cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

ti-abb-regulator.c (24408B)


      1/*
      2 * Texas Instruments SoC Adaptive Body Bias(ABB) Regulator
      3 *
      4 * Copyright (C) 2011 Texas Instruments, Inc.
      5 * Mike Turquette <mturquette@ti.com>
      6 *
      7 * Copyright (C) 2012-2013 Texas Instruments, Inc.
      8 * Andrii Tseglytskyi <andrii.tseglytskyi@ti.com>
      9 * Nishanth Menon <nm@ti.com>
     10 *
     11 * This program is free software; you can redistribute it and/or modify
     12 * it under the terms of the GNU General Public License version 2 as
     13 * published by the Free Software Foundation.
     14 *
     15 * This program is distributed "as is" WITHOUT ANY WARRANTY of any
     16 * kind, whether express or implied; without even the implied warranty
     17 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     18 * GNU General Public License for more details.
     19 */
     20#include <linux/clk.h>
     21#include <linux/delay.h>
     22#include <linux/err.h>
     23#include <linux/io.h>
     24#include <linux/module.h>
     25#include <linux/of_device.h>
     26#include <linux/of.h>
     27#include <linux/platform_device.h>
     28#include <linux/regulator/driver.h>
     29#include <linux/regulator/machine.h>
     30#include <linux/regulator/of_regulator.h>
     31
     32/*
     33 * ABB LDO operating states:
     34 * NOMINAL_OPP:	bypasses the ABB LDO
     35 * FAST_OPP:	sets ABB LDO to Forward Body-Bias
     36 * SLOW_OPP:	sets ABB LDO to Reverse Body-Bias
     37 */
     38#define TI_ABB_NOMINAL_OPP	0
     39#define TI_ABB_FAST_OPP		1
     40#define TI_ABB_SLOW_OPP		3
     41
     42/**
     43 * struct ti_abb_info - ABB information per voltage setting
     44 * @opp_sel:	one of TI_ABB macro
     45 * @vset:	(optional) vset value that LDOVBB needs to be overridden with.
     46 *
     47 * Array of per voltage entries organized in the same order as regulator_desc's
     48 * volt_table list. (selector is used to index from this array)
     49 */
     50struct ti_abb_info {
     51	u32 opp_sel;
     52	u32 vset;
     53};
     54
     55/**
     56 * struct ti_abb_reg - Register description for ABB block
     57 * @setup_off:			setup register offset from base
     58 * @control_off:		control register offset from base
     59 * @sr2_wtcnt_value_mask:	setup register- sr2_wtcnt_value mask
     60 * @fbb_sel_mask:		setup register- FBB sel mask
     61 * @rbb_sel_mask:		setup register- RBB sel mask
     62 * @sr2_en_mask:		setup register- enable mask
     63 * @opp_change_mask:		control register - mask to trigger LDOVBB change
     64 * @opp_sel_mask:		control register - mask for mode to operate
     65 */
     66struct ti_abb_reg {
     67	u32 setup_off;
     68	u32 control_off;
     69
     70	/* Setup register fields */
     71	u32 sr2_wtcnt_value_mask;
     72	u32 fbb_sel_mask;
     73	u32 rbb_sel_mask;
     74	u32 sr2_en_mask;
     75
     76	/* Control register fields */
     77	u32 opp_change_mask;
     78	u32 opp_sel_mask;
     79};
     80
     81/**
     82 * struct ti_abb - ABB instance data
     83 * @rdesc:			regulator descriptor
     84 * @clk:			clock(usually sysclk) supplying ABB block
     85 * @base:			base address of ABB block
     86 * @setup_reg:			setup register of ABB block
     87 * @control_reg:		control register of ABB block
     88 * @int_base:			interrupt register base address
     89 * @efuse_base:			(optional) efuse base address for ABB modes
     90 * @ldo_base:			(optional) LDOVBB vset override base address
     91 * @regs:			pointer to struct ti_abb_reg for ABB block
     92 * @txdone_mask:		mask on int_base for tranxdone interrupt
     93 * @ldovbb_override_mask:	mask to ldo_base for overriding default LDO VBB
     94 *				vset with value from efuse
     95 * @ldovbb_vset_mask:		mask to ldo_base for providing the VSET override
     96 * @info:			array to per voltage ABB configuration
     97 * @current_info_idx:		current index to info
     98 * @settling_time:		SoC specific settling time for LDO VBB
     99 */
    100struct ti_abb {
    101	struct regulator_desc rdesc;
    102	struct clk *clk;
    103	void __iomem *base;
    104	void __iomem *setup_reg;
    105	void __iomem *control_reg;
    106	void __iomem *int_base;
    107	void __iomem *efuse_base;
    108	void __iomem *ldo_base;
    109
    110	const struct ti_abb_reg *regs;
    111	u32 txdone_mask;
    112	u32 ldovbb_override_mask;
    113	u32 ldovbb_vset_mask;
    114
    115	struct ti_abb_info *info;
    116	int current_info_idx;
    117
    118	u32 settling_time;
    119};
    120
    121/**
    122 * ti_abb_rmw() - handy wrapper to set specific register bits
    123 * @mask:	mask for register field
    124 * @value:	value shifted to mask location and written
    125 * @reg:	register address
    126 *
    127 * Return: final register value (may be unused)
    128 */
    129static inline u32 ti_abb_rmw(u32 mask, u32 value, void __iomem *reg)
    130{
    131	u32 val;
    132
    133	val = readl(reg);
    134	val &= ~mask;
    135	val |= (value << __ffs(mask)) & mask;
    136	writel(val, reg);
    137
    138	return val;
    139}
    140
    141/**
    142 * ti_abb_check_txdone() - handy wrapper to check ABB tranxdone status
    143 * @abb:	pointer to the abb instance
    144 *
    145 * Return: true or false
    146 */
    147static inline bool ti_abb_check_txdone(const struct ti_abb *abb)
    148{
    149	return !!(readl(abb->int_base) & abb->txdone_mask);
    150}
    151
    152/**
    153 * ti_abb_clear_txdone() - handy wrapper to clear ABB tranxdone status
    154 * @abb:	pointer to the abb instance
    155 */
    156static inline void ti_abb_clear_txdone(const struct ti_abb *abb)
    157{
    158	writel(abb->txdone_mask, abb->int_base);
    159};
    160
    161/**
    162 * ti_abb_wait_tranx() - waits for ABB tranxdone event
    163 * @dev:	device
    164 * @abb:	pointer to the abb instance
    165 *
    166 * Return: 0 on success or -ETIMEDOUT if the event is not cleared on time.
    167 */
    168static int ti_abb_wait_txdone(struct device *dev, struct ti_abb *abb)
    169{
    170	int timeout = 0;
    171	bool status;
    172
    173	while (timeout++ <= abb->settling_time) {
    174		status = ti_abb_check_txdone(abb);
    175		if (status)
    176			return 0;
    177
    178		udelay(1);
    179	}
    180
    181	dev_warn_ratelimited(dev, "%s:TRANXDONE timeout(%duS) int=0x%08x\n",
    182			     __func__, timeout, readl(abb->int_base));
    183	return -ETIMEDOUT;
    184}
    185
    186/**
    187 * ti_abb_clear_all_txdone() - clears ABB tranxdone event
    188 * @dev:	device
    189 * @abb:	pointer to the abb instance
    190 *
    191 * Return: 0 on success or -ETIMEDOUT if the event is not cleared on time.
    192 */
    193static int ti_abb_clear_all_txdone(struct device *dev, const struct ti_abb *abb)
    194{
    195	int timeout = 0;
    196	bool status;
    197
    198	while (timeout++ <= abb->settling_time) {
    199		ti_abb_clear_txdone(abb);
    200
    201		status = ti_abb_check_txdone(abb);
    202		if (!status)
    203			return 0;
    204
    205		udelay(1);
    206	}
    207
    208	dev_warn_ratelimited(dev, "%s:TRANXDONE timeout(%duS) int=0x%08x\n",
    209			     __func__, timeout, readl(abb->int_base));
    210	return -ETIMEDOUT;
    211}
    212
    213/**
    214 * ti_abb_program_ldovbb() - program LDOVBB register for override value
    215 * @dev:	device
    216 * @abb:	pointer to the abb instance
    217 * @info:	ABB info to program
    218 */
    219static void ti_abb_program_ldovbb(struct device *dev, const struct ti_abb *abb,
    220				  struct ti_abb_info *info)
    221{
    222	u32 val;
    223
    224	val = readl(abb->ldo_base);
    225	/* clear up previous values */
    226	val &= ~(abb->ldovbb_override_mask | abb->ldovbb_vset_mask);
    227
    228	switch (info->opp_sel) {
    229	case TI_ABB_SLOW_OPP:
    230	case TI_ABB_FAST_OPP:
    231		val |= abb->ldovbb_override_mask;
    232		val |= info->vset << __ffs(abb->ldovbb_vset_mask);
    233		break;
    234	}
    235
    236	writel(val, abb->ldo_base);
    237}
    238
    239/**
    240 * ti_abb_set_opp() - Setup ABB and LDO VBB for required bias
    241 * @rdev:	regulator device
    242 * @abb:	pointer to the abb instance
    243 * @info:	ABB info to program
    244 *
    245 * Return: 0 on success or appropriate error value when fails
    246 */
    247static int ti_abb_set_opp(struct regulator_dev *rdev, struct ti_abb *abb,
    248			  struct ti_abb_info *info)
    249{
    250	const struct ti_abb_reg *regs = abb->regs;
    251	struct device *dev = &rdev->dev;
    252	int ret;
    253
    254	ret = ti_abb_clear_all_txdone(dev, abb);
    255	if (ret)
    256		goto out;
    257
    258	ti_abb_rmw(regs->fbb_sel_mask | regs->rbb_sel_mask, 0, abb->setup_reg);
    259
    260	switch (info->opp_sel) {
    261	case TI_ABB_SLOW_OPP:
    262		ti_abb_rmw(regs->rbb_sel_mask, 1, abb->setup_reg);
    263		break;
    264	case TI_ABB_FAST_OPP:
    265		ti_abb_rmw(regs->fbb_sel_mask, 1, abb->setup_reg);
    266		break;
    267	}
    268
    269	/* program next state of ABB ldo */
    270	ti_abb_rmw(regs->opp_sel_mask, info->opp_sel, abb->control_reg);
    271
    272	/*
    273	 * program LDO VBB vset override if needed for !bypass mode
    274	 * XXX: Do not switch sequence - for !bypass, LDO override reset *must*
    275	 * be performed *before* switch to bias mode else VBB glitches.
    276	 */
    277	if (abb->ldo_base && info->opp_sel != TI_ABB_NOMINAL_OPP)
    278		ti_abb_program_ldovbb(dev, abb, info);
    279
    280	/* Initiate ABB ldo change */
    281	ti_abb_rmw(regs->opp_change_mask, 1, abb->control_reg);
    282
    283	/* Wait for ABB LDO to complete transition to new Bias setting */
    284	ret = ti_abb_wait_txdone(dev, abb);
    285	if (ret)
    286		goto out;
    287
    288	ret = ti_abb_clear_all_txdone(dev, abb);
    289	if (ret)
    290		goto out;
    291
    292	/*
    293	 * Reset LDO VBB vset override bypass mode
    294	 * XXX: Do not switch sequence - for bypass, LDO override reset *must*
    295	 * be performed *after* switch to bypass else VBB glitches.
    296	 */
    297	if (abb->ldo_base && info->opp_sel == TI_ABB_NOMINAL_OPP)
    298		ti_abb_program_ldovbb(dev, abb, info);
    299
    300out:
    301	return ret;
    302}
    303
    304/**
    305 * ti_abb_set_voltage_sel() - regulator accessor function to set ABB LDO
    306 * @rdev:	regulator device
    307 * @sel:	selector to index into required ABB LDO settings (maps to
    308 *		regulator descriptor's volt_table)
    309 *
    310 * Return: 0 on success or appropriate error value when fails
    311 */
    312static int ti_abb_set_voltage_sel(struct regulator_dev *rdev, unsigned sel)
    313{
    314	const struct regulator_desc *desc = rdev->desc;
    315	struct ti_abb *abb = rdev_get_drvdata(rdev);
    316	struct device *dev = &rdev->dev;
    317	struct ti_abb_info *info, *oinfo;
    318	int ret = 0;
    319
    320	if (!abb) {
    321		dev_err_ratelimited(dev, "%s: No regulator drvdata\n",
    322				    __func__);
    323		return -ENODEV;
    324	}
    325
    326	if (!desc->n_voltages || !abb->info) {
    327		dev_err_ratelimited(dev,
    328				    "%s: No valid voltage table entries?\n",
    329				    __func__);
    330		return -EINVAL;
    331	}
    332
    333	if (sel >= desc->n_voltages) {
    334		dev_err(dev, "%s: sel idx(%d) >= n_voltages(%d)\n", __func__,
    335			sel, desc->n_voltages);
    336		return -EINVAL;
    337	}
    338
    339	/* If we are in the same index as we were, nothing to do here! */
    340	if (sel == abb->current_info_idx) {
    341		dev_dbg(dev, "%s: Already at sel=%d\n", __func__, sel);
    342		return ret;
    343	}
    344
    345	info = &abb->info[sel];
    346	/*
    347	 * When Linux kernel is starting up, we are'nt sure of the
    348	 * Bias configuration that bootloader has configured.
    349	 * So, we get to know the actual setting the first time
    350	 * we are asked to transition.
    351	 */
    352	if (abb->current_info_idx == -EINVAL)
    353		goto just_set_abb;
    354
    355	/* If data is exactly the same, then just update index, no change */
    356	oinfo = &abb->info[abb->current_info_idx];
    357	if (!memcmp(info, oinfo, sizeof(*info))) {
    358		dev_dbg(dev, "%s: Same data new idx=%d, old idx=%d\n", __func__,
    359			sel, abb->current_info_idx);
    360		goto out;
    361	}
    362
    363just_set_abb:
    364	ret = ti_abb_set_opp(rdev, abb, info);
    365
    366out:
    367	if (!ret)
    368		abb->current_info_idx = sel;
    369	else
    370		dev_err_ratelimited(dev,
    371				    "%s: Volt[%d] idx[%d] mode[%d] Fail(%d)\n",
    372				    __func__, desc->volt_table[sel], sel,
    373				    info->opp_sel, ret);
    374	return ret;
    375}
    376
    377/**
    378 * ti_abb_get_voltage_sel() - Regulator accessor to get current ABB LDO setting
    379 * @rdev:	regulator device
    380 *
    381 * Return: 0 on success or appropriate error value when fails
    382 */
    383static int ti_abb_get_voltage_sel(struct regulator_dev *rdev)
    384{
    385	const struct regulator_desc *desc = rdev->desc;
    386	struct ti_abb *abb = rdev_get_drvdata(rdev);
    387	struct device *dev = &rdev->dev;
    388
    389	if (!abb) {
    390		dev_err_ratelimited(dev, "%s: No regulator drvdata\n",
    391				    __func__);
    392		return -ENODEV;
    393	}
    394
    395	if (!desc->n_voltages || !abb->info) {
    396		dev_err_ratelimited(dev,
    397				    "%s: No valid voltage table entries?\n",
    398				    __func__);
    399		return -EINVAL;
    400	}
    401
    402	if (abb->current_info_idx >= (int)desc->n_voltages) {
    403		dev_err(dev, "%s: Corrupted data? idx(%d) >= n_voltages(%d)\n",
    404			__func__, abb->current_info_idx, desc->n_voltages);
    405		return -EINVAL;
    406	}
    407
    408	return abb->current_info_idx;
    409}
    410
    411/**
    412 * ti_abb_init_timings() - setup ABB clock timing for the current platform
    413 * @dev:	device
    414 * @abb:	pointer to the abb instance
    415 *
    416 * Return: 0 if timing is updated, else returns error result.
    417 */
    418static int ti_abb_init_timings(struct device *dev, struct ti_abb *abb)
    419{
    420	u32 clock_cycles;
    421	u32 clk_rate, sr2_wt_cnt_val, cycle_rate;
    422	const struct ti_abb_reg *regs = abb->regs;
    423	int ret;
    424	char *pname = "ti,settling-time";
    425
    426	/* read device tree properties */
    427	ret = of_property_read_u32(dev->of_node, pname, &abb->settling_time);
    428	if (ret) {
    429		dev_err(dev, "Unable to get property '%s'(%d)\n", pname, ret);
    430		return ret;
    431	}
    432
    433	/* ABB LDO cannot be settle in 0 time */
    434	if (!abb->settling_time) {
    435		dev_err(dev, "Invalid property:'%s' set as 0!\n", pname);
    436		return -EINVAL;
    437	}
    438
    439	pname = "ti,clock-cycles";
    440	ret = of_property_read_u32(dev->of_node, pname, &clock_cycles);
    441	if (ret) {
    442		dev_err(dev, "Unable to get property '%s'(%d)\n", pname, ret);
    443		return ret;
    444	}
    445	/* ABB LDO cannot be settle in 0 clock cycles */
    446	if (!clock_cycles) {
    447		dev_err(dev, "Invalid property:'%s' set as 0!\n", pname);
    448		return -EINVAL;
    449	}
    450
    451	abb->clk = devm_clk_get(dev, NULL);
    452	if (IS_ERR(abb->clk)) {
    453		ret = PTR_ERR(abb->clk);
    454		dev_err(dev, "%s: Unable to get clk(%d)\n", __func__, ret);
    455		return ret;
    456	}
    457
    458	/*
    459	 * SR2_WTCNT_VALUE is the settling time for the ABB ldo after a
    460	 * transition and must be programmed with the correct time at boot.
    461	 * The value programmed into the register is the number of SYS_CLK
    462	 * clock cycles that match a given wall time profiled for the ldo.
    463	 * This value depends on:
    464	 * settling time of ldo in micro-seconds (varies per OMAP family)
    465	 * # of clock cycles per SYS_CLK period (varies per OMAP family)
    466	 * the SYS_CLK frequency in MHz (varies per board)
    467	 * The formula is:
    468	 *
    469	 *                      ldo settling time (in micro-seconds)
    470	 * SR2_WTCNT_VALUE = ------------------------------------------
    471	 *                   (# system clock cycles) * (sys_clk period)
    472	 *
    473	 * Put another way:
    474	 *
    475	 * SR2_WTCNT_VALUE = settling time / (# SYS_CLK cycles / SYS_CLK rate))
    476	 *
    477	 * To avoid dividing by zero multiply both "# clock cycles" and
    478	 * "settling time" by 10 such that the final result is the one we want.
    479	 */
    480
    481	/* Convert SYS_CLK rate to MHz & prevent divide by zero */
    482	clk_rate = DIV_ROUND_CLOSEST(clk_get_rate(abb->clk), 1000000);
    483
    484	/* Calculate cycle rate */
    485	cycle_rate = DIV_ROUND_CLOSEST(clock_cycles * 10, clk_rate);
    486
    487	/* Calculate SR2_WTCNT_VALUE */
    488	sr2_wt_cnt_val = DIV_ROUND_CLOSEST(abb->settling_time * 10, cycle_rate);
    489
    490	dev_dbg(dev, "%s: Clk_rate=%ld, sr2_cnt=0x%08x\n", __func__,
    491		clk_get_rate(abb->clk), sr2_wt_cnt_val);
    492
    493	ti_abb_rmw(regs->sr2_wtcnt_value_mask, sr2_wt_cnt_val, abb->setup_reg);
    494
    495	return 0;
    496}
    497
    498/**
    499 * ti_abb_init_table() - Initialize ABB table from device tree
    500 * @dev:	device
    501 * @abb:	pointer to the abb instance
    502 * @rinit_data:	regulator initdata
    503 *
    504 * Return: 0 on success or appropriate error value when fails
    505 */
    506static int ti_abb_init_table(struct device *dev, struct ti_abb *abb,
    507			     struct regulator_init_data *rinit_data)
    508{
    509	struct ti_abb_info *info;
    510	const u32 num_values = 6;
    511	char *pname = "ti,abb_info";
    512	u32 i;
    513	unsigned int *volt_table;
    514	int num_entries, min_uV = INT_MAX, max_uV = 0;
    515	struct regulation_constraints *c = &rinit_data->constraints;
    516
    517	/*
    518	 * Each abb_info is a set of n-tuple, where n is num_values, consisting
    519	 * of voltage and a set of detection logic for ABB information for that
    520	 * voltage to apply.
    521	 */
    522	num_entries = of_property_count_u32_elems(dev->of_node, pname);
    523	if (num_entries < 0) {
    524		dev_err(dev, "No '%s' property?\n", pname);
    525		return num_entries;
    526	}
    527
    528	if (!num_entries || (num_entries % num_values)) {
    529		dev_err(dev, "All '%s' list entries need %d vals\n", pname,
    530			num_values);
    531		return -EINVAL;
    532	}
    533	num_entries /= num_values;
    534
    535	info = devm_kcalloc(dev, num_entries, sizeof(*info), GFP_KERNEL);
    536	if (!info)
    537		return -ENOMEM;
    538
    539	abb->info = info;
    540
    541	volt_table = devm_kcalloc(dev, num_entries, sizeof(unsigned int),
    542				  GFP_KERNEL);
    543	if (!volt_table)
    544		return -ENOMEM;
    545
    546	abb->rdesc.n_voltages = num_entries;
    547	abb->rdesc.volt_table = volt_table;
    548	/* We do not know where the OPP voltage is at the moment */
    549	abb->current_info_idx = -EINVAL;
    550
    551	for (i = 0; i < num_entries; i++, info++, volt_table++) {
    552		u32 efuse_offset, rbb_mask, fbb_mask, vset_mask;
    553		u32 efuse_val;
    554
    555		/* NOTE: num_values should equal to entries picked up here */
    556		of_property_read_u32_index(dev->of_node, pname, i * num_values,
    557					   volt_table);
    558		of_property_read_u32_index(dev->of_node, pname,
    559					   i * num_values + 1, &info->opp_sel);
    560		of_property_read_u32_index(dev->of_node, pname,
    561					   i * num_values + 2, &efuse_offset);
    562		of_property_read_u32_index(dev->of_node, pname,
    563					   i * num_values + 3, &rbb_mask);
    564		of_property_read_u32_index(dev->of_node, pname,
    565					   i * num_values + 4, &fbb_mask);
    566		of_property_read_u32_index(dev->of_node, pname,
    567					   i * num_values + 5, &vset_mask);
    568
    569		dev_dbg(dev,
    570			"[%d]v=%d ABB=%d ef=0x%x rbb=0x%x fbb=0x%x vset=0x%x\n",
    571			i, *volt_table, info->opp_sel, efuse_offset, rbb_mask,
    572			fbb_mask, vset_mask);
    573
    574		/* Find min/max for voltage set */
    575		if (min_uV > *volt_table)
    576			min_uV = *volt_table;
    577		if (max_uV < *volt_table)
    578			max_uV = *volt_table;
    579
    580		if (!abb->efuse_base) {
    581			/* Ignore invalid data, but warn to help cleanup */
    582			if (efuse_offset || rbb_mask || fbb_mask || vset_mask)
    583				dev_err(dev, "prop '%s': v=%d,bad efuse/mask\n",
    584					pname, *volt_table);
    585			goto check_abb;
    586		}
    587
    588		efuse_val = readl(abb->efuse_base + efuse_offset);
    589
    590		/* Use ABB recommendation from Efuse */
    591		if (efuse_val & rbb_mask)
    592			info->opp_sel = TI_ABB_SLOW_OPP;
    593		else if (efuse_val & fbb_mask)
    594			info->opp_sel = TI_ABB_FAST_OPP;
    595		else if (rbb_mask || fbb_mask)
    596			info->opp_sel = TI_ABB_NOMINAL_OPP;
    597
    598		dev_dbg(dev,
    599			"[%d]v=%d efusev=0x%x final ABB=%d\n",
    600			i, *volt_table, efuse_val, info->opp_sel);
    601
    602		/* Use recommended Vset bits from Efuse */
    603		if (!abb->ldo_base) {
    604			if (vset_mask)
    605				dev_err(dev, "prop'%s':v=%d vst=%x LDO base?\n",
    606					pname, *volt_table, vset_mask);
    607			continue;
    608		}
    609		info->vset = (efuse_val & vset_mask) >> __ffs(vset_mask);
    610		dev_dbg(dev, "[%d]v=%d vset=%x\n", i, *volt_table, info->vset);
    611check_abb:
    612		switch (info->opp_sel) {
    613		case TI_ABB_NOMINAL_OPP:
    614		case TI_ABB_FAST_OPP:
    615		case TI_ABB_SLOW_OPP:
    616			/* Valid values */
    617			break;
    618		default:
    619			dev_err(dev, "%s:[%d]v=%d, ABB=%d is invalid! Abort!\n",
    620				__func__, i, *volt_table, info->opp_sel);
    621			return -EINVAL;
    622		}
    623	}
    624
    625	/* Setup the min/max voltage constraints from the supported list */
    626	c->min_uV = min_uV;
    627	c->max_uV = max_uV;
    628
    629	return 0;
    630}
    631
    632static const struct regulator_ops ti_abb_reg_ops = {
    633	.list_voltage = regulator_list_voltage_table,
    634
    635	.set_voltage_sel = ti_abb_set_voltage_sel,
    636	.get_voltage_sel = ti_abb_get_voltage_sel,
    637};
    638
    639/* Default ABB block offsets, IF this changes in future, create new one */
    640static const struct ti_abb_reg abb_regs_v1 = {
    641	/* WARNING: registers are wrongly documented in TRM */
    642	.setup_off		= 0x04,
    643	.control_off		= 0x00,
    644
    645	.sr2_wtcnt_value_mask	= (0xff << 8),
    646	.fbb_sel_mask		= (0x01 << 2),
    647	.rbb_sel_mask		= (0x01 << 1),
    648	.sr2_en_mask		= (0x01 << 0),
    649
    650	.opp_change_mask	= (0x01 << 2),
    651	.opp_sel_mask		= (0x03 << 0),
    652};
    653
    654static const struct ti_abb_reg abb_regs_v2 = {
    655	.setup_off		= 0x00,
    656	.control_off		= 0x04,
    657
    658	.sr2_wtcnt_value_mask	= (0xff << 8),
    659	.fbb_sel_mask		= (0x01 << 2),
    660	.rbb_sel_mask		= (0x01 << 1),
    661	.sr2_en_mask		= (0x01 << 0),
    662
    663	.opp_change_mask	= (0x01 << 2),
    664	.opp_sel_mask		= (0x03 << 0),
    665};
    666
    667static const struct ti_abb_reg abb_regs_generic = {
    668	.sr2_wtcnt_value_mask	= (0xff << 8),
    669	.fbb_sel_mask		= (0x01 << 2),
    670	.rbb_sel_mask		= (0x01 << 1),
    671	.sr2_en_mask		= (0x01 << 0),
    672
    673	.opp_change_mask	= (0x01 << 2),
    674	.opp_sel_mask		= (0x03 << 0),
    675};
    676
    677static const struct of_device_id ti_abb_of_match[] = {
    678	{.compatible = "ti,abb-v1", .data = &abb_regs_v1},
    679	{.compatible = "ti,abb-v2", .data = &abb_regs_v2},
    680	{.compatible = "ti,abb-v3", .data = &abb_regs_generic},
    681	{ },
    682};
    683
    684MODULE_DEVICE_TABLE(of, ti_abb_of_match);
    685
    686/**
    687 * ti_abb_probe() - Initialize an ABB ldo instance
    688 * @pdev: ABB platform device
    689 *
    690 * Initializes an individual ABB LDO for required Body-Bias. ABB is used to
    691 * additional bias supply to SoC modules for power savings or mandatory stability
    692 * configuration at certain Operating Performance Points(OPPs).
    693 *
    694 * Return: 0 on success or appropriate error value when fails
    695 */
    696static int ti_abb_probe(struct platform_device *pdev)
    697{
    698	struct device *dev = &pdev->dev;
    699	const struct of_device_id *match;
    700	struct resource *res;
    701	struct ti_abb *abb;
    702	struct regulator_init_data *initdata = NULL;
    703	struct regulator_dev *rdev = NULL;
    704	struct regulator_desc *desc;
    705	struct regulation_constraints *c;
    706	struct regulator_config config = { };
    707	char *pname;
    708	int ret = 0;
    709
    710	match = of_match_device(ti_abb_of_match, dev);
    711	if (!match) {
    712		/* We do not expect this to happen */
    713		dev_err(dev, "%s: Unable to match device\n", __func__);
    714		return -ENODEV;
    715	}
    716	if (!match->data) {
    717		dev_err(dev, "%s: Bad data in match\n", __func__);
    718		return -EINVAL;
    719	}
    720
    721	abb = devm_kzalloc(dev, sizeof(struct ti_abb), GFP_KERNEL);
    722	if (!abb)
    723		return -ENOMEM;
    724	abb->regs = match->data;
    725
    726	/* Map ABB resources */
    727	if (abb->regs->setup_off || abb->regs->control_off) {
    728		abb->base = devm_platform_ioremap_resource_byname(pdev, "base-address");
    729		if (IS_ERR(abb->base))
    730			return PTR_ERR(abb->base);
    731
    732		abb->setup_reg = abb->base + abb->regs->setup_off;
    733		abb->control_reg = abb->base + abb->regs->control_off;
    734
    735	} else {
    736		abb->control_reg = devm_platform_ioremap_resource_byname(pdev, "control-address");
    737		if (IS_ERR(abb->control_reg))
    738			return PTR_ERR(abb->control_reg);
    739
    740		abb->setup_reg = devm_platform_ioremap_resource_byname(pdev, "setup-address");
    741		if (IS_ERR(abb->setup_reg))
    742			return PTR_ERR(abb->setup_reg);
    743	}
    744
    745	abb->int_base = devm_platform_ioremap_resource_byname(pdev, "int-address");
    746	if (IS_ERR(abb->int_base))
    747		return PTR_ERR(abb->int_base);
    748
    749	/* Map Optional resources */
    750	pname = "efuse-address";
    751	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, pname);
    752	if (!res) {
    753		dev_dbg(dev, "Missing '%s' IO resource\n", pname);
    754		ret = -ENODEV;
    755		goto skip_opt;
    756	}
    757
    758	/*
    759	 * We may have shared efuse register offsets which are read-only
    760	 * between domains
    761	 */
    762	abb->efuse_base = devm_ioremap(dev, res->start,
    763					       resource_size(res));
    764	if (!abb->efuse_base) {
    765		dev_err(dev, "Unable to map '%s'\n", pname);
    766		return -ENOMEM;
    767	}
    768
    769	pname = "ldo-address";
    770	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, pname);
    771	if (!res) {
    772		dev_dbg(dev, "Missing '%s' IO resource\n", pname);
    773		ret = -ENODEV;
    774		goto skip_opt;
    775	}
    776	abb->ldo_base = devm_ioremap_resource(dev, res);
    777	if (IS_ERR(abb->ldo_base))
    778		return PTR_ERR(abb->ldo_base);
    779
    780	/* IF ldo_base is set, the following are mandatory */
    781	pname = "ti,ldovbb-override-mask";
    782	ret =
    783	    of_property_read_u32(pdev->dev.of_node, pname,
    784				 &abb->ldovbb_override_mask);
    785	if (ret) {
    786		dev_err(dev, "Missing '%s' (%d)\n", pname, ret);
    787		return ret;
    788	}
    789	if (!abb->ldovbb_override_mask) {
    790		dev_err(dev, "Invalid property:'%s' set as 0!\n", pname);
    791		return -EINVAL;
    792	}
    793
    794	pname = "ti,ldovbb-vset-mask";
    795	ret =
    796	    of_property_read_u32(pdev->dev.of_node, pname,
    797				 &abb->ldovbb_vset_mask);
    798	if (ret) {
    799		dev_err(dev, "Missing '%s' (%d)\n", pname, ret);
    800		return ret;
    801	}
    802	if (!abb->ldovbb_vset_mask) {
    803		dev_err(dev, "Invalid property:'%s' set as 0!\n", pname);
    804		return -EINVAL;
    805	}
    806
    807skip_opt:
    808	pname = "ti,tranxdone-status-mask";
    809	ret =
    810	    of_property_read_u32(pdev->dev.of_node, pname,
    811				 &abb->txdone_mask);
    812	if (ret) {
    813		dev_err(dev, "Missing '%s' (%d)\n", pname, ret);
    814		return ret;
    815	}
    816	if (!abb->txdone_mask) {
    817		dev_err(dev, "Invalid property:'%s' set as 0!\n", pname);
    818		return -EINVAL;
    819	}
    820
    821	initdata = of_get_regulator_init_data(dev, pdev->dev.of_node,
    822					      &abb->rdesc);
    823	if (!initdata) {
    824		dev_err(dev, "%s: Unable to alloc regulator init data\n",
    825			__func__);
    826		return -ENOMEM;
    827	}
    828
    829	/* init ABB opp_sel table */
    830	ret = ti_abb_init_table(dev, abb, initdata);
    831	if (ret)
    832		return ret;
    833
    834	/* init ABB timing */
    835	ret = ti_abb_init_timings(dev, abb);
    836	if (ret)
    837		return ret;
    838
    839	desc = &abb->rdesc;
    840	desc->name = dev_name(dev);
    841	desc->owner = THIS_MODULE;
    842	desc->type = REGULATOR_VOLTAGE;
    843	desc->ops = &ti_abb_reg_ops;
    844
    845	c = &initdata->constraints;
    846	if (desc->n_voltages > 1)
    847		c->valid_ops_mask |= REGULATOR_CHANGE_VOLTAGE;
    848	c->always_on = true;
    849
    850	config.dev = dev;
    851	config.init_data = initdata;
    852	config.driver_data = abb;
    853	config.of_node = pdev->dev.of_node;
    854
    855	rdev = devm_regulator_register(dev, desc, &config);
    856	if (IS_ERR(rdev)) {
    857		ret = PTR_ERR(rdev);
    858		dev_err(dev, "%s: failed to register regulator(%d)\n",
    859			__func__, ret);
    860		return ret;
    861	}
    862	platform_set_drvdata(pdev, rdev);
    863
    864	/* Enable the ldo if not already done by bootloader */
    865	ti_abb_rmw(abb->regs->sr2_en_mask, 1, abb->setup_reg);
    866
    867	return 0;
    868}
    869
    870MODULE_ALIAS("platform:ti_abb");
    871
    872static struct platform_driver ti_abb_driver = {
    873	.probe = ti_abb_probe,
    874	.driver = {
    875		   .name = "ti_abb",
    876		   .of_match_table = of_match_ptr(ti_abb_of_match),
    877		   },
    878};
    879module_platform_driver(ti_abb_driver);
    880
    881MODULE_DESCRIPTION("Texas Instruments ABB LDO regulator driver");
    882MODULE_AUTHOR("Texas Instruments Inc.");
    883MODULE_LICENSE("GPL v2");