543 lines
15 KiB
C
543 lines
15 KiB
C
/*
|
|
* sm5705.c - Regulator driver for the sm5705
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/bug.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/err.h>
|
|
#include <linux/gpio.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/regulator/driver.h>
|
|
#include <linux/regulator/machine.h>
|
|
#include <linux/mfd/sm5705/sm5705.h>
|
|
#include <linux/regulator/of_regulator.h>
|
|
|
|
/* SM5705 regulator IDs */
|
|
enum sm5705_regulators {
|
|
SM5705_USBLDO1 = 0,
|
|
SM5705_USBLDO2,
|
|
|
|
SM5705_LDO_MAX,
|
|
};
|
|
|
|
struct sm5705_data {
|
|
struct device *dev;
|
|
struct sm5705_dev *iodev;
|
|
int num_regulators;
|
|
struct regulator_dev **rdev;
|
|
|
|
u8 saved_states[SM5705_LDO_MAX];
|
|
};
|
|
|
|
struct voltage_map_desc {
|
|
int min;
|
|
int max;
|
|
int step;
|
|
unsigned int n_bits;
|
|
};
|
|
|
|
static const struct voltage_map_desc usbldo1_map_desc = {
|
|
.min = 4700, .max = 4700, .step = 1, .n_bits = 3,
|
|
};
|
|
|
|
static const struct voltage_map_desc usbldo2_map_desc = {
|
|
.min = 4700, .max = 4700, .step = 1, .n_bits = 4,
|
|
};
|
|
|
|
static const struct voltage_map_desc *reg_voltage_map[] = {
|
|
[SM5705_USBLDO1] = &usbldo1_map_desc,
|
|
[SM5705_USBLDO2] = &usbldo2_map_desc,
|
|
};
|
|
|
|
int sm5705_regulator_update_reg
|
|
(struct i2c_client *i2c, u8 reg, u8 val, u8 mask)
|
|
{
|
|
u8 val_before = -1, val_after = -1;
|
|
int ret;
|
|
|
|
sm5705_read_reg(i2c, reg, &val_before);
|
|
|
|
ret = sm5705_update_reg(i2c, reg, val, mask);
|
|
if (ret)
|
|
pr_err("%s: fail to update reg(%d)\n", __func__, ret);
|
|
|
|
sm5705_read_reg(i2c, reg, &val_after);
|
|
|
|
pr_info("%s: reg(0x%02x): [0x%02x]+[0x%02x]:[mask 0x%02x]->[0x%02x]\n",
|
|
__func__, reg, val_before, val, mask, val_after);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static inline int sm5705_get_rid(struct regulator_dev *rdev)
|
|
{
|
|
if (!rdev)
|
|
return -ENODEV;
|
|
|
|
if (!rdev->desc)
|
|
return -ENODEV;
|
|
|
|
dev_info(&rdev->dev, "func:%s\n", __func__);
|
|
return rdev_get_id(rdev);
|
|
}
|
|
|
|
static bool sm5705_regulator_check_disable(struct regulator_dev *rdev)
|
|
{
|
|
int rid = sm5705_get_rid(rdev);
|
|
bool ret = false;
|
|
|
|
//Please check below two case
|
|
switch(rid) {
|
|
case SM5705_USBLDO1:
|
|
ret = is_muic_usb_path_ap_usb();
|
|
break;
|
|
case SM5705_USBLDO2:
|
|
ret = is_muic_usb_path_cp_usb();
|
|
break;
|
|
default:
|
|
pr_err("%s: invalid value rid(%d)\n", __func__, rid);
|
|
break;
|
|
}
|
|
|
|
if (ret) {
|
|
pr_info("%s: cannot disable regulator(%d)\n", __func__, rid);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
/*
|
|
static int sm5705_list_voltage_usbldo(struct regulator_dev *rdev,
|
|
unsigned int selector)
|
|
{
|
|
int rid = sm5705_get_rid(rdev);
|
|
dev_info(&rdev->dev, "func:%s\n", __func__);
|
|
|
|
if (rid == SM5705_USBLDO1 || rid == SM5705_USBLDO2) {
|
|
switch (selector) {
|
|
case 0:
|
|
return 4700000;
|
|
case 1:
|
|
return 4700000;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
*/
|
|
static int sm5705_get_enable_register(struct regulator_dev *rdev,
|
|
int *reg, int *mask, int *pattern)
|
|
{
|
|
int rid = sm5705_get_rid(rdev);
|
|
dev_info(&rdev->dev, "func:%s\n", __func__);
|
|
|
|
switch (rid) {
|
|
case SM5705_USBLDO1:
|
|
*reg = SM5705_REG_CHGCNTL7;
|
|
*mask = 0x08;
|
|
*pattern = 0x08;
|
|
break;
|
|
case SM5705_USBLDO2:
|
|
*reg = SM5705_REG_CHGCNTL7;
|
|
*mask = 0x10;
|
|
*pattern = 0x10;
|
|
break;
|
|
default:
|
|
/* Not controllable or not exists */
|
|
return -EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int sm5705_get_disable_register(struct regulator_dev *rdev,
|
|
int *reg, int *mask, int *pattern)
|
|
{
|
|
int rid = sm5705_get_rid(rdev);
|
|
dev_info(&rdev->dev, "func:%s\n", __func__);
|
|
|
|
switch (rid) {
|
|
case SM5705_USBLDO1:
|
|
*reg = SM5705_REG_CHGCNTL7;
|
|
*mask = 0x08;
|
|
*pattern = 0x00;
|
|
break;
|
|
case SM5705_USBLDO2:
|
|
*reg = SM5705_REG_CHGCNTL7;
|
|
*mask = 0x10;
|
|
*pattern = 0x00;
|
|
break;
|
|
default:
|
|
/* Not controllable or not exists */
|
|
return -EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int sm5705_reg_is_enabled(struct regulator_dev *rdev)
|
|
{
|
|
struct sm5705_data *sm5705 = rdev_get_drvdata(rdev);
|
|
struct i2c_client *i2c = sm5705->iodev->i2c;
|
|
int ret, reg, mask, pattern;
|
|
u8 val;
|
|
|
|
dev_info(&rdev->dev, "func:%s\n", __func__);
|
|
|
|
ret = sm5705_get_enable_register(rdev, ®, &mask, &pattern);
|
|
|
|
if (ret == -EINVAL)
|
|
return 1; /* "not controllable" */
|
|
else if (ret)
|
|
return ret;
|
|
|
|
ret = sm5705_read_reg(i2c, reg, &val);
|
|
if (ret)
|
|
return ret;
|
|
|
|
return (val & mask) == pattern;
|
|
}
|
|
|
|
static int sm5705_reg_enable(struct regulator_dev *rdev)
|
|
{
|
|
struct sm5705_data *sm5705 = rdev_get_drvdata(rdev);
|
|
struct i2c_client *i2c = sm5705->iodev->i2c;
|
|
int ret, reg, mask, pattern;
|
|
|
|
dev_info(&rdev->dev, "func:%s\n", __func__);
|
|
|
|
ret = sm5705_get_enable_register(rdev, ®, &mask, &pattern);
|
|
if (ret)
|
|
return ret;
|
|
|
|
return sm5705_regulator_update_reg(i2c, reg, pattern, mask);
|
|
}
|
|
|
|
static int sm5705_reg_disable(struct regulator_dev *rdev)
|
|
{
|
|
struct sm5705_data *sm5705 = rdev_get_drvdata(rdev);
|
|
struct i2c_client *i2c = sm5705->iodev->i2c;
|
|
int ret, reg, mask, pattern;
|
|
dev_info(&rdev->dev, "func:%s\n", __func__);
|
|
|
|
if (!sm5705_regulator_check_disable(rdev))
|
|
return -EINVAL;
|
|
|
|
ret = sm5705_get_disable_register(rdev, ®, &mask, &pattern);
|
|
if (ret)
|
|
return ret;
|
|
|
|
return sm5705_regulator_update_reg(i2c, reg, pattern, mask);
|
|
}
|
|
|
|
static int sm5705_reg_enable_suspend(struct regulator_dev *rdev)
|
|
{
|
|
dev_info(&rdev->dev, "func:%s\n", __func__);
|
|
return 0;
|
|
}
|
|
|
|
static int sm5705_reg_disable_suspend(struct regulator_dev *rdev)
|
|
{
|
|
struct sm5705_data *sm5705 = rdev_get_drvdata(rdev);
|
|
struct i2c_client *i2c = sm5705->iodev->i2c;
|
|
int ret, reg, mask, pattern;
|
|
int rid = sm5705_get_rid(rdev);
|
|
|
|
dev_info(&rdev->dev, "func:%s\n", __func__);
|
|
|
|
ret = sm5705_get_disable_register(rdev, ®, &mask, &pattern);
|
|
if (ret)
|
|
return ret;
|
|
|
|
if (rid != SM5705_USBLDO1 && rid != SM5705_USBLDO2)
|
|
return -EINVAL;
|
|
|
|
sm5705_read_reg(i2c, reg, &sm5705->saved_states[rid]);
|
|
|
|
dev_dbg(&rdev->dev, "%s (%xh -> %xh)\n",
|
|
rdev->desc->name, sm5705->saved_states[rid] & mask,
|
|
(~pattern) & mask);
|
|
|
|
return sm5705_regulator_update_reg(i2c, reg, pattern, mask);
|
|
}
|
|
|
|
static struct regulator_ops sm5705_usbldo_ops = {
|
|
// .list_voltage = sm5705_list_voltage_usbldo,
|
|
.is_enabled = sm5705_reg_is_enabled,
|
|
.enable = sm5705_reg_enable,
|
|
.disable = sm5705_reg_disable,
|
|
.set_suspend_enable = sm5705_reg_enable_suspend,
|
|
.set_suspend_disable = sm5705_reg_disable_suspend,
|
|
};
|
|
|
|
static struct regulator_desc regulators[] = {
|
|
{
|
|
.name = "USBLDO1",
|
|
.id = SM5705_USBLDO1,
|
|
.ops = &sm5705_usbldo_ops,
|
|
.type = REGULATOR_VOLTAGE,
|
|
.owner = THIS_MODULE,
|
|
}, {
|
|
.name = "USBLDO2",
|
|
.id = SM5705_USBLDO2,
|
|
.ops = &sm5705_usbldo_ops,
|
|
.type = REGULATOR_VOLTAGE,
|
|
.owner = THIS_MODULE,
|
|
},
|
|
};
|
|
|
|
static struct regulator_consumer_supply usbldo1_supply[] = {
|
|
REGULATOR_SUPPLY("usbldo1", NULL),
|
|
};
|
|
|
|
static struct regulator_consumer_supply usbldo2_supply[] = {
|
|
REGULATOR_SUPPLY("usbldo2", NULL),
|
|
};
|
|
|
|
#define USBLDO1_MIN_UV 4700000
|
|
#define USBLDO1_MAX_UV 4700000
|
|
#define USBLDO2_MIN_UV 4700000
|
|
#define USBLDO2_MAX_UV 4700000
|
|
|
|
#define USBLDO1_APPLY_UV 0
|
|
#define USBLDO2_APPLY_UV 0
|
|
|
|
#if defined(CONFIG_OF)
|
|
|
|
#define sm5705_init_consumer_supplies(p_data, r_init_data, id) \
|
|
(r_init_data) = (p_data)->regulators[SM5705_USBLDO##id].initdata; \
|
|
(r_init_data)->constraints.state_mem.enabled = 1; \
|
|
(r_init_data)->num_consumer_supplies = ARRAY_SIZE(usbldo## id ##_supply); \
|
|
(r_init_data)->consumer_supplies = usbldo## id ##_supply; \
|
|
(r_init_data)->constraints.min_uV = USBLDO## id ##_MIN_UV; \
|
|
(r_init_data)->constraints.max_uV = USBLDO## id ##_MAX_UV; \
|
|
(r_init_data)->constraints.apply_uV = USBLDO## id ##_APPLY_UV;
|
|
|
|
static int sm5705_pmic_dt_parse_pdata(struct platform_device *pdev,
|
|
struct sm5705_platform_data *pdata)
|
|
{
|
|
struct sm5705_dev *iodev = dev_get_drvdata(pdev->dev.parent);
|
|
struct device_node *pmic_np, *regulators_np, *reg_np;
|
|
struct sm5705_regulator_data *rdata;
|
|
struct regulator_init_data *r_initdata;
|
|
|
|
unsigned int i;
|
|
|
|
pmic_np = of_node_get(iodev->dev->of_node);
|
|
if (!pmic_np) {
|
|
dev_err(&pdev->dev, "could not find pmic sub-node\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
regulators_np = of_find_node_by_name(pmic_np, "regulators");
|
|
if (!regulators_np) {
|
|
dev_err(&pdev->dev, "could not find regulators sub-node\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* count the number of regulators to be supported in pmic */
|
|
pdata->num_regulators = 0;
|
|
|
|
for_each_child_of_node(regulators_np, reg_np) {
|
|
pdata->num_regulators++;
|
|
}
|
|
|
|
rdata = devm_kzalloc(&pdev->dev, sizeof(*rdata) *
|
|
pdata->num_regulators, GFP_KERNEL);
|
|
if (!rdata) {
|
|
of_node_put(regulators_np);
|
|
dev_err(&pdev->dev, "could not allocate memory for regulator data\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
pdata->regulators = rdata;
|
|
|
|
for_each_child_of_node(regulators_np, reg_np) {
|
|
for (i = 0; i < ARRAY_SIZE(regulators); i++) {
|
|
if (!of_node_cmp(reg_np->name, regulators[i].name))
|
|
break;
|
|
}
|
|
|
|
if (i == ARRAY_SIZE(regulators)) {
|
|
dev_warn(&pdev->dev, "don't know how to configure regulator %s\n",
|
|
reg_np->name);
|
|
continue;
|
|
}
|
|
|
|
rdata->id = i;
|
|
rdata->initdata = of_get_regulator_init_data(&pdev->dev, reg_np);//dts parse
|
|
rdata->reg_node = reg_np;
|
|
rdata++;
|
|
}
|
|
of_node_put(regulators_np);
|
|
|
|
/* original shelve source */
|
|
sm5705_init_consumer_supplies(pdata, r_initdata, 1);
|
|
sm5705_init_consumer_supplies(pdata, r_initdata, 2);
|
|
|
|
return 0;
|
|
}
|
|
#else
|
|
static int sm5705_pmic_dt_parse_pdata(struct platform_device *pdev,
|
|
struct sm5705_platform_data *pdata)
|
|
{
|
|
return 0;
|
|
}
|
|
#endif /* CONFIG_OF */
|
|
|
|
static int sm5705_pmic_probe(struct platform_device *pdev)
|
|
{
|
|
struct sm5705_dev *iodev = dev_get_drvdata(pdev->dev.parent);
|
|
struct sm5705_platform_data *pdata = dev_get_platdata(iodev->dev);
|
|
struct regulator_config config = { };
|
|
struct regulator_dev **rdev;
|
|
struct sm5705_data *sm5705;
|
|
struct i2c_client *i2c;
|
|
int i, ret, size;
|
|
|
|
//dev_info(&pdev->dev, "%s\n", __func__);
|
|
printk("%s\n", __func__);
|
|
if (!pdata) {
|
|
pr_info("[%s:%d] !pdata\n", __FILE__, __LINE__);
|
|
dev_err(pdev->dev.parent, "No platform init data supplied.\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
if (iodev->dev->of_node) {
|
|
ret = sm5705_pmic_dt_parse_pdata(pdev, pdata);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
sm5705 = devm_kzalloc(&pdev->dev, sizeof(struct sm5705_data),
|
|
GFP_KERNEL);
|
|
if (!sm5705) {
|
|
pr_info("[%s:%d] if (!sm5705)\n", __FILE__, __LINE__);
|
|
return -ENOMEM;
|
|
}
|
|
size = sizeof(struct regulator_dev *) * pdata->num_regulators;
|
|
sm5705->rdev = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
|
|
if (!sm5705->rdev) {
|
|
pr_info("[%s:%d] if (!sm5705->rdev)\n", __FILE__, __LINE__);
|
|
kfree(sm5705);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
rdev = sm5705->rdev;
|
|
sm5705->dev = &pdev->dev;
|
|
sm5705->iodev = iodev;
|
|
sm5705->num_regulators = pdata->num_regulators;
|
|
platform_set_drvdata(pdev, sm5705);
|
|
i2c = sm5705->iodev->i2c;
|
|
pr_info("[%s:%d] pdata->num_regulators:%d\n", __FILE__, __LINE__,
|
|
pdata->num_regulators);
|
|
|
|
for (i = 0; i < pdata->num_regulators; i++) {
|
|
|
|
const struct voltage_map_desc *desc;
|
|
int id = pdata->regulators[i].id;
|
|
pr_info("[%s:%d] for in pdata->num_regulators:%d\n", __FILE__,
|
|
__LINE__, pdata->num_regulators);
|
|
desc = reg_voltage_map[id];
|
|
if (id == SM5705_USBLDO1 || id == SM5705_USBLDO2)
|
|
regulators[id].n_voltages = 1;
|
|
|
|
config.dev = sm5705->dev;
|
|
config.init_data = pdata->regulators[i].initdata;
|
|
config.driver_data = sm5705;
|
|
config.of_node = pdata->regulators[i].reg_node;
|
|
|
|
rdev[i] = regulator_register(®ulators[id], &config);
|
|
if (IS_ERR(rdev[i])) {
|
|
ret = PTR_ERR(rdev[i]);
|
|
dev_err(sm5705->dev, "regulator init failed for %d\n",
|
|
id);
|
|
rdev[i] = NULL;
|
|
goto err;
|
|
}
|
|
}
|
|
|
|
//dev_info(&pdev->dev, "%s DONE\n", __func__);
|
|
printk("%s DONE\n", __func__);
|
|
|
|
return 0;
|
|
err:
|
|
pr_info("[%s:%d] err - (i = %d):\n", __FILE__, __LINE__, i);
|
|
//for (; i > 0; i--)
|
|
// if (rdev[i])
|
|
// regulator_unregister(rdev[i-1]);
|
|
|
|
//kfree(sm5705);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int sm5705_pmic_remove(struct platform_device *pdev)
|
|
{
|
|
struct sm5705_data *sm5705 = platform_get_drvdata(pdev);
|
|
struct regulator_dev **rdev = sm5705->rdev;
|
|
int i;
|
|
dev_info(&pdev->dev, "%s\n", __func__);
|
|
for (i = 0; i < sm5705->num_regulators; i++)
|
|
if (rdev[i])
|
|
regulator_unregister(rdev[i]);
|
|
|
|
kfree(sm5705->rdev);
|
|
kfree(sm5705);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct platform_device_id sm5705_pmic_id[] = {
|
|
{"sm5705-usbldo", 0},
|
|
{},
|
|
};
|
|
MODULE_DEVICE_TABLE(platform, sm5705_pmic_id);
|
|
|
|
static struct platform_driver sm5705_pmic_driver = {
|
|
.driver = {
|
|
.name = "sm5705-usbldo",
|
|
.owner = THIS_MODULE,
|
|
},
|
|
.probe = sm5705_pmic_probe,
|
|
.remove = sm5705_pmic_remove,
|
|
.id_table = sm5705_pmic_id,
|
|
};
|
|
|
|
static int __init sm5705_pmic_init(void)
|
|
{
|
|
printk("%s\n",__func__);
|
|
return platform_driver_register(&sm5705_pmic_driver);
|
|
}
|
|
module_init(sm5705_pmic_init);
|
|
|
|
static void __exit sm5705_pmic_cleanup(void)
|
|
{
|
|
platform_driver_unregister(&sm5705_pmic_driver);
|
|
}
|
|
|
|
module_exit(sm5705_pmic_cleanup);
|
|
|
|
MODULE_DESCRIPTION("SM5705 Regulator Driver");
|
|
MODULE_LICENSE("GPL");
|
|
|