2019-04-20 19:26:56 -07:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
|
|
|
//
|
|
|
|
// Copyright (c) 2014 MediaTek Inc.
|
|
|
|
// Author: Flora Fu <flora.fu@mediatek.com>
|
2014-12-04 21:07:54 -07:00
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/of.h>
|
|
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <linux/regmap.h>
|
|
|
|
#include <linux/mfd/mt6397/core.h>
|
|
|
|
#include <linux/mfd/mt6397/registers.h>
|
|
|
|
#include <linux/regulator/driver.h>
|
|
|
|
#include <linux/regulator/machine.h>
|
|
|
|
#include <linux/regulator/mt6397-regulator.h>
|
|
|
|
#include <linux/regulator/of_regulator.h>
|
2020-07-01 23:23:17 -07:00
|
|
|
#include <dt-bindings/regulator/mediatek,mt6397-regulator.h>
|
2016-05-23 00:13:31 -07:00
|
|
|
|
2014-12-04 21:07:54 -07:00
|
|
|
/*
|
|
|
|
* MT6397 regulators' information
|
|
|
|
*
|
|
|
|
* @desc: standard fields of regulator description.
|
|
|
|
* @qi: Mask for query enable signal status of regulators
|
|
|
|
* @vselon_reg: Register sections for hardware control mode of bucks
|
|
|
|
* @vselctrl_reg: Register for controlling the buck control mode.
|
|
|
|
* @vselctrl_mask: Mask for query buck's voltage control mode.
|
|
|
|
*/
|
|
|
|
struct mt6397_regulator_info {
|
|
|
|
struct regulator_desc desc;
|
|
|
|
u32 qi;
|
|
|
|
u32 vselon_reg;
|
|
|
|
u32 vselctrl_reg;
|
|
|
|
u32 vselctrl_mask;
|
2016-05-23 00:13:31 -07:00
|
|
|
u32 modeset_reg;
|
|
|
|
u32 modeset_mask;
|
2014-12-04 21:07:54 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
#define MT6397_BUCK(match, vreg, min, max, step, volt_ranges, enreg, \
|
2016-05-23 00:13:31 -07:00
|
|
|
vosel, vosel_mask, voselon, vosel_ctrl, _modeset_reg, \
|
|
|
|
_modeset_shift) \
|
2014-12-04 21:07:54 -07:00
|
|
|
[MT6397_ID_##vreg] = { \
|
|
|
|
.desc = { \
|
|
|
|
.name = #vreg, \
|
|
|
|
.of_match = of_match_ptr(match), \
|
|
|
|
.ops = &mt6397_volt_range_ops, \
|
|
|
|
.type = REGULATOR_VOLTAGE, \
|
|
|
|
.id = MT6397_ID_##vreg, \
|
|
|
|
.owner = THIS_MODULE, \
|
|
|
|
.n_voltages = (max - min)/step + 1, \
|
|
|
|
.linear_ranges = volt_ranges, \
|
|
|
|
.n_linear_ranges = ARRAY_SIZE(volt_ranges), \
|
|
|
|
.vsel_reg = vosel, \
|
|
|
|
.vsel_mask = vosel_mask, \
|
|
|
|
.enable_reg = enreg, \
|
|
|
|
.enable_mask = BIT(0), \
|
2020-07-01 23:23:19 -07:00
|
|
|
.of_map_mode = mt6397_map_mode, \
|
2014-12-04 21:07:54 -07:00
|
|
|
}, \
|
|
|
|
.qi = BIT(13), \
|
|
|
|
.vselon_reg = voselon, \
|
|
|
|
.vselctrl_reg = vosel_ctrl, \
|
|
|
|
.vselctrl_mask = BIT(1), \
|
2016-05-23 00:13:31 -07:00
|
|
|
.modeset_reg = _modeset_reg, \
|
|
|
|
.modeset_mask = BIT(_modeset_shift), \
|
2014-12-04 21:07:54 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
#define MT6397_LDO(match, vreg, ldo_volt_table, enreg, enbit, vosel, \
|
|
|
|
vosel_mask) \
|
|
|
|
[MT6397_ID_##vreg] = { \
|
|
|
|
.desc = { \
|
|
|
|
.name = #vreg, \
|
|
|
|
.of_match = of_match_ptr(match), \
|
|
|
|
.ops = &mt6397_volt_table_ops, \
|
|
|
|
.type = REGULATOR_VOLTAGE, \
|
|
|
|
.id = MT6397_ID_##vreg, \
|
|
|
|
.owner = THIS_MODULE, \
|
|
|
|
.n_voltages = ARRAY_SIZE(ldo_volt_table), \
|
|
|
|
.volt_table = ldo_volt_table, \
|
|
|
|
.vsel_reg = vosel, \
|
|
|
|
.vsel_mask = vosel_mask, \
|
|
|
|
.enable_reg = enreg, \
|
|
|
|
.enable_mask = BIT(enbit), \
|
|
|
|
}, \
|
|
|
|
.qi = BIT(15), \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define MT6397_REG_FIXED(match, vreg, enreg, enbit, volt) \
|
|
|
|
[MT6397_ID_##vreg] = { \
|
|
|
|
.desc = { \
|
|
|
|
.name = #vreg, \
|
|
|
|
.of_match = of_match_ptr(match), \
|
|
|
|
.ops = &mt6397_volt_fixed_ops, \
|
|
|
|
.type = REGULATOR_VOLTAGE, \
|
|
|
|
.id = MT6397_ID_##vreg, \
|
|
|
|
.owner = THIS_MODULE, \
|
|
|
|
.n_voltages = 1, \
|
|
|
|
.enable_reg = enreg, \
|
|
|
|
.enable_mask = BIT(enbit), \
|
|
|
|
.min_uV = volt, \
|
|
|
|
}, \
|
|
|
|
.qi = BIT(15), \
|
|
|
|
}
|
|
|
|
|
2020-05-08 08:43:36 -07:00
|
|
|
static const struct linear_range buck_volt_range1[] = {
|
2014-12-04 21:07:54 -07:00
|
|
|
REGULATOR_LINEAR_RANGE(700000, 0, 0x7f, 6250),
|
|
|
|
};
|
|
|
|
|
2020-05-08 08:43:36 -07:00
|
|
|
static const struct linear_range buck_volt_range2[] = {
|
2014-12-04 21:07:54 -07:00
|
|
|
REGULATOR_LINEAR_RANGE(800000, 0, 0x7f, 6250),
|
|
|
|
};
|
|
|
|
|
2020-05-08 08:43:36 -07:00
|
|
|
static const struct linear_range buck_volt_range3[] = {
|
2014-12-04 21:07:54 -07:00
|
|
|
REGULATOR_LINEAR_RANGE(1500000, 0, 0x1f, 20000),
|
|
|
|
};
|
|
|
|
|
2019-03-05 18:43:32 -07:00
|
|
|
static const unsigned int ldo_volt_table1[] = {
|
2014-12-04 21:07:54 -07:00
|
|
|
1500000, 1800000, 2500000, 2800000,
|
|
|
|
};
|
|
|
|
|
2019-03-05 18:43:32 -07:00
|
|
|
static const unsigned int ldo_volt_table2[] = {
|
2014-12-04 21:07:54 -07:00
|
|
|
1800000, 3300000,
|
|
|
|
};
|
|
|
|
|
2019-03-05 18:43:32 -07:00
|
|
|
static const unsigned int ldo_volt_table3[] = {
|
2014-12-04 21:07:54 -07:00
|
|
|
3000000, 3300000,
|
|
|
|
};
|
|
|
|
|
2019-03-05 18:43:32 -07:00
|
|
|
static const unsigned int ldo_volt_table4[] = {
|
2014-12-04 21:07:54 -07:00
|
|
|
1220000, 1300000, 1500000, 1800000, 2500000, 2800000, 3000000, 3300000,
|
|
|
|
};
|
|
|
|
|
2019-03-05 18:43:32 -07:00
|
|
|
static const unsigned int ldo_volt_table5[] = {
|
2014-12-04 21:07:54 -07:00
|
|
|
1200000, 1300000, 1500000, 1800000, 2500000, 2800000, 3000000, 3300000,
|
|
|
|
};
|
|
|
|
|
2019-03-05 18:43:32 -07:00
|
|
|
static const unsigned int ldo_volt_table5_v2[] = {
|
2014-12-04 21:07:54 -07:00
|
|
|
1200000, 1000000, 1500000, 1800000, 2500000, 2800000, 3000000, 3300000,
|
|
|
|
};
|
|
|
|
|
2019-03-05 18:43:32 -07:00
|
|
|
static const unsigned int ldo_volt_table6[] = {
|
2014-12-04 21:07:54 -07:00
|
|
|
1200000, 1300000, 1500000, 1800000, 2500000, 2800000, 3000000, 2000000,
|
|
|
|
};
|
|
|
|
|
2019-03-05 18:43:32 -07:00
|
|
|
static const unsigned int ldo_volt_table7[] = {
|
2014-12-04 21:07:54 -07:00
|
|
|
1300000, 1500000, 1800000, 2000000, 2500000, 2800000, 3000000, 3300000,
|
|
|
|
};
|
|
|
|
|
2020-07-01 23:23:19 -07:00
|
|
|
static unsigned int mt6397_map_mode(unsigned int mode)
|
|
|
|
{
|
|
|
|
switch (mode) {
|
|
|
|
case MT6397_BUCK_MODE_AUTO:
|
|
|
|
return REGULATOR_MODE_NORMAL;
|
|
|
|
case MT6397_BUCK_MODE_FORCE_PWM:
|
|
|
|
return REGULATOR_MODE_FAST;
|
|
|
|
default:
|
|
|
|
return REGULATOR_MODE_INVALID;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-23 00:13:31 -07:00
|
|
|
static int mt6397_regulator_set_mode(struct regulator_dev *rdev,
|
|
|
|
unsigned int mode)
|
|
|
|
{
|
|
|
|
struct mt6397_regulator_info *info = rdev_get_drvdata(rdev);
|
|
|
|
int ret, val;
|
|
|
|
|
|
|
|
switch (mode) {
|
|
|
|
case REGULATOR_MODE_FAST:
|
|
|
|
val = MT6397_BUCK_MODE_FORCE_PWM;
|
|
|
|
break;
|
|
|
|
case REGULATOR_MODE_NORMAL:
|
|
|
|
val = MT6397_BUCK_MODE_AUTO;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto err_mode;
|
|
|
|
}
|
|
|
|
|
2021-06-29 06:05:03 -07:00
|
|
|
dev_dbg(&rdev->dev, "mt6397 buck set_mode %#x, %#x, %#x\n",
|
|
|
|
info->modeset_reg, info->modeset_mask, val);
|
|
|
|
|
|
|
|
val <<= ffs(info->modeset_mask) - 1;
|
2016-05-23 00:13:31 -07:00
|
|
|
|
|
|
|
ret = regmap_update_bits(rdev->regmap, info->modeset_reg,
|
|
|
|
info->modeset_mask, val);
|
|
|
|
err_mode:
|
|
|
|
if (ret != 0) {
|
|
|
|
dev_err(&rdev->dev,
|
|
|
|
"Failed to set mt6397 buck mode: %d\n", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int mt6397_regulator_get_mode(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
struct mt6397_regulator_info *info = rdev_get_drvdata(rdev);
|
|
|
|
int ret, regval;
|
|
|
|
|
|
|
|
ret = regmap_read(rdev->regmap, info->modeset_reg, ®val);
|
|
|
|
if (ret != 0) {
|
|
|
|
dev_err(&rdev->dev,
|
|
|
|
"Failed to get mt6397 buck mode: %d\n", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2021-06-29 06:05:03 -07:00
|
|
|
regval &= info->modeset_mask;
|
|
|
|
regval >>= ffs(info->modeset_mask) - 1;
|
|
|
|
|
|
|
|
switch (regval) {
|
2016-05-23 00:13:31 -07:00
|
|
|
case MT6397_BUCK_MODE_AUTO:
|
|
|
|
return REGULATOR_MODE_NORMAL;
|
|
|
|
case MT6397_BUCK_MODE_FORCE_PWM:
|
|
|
|
return REGULATOR_MODE_FAST;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-12-04 21:07:54 -07:00
|
|
|
static int mt6397_get_status(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
u32 regval;
|
|
|
|
struct mt6397_regulator_info *info = rdev_get_drvdata(rdev);
|
|
|
|
|
|
|
|
ret = regmap_read(rdev->regmap, info->desc.enable_reg, ®val);
|
|
|
|
if (ret != 0) {
|
|
|
|
dev_err(&rdev->dev, "Failed to get enable reg: %d\n", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return (regval & info->qi) ? REGULATOR_STATUS_ON : REGULATOR_STATUS_OFF;
|
|
|
|
}
|
|
|
|
|
2016-05-23 00:30:16 -07:00
|
|
|
static const struct regulator_ops mt6397_volt_range_ops = {
|
2014-12-04 21:07:54 -07:00
|
|
|
.list_voltage = regulator_list_voltage_linear_range,
|
|
|
|
.map_voltage = regulator_map_voltage_linear_range,
|
|
|
|
.set_voltage_sel = regulator_set_voltage_sel_regmap,
|
|
|
|
.get_voltage_sel = regulator_get_voltage_sel_regmap,
|
|
|
|
.set_voltage_time_sel = regulator_set_voltage_time_sel,
|
|
|
|
.enable = regulator_enable_regmap,
|
|
|
|
.disable = regulator_disable_regmap,
|
|
|
|
.is_enabled = regulator_is_enabled_regmap,
|
|
|
|
.get_status = mt6397_get_status,
|
2016-05-23 00:13:31 -07:00
|
|
|
.set_mode = mt6397_regulator_set_mode,
|
|
|
|
.get_mode = mt6397_regulator_get_mode,
|
2014-12-04 21:07:54 -07:00
|
|
|
};
|
|
|
|
|
2016-05-23 00:30:16 -07:00
|
|
|
static const struct regulator_ops mt6397_volt_table_ops = {
|
2014-12-04 21:07:54 -07:00
|
|
|
.list_voltage = regulator_list_voltage_table,
|
|
|
|
.map_voltage = regulator_map_voltage_iterate,
|
|
|
|
.set_voltage_sel = regulator_set_voltage_sel_regmap,
|
|
|
|
.get_voltage_sel = regulator_get_voltage_sel_regmap,
|
|
|
|
.set_voltage_time_sel = regulator_set_voltage_time_sel,
|
|
|
|
.enable = regulator_enable_regmap,
|
|
|
|
.disable = regulator_disable_regmap,
|
|
|
|
.is_enabled = regulator_is_enabled_regmap,
|
|
|
|
.get_status = mt6397_get_status,
|
|
|
|
};
|
|
|
|
|
2016-05-23 00:30:16 -07:00
|
|
|
static const struct regulator_ops mt6397_volt_fixed_ops = {
|
2014-12-04 21:07:54 -07:00
|
|
|
.list_voltage = regulator_list_voltage_linear,
|
|
|
|
.enable = regulator_enable_regmap,
|
|
|
|
.disable = regulator_disable_regmap,
|
|
|
|
.is_enabled = regulator_is_enabled_regmap,
|
|
|
|
.get_status = mt6397_get_status,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* The array is indexed by id(MT6397_ID_XXX) */
|
|
|
|
static struct mt6397_regulator_info mt6397_regulators[] = {
|
|
|
|
MT6397_BUCK("buck_vpca15", VPCA15, 700000, 1493750, 6250,
|
|
|
|
buck_volt_range1, MT6397_VCA15_CON7, MT6397_VCA15_CON9, 0x7f,
|
2016-05-23 00:13:31 -07:00
|
|
|
MT6397_VCA15_CON10, MT6397_VCA15_CON5, MT6397_VCA15_CON2, 11),
|
2014-12-04 21:07:54 -07:00
|
|
|
MT6397_BUCK("buck_vpca7", VPCA7, 700000, 1493750, 6250,
|
|
|
|
buck_volt_range1, MT6397_VPCA7_CON7, MT6397_VPCA7_CON9, 0x7f,
|
2016-05-23 00:13:31 -07:00
|
|
|
MT6397_VPCA7_CON10, MT6397_VPCA7_CON5, MT6397_VPCA7_CON2, 8),
|
2014-12-04 21:07:54 -07:00
|
|
|
MT6397_BUCK("buck_vsramca15", VSRAMCA15, 700000, 1493750, 6250,
|
|
|
|
buck_volt_range1, MT6397_VSRMCA15_CON7, MT6397_VSRMCA15_CON9,
|
2016-05-23 00:13:31 -07:00
|
|
|
0x7f, MT6397_VSRMCA15_CON10, MT6397_VSRMCA15_CON5,
|
|
|
|
MT6397_VSRMCA15_CON2, 8),
|
2014-12-04 21:07:54 -07:00
|
|
|
MT6397_BUCK("buck_vsramca7", VSRAMCA7, 700000, 1493750, 6250,
|
|
|
|
buck_volt_range1, MT6397_VSRMCA7_CON7, MT6397_VSRMCA7_CON9,
|
2016-05-23 00:13:31 -07:00
|
|
|
0x7f, MT6397_VSRMCA7_CON10, MT6397_VSRMCA7_CON5,
|
|
|
|
MT6397_VSRMCA7_CON2, 8),
|
2014-12-04 21:07:54 -07:00
|
|
|
MT6397_BUCK("buck_vcore", VCORE, 700000, 1493750, 6250,
|
|
|
|
buck_volt_range1, MT6397_VCORE_CON7, MT6397_VCORE_CON9, 0x7f,
|
2016-05-23 00:13:31 -07:00
|
|
|
MT6397_VCORE_CON10, MT6397_VCORE_CON5, MT6397_VCORE_CON2, 8),
|
2014-12-04 21:07:54 -07:00
|
|
|
MT6397_BUCK("buck_vgpu", VGPU, 700000, 1493750, 6250, buck_volt_range1,
|
|
|
|
MT6397_VGPU_CON7, MT6397_VGPU_CON9, 0x7f,
|
2016-05-23 00:13:31 -07:00
|
|
|
MT6397_VGPU_CON10, MT6397_VGPU_CON5, MT6397_VGPU_CON2, 8),
|
2014-12-04 21:07:54 -07:00
|
|
|
MT6397_BUCK("buck_vdrm", VDRM, 800000, 1593750, 6250, buck_volt_range2,
|
|
|
|
MT6397_VDRM_CON7, MT6397_VDRM_CON9, 0x7f,
|
2016-05-23 00:13:31 -07:00
|
|
|
MT6397_VDRM_CON10, MT6397_VDRM_CON5, MT6397_VDRM_CON2, 8),
|
2014-12-04 21:07:54 -07:00
|
|
|
MT6397_BUCK("buck_vio18", VIO18, 1500000, 2120000, 20000,
|
|
|
|
buck_volt_range3, MT6397_VIO18_CON7, MT6397_VIO18_CON9, 0x1f,
|
2016-05-23 00:13:31 -07:00
|
|
|
MT6397_VIO18_CON10, MT6397_VIO18_CON5, MT6397_VIO18_CON2, 8),
|
2014-12-04 21:07:54 -07:00
|
|
|
MT6397_REG_FIXED("ldo_vtcxo", VTCXO, MT6397_ANALDO_CON0, 10, 2800000),
|
|
|
|
MT6397_REG_FIXED("ldo_va28", VA28, MT6397_ANALDO_CON1, 14, 2800000),
|
|
|
|
MT6397_LDO("ldo_vcama", VCAMA, ldo_volt_table1,
|
|
|
|
MT6397_ANALDO_CON2, 15, MT6397_ANALDO_CON6, 0xC0),
|
|
|
|
MT6397_REG_FIXED("ldo_vio28", VIO28, MT6397_DIGLDO_CON0, 14, 2800000),
|
|
|
|
MT6397_REG_FIXED("ldo_vusb", VUSB, MT6397_DIGLDO_CON1, 14, 3300000),
|
|
|
|
MT6397_LDO("ldo_vmc", VMC, ldo_volt_table2,
|
|
|
|
MT6397_DIGLDO_CON2, 12, MT6397_DIGLDO_CON29, 0x10),
|
|
|
|
MT6397_LDO("ldo_vmch", VMCH, ldo_volt_table3,
|
|
|
|
MT6397_DIGLDO_CON3, 14, MT6397_DIGLDO_CON17, 0x80),
|
|
|
|
MT6397_LDO("ldo_vemc3v3", VEMC3V3, ldo_volt_table3,
|
|
|
|
MT6397_DIGLDO_CON4, 14, MT6397_DIGLDO_CON18, 0x10),
|
|
|
|
MT6397_LDO("ldo_vgp1", VGP1, ldo_volt_table4,
|
|
|
|
MT6397_DIGLDO_CON5, 15, MT6397_DIGLDO_CON19, 0xE0),
|
|
|
|
MT6397_LDO("ldo_vgp2", VGP2, ldo_volt_table5,
|
|
|
|
MT6397_DIGLDO_CON6, 15, MT6397_DIGLDO_CON20, 0xE0),
|
|
|
|
MT6397_LDO("ldo_vgp3", VGP3, ldo_volt_table5,
|
|
|
|
MT6397_DIGLDO_CON7, 15, MT6397_DIGLDO_CON21, 0xE0),
|
|
|
|
MT6397_LDO("ldo_vgp4", VGP4, ldo_volt_table5,
|
|
|
|
MT6397_DIGLDO_CON8, 15, MT6397_DIGLDO_CON22, 0xE0),
|
|
|
|
MT6397_LDO("ldo_vgp5", VGP5, ldo_volt_table6,
|
|
|
|
MT6397_DIGLDO_CON9, 15, MT6397_DIGLDO_CON23, 0xE0),
|
|
|
|
MT6397_LDO("ldo_vgp6", VGP6, ldo_volt_table5,
|
|
|
|
MT6397_DIGLDO_CON10, 15, MT6397_DIGLDO_CON33, 0xE0),
|
|
|
|
MT6397_LDO("ldo_vibr", VIBR, ldo_volt_table7,
|
|
|
|
MT6397_DIGLDO_CON24, 15, MT6397_DIGLDO_CON25, 0xE00),
|
|
|
|
};
|
|
|
|
|
|
|
|
static int mt6397_set_buck_vosel_reg(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct mt6397_chip *mt6397 = dev_get_drvdata(pdev->dev.parent);
|
|
|
|
int i;
|
|
|
|
u32 regval;
|
|
|
|
|
|
|
|
for (i = 0; i < MT6397_MAX_REGULATOR; i++) {
|
|
|
|
if (mt6397_regulators[i].vselctrl_reg) {
|
|
|
|
if (regmap_read(mt6397->regmap,
|
|
|
|
mt6397_regulators[i].vselctrl_reg,
|
|
|
|
®val) < 0) {
|
|
|
|
dev_err(&pdev->dev,
|
|
|
|
"Failed to read buck ctrl\n");
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (regval & mt6397_regulators[i].vselctrl_mask) {
|
|
|
|
mt6397_regulators[i].desc.vsel_reg =
|
|
|
|
mt6397_regulators[i].vselon_reg;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mt6397_regulator_probe(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct mt6397_chip *mt6397 = dev_get_drvdata(pdev->dev.parent);
|
|
|
|
struct regulator_config config = {};
|
|
|
|
struct regulator_dev *rdev;
|
|
|
|
int i;
|
|
|
|
u32 reg_value, version;
|
|
|
|
|
|
|
|
/* Query buck controller to select activated voltage register part */
|
|
|
|
if (mt6397_set_buck_vosel_reg(pdev))
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
/* Read PMIC chip revision to update constraints and voltage table */
|
|
|
|
if (regmap_read(mt6397->regmap, MT6397_CID, ®_value) < 0) {
|
|
|
|
dev_err(&pdev->dev, "Failed to read Chip ID\n");
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
dev_info(&pdev->dev, "Chip ID = 0x%x\n", reg_value);
|
|
|
|
|
|
|
|
version = (reg_value & 0xFF);
|
|
|
|
switch (version) {
|
|
|
|
case MT6397_REGULATOR_ID91:
|
|
|
|
mt6397_regulators[MT6397_ID_VGP2].desc.volt_table =
|
|
|
|
ldo_volt_table5_v2;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < MT6397_MAX_REGULATOR; i++) {
|
|
|
|
config.dev = &pdev->dev;
|
|
|
|
config.driver_data = &mt6397_regulators[i];
|
|
|
|
config.regmap = mt6397->regmap;
|
|
|
|
rdev = devm_regulator_register(&pdev->dev,
|
|
|
|
&mt6397_regulators[i].desc, &config);
|
|
|
|
if (IS_ERR(rdev)) {
|
|
|
|
dev_err(&pdev->dev, "failed to register %s\n",
|
|
|
|
mt6397_regulators[i].desc.name);
|
|
|
|
return PTR_ERR(rdev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-01-25 07:37:15 -07:00
|
|
|
static const struct platform_device_id mt6397_platform_ids[] = {
|
|
|
|
{"mt6397-regulator", 0},
|
|
|
|
{ /* sentinel */ },
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(platform, mt6397_platform_ids);
|
|
|
|
|
2023-03-10 14:45:48 -07:00
|
|
|
static const struct of_device_id mt6397_of_match[] __maybe_unused = {
|
2016-01-25 07:37:16 -07:00
|
|
|
{ .compatible = "mediatek,mt6397-regulator", },
|
|
|
|
{ /* sentinel */ },
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(of, mt6397_of_match);
|
|
|
|
|
2014-12-04 21:07:54 -07:00
|
|
|
static struct platform_driver mt6397_regulator_driver = {
|
|
|
|
.driver = {
|
|
|
|
.name = "mt6397-regulator",
|
regulator: Set PROBE_PREFER_ASYNCHRONOUS for drivers that existed in 4.14
Probing of regulators can be a slow operation and can contribute to
slower boot times. This is especially true if a regulator is turned on
at probe time (with regulator-boot-on or regulator-always-on) and the
regulator requires delays (off-on-time, ramp time, etc).
While the overall kernel is not ready to switch to async probe by
default, as per the discussion on the mailing lists [1] it is believed
that the regulator subsystem is in good shape and we can move
regulator drivers over wholesale. There is no way to just magically
opt in all regulators (regulators are just normal drivers like
platform_driver), so we set PROBE_PREFER_ASYNCHRONOUS for all
regulators found in 'drivers/regulator' individually.
Given the number of drivers touched and the impossibility to test this
ahead of time, it wouldn't be shocking at all if this caused a
regression for someone. If there is a regression caused by this patch,
it's likely to be one of the cases talked about in [1]. As a "quick
fix", drivers involved in the regression could be fixed by changing
them to PROBE_FORCE_SYNCHRONOUS. That being said, the correct fix
would be to directly fix the problem that caused the issue with async
probe.
The approach here follows a similar approach that was used for the mmc
subsystem several years ago [2]. In fact, I ran nearly the same python
script to auto-generate the changes. The only thing I changed was to
search for "i2c_driver", "spmi_driver", and "spi_driver" in addition
to "platform_driver".
[1] https://lore.kernel.org/r/06db017f-e985-4434-8d1d-02ca2100cca0@sirena.org.uk
[2] https://lore.kernel.org/r/20200903232441.2694866-1-dianders@chromium.org/
Signed-off-by: Douglas Anderson <dianders@chromium.org>
Link: https://lore.kernel.org/r/20230316125351.1.I2a4677392a38db5758dee0788b2cea5872562a82@changeid
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-03-16 12:54:38 -07:00
|
|
|
.probe_type = PROBE_PREFER_ASYNCHRONOUS,
|
2016-01-25 07:37:16 -07:00
|
|
|
.of_match_table = of_match_ptr(mt6397_of_match),
|
2014-12-04 21:07:54 -07:00
|
|
|
},
|
|
|
|
.probe = mt6397_regulator_probe,
|
2016-01-25 07:37:15 -07:00
|
|
|
.id_table = mt6397_platform_ids,
|
2014-12-04 21:07:54 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
module_platform_driver(mt6397_regulator_driver);
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Flora Fu <flora.fu@mediatek.com>");
|
|
|
|
MODULE_DESCRIPTION("Regulator Driver for MediaTek MT6397 PMIC");
|
|
|
|
MODULE_LICENSE("GPL");
|