630 строки
14 KiB
C
630 строки
14 KiB
C
|
/*
|
||
|
* TI LP8788 MFD - buck regulator driver
|
||
|
*
|
||
|
* Copyright 2012 Texas Instruments
|
||
|
*
|
||
|
* Author: Milo(Woogyom) Kim <milo.kim@ti.com>
|
||
|
*
|
||
|
* This program is free software; you can redistribute it and/or modify
|
||
|
* it under the terms of the GNU General Public License version 2 as
|
||
|
* published by the Free Software Foundation.
|
||
|
*
|
||
|
*/
|
||
|
|
||
|
#include <linux/module.h>
|
||
|
#include <linux/slab.h>
|
||
|
#include <linux/err.h>
|
||
|
#include <linux/platform_device.h>
|
||
|
#include <linux/regulator/driver.h>
|
||
|
#include <linux/mfd/lp8788.h>
|
||
|
#include <linux/gpio.h>
|
||
|
|
||
|
/* register address */
|
||
|
#define LP8788_EN_BUCK 0x0C
|
||
|
#define LP8788_BUCK_DVS_SEL 0x1D
|
||
|
#define LP8788_BUCK1_VOUT0 0x1E
|
||
|
#define LP8788_BUCK1_VOUT1 0x1F
|
||
|
#define LP8788_BUCK1_VOUT2 0x20
|
||
|
#define LP8788_BUCK1_VOUT3 0x21
|
||
|
#define LP8788_BUCK2_VOUT0 0x22
|
||
|
#define LP8788_BUCK2_VOUT1 0x23
|
||
|
#define LP8788_BUCK2_VOUT2 0x24
|
||
|
#define LP8788_BUCK2_VOUT3 0x25
|
||
|
#define LP8788_BUCK3_VOUT 0x26
|
||
|
#define LP8788_BUCK4_VOUT 0x27
|
||
|
#define LP8788_BUCK1_TIMESTEP 0x28
|
||
|
#define LP8788_BUCK_PWM 0x2D
|
||
|
|
||
|
/* mask/shift bits */
|
||
|
#define LP8788_EN_BUCK1_M BIT(0) /* Addr 0Ch */
|
||
|
#define LP8788_EN_BUCK2_M BIT(1)
|
||
|
#define LP8788_EN_BUCK3_M BIT(2)
|
||
|
#define LP8788_EN_BUCK4_M BIT(3)
|
||
|
#define LP8788_BUCK1_DVS_SEL_M 0x04 /* Addr 1Dh */
|
||
|
#define LP8788_BUCK1_DVS_M 0x03
|
||
|
#define LP8788_BUCK1_DVS_S 0
|
||
|
#define LP8788_BUCK2_DVS_SEL_M 0x40
|
||
|
#define LP8788_BUCK2_DVS_M 0x30
|
||
|
#define LP8788_BUCK2_DVS_S 4
|
||
|
#define LP8788_BUCK1_DVS_I2C BIT(2)
|
||
|
#define LP8788_BUCK2_DVS_I2C BIT(6)
|
||
|
#define LP8788_BUCK1_DVS_PIN (0 << 2)
|
||
|
#define LP8788_BUCK2_DVS_PIN (0 << 6)
|
||
|
#define LP8788_VOUT_M 0x1F /* Addr 1Eh ~ 27h */
|
||
|
#define LP8788_STARTUP_TIME_M 0xF8 /* Addr 28h ~ 2Bh */
|
||
|
#define LP8788_STARTUP_TIME_S 3
|
||
|
#define LP8788_FPWM_BUCK1_M BIT(0) /* Addr 2Dh */
|
||
|
#define LP8788_FPWM_BUCK1_S 0
|
||
|
#define LP8788_FPWM_BUCK2_M BIT(1)
|
||
|
#define LP8788_FPWM_BUCK2_S 1
|
||
|
#define LP8788_FPWM_BUCK3_M BIT(2)
|
||
|
#define LP8788_FPWM_BUCK3_S 2
|
||
|
#define LP8788_FPWM_BUCK4_M BIT(3)
|
||
|
#define LP8788_FPWM_BUCK4_S 3
|
||
|
|
||
|
#define INVALID_ADDR 0xFF
|
||
|
#define LP8788_FORCE_PWM 1
|
||
|
#define LP8788_AUTO_PWM 0
|
||
|
#define PIN_LOW 0
|
||
|
#define PIN_HIGH 1
|
||
|
#define ENABLE_TIME_USEC 32
|
||
|
|
||
|
enum lp8788_dvs_state {
|
||
|
DVS_LOW = GPIOF_OUT_INIT_LOW,
|
||
|
DVS_HIGH = GPIOF_OUT_INIT_HIGH,
|
||
|
};
|
||
|
|
||
|
enum lp8788_dvs_mode {
|
||
|
REGISTER,
|
||
|
EXTPIN,
|
||
|
};
|
||
|
|
||
|
enum lp8788_buck_id {
|
||
|
BUCK1,
|
||
|
BUCK2,
|
||
|
BUCK3,
|
||
|
BUCK4,
|
||
|
};
|
||
|
|
||
|
struct lp8788_pwm_map {
|
||
|
u8 mask;
|
||
|
u8 shift;
|
||
|
};
|
||
|
|
||
|
struct lp8788_buck {
|
||
|
struct lp8788 *lp;
|
||
|
struct regulator_dev *regulator;
|
||
|
struct lp8788_pwm_map *pmap;
|
||
|
void *dvs;
|
||
|
};
|
||
|
|
||
|
/* BUCK 1 ~ 4 voltage table */
|
||
|
static const int lp8788_buck_vtbl[] = {
|
||
|
500000, 800000, 850000, 900000, 950000, 1000000, 1050000, 1100000,
|
||
|
1150000, 1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000,
|
||
|
1550000, 1600000, 1650000, 1700000, 1750000, 1800000, 1850000, 1900000,
|
||
|
1950000, 2000000,
|
||
|
};
|
||
|
|
||
|
/* buck pwm mode selection : used for set/get_mode in regulator ops
|
||
|
* @forced pwm : fast mode
|
||
|
* @auto pwm : normal mode
|
||
|
*/
|
||
|
static struct lp8788_pwm_map buck_pmap[] = {
|
||
|
[BUCK1] = {
|
||
|
.mask = LP8788_FPWM_BUCK1_M,
|
||
|
.shift = LP8788_FPWM_BUCK1_S,
|
||
|
},
|
||
|
[BUCK2] = {
|
||
|
.mask = LP8788_FPWM_BUCK2_M,
|
||
|
.shift = LP8788_FPWM_BUCK2_S,
|
||
|
},
|
||
|
[BUCK3] = {
|
||
|
.mask = LP8788_FPWM_BUCK3_M,
|
||
|
.shift = LP8788_FPWM_BUCK3_S,
|
||
|
},
|
||
|
[BUCK4] = {
|
||
|
.mask = LP8788_FPWM_BUCK4_M,
|
||
|
.shift = LP8788_FPWM_BUCK4_S,
|
||
|
},
|
||
|
};
|
||
|
|
||
|
static const u8 buck1_vout_addr[] = {
|
||
|
LP8788_BUCK1_VOUT0, LP8788_BUCK1_VOUT1,
|
||
|
LP8788_BUCK1_VOUT2, LP8788_BUCK1_VOUT3,
|
||
|
};
|
||
|
|
||
|
static const u8 buck2_vout_addr[] = {
|
||
|
LP8788_BUCK2_VOUT0, LP8788_BUCK2_VOUT1,
|
||
|
LP8788_BUCK2_VOUT2, LP8788_BUCK2_VOUT3,
|
||
|
};
|
||
|
|
||
|
static void lp8788_buck1_set_dvs(struct lp8788_buck *buck)
|
||
|
{
|
||
|
struct lp8788_buck1_dvs *dvs = (struct lp8788_buck1_dvs *)buck->dvs;
|
||
|
enum lp8788_dvs_state pinstate;
|
||
|
|
||
|
if (!dvs)
|
||
|
return;
|
||
|
|
||
|
pinstate = dvs->vsel == DVS_SEL_V0 ? DVS_LOW : DVS_HIGH;
|
||
|
if (gpio_is_valid(dvs->gpio))
|
||
|
gpio_set_value(dvs->gpio, pinstate);
|
||
|
}
|
||
|
|
||
|
static void lp8788_buck2_set_dvs(struct lp8788_buck *buck)
|
||
|
{
|
||
|
struct lp8788_buck2_dvs *dvs = (struct lp8788_buck2_dvs *)buck->dvs;
|
||
|
enum lp8788_dvs_state pin1, pin2;
|
||
|
|
||
|
if (!dvs)
|
||
|
return;
|
||
|
|
||
|
switch (dvs->vsel) {
|
||
|
case DVS_SEL_V0:
|
||
|
pin1 = DVS_LOW;
|
||
|
pin2 = DVS_LOW;
|
||
|
break;
|
||
|
case DVS_SEL_V1:
|
||
|
pin1 = DVS_HIGH;
|
||
|
pin2 = DVS_LOW;
|
||
|
break;
|
||
|
case DVS_SEL_V2:
|
||
|
pin1 = DVS_LOW;
|
||
|
pin2 = DVS_HIGH;
|
||
|
break;
|
||
|
case DVS_SEL_V3:
|
||
|
pin1 = DVS_HIGH;
|
||
|
pin2 = DVS_HIGH;
|
||
|
break;
|
||
|
default:
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
if (gpio_is_valid(dvs->gpio[0]))
|
||
|
gpio_set_value(dvs->gpio[0], pin1);
|
||
|
|
||
|
if (gpio_is_valid(dvs->gpio[1]))
|
||
|
gpio_set_value(dvs->gpio[1], pin2);
|
||
|
}
|
||
|
|
||
|
static void lp8788_set_dvs(struct lp8788_buck *buck, enum lp8788_buck_id id)
|
||
|
{
|
||
|
switch (id) {
|
||
|
case BUCK1:
|
||
|
lp8788_buck1_set_dvs(buck);
|
||
|
break;
|
||
|
case BUCK2:
|
||
|
lp8788_buck2_set_dvs(buck);
|
||
|
break;
|
||
|
default:
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
static enum lp8788_dvs_mode
|
||
|
lp8788_get_buck_dvs_ctrl_mode(struct lp8788_buck *buck, enum lp8788_buck_id id)
|
||
|
{
|
||
|
u8 val, mask;
|
||
|
|
||
|
switch (id) {
|
||
|
case BUCK1:
|
||
|
mask = LP8788_BUCK1_DVS_SEL_M;
|
||
|
break;
|
||
|
case BUCK2:
|
||
|
mask = LP8788_BUCK2_DVS_SEL_M;
|
||
|
break;
|
||
|
default:
|
||
|
return REGISTER;
|
||
|
}
|
||
|
|
||
|
lp8788_read_byte(buck->lp, LP8788_BUCK_DVS_SEL, &val);
|
||
|
|
||
|
return val & mask ? REGISTER : EXTPIN;
|
||
|
}
|
||
|
|
||
|
static bool lp8788_is_valid_buck_addr(u8 addr)
|
||
|
{
|
||
|
switch (addr) {
|
||
|
case LP8788_BUCK1_VOUT0:
|
||
|
case LP8788_BUCK1_VOUT1:
|
||
|
case LP8788_BUCK1_VOUT2:
|
||
|
case LP8788_BUCK1_VOUT3:
|
||
|
case LP8788_BUCK2_VOUT0:
|
||
|
case LP8788_BUCK2_VOUT1:
|
||
|
case LP8788_BUCK2_VOUT2:
|
||
|
case LP8788_BUCK2_VOUT3:
|
||
|
return true;
|
||
|
default:
|
||
|
return false;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
static u8 lp8788_select_buck_vout_addr(struct lp8788_buck *buck,
|
||
|
enum lp8788_buck_id id)
|
||
|
{
|
||
|
enum lp8788_dvs_mode mode = lp8788_get_buck_dvs_ctrl_mode(buck, id);
|
||
|
struct lp8788_buck1_dvs *b1_dvs;
|
||
|
struct lp8788_buck2_dvs *b2_dvs;
|
||
|
u8 val, idx, addr;
|
||
|
int pin1, pin2;
|
||
|
|
||
|
switch (id) {
|
||
|
case BUCK1:
|
||
|
if (mode == EXTPIN) {
|
||
|
b1_dvs = (struct lp8788_buck1_dvs *)buck->dvs;
|
||
|
if (!b1_dvs)
|
||
|
goto err;
|
||
|
|
||
|
idx = gpio_get_value(b1_dvs->gpio) ? 1 : 0;
|
||
|
} else {
|
||
|
lp8788_read_byte(buck->lp, LP8788_BUCK_DVS_SEL, &val);
|
||
|
idx = (val & LP8788_BUCK1_DVS_M) >> LP8788_BUCK1_DVS_S;
|
||
|
}
|
||
|
addr = buck1_vout_addr[idx];
|
||
|
break;
|
||
|
case BUCK2:
|
||
|
if (mode == EXTPIN) {
|
||
|
b2_dvs = (struct lp8788_buck2_dvs *)buck->dvs;
|
||
|
if (!b2_dvs)
|
||
|
goto err;
|
||
|
|
||
|
pin1 = gpio_get_value(b2_dvs->gpio[0]);
|
||
|
pin2 = gpio_get_value(b2_dvs->gpio[1]);
|
||
|
|
||
|
if (pin1 == PIN_LOW && pin2 == PIN_LOW)
|
||
|
idx = 0;
|
||
|
else if (pin1 == PIN_LOW && pin2 == PIN_HIGH)
|
||
|
idx = 2;
|
||
|
else if (pin1 == PIN_HIGH && pin2 == PIN_LOW)
|
||
|
idx = 1;
|
||
|
else
|
||
|
idx = 3;
|
||
|
} else {
|
||
|
lp8788_read_byte(buck->lp, LP8788_BUCK_DVS_SEL, &val);
|
||
|
idx = (val & LP8788_BUCK2_DVS_M) >> LP8788_BUCK2_DVS_S;
|
||
|
}
|
||
|
addr = buck2_vout_addr[idx];
|
||
|
break;
|
||
|
default:
|
||
|
goto err;
|
||
|
}
|
||
|
|
||
|
return addr;
|
||
|
err:
|
||
|
return INVALID_ADDR;
|
||
|
}
|
||
|
|
||
|
static int lp8788_buck12_set_voltage_sel(struct regulator_dev *rdev,
|
||
|
unsigned selector)
|
||
|
{
|
||
|
struct lp8788_buck *buck = rdev_get_drvdata(rdev);
|
||
|
enum lp8788_buck_id id = rdev_get_id(rdev);
|
||
|
u8 addr;
|
||
|
|
||
|
if (buck->dvs)
|
||
|
lp8788_set_dvs(buck, id);
|
||
|
|
||
|
addr = lp8788_select_buck_vout_addr(buck, id);
|
||
|
if (!lp8788_is_valid_buck_addr(addr))
|
||
|
return -EINVAL;
|
||
|
|
||
|
return lp8788_update_bits(buck->lp, addr, LP8788_VOUT_M, selector);
|
||
|
}
|
||
|
|
||
|
static int lp8788_buck12_get_voltage_sel(struct regulator_dev *rdev)
|
||
|
{
|
||
|
struct lp8788_buck *buck = rdev_get_drvdata(rdev);
|
||
|
enum lp8788_buck_id id = rdev_get_id(rdev);
|
||
|
int ret;
|
||
|
u8 val, addr;
|
||
|
|
||
|
addr = lp8788_select_buck_vout_addr(buck, id);
|
||
|
if (!lp8788_is_valid_buck_addr(addr))
|
||
|
return -EINVAL;
|
||
|
|
||
|
ret = lp8788_read_byte(buck->lp, addr, &val);
|
||
|
if (ret)
|
||
|
return ret;
|
||
|
|
||
|
return val & LP8788_VOUT_M;
|
||
|
}
|
||
|
|
||
|
static int lp8788_buck_enable_time(struct regulator_dev *rdev)
|
||
|
{
|
||
|
struct lp8788_buck *buck = rdev_get_drvdata(rdev);
|
||
|
enum lp8788_buck_id id = rdev_get_id(rdev);
|
||
|
u8 val, addr = LP8788_BUCK1_TIMESTEP + id;
|
||
|
|
||
|
if (lp8788_read_byte(buck->lp, addr, &val))
|
||
|
return -EINVAL;
|
||
|
|
||
|
val = (val & LP8788_STARTUP_TIME_M) >> LP8788_STARTUP_TIME_S;
|
||
|
|
||
|
return ENABLE_TIME_USEC * val;
|
||
|
}
|
||
|
|
||
|
static int lp8788_buck_set_mode(struct regulator_dev *rdev, unsigned int mode)
|
||
|
{
|
||
|
struct lp8788_buck *buck = rdev_get_drvdata(rdev);
|
||
|
struct lp8788_pwm_map *pmap = buck->pmap;
|
||
|
u8 val;
|
||
|
|
||
|
if (!pmap)
|
||
|
return -EINVAL;
|
||
|
|
||
|
switch (mode) {
|
||
|
case REGULATOR_MODE_FAST:
|
||
|
val = LP8788_FORCE_PWM << pmap->shift;
|
||
|
break;
|
||
|
case REGULATOR_MODE_NORMAL:
|
||
|
val = LP8788_AUTO_PWM << pmap->shift;
|
||
|
break;
|
||
|
default:
|
||
|
return -EINVAL;
|
||
|
}
|
||
|
|
||
|
return lp8788_update_bits(buck->lp, LP8788_BUCK_PWM, pmap->mask, val);
|
||
|
}
|
||
|
|
||
|
static unsigned int lp8788_buck_get_mode(struct regulator_dev *rdev)
|
||
|
{
|
||
|
struct lp8788_buck *buck = rdev_get_drvdata(rdev);
|
||
|
struct lp8788_pwm_map *pmap = buck->pmap;
|
||
|
u8 val;
|
||
|
int ret;
|
||
|
|
||
|
if (!pmap)
|
||
|
return -EINVAL;
|
||
|
|
||
|
ret = lp8788_read_byte(buck->lp, LP8788_BUCK_PWM, &val);
|
||
|
if (ret)
|
||
|
return ret;
|
||
|
|
||
|
return val & pmap->mask ? REGULATOR_MODE_FAST : REGULATOR_MODE_NORMAL;
|
||
|
}
|
||
|
|
||
|
static struct regulator_ops lp8788_buck12_ops = {
|
||
|
.list_voltage = regulator_list_voltage_table,
|
||
|
.set_voltage_sel = lp8788_buck12_set_voltage_sel,
|
||
|
.get_voltage_sel = lp8788_buck12_get_voltage_sel,
|
||
|
.enable = regulator_enable_regmap,
|
||
|
.disable = regulator_disable_regmap,
|
||
|
.is_enabled = regulator_is_enabled_regmap,
|
||
|
.enable_time = lp8788_buck_enable_time,
|
||
|
.set_mode = lp8788_buck_set_mode,
|
||
|
.get_mode = lp8788_buck_get_mode,
|
||
|
};
|
||
|
|
||
|
static struct regulator_ops lp8788_buck34_ops = {
|
||
|
.list_voltage = regulator_list_voltage_table,
|
||
|
.set_voltage_sel = regulator_set_voltage_sel_regmap,
|
||
|
.get_voltage_sel = regulator_get_voltage_sel_regmap,
|
||
|
.enable = regulator_enable_regmap,
|
||
|
.disable = regulator_disable_regmap,
|
||
|
.is_enabled = regulator_is_enabled_regmap,
|
||
|
.enable_time = lp8788_buck_enable_time,
|
||
|
.set_mode = lp8788_buck_set_mode,
|
||
|
.get_mode = lp8788_buck_get_mode,
|
||
|
};
|
||
|
|
||
|
static struct regulator_desc lp8788_buck_desc[] = {
|
||
|
{
|
||
|
.name = "buck1",
|
||
|
.id = BUCK1,
|
||
|
.ops = &lp8788_buck12_ops,
|
||
|
.n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
|
||
|
.volt_table = lp8788_buck_vtbl,
|
||
|
.type = REGULATOR_VOLTAGE,
|
||
|
.owner = THIS_MODULE,
|
||
|
.enable_reg = LP8788_EN_BUCK,
|
||
|
.enable_mask = LP8788_EN_BUCK1_M,
|
||
|
},
|
||
|
{
|
||
|
.name = "buck2",
|
||
|
.id = BUCK2,
|
||
|
.ops = &lp8788_buck12_ops,
|
||
|
.n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
|
||
|
.volt_table = lp8788_buck_vtbl,
|
||
|
.type = REGULATOR_VOLTAGE,
|
||
|
.owner = THIS_MODULE,
|
||
|
.enable_reg = LP8788_EN_BUCK,
|
||
|
.enable_mask = LP8788_EN_BUCK2_M,
|
||
|
},
|
||
|
{
|
||
|
.name = "buck3",
|
||
|
.id = BUCK3,
|
||
|
.ops = &lp8788_buck34_ops,
|
||
|
.n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
|
||
|
.volt_table = lp8788_buck_vtbl,
|
||
|
.type = REGULATOR_VOLTAGE,
|
||
|
.owner = THIS_MODULE,
|
||
|
.vsel_reg = LP8788_BUCK3_VOUT,
|
||
|
.vsel_mask = LP8788_VOUT_M,
|
||
|
.enable_reg = LP8788_EN_BUCK,
|
||
|
.enable_mask = LP8788_EN_BUCK3_M,
|
||
|
},
|
||
|
{
|
||
|
.name = "buck4",
|
||
|
.id = BUCK4,
|
||
|
.ops = &lp8788_buck34_ops,
|
||
|
.n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
|
||
|
.volt_table = lp8788_buck_vtbl,
|
||
|
.type = REGULATOR_VOLTAGE,
|
||
|
.owner = THIS_MODULE,
|
||
|
.vsel_reg = LP8788_BUCK4_VOUT,
|
||
|
.vsel_mask = LP8788_VOUT_M,
|
||
|
.enable_reg = LP8788_EN_BUCK,
|
||
|
.enable_mask = LP8788_EN_BUCK4_M,
|
||
|
},
|
||
|
};
|
||
|
|
||
|
static int lp8788_set_default_dvs_ctrl_mode(struct lp8788 *lp,
|
||
|
enum lp8788_buck_id id)
|
||
|
{
|
||
|
u8 mask, val;
|
||
|
|
||
|
switch (id) {
|
||
|
case BUCK1:
|
||
|
mask = LP8788_BUCK1_DVS_SEL_M;
|
||
|
val = LP8788_BUCK1_DVS_I2C;
|
||
|
break;
|
||
|
case BUCK2:
|
||
|
mask = LP8788_BUCK2_DVS_SEL_M;
|
||
|
val = LP8788_BUCK2_DVS_I2C;
|
||
|
break;
|
||
|
default:
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
return lp8788_update_bits(lp, LP8788_BUCK_DVS_SEL, mask, val);
|
||
|
}
|
||
|
|
||
|
static int _gpio_request(struct lp8788_buck *buck, int gpio, char *name)
|
||
|
{
|
||
|
struct device *dev = buck->lp->dev;
|
||
|
|
||
|
if (!gpio_is_valid(gpio)) {
|
||
|
dev_err(dev, "invalid gpio: %d\n", gpio);
|
||
|
return -EINVAL;
|
||
|
}
|
||
|
|
||
|
return devm_gpio_request_one(dev, gpio, DVS_LOW, name);
|
||
|
}
|
||
|
|
||
|
static int lp8788_dvs_gpio_request(struct lp8788_buck *buck,
|
||
|
enum lp8788_buck_id id)
|
||
|
{
|
||
|
struct lp8788_platform_data *pdata = buck->lp->pdata;
|
||
|
char *b1_name = "LP8788_B1_DVS";
|
||
|
char *b2_name[] = { "LP8788_B2_DVS1", "LP8788_B2_DVS2" };
|
||
|
int i, gpio, ret;
|
||
|
|
||
|
switch (id) {
|
||
|
case BUCK1:
|
||
|
gpio = pdata->buck1_dvs->gpio;
|
||
|
ret = _gpio_request(buck, gpio, b1_name);
|
||
|
if (ret)
|
||
|
return ret;
|
||
|
|
||
|
buck->dvs = pdata->buck1_dvs;
|
||
|
break;
|
||
|
case BUCK2:
|
||
|
for (i = 0 ; i < LP8788_NUM_BUCK2_DVS ; i++) {
|
||
|
gpio = pdata->buck2_dvs->gpio[i];
|
||
|
ret = _gpio_request(buck, gpio, b2_name[i]);
|
||
|
if (ret)
|
||
|
return ret;
|
||
|
}
|
||
|
buck->dvs = pdata->buck2_dvs;
|
||
|
break;
|
||
|
default:
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
static int lp8788_init_dvs(struct lp8788_buck *buck, enum lp8788_buck_id id)
|
||
|
{
|
||
|
struct lp8788_platform_data *pdata = buck->lp->pdata;
|
||
|
u8 mask[] = { LP8788_BUCK1_DVS_SEL_M, LP8788_BUCK2_DVS_SEL_M };
|
||
|
u8 val[] = { LP8788_BUCK1_DVS_PIN, LP8788_BUCK2_DVS_PIN };
|
||
|
|
||
|
/* no dvs for buck3, 4 */
|
||
|
if (id == BUCK3 || id == BUCK4)
|
||
|
return 0;
|
||
|
|
||
|
/* no dvs platform data, then dvs will be selected by I2C registers */
|
||
|
if (!pdata)
|
||
|
goto set_default_dvs_mode;
|
||
|
|
||
|
if ((id == BUCK1 && !pdata->buck1_dvs) ||
|
||
|
(id == BUCK2 && !pdata->buck2_dvs))
|
||
|
goto set_default_dvs_mode;
|
||
|
|
||
|
if (lp8788_dvs_gpio_request(buck, id))
|
||
|
goto set_default_dvs_mode;
|
||
|
|
||
|
return lp8788_update_bits(buck->lp, LP8788_BUCK_DVS_SEL, mask[id],
|
||
|
val[id]);
|
||
|
|
||
|
set_default_dvs_mode:
|
||
|
return lp8788_set_default_dvs_ctrl_mode(buck->lp, id);
|
||
|
}
|
||
|
|
||
|
static __devinit int lp8788_buck_probe(struct platform_device *pdev)
|
||
|
{
|
||
|
struct lp8788 *lp = dev_get_drvdata(pdev->dev.parent);
|
||
|
int id = pdev->id;
|
||
|
struct lp8788_buck *buck;
|
||
|
struct regulator_config cfg = { };
|
||
|
struct regulator_dev *rdev;
|
||
|
int ret;
|
||
|
|
||
|
buck = devm_kzalloc(lp->dev, sizeof(struct lp8788_buck), GFP_KERNEL);
|
||
|
if (!buck)
|
||
|
return -ENOMEM;
|
||
|
|
||
|
buck->lp = lp;
|
||
|
buck->pmap = &buck_pmap[id];
|
||
|
|
||
|
ret = lp8788_init_dvs(buck, id);
|
||
|
if (ret)
|
||
|
return ret;
|
||
|
|
||
|
cfg.dev = lp->dev;
|
||
|
cfg.init_data = lp->pdata ? lp->pdata->buck_data[id] : NULL;
|
||
|
cfg.driver_data = buck;
|
||
|
cfg.regmap = lp->regmap;
|
||
|
|
||
|
rdev = regulator_register(&lp8788_buck_desc[id], &cfg);
|
||
|
if (IS_ERR(rdev)) {
|
||
|
ret = PTR_ERR(rdev);
|
||
|
dev_err(lp->dev, "BUCK%d regulator register err = %d\n",
|
||
|
id + 1, ret);
|
||
|
return ret;
|
||
|
}
|
||
|
|
||
|
buck->regulator = rdev;
|
||
|
platform_set_drvdata(pdev, buck);
|
||
|
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
static int __devexit lp8788_buck_remove(struct platform_device *pdev)
|
||
|
{
|
||
|
struct lp8788_buck *buck = platform_get_drvdata(pdev);
|
||
|
|
||
|
platform_set_drvdata(pdev, NULL);
|
||
|
regulator_unregister(buck->regulator);
|
||
|
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
static struct platform_driver lp8788_buck_driver = {
|
||
|
.probe = lp8788_buck_probe,
|
||
|
.remove = __devexit_p(lp8788_buck_remove),
|
||
|
.driver = {
|
||
|
.name = LP8788_DEV_BUCK,
|
||
|
.owner = THIS_MODULE,
|
||
|
},
|
||
|
};
|
||
|
|
||
|
static int __init lp8788_buck_init(void)
|
||
|
{
|
||
|
return platform_driver_register(&lp8788_buck_driver);
|
||
|
}
|
||
|
subsys_initcall(lp8788_buck_init);
|
||
|
|
||
|
static void __exit lp8788_buck_exit(void)
|
||
|
{
|
||
|
platform_driver_unregister(&lp8788_buck_driver);
|
||
|
}
|
||
|
module_exit(lp8788_buck_exit);
|
||
|
|
||
|
MODULE_DESCRIPTION("TI LP8788 BUCK Driver");
|
||
|
MODULE_AUTHOR("Milo Kim");
|
||
|
MODULE_LICENSE("GPL");
|
||
|
MODULE_ALIAS("platform:lp8788-buck");
|