blob: ae1e27395eda594e8d9fa4dc40febc24946a772e [file] [log] [blame]
/* Copyright (c) 2010-2011, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only version 2 as published by the Free Software Foundation.
*
* 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.
*/
#define pr_fmt(fmt) "%s: " fmt, __func__
#include <linux/err.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/platform_device.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/machine.h>
#include <linux/mfd/pmic8901.h>
#include "spm.h"
#define FTSMPS_VCTRL_BAND_MASK 0xC0
#define FTSMPS_VCTRL_BAND_1 0x40
#define FTSMPS_VCTRL_BAND_2 0x80
#define FTSMPS_VCTRL_BAND_3 0xC0
#define FTSMPS_VCTRL_VPROG_MASK 0x3F
#define FTSMPS_BAND1_UV_MIN 350000
#define FTSMPS_BAND1_UV_MAX 650000
/* 3 LSB's of program voltage must be 0 in band 1. */
/* Logical step size */
#define FTSMPS_BAND1_UV_LOG_STEP 50000
/* Physical step size */
#define FTSMPS_BAND1_UV_PHYS_STEP 6250
#define FTSMPS_BAND2_UV_MIN 700000
#define FTSMPS_BAND2_UV_MAX 1400000
#define FTSMPS_BAND2_UV_STEP 12500
#define FTSMPS_BAND3_UV_MIN 1400000
#define FTSMPS_BAND3_UV_SET_POINT_MIN 1500000
#define FTSMPS_BAND3_UV_MAX 3300000
#define FTSMPS_BAND3_UV_STEP 50000
struct saw_vreg {
struct regulator_desc desc;
struct regulator_dev *rdev;
char *name;
int uV;
int last_set_uV;
unsigned vlevel;
bool online;
};
/* Minimum core operating voltage */
#define MIN_CORE_VOLTAGE 950000
/* Specifies an uninitialized voltage */
#define INVALID_VOLTAGE -1
/* Specifies the PMIC internal slew rate in uV/us. */
#define REGULATOR_SLEW_RATE 1250
static int saw_get_voltage(struct regulator_dev *rdev)
{
struct saw_vreg *vreg = rdev_get_drvdata(rdev);
return vreg->uV;
}
static int _set_voltage(struct regulator_dev *rdev)
{
struct saw_vreg *vreg = rdev_get_drvdata(rdev);
int rc;
rc = msm_spm_set_vdd(rdev_get_id(rdev), vreg->vlevel);
if (!rc) {
if (vreg->uV > vreg->last_set_uV) {
/* Wait for voltage to stabalize. */
udelay((vreg->uV - vreg->last_set_uV) /
REGULATOR_SLEW_RATE);
}
vreg->last_set_uV = vreg->uV;
} else {
pr_err("%s: msm_spm_set_vdd failed %d\n", vreg->name, rc);
vreg->uV = vreg->last_set_uV;
}
return rc;
}
static int saw_set_voltage(struct regulator_dev *rdev, int min_uV, int max_uV,
unsigned *selector)
{
struct saw_vreg *vreg = rdev_get_drvdata(rdev);
int uV = min_uV;
u8 vprog, band;
if (uV < FTSMPS_BAND1_UV_MIN && max_uV >= FTSMPS_BAND1_UV_MIN)
uV = FTSMPS_BAND1_UV_MIN;
if (uV < FTSMPS_BAND1_UV_MIN || uV > FTSMPS_BAND3_UV_MAX) {
pr_err("%s: request v=[%d, %d] is outside possible "
"v=[%d, %d]\n", vreg->name, min_uV, max_uV,
FTSMPS_BAND1_UV_MIN, FTSMPS_BAND3_UV_MAX);
return -EINVAL;
}
/* Round up for set points in the gaps between bands. */
if (uV > FTSMPS_BAND1_UV_MAX && uV < FTSMPS_BAND2_UV_MIN)
uV = FTSMPS_BAND2_UV_MIN;
else if (uV > FTSMPS_BAND2_UV_MAX
&& uV < FTSMPS_BAND3_UV_SET_POINT_MIN)
uV = FTSMPS_BAND3_UV_SET_POINT_MIN;
if (uV > FTSMPS_BAND2_UV_MAX) {
vprog = (uV - FTSMPS_BAND3_UV_MIN + FTSMPS_BAND3_UV_STEP - 1)
/ FTSMPS_BAND3_UV_STEP;
band = FTSMPS_VCTRL_BAND_3;
uV = FTSMPS_BAND3_UV_MIN + vprog * FTSMPS_BAND3_UV_STEP;
} else if (uV > FTSMPS_BAND1_UV_MAX) {
vprog = (uV - FTSMPS_BAND2_UV_MIN + FTSMPS_BAND2_UV_STEP - 1)
/ FTSMPS_BAND2_UV_STEP;
band = FTSMPS_VCTRL_BAND_2;
uV = FTSMPS_BAND2_UV_MIN + vprog * FTSMPS_BAND2_UV_STEP;
} else {
vprog = (uV - FTSMPS_BAND1_UV_MIN
+ FTSMPS_BAND1_UV_LOG_STEP - 1)
/ FTSMPS_BAND1_UV_LOG_STEP;
uV = FTSMPS_BAND1_UV_MIN + vprog * FTSMPS_BAND1_UV_LOG_STEP;
vprog *= FTSMPS_BAND1_UV_LOG_STEP / FTSMPS_BAND1_UV_PHYS_STEP;
band = FTSMPS_VCTRL_BAND_1;
}
if (uV > max_uV) {
pr_err("%s: request v=[%d, %d] cannot be met by any setpoint\n",
vreg->name, min_uV, max_uV);
return -EINVAL;
}
vreg->vlevel = band | vprog;
vreg->uV = uV;
if (!vreg->online)
return 0;
return _set_voltage(rdev);
}
static int saw_enable(struct regulator_dev *rdev)
{
struct saw_vreg *vreg = rdev_get_drvdata(rdev);
int rc = 0;
if (vreg->uV != vreg->last_set_uV)
rc = _set_voltage(rdev);
if (!rc)
vreg->online = true;
return rc;
}
static int saw_disable(struct regulator_dev *rdev)
{
struct saw_vreg *vreg = rdev_get_drvdata(rdev);
vreg->online = false;
return 0;
}
static int saw_is_enabled(struct regulator_dev *rdev)
{
struct saw_vreg *vreg = rdev_get_drvdata(rdev);
return vreg->online;
}
static struct regulator_ops saw_ops = {
.get_voltage = saw_get_voltage,
.set_voltage = saw_set_voltage,
.enable = saw_enable,
.disable = saw_disable,
.is_enabled = saw_is_enabled,
};
static int __devinit saw_probe(struct platform_device *pdev)
{
struct regulator_init_data *init_data;
struct saw_vreg *vreg;
int rc = 0;
if (!pdev->dev.platform_data) {
pr_err("platform data required.\n");
return -EINVAL;
}
init_data = pdev->dev.platform_data;
if (!init_data->constraints.name) {
pr_err("regulator name must be specified in constraints.\n");
return -EINVAL;
}
vreg = kzalloc(sizeof(struct saw_vreg), GFP_KERNEL);
if (!vreg) {
pr_err("kzalloc failed.\n");
return -ENOMEM;
}
vreg->name = kstrdup(init_data->constraints.name, GFP_KERNEL);
if (!vreg->name) {
pr_err("kzalloc failed.\n");
rc = -ENOMEM;
goto free_vreg;
}
vreg->desc.name = vreg->name;
vreg->desc.id = pdev->id;
vreg->desc.ops = &saw_ops;
vreg->desc.type = REGULATOR_VOLTAGE;
vreg->desc.owner = THIS_MODULE;
vreg->uV = INVALID_VOLTAGE;
vreg->last_set_uV = MIN_CORE_VOLTAGE;
vreg->rdev = regulator_register(&vreg->desc, &pdev->dev,
init_data, vreg, NULL);
if (IS_ERR(vreg->rdev)) {
rc = PTR_ERR(vreg->rdev);
pr_err("regulator_register failed, rc=%d.\n", rc);
goto free_name;
}
platform_set_drvdata(pdev, vreg);
pr_info("id=%d, name=%s\n", pdev->id, vreg->name);
return rc;
free_name:
kfree(vreg->name);
free_vreg:
kfree(vreg);
return rc;
}
static int __devexit saw_remove(struct platform_device *pdev)
{
struct saw_vreg *vreg = platform_get_drvdata(pdev);
regulator_unregister(vreg->rdev);
kfree(vreg->name);
kfree(vreg);
platform_set_drvdata(pdev, NULL);
return 0;
}
static struct platform_driver saw_driver = {
.probe = saw_probe,
.remove = __devexit_p(saw_remove),
.driver = {
.name = "saw-regulator",
.owner = THIS_MODULE,
},
};
static int __init saw_init(void)
{
return platform_driver_register(&saw_driver);
}
static void __exit saw_exit(void)
{
platform_driver_unregister(&saw_driver);
}
postcore_initcall(saw_init);
module_exit(saw_exit);
MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("SAW regulator driver");
MODULE_ALIAS("platform:saw-regulator");