#define VOLT_TOL (10000)
-struct stf_cpu_dvfs_info {
+struct starfive_cpu_dvfs_info {
struct regulator *vddcpu;
struct clk *cpu_clk;
struct clk *pll0_clk;
struct cpumask cpus;
};
-static int stf_cpufreq_set_target_index(struct cpufreq_policy *policy,
+static int starfive_cpufreq_set_target_index(struct cpufreq_policy *policy,
unsigned int index)
{
struct cpufreq_frequency_table *freq_table = policy->freq_table;
- struct stf_cpu_dvfs_info *info = cpufreq_get_driver_data();
+ struct starfive_cpu_dvfs_info *info = cpufreq_get_driver_data();
struct dev_pm_opp *opp;
unsigned long old_freq, new_freq;
int old_vdd, target_vdd, ret;
return 0;
}
-static int stf_cpufreq_driver_init(struct cpufreq_policy *policy)
+static int starfive_cpufreq_driver_init(struct cpufreq_policy *policy)
{
- struct stf_cpu_dvfs_info *info = cpufreq_get_driver_data();
+ struct starfive_cpu_dvfs_info *info = cpufreq_get_driver_data();
struct cpufreq_frequency_table *freq_table;
int ret;
return 0;
}
-static int stf_cpu_dvfs_info_init(struct platform_device *pdev,
- struct stf_cpu_dvfs_info *info)
+static int starfive_cpu_dvfs_info_init(struct platform_device *pdev,
+ struct starfive_cpu_dvfs_info *info)
{
struct device *dev = &pdev->dev;
int ret;
return 0;
}
-static struct cpufreq_driver stf_cpufreq_driver = {
+static struct cpufreq_driver starfive_cpufreq_driver = {
.flags = CPUFREQ_NEED_INITIAL_FREQ_CHECK,
.verify = cpufreq_generic_frequency_table_verify,
- .target_index = stf_cpufreq_set_target_index,
+ .target_index = starfive_cpufreq_set_target_index,
.get = cpufreq_generic_get,
- .init = stf_cpufreq_driver_init,
- .name = "stf-cpufreq",
+ .init = starfive_cpufreq_driver_init,
+ .name = "starfive-cpufreq",
.attr = cpufreq_generic_attr,
};
-static int stf_cpufreq_probe(struct platform_device *pdev)
+static int starfive_cpufreq_probe(struct platform_device *pdev)
{
- struct stf_cpu_dvfs_info *info;
+ struct starfive_cpu_dvfs_info *info;
int ret;
info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
if (!info)
return -ENOMEM;
- ret = stf_cpu_dvfs_info_init(pdev, info);
+ ret = starfive_cpu_dvfs_info_init(pdev, info);
if (ret) {
- dev_err(&pdev->dev, "Failed to init stf cpu dvfs info\n");
+ dev_err(&pdev->dev, "Failed to init starfive cpu dvfs info\n");
return ret;
}
- stf_cpufreq_driver.driver_data = info;
- ret = cpufreq_register_driver(&stf_cpufreq_driver);
+ starfive_cpufreq_driver.driver_data = info;
+ ret = cpufreq_register_driver(&starfive_cpufreq_driver);
if (ret)
- dev_err(&pdev->dev, "Failed to register stf cpufreq driver\n");
+ dev_err(&pdev->dev, "Failed to register starfive cpufreq driver\n");
return ret;
}
-static const struct of_device_id stf_cpufreq_match_table[] = {
- { .compatible = "starfive,stf-cpufreq" },
+static const struct of_device_id starfive_cpufreq_match_table[] = {
+ { .compatible = "starfive,jh7110-cpufreq" },
{}
};
-static struct platform_driver stf_cpufreq_plat_driver = {
- .probe = stf_cpufreq_probe,
+static struct platform_driver starfive_cpufreq_plat_driver = {
+ .probe = starfive_cpufreq_probe,
.driver = {
- .name = "stf-cpufreq",
- .of_match_table = stf_cpufreq_match_table,
+ .name = "starfive-cpufreq",
+ .of_match_table = starfive_cpufreq_match_table,
},
};
-static int __init stf_cpufreq_init(void)
+static int __init starfive_cpufreq_init(void)
{
- return platform_driver_register(&stf_cpufreq_plat_driver);
+ return platform_driver_register(&starfive_cpufreq_plat_driver);
}
-postcore_initcall(stf_cpufreq_init);
+postcore_initcall(starfive_cpufreq_init);
MODULE_DESCRIPTION("STARFIVE CPUFREQ Driver");
MODULE_AUTHOR("Mason Huuo <mason.huo@starfivetech.com>");
#include <linux/regulator/driver.h>
#include <linux/regulator/machine.h>
#include <linux/regulator/of_regulator.h>
-#include <linux/regulator/stf7110.h>
+#include <linux/regulator/jh7110.h>
#include <linux/slab.h>
-#define STF7110_PM_POWER_SW_0 0x80
-#define STF7110_PM_POWER_SW_1 0x81
+#define JH7110_PM_POWER_SW_0 0x80
+#define JH7110_PM_POWER_SW_1 0x81
#define ENABLE_MASK(id) BIT(id)
-static const struct regmap_config stf7110_regmap_config = {
+static const struct regmap_config jh7110_regmap_config = {
.reg_bits = 8,
.val_bits = 8,
- .max_register = STF7110_PM_POWER_SW_1,
+ .max_register = JH7110_PM_POWER_SW_1,
.cache_type = REGCACHE_FLAT,
};
-static const struct regulator_ops stf7110_ldo_ops = {
+static const struct regulator_ops jh7110_ldo_ops = {
.enable = regulator_enable_regmap,
.disable = regulator_disable_regmap,
.is_enabled = regulator_is_enabled_regmap,
};
-#define STF7110_LDO(_id, _name, en_reg, en_mask) \
+#define JH7110_LDO(_id, _name, en_reg, en_mask) \
{\
.name = (_name),\
- .ops = &stf7110_ldo_ops,\
+ .ops = &jh7110_ldo_ops,\
.of_match = of_match_ptr(_name),\
.regulators_node = of_match_ptr("regulators"),\
.type = REGULATOR_VOLTAGE,\
- .id = STF7110_ID_##_id,\
+ .id = JH7110_ID_##_id,\
.owner = THIS_MODULE,\
- .enable_reg = STF7110_PM_POWER_SW_##en_reg,\
+ .enable_reg = JH7110_PM_POWER_SW_##en_reg,\
.enable_mask = ENABLE_MASK(en_mask),\
}
-static const struct regulator_desc stf7110_regulators[] = {
- STF7110_LDO(LDO_REG1, "hdmi_1p8", 0, 0),
- STF7110_LDO(LDO_REG2, "mipitx_1p8", 0, 1),
- STF7110_LDO(LDO_REG3, "mipirx_1p8", 0, 2),
- STF7110_LDO(LDO_REG4, "hdmi_0p9", 0, 3),
- STF7110_LDO(LDO_REG5, "mipitx_0p9", 0, 4),
- STF7110_LDO(LDO_REG6, "mipirx_0p9", 0, 5),
- STF7110_LDO(LDO_REG7, "sdio_vdd", 1, 0),
+static const struct regulator_desc jh7110_regulators[] = {
+ JH7110_LDO(LDO_REG1, "hdmi_1p8", 0, 0),
+ JH7110_LDO(LDO_REG2, "mipitx_1p8", 0, 1),
+ JH7110_LDO(LDO_REG3, "mipirx_1p8", 0, 2),
+ JH7110_LDO(LDO_REG4, "hdmi_0p9", 0, 3),
+ JH7110_LDO(LDO_REG5, "mipitx_0p9", 0, 4),
+ JH7110_LDO(LDO_REG6, "mipirx_0p9", 0, 5),
+ JH7110_LDO(LDO_REG7, "sdio_vdd", 1, 0),
};
-static int stf7110_i2c_probe(struct i2c_client *i2c)
+static int jh7110_i2c_probe(struct i2c_client *i2c)
{
struct regulator_config config = { };
struct regulator_dev *rdev;
struct regmap *regmap;
int i, ret;
- regmap = devm_regmap_init_i2c(i2c, &stf7110_regmap_config);
+ regmap = devm_regmap_init_i2c(i2c, &jh7110_regmap_config);
if (IS_ERR(regmap)) {
ret = PTR_ERR(regmap);
dev_err(&i2c->dev, "Failed to allocate register map: %d\n",
return -ENOMEM;
config.init_data = init_data;
- for (i = 0; i < STF7110_MAX_REGULATORS; i++) {
+ for (i = 0; i < JH7110_MAX_REGULATORS; i++) {
config.dev = &i2c->dev;
config.regmap = regmap;
rdev = devm_regulator_register(&i2c->dev,
- &stf7110_regulators[i], &config);
+ &jh7110_regulators[i], &config);
if (IS_ERR(rdev)) {
dev_err(&i2c->dev,
- "Failed to register STF7110 regulator\n");
+ "Failed to register JH7110 regulator\n");
return PTR_ERR(rdev);
}
}
return 0;
}
-static const struct i2c_device_id stf7110_i2c_id[] = {
- {"stf7110_evb_reg", 0},
+static const struct i2c_device_id jh7110_i2c_id[] = {
+ {"jh7110_evb_reg", 0},
{},
};
-MODULE_DEVICE_TABLE(i2c, stf7110_i2c_id);
+MODULE_DEVICE_TABLE(i2c, jh7110_i2c_id);
#ifdef CONFIG_OF
-static const struct of_device_id stf7110_dt_ids[] = {
- { .compatible = "stf,jh7110-evb-regulator",
- .data = &stf7110_i2c_id[0] },
+static const struct of_device_id jh7110_dt_ids[] = {
+ { .compatible = "starfive,jh7110-evb-regulator",
+ .data = &jh7110_i2c_id[0] },
{},
};
-MODULE_DEVICE_TABLE(of, stf7110_dt_ids);
+MODULE_DEVICE_TABLE(of, jh7110_dt_ids);
#endif
-static struct i2c_driver stf7110_regulator_driver = {
+static struct i2c_driver jh7110_regulator_driver = {
.driver = {
- .name = "stf7110-evb-regulator",
- .of_match_table = of_match_ptr(stf7110_dt_ids),
+ .name = "jh7110-evb-regulator",
+ .of_match_table = of_match_ptr(jh7110_dt_ids),
},
- .probe_new = stf7110_i2c_probe,
- .id_table = stf7110_i2c_id,
+ .probe_new = jh7110_i2c_probe,
+ .id_table = jh7110_i2c_id,
};
-module_i2c_driver(stf7110_regulator_driver);
+module_i2c_driver(jh7110_regulator_driver);
MODULE_AUTHOR("Mason Huo <mason.huo@starfivetech.com>");
-MODULE_DESCRIPTION("Regulator device driver for Starfive STF7110");
+MODULE_DESCRIPTION("Regulator device driver for Starfive JH7110");
MODULE_LICENSE("GPL v2");
projects / platform / kernel / linux-starfive.git / commitdiff