forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
502 lines
12 KiB
502 lines
12 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
/* |
|
* Copyright (C) ST-Ericsson SA 2010 |
|
* |
|
* Authors: Sundar Iyer <[email protected]> for ST-Ericsson |
|
* Bengt Jonsson <[email protected]> for ST-Ericsson |
|
* |
|
* Power domain regulators on DB8500 |
|
*/ |
|
|
|
#include <linux/kernel.h> |
|
#include <linux/init.h> |
|
#include <linux/err.h> |
|
#include <linux/spinlock.h> |
|
#include <linux/platform_device.h> |
|
#include <linux/mfd/dbx500-prcmu.h> |
|
#include <linux/regulator/driver.h> |
|
#include <linux/regulator/machine.h> |
|
#include <linux/regulator/db8500-prcmu.h> |
|
#include <linux/regulator/of_regulator.h> |
|
#include <linux/of.h> |
|
#include <linux/module.h> |
|
#include "dbx500-prcmu.h" |
|
|
|
static int db8500_regulator_enable(struct regulator_dev *rdev) |
|
{ |
|
struct dbx500_regulator_info *info = rdev_get_drvdata(rdev); |
|
|
|
if (info == NULL) |
|
return -EINVAL; |
|
|
|
dev_vdbg(rdev_get_dev(rdev), "regulator-%s-enable\n", |
|
info->desc.name); |
|
|
|
if (!info->is_enabled) { |
|
info->is_enabled = true; |
|
if (!info->exclude_from_power_state) |
|
power_state_active_enable(); |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static int db8500_regulator_disable(struct regulator_dev *rdev) |
|
{ |
|
struct dbx500_regulator_info *info = rdev_get_drvdata(rdev); |
|
int ret = 0; |
|
|
|
if (info == NULL) |
|
return -EINVAL; |
|
|
|
dev_vdbg(rdev_get_dev(rdev), "regulator-%s-disable\n", |
|
info->desc.name); |
|
|
|
if (info->is_enabled) { |
|
info->is_enabled = false; |
|
if (!info->exclude_from_power_state) |
|
ret = power_state_active_disable(); |
|
} |
|
|
|
return ret; |
|
} |
|
|
|
static int db8500_regulator_is_enabled(struct regulator_dev *rdev) |
|
{ |
|
struct dbx500_regulator_info *info = rdev_get_drvdata(rdev); |
|
|
|
if (info == NULL) |
|
return -EINVAL; |
|
|
|
dev_vdbg(rdev_get_dev(rdev), "regulator-%s-is_enabled (is_enabled):" |
|
" %i\n", info->desc.name, info->is_enabled); |
|
|
|
return info->is_enabled; |
|
} |
|
|
|
/* db8500 regulator operations */ |
|
static const struct regulator_ops db8500_regulator_ops = { |
|
.enable = db8500_regulator_enable, |
|
.disable = db8500_regulator_disable, |
|
.is_enabled = db8500_regulator_is_enabled, |
|
}; |
|
|
|
/* |
|
* EPOD control |
|
*/ |
|
static bool epod_on[NUM_EPOD_ID]; |
|
static bool epod_ramret[NUM_EPOD_ID]; |
|
|
|
static int enable_epod(u16 epod_id, bool ramret) |
|
{ |
|
int ret; |
|
|
|
if (ramret) { |
|
if (!epod_on[epod_id]) { |
|
ret = prcmu_set_epod(epod_id, EPOD_STATE_RAMRET); |
|
if (ret < 0) |
|
return ret; |
|
} |
|
epod_ramret[epod_id] = true; |
|
} else { |
|
ret = prcmu_set_epod(epod_id, EPOD_STATE_ON); |
|
if (ret < 0) |
|
return ret; |
|
epod_on[epod_id] = true; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static int disable_epod(u16 epod_id, bool ramret) |
|
{ |
|
int ret; |
|
|
|
if (ramret) { |
|
if (!epod_on[epod_id]) { |
|
ret = prcmu_set_epod(epod_id, EPOD_STATE_OFF); |
|
if (ret < 0) |
|
return ret; |
|
} |
|
epod_ramret[epod_id] = false; |
|
} else { |
|
if (epod_ramret[epod_id]) { |
|
ret = prcmu_set_epod(epod_id, EPOD_STATE_RAMRET); |
|
if (ret < 0) |
|
return ret; |
|
} else { |
|
ret = prcmu_set_epod(epod_id, EPOD_STATE_OFF); |
|
if (ret < 0) |
|
return ret; |
|
} |
|
epod_on[epod_id] = false; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
/* |
|
* Regulator switch |
|
*/ |
|
static int db8500_regulator_switch_enable(struct regulator_dev *rdev) |
|
{ |
|
struct dbx500_regulator_info *info = rdev_get_drvdata(rdev); |
|
int ret; |
|
|
|
if (info == NULL) |
|
return -EINVAL; |
|
|
|
dev_vdbg(rdev_get_dev(rdev), "regulator-switch-%s-enable\n", |
|
info->desc.name); |
|
|
|
ret = enable_epod(info->epod_id, info->is_ramret); |
|
if (ret < 0) { |
|
dev_err(rdev_get_dev(rdev), |
|
"regulator-switch-%s-enable: prcmu call failed\n", |
|
info->desc.name); |
|
goto out; |
|
} |
|
|
|
info->is_enabled = true; |
|
out: |
|
return ret; |
|
} |
|
|
|
static int db8500_regulator_switch_disable(struct regulator_dev *rdev) |
|
{ |
|
struct dbx500_regulator_info *info = rdev_get_drvdata(rdev); |
|
int ret; |
|
|
|
if (info == NULL) |
|
return -EINVAL; |
|
|
|
dev_vdbg(rdev_get_dev(rdev), "regulator-switch-%s-disable\n", |
|
info->desc.name); |
|
|
|
ret = disable_epod(info->epod_id, info->is_ramret); |
|
if (ret < 0) { |
|
dev_err(rdev_get_dev(rdev), |
|
"regulator_switch-%s-disable: prcmu call failed\n", |
|
info->desc.name); |
|
goto out; |
|
} |
|
|
|
info->is_enabled = false; |
|
out: |
|
return ret; |
|
} |
|
|
|
static int db8500_regulator_switch_is_enabled(struct regulator_dev *rdev) |
|
{ |
|
struct dbx500_regulator_info *info = rdev_get_drvdata(rdev); |
|
|
|
if (info == NULL) |
|
return -EINVAL; |
|
|
|
dev_vdbg(rdev_get_dev(rdev), |
|
"regulator-switch-%s-is_enabled (is_enabled): %i\n", |
|
info->desc.name, info->is_enabled); |
|
|
|
return info->is_enabled; |
|
} |
|
|
|
static const struct regulator_ops db8500_regulator_switch_ops = { |
|
.enable = db8500_regulator_switch_enable, |
|
.disable = db8500_regulator_switch_disable, |
|
.is_enabled = db8500_regulator_switch_is_enabled, |
|
}; |
|
|
|
/* |
|
* Regulator information |
|
*/ |
|
static struct dbx500_regulator_info |
|
dbx500_regulator_info[DB8500_NUM_REGULATORS] = { |
|
[DB8500_REGULATOR_VAPE] = { |
|
.desc = { |
|
.name = "db8500-vape", |
|
.of_match = of_match_ptr("db8500_vape"), |
|
.id = DB8500_REGULATOR_VAPE, |
|
.ops = &db8500_regulator_ops, |
|
.type = REGULATOR_VOLTAGE, |
|
.owner = THIS_MODULE, |
|
}, |
|
}, |
|
[DB8500_REGULATOR_VARM] = { |
|
.desc = { |
|
.name = "db8500-varm", |
|
.of_match = of_match_ptr("db8500_varm"), |
|
.id = DB8500_REGULATOR_VARM, |
|
.ops = &db8500_regulator_ops, |
|
.type = REGULATOR_VOLTAGE, |
|
.owner = THIS_MODULE, |
|
}, |
|
}, |
|
[DB8500_REGULATOR_VMODEM] = { |
|
.desc = { |
|
.name = "db8500-vmodem", |
|
.of_match = of_match_ptr("db8500_vmodem"), |
|
.id = DB8500_REGULATOR_VMODEM, |
|
.ops = &db8500_regulator_ops, |
|
.type = REGULATOR_VOLTAGE, |
|
.owner = THIS_MODULE, |
|
}, |
|
}, |
|
[DB8500_REGULATOR_VPLL] = { |
|
.desc = { |
|
.name = "db8500-vpll", |
|
.of_match = of_match_ptr("db8500_vpll"), |
|
.id = DB8500_REGULATOR_VPLL, |
|
.ops = &db8500_regulator_ops, |
|
.type = REGULATOR_VOLTAGE, |
|
.owner = THIS_MODULE, |
|
}, |
|
}, |
|
[DB8500_REGULATOR_VSMPS1] = { |
|
.desc = { |
|
.name = "db8500-vsmps1", |
|
.of_match = of_match_ptr("db8500_vsmps1"), |
|
.id = DB8500_REGULATOR_VSMPS1, |
|
.ops = &db8500_regulator_ops, |
|
.type = REGULATOR_VOLTAGE, |
|
.owner = THIS_MODULE, |
|
}, |
|
}, |
|
[DB8500_REGULATOR_VSMPS2] = { |
|
.desc = { |
|
.name = "db8500-vsmps2", |
|
.of_match = of_match_ptr("db8500_vsmps2"), |
|
.id = DB8500_REGULATOR_VSMPS2, |
|
.ops = &db8500_regulator_ops, |
|
.type = REGULATOR_VOLTAGE, |
|
.owner = THIS_MODULE, |
|
.fixed_uV = 1800000, |
|
.n_voltages = 1, |
|
}, |
|
.exclude_from_power_state = true, |
|
}, |
|
[DB8500_REGULATOR_VSMPS3] = { |
|
.desc = { |
|
.name = "db8500-vsmps3", |
|
.of_match = of_match_ptr("db8500_vsmps3"), |
|
.id = DB8500_REGULATOR_VSMPS3, |
|
.ops = &db8500_regulator_ops, |
|
.type = REGULATOR_VOLTAGE, |
|
.owner = THIS_MODULE, |
|
}, |
|
}, |
|
[DB8500_REGULATOR_VRF1] = { |
|
.desc = { |
|
.name = "db8500-vrf1", |
|
.of_match = of_match_ptr("db8500_vrf1"), |
|
.id = DB8500_REGULATOR_VRF1, |
|
.ops = &db8500_regulator_ops, |
|
.type = REGULATOR_VOLTAGE, |
|
.owner = THIS_MODULE, |
|
}, |
|
}, |
|
[DB8500_REGULATOR_SWITCH_SVAMMDSP] = { |
|
.desc = { |
|
.name = "db8500-sva-mmdsp", |
|
.of_match = of_match_ptr("db8500_sva_mmdsp"), |
|
.id = DB8500_REGULATOR_SWITCH_SVAMMDSP, |
|
.ops = &db8500_regulator_switch_ops, |
|
.type = REGULATOR_VOLTAGE, |
|
.owner = THIS_MODULE, |
|
}, |
|
.epod_id = EPOD_ID_SVAMMDSP, |
|
}, |
|
[DB8500_REGULATOR_SWITCH_SVAMMDSPRET] = { |
|
.desc = { |
|
.name = "db8500-sva-mmdsp-ret", |
|
.of_match = of_match_ptr("db8500_sva_mmdsp_ret"), |
|
.id = DB8500_REGULATOR_SWITCH_SVAMMDSPRET, |
|
.ops = &db8500_regulator_switch_ops, |
|
.type = REGULATOR_VOLTAGE, |
|
.owner = THIS_MODULE, |
|
}, |
|
.epod_id = EPOD_ID_SVAMMDSP, |
|
.is_ramret = true, |
|
}, |
|
[DB8500_REGULATOR_SWITCH_SVAPIPE] = { |
|
.desc = { |
|
.name = "db8500-sva-pipe", |
|
.of_match = of_match_ptr("db8500_sva_pipe"), |
|
.id = DB8500_REGULATOR_SWITCH_SVAPIPE, |
|
.ops = &db8500_regulator_switch_ops, |
|
.type = REGULATOR_VOLTAGE, |
|
.owner = THIS_MODULE, |
|
}, |
|
.epod_id = EPOD_ID_SVAPIPE, |
|
}, |
|
[DB8500_REGULATOR_SWITCH_SIAMMDSP] = { |
|
.desc = { |
|
.name = "db8500-sia-mmdsp", |
|
.of_match = of_match_ptr("db8500_sia_mmdsp"), |
|
.id = DB8500_REGULATOR_SWITCH_SIAMMDSP, |
|
.ops = &db8500_regulator_switch_ops, |
|
.type = REGULATOR_VOLTAGE, |
|
.owner = THIS_MODULE, |
|
}, |
|
.epod_id = EPOD_ID_SIAMMDSP, |
|
}, |
|
[DB8500_REGULATOR_SWITCH_SIAMMDSPRET] = { |
|
.desc = { |
|
.name = "db8500-sia-mmdsp-ret", |
|
.of_match = of_match_ptr("db8500_sia_mmdsp_ret"), |
|
.id = DB8500_REGULATOR_SWITCH_SIAMMDSPRET, |
|
.ops = &db8500_regulator_switch_ops, |
|
.type = REGULATOR_VOLTAGE, |
|
.owner = THIS_MODULE, |
|
}, |
|
.epod_id = EPOD_ID_SIAMMDSP, |
|
.is_ramret = true, |
|
}, |
|
[DB8500_REGULATOR_SWITCH_SIAPIPE] = { |
|
.desc = { |
|
.name = "db8500-sia-pipe", |
|
.of_match = of_match_ptr("db8500_sia_pipe"), |
|
.id = DB8500_REGULATOR_SWITCH_SIAPIPE, |
|
.ops = &db8500_regulator_switch_ops, |
|
.type = REGULATOR_VOLTAGE, |
|
.owner = THIS_MODULE, |
|
}, |
|
.epod_id = EPOD_ID_SIAPIPE, |
|
}, |
|
[DB8500_REGULATOR_SWITCH_SGA] = { |
|
.desc = { |
|
.name = "db8500-sga", |
|
.of_match = of_match_ptr("db8500_sga"), |
|
.id = DB8500_REGULATOR_SWITCH_SGA, |
|
.ops = &db8500_regulator_switch_ops, |
|
.type = REGULATOR_VOLTAGE, |
|
.owner = THIS_MODULE, |
|
}, |
|
.epod_id = EPOD_ID_SGA, |
|
}, |
|
[DB8500_REGULATOR_SWITCH_B2R2_MCDE] = { |
|
.desc = { |
|
.name = "db8500-b2r2-mcde", |
|
.of_match = of_match_ptr("db8500_b2r2_mcde"), |
|
.id = DB8500_REGULATOR_SWITCH_B2R2_MCDE, |
|
.ops = &db8500_regulator_switch_ops, |
|
.type = REGULATOR_VOLTAGE, |
|
.owner = THIS_MODULE, |
|
}, |
|
.epod_id = EPOD_ID_B2R2_MCDE, |
|
}, |
|
[DB8500_REGULATOR_SWITCH_ESRAM12] = { |
|
.desc = { |
|
.name = "db8500-esram12", |
|
.of_match = of_match_ptr("db8500_esram12"), |
|
.id = DB8500_REGULATOR_SWITCH_ESRAM12, |
|
.ops = &db8500_regulator_switch_ops, |
|
.type = REGULATOR_VOLTAGE, |
|
.owner = THIS_MODULE, |
|
}, |
|
.epod_id = EPOD_ID_ESRAM12, |
|
.is_enabled = true, |
|
}, |
|
[DB8500_REGULATOR_SWITCH_ESRAM12RET] = { |
|
.desc = { |
|
.name = "db8500-esram12-ret", |
|
.of_match = of_match_ptr("db8500_esram12_ret"), |
|
.id = DB8500_REGULATOR_SWITCH_ESRAM12RET, |
|
.ops = &db8500_regulator_switch_ops, |
|
.type = REGULATOR_VOLTAGE, |
|
.owner = THIS_MODULE, |
|
}, |
|
.epod_id = EPOD_ID_ESRAM12, |
|
.is_ramret = true, |
|
}, |
|
[DB8500_REGULATOR_SWITCH_ESRAM34] = { |
|
.desc = { |
|
.name = "db8500-esram34", |
|
.of_match = of_match_ptr("db8500_esram34"), |
|
.id = DB8500_REGULATOR_SWITCH_ESRAM34, |
|
.ops = &db8500_regulator_switch_ops, |
|
.type = REGULATOR_VOLTAGE, |
|
.owner = THIS_MODULE, |
|
}, |
|
.epod_id = EPOD_ID_ESRAM34, |
|
.is_enabled = true, |
|
}, |
|
[DB8500_REGULATOR_SWITCH_ESRAM34RET] = { |
|
.desc = { |
|
.name = "db8500-esram34-ret", |
|
.of_match = of_match_ptr("db8500_esram34_ret"), |
|
.id = DB8500_REGULATOR_SWITCH_ESRAM34RET, |
|
.ops = &db8500_regulator_switch_ops, |
|
.type = REGULATOR_VOLTAGE, |
|
.owner = THIS_MODULE, |
|
}, |
|
.epod_id = EPOD_ID_ESRAM34, |
|
.is_ramret = true, |
|
}, |
|
}; |
|
|
|
static int db8500_regulator_probe(struct platform_device *pdev) |
|
{ |
|
struct regulator_init_data *db8500_init_data; |
|
struct dbx500_regulator_info *info; |
|
struct regulator_config config = { }; |
|
struct regulator_dev *rdev; |
|
int err, i; |
|
|
|
db8500_init_data = dev_get_platdata(&pdev->dev); |
|
|
|
for (i = 0; i < ARRAY_SIZE(dbx500_regulator_info); i++) { |
|
/* assign per-regulator data */ |
|
info = &dbx500_regulator_info[i]; |
|
|
|
config.driver_data = info; |
|
config.dev = &pdev->dev; |
|
if (db8500_init_data) |
|
config.init_data = &db8500_init_data[i]; |
|
|
|
rdev = devm_regulator_register(&pdev->dev, &info->desc, |
|
&config); |
|
if (IS_ERR(rdev)) { |
|
err = PTR_ERR(rdev); |
|
dev_err(&pdev->dev, "failed to register %s: err %i\n", |
|
info->desc.name, err); |
|
return err; |
|
} |
|
dev_dbg(&pdev->dev, "regulator-%s-probed\n", info->desc.name); |
|
} |
|
|
|
ux500_regulator_debug_init(pdev, dbx500_regulator_info, |
|
ARRAY_SIZE(dbx500_regulator_info)); |
|
return 0; |
|
} |
|
|
|
static int db8500_regulator_remove(struct platform_device *pdev) |
|
{ |
|
ux500_regulator_debug_exit(); |
|
|
|
return 0; |
|
} |
|
|
|
static struct platform_driver db8500_regulator_driver = { |
|
.driver = { |
|
.name = "db8500-prcmu-regulators", |
|
}, |
|
.probe = db8500_regulator_probe, |
|
.remove = db8500_regulator_remove, |
|
}; |
|
|
|
static int __init db8500_regulator_init(void) |
|
{ |
|
return platform_driver_register(&db8500_regulator_driver); |
|
} |
|
|
|
static void __exit db8500_regulator_exit(void) |
|
{ |
|
platform_driver_unregister(&db8500_regulator_driver); |
|
} |
|
|
|
arch_initcall(db8500_regulator_init); |
|
module_exit(db8500_regulator_exit); |
|
|
|
MODULE_AUTHOR("STMicroelectronics/ST-Ericsson"); |
|
MODULE_DESCRIPTION("DB8500 regulator driver"); |
|
MODULE_LICENSE("GPL v2");
|
|
|