| /* |
| * Device driver for regulators in Hi6421 IC |
| * |
| * Copyright (c) <2011-2014> HiSilicon Technologies Co., Ltd. |
| * http://www.hisilicon.com |
| * Copyright (c) <2013-2014> Linaro Ltd. |
| * http://www.linaro.org |
| * |
| * Author: Guodong Xu <guodong.xu@linaro.org> |
| * |
| * 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/slab.h> |
| #include <linux/device.h> |
| #include <linux/module.h> |
| #include <linux/err.h> |
| #include <linux/platform_device.h> |
| #include <linux/of.h> |
| #include <linux/regmap.h> |
| #include <linux/regulator/driver.h> |
| #include <linux/regulator/machine.h> |
| #include <linux/regulator/of_regulator.h> |
| #include <linux/mfd/hi6421-pmic.h> |
| |
| /* |
| * struct hi6421_regulator_pdata - Hi6421 regulator data of platform device |
| * @lock: mutex to serialize regulator enable |
| */ |
| struct hi6421_regulator_pdata { |
| struct mutex lock; |
| }; |
| |
| /* |
| * struct hi6421_regulator_info - hi6421 regulator information |
| * @desc: regulator description |
| * @mode_mask: ECO mode bitmask of LDOs; for BUCKs, this masks sleep |
| * @eco_microamp: eco mode load upper limit (in uA), valid for LDOs only |
| */ |
| struct hi6421_regulator_info { |
| struct regulator_desc desc; |
| u8 mode_mask; |
| u32 eco_microamp; |
| }; |
| |
| /* HI6421 regulators */ |
| enum hi6421_regulator_id { |
| HI6421_LDO0, |
| HI6421_LDO1, |
| HI6421_LDO2, |
| HI6421_LDO3, |
| HI6421_LDO4, |
| HI6421_LDO5, |
| HI6421_LDO6, |
| HI6421_LDO7, |
| HI6421_LDO8, |
| HI6421_LDO9, |
| HI6421_LDO10, |
| HI6421_LDO11, |
| HI6421_LDO12, |
| HI6421_LDO13, |
| HI6421_LDO14, |
| HI6421_LDO15, |
| HI6421_LDO16, |
| HI6421_LDO17, |
| HI6421_LDO18, |
| HI6421_LDO19, |
| HI6421_LDO20, |
| HI6421_LDOAUDIO, |
| HI6421_BUCK0, |
| HI6421_BUCK1, |
| HI6421_BUCK2, |
| HI6421_BUCK3, |
| HI6421_BUCK4, |
| HI6421_BUCK5, |
| HI6421_NUM_REGULATORS, |
| }; |
| |
| #define HI6421_REGULATOR_OF_MATCH(_name, id) \ |
| { \ |
| .name = #_name, \ |
| .driver_data = (void *) HI6421_##id, \ |
| } |
| |
| static struct of_regulator_match hi6421_regulator_match[] = { |
| HI6421_REGULATOR_OF_MATCH(hi6421_vout0, LDO0), |
| HI6421_REGULATOR_OF_MATCH(hi6421_vout1, LDO1), |
| HI6421_REGULATOR_OF_MATCH(hi6421_vout2, LDO2), |
| HI6421_REGULATOR_OF_MATCH(hi6421_vout3, LDO3), |
| HI6421_REGULATOR_OF_MATCH(hi6421_vout4, LDO4), |
| HI6421_REGULATOR_OF_MATCH(hi6421_vout5, LDO5), |
| HI6421_REGULATOR_OF_MATCH(hi6421_vout6, LDO6), |
| HI6421_REGULATOR_OF_MATCH(hi6421_vout7, LDO7), |
| HI6421_REGULATOR_OF_MATCH(hi6421_vout8, LDO8), |
| HI6421_REGULATOR_OF_MATCH(hi6421_vout9, LDO9), |
| HI6421_REGULATOR_OF_MATCH(hi6421_vout10, LDO10), |
| HI6421_REGULATOR_OF_MATCH(hi6421_vout11, LDO11), |
| HI6421_REGULATOR_OF_MATCH(hi6421_vout12, LDO12), |
| HI6421_REGULATOR_OF_MATCH(hi6421_vout13, LDO13), |
| HI6421_REGULATOR_OF_MATCH(hi6421_vout14, LDO14), |
| HI6421_REGULATOR_OF_MATCH(hi6421_vout15, LDO15), |
| HI6421_REGULATOR_OF_MATCH(hi6421_vout16, LDO16), |
| HI6421_REGULATOR_OF_MATCH(hi6421_vout17, LDO17), |
| HI6421_REGULATOR_OF_MATCH(hi6421_vout18, LDO18), |
| HI6421_REGULATOR_OF_MATCH(hi6421_vout19, LDO19), |
| HI6421_REGULATOR_OF_MATCH(hi6421_vout20, LDO20), |
| HI6421_REGULATOR_OF_MATCH(hi6421_vout_audio, LDOAUDIO), |
| HI6421_REGULATOR_OF_MATCH(hi6421_buck0, BUCK0), |
| HI6421_REGULATOR_OF_MATCH(hi6421_buck1, BUCK1), |
| HI6421_REGULATOR_OF_MATCH(hi6421_buck2, BUCK2), |
| HI6421_REGULATOR_OF_MATCH(hi6421_buck3, BUCK3), |
| HI6421_REGULATOR_OF_MATCH(hi6421_buck4, BUCK4), |
| HI6421_REGULATOR_OF_MATCH(hi6421_buck5, BUCK5), |
| }; |
| |
| /* LDO 0, 4~7, 9~14, 16~20 have same voltage table. */ |
| static const unsigned int ldo_0_voltages[] = { |
| 1500000, 1800000, 2400000, 2500000, |
| 2600000, 2700000, 2850000, 3000000, |
| }; |
| |
| /* LDO 8, 15 have same voltage table. */ |
| static const unsigned int ldo_8_voltages[] = { |
| 1500000, 1800000, 2400000, 2600000, |
| 2700000, 2850000, 3000000, 3300000, |
| }; |
| |
| /* Ranges are sorted in ascending order. */ |
| static const struct regulator_linear_range ldo_audio_volt_range[] = { |
| REGULATOR_LINEAR_RANGE(2800000, 0, 3, 50000), |
| REGULATOR_LINEAR_RANGE(3000000, 4, 7, 100000), |
| }; |
| |
| static const unsigned int buck_3_voltages[] = { |
| 950000, 1050000, 1100000, 1117000, |
| 1134000, 1150000, 1167000, 1200000, |
| }; |
| |
| static const unsigned int buck_4_voltages[] = { |
| 1150000, 1200000, 1250000, 1350000, |
| 1700000, 1800000, 1900000, 2000000, |
| }; |
| |
| static const unsigned int buck_5_voltages[] = { |
| 1150000, 1200000, 1250000, 1350000, |
| 1600000, 1700000, 1800000, 1900000, |
| }; |
| |
| static const struct regulator_ops hi6421_ldo_ops; |
| static const struct regulator_ops hi6421_ldo_linear_ops; |
| static const struct regulator_ops hi6421_ldo_linear_range_ops; |
| static const struct regulator_ops hi6421_buck012_ops; |
| static const struct regulator_ops hi6421_buck345_ops; |
| |
| #define HI6421_LDO_ENABLE_TIME (350) |
| /* |
| * _id - LDO id name string |
| * v_table - voltage table |
| * vreg - voltage select register |
| * vmask - voltage select mask |
| * ereg - enable register |
| * emask - enable mask |
| * odelay - off/on delay time in uS |
| * ecomask - eco mode mask |
| * ecoamp - eco mode load uppler limit in uA |
| */ |
| #define HI6421_LDO(_id, v_table, vreg, vmask, ereg, emask, \ |
| odelay, ecomask, ecoamp) \ |
| [HI6421_##_id] = { \ |
| .desc = { \ |
| .name = #_id, \ |
| .ops = &hi6421_ldo_ops, \ |
| .type = REGULATOR_VOLTAGE, \ |
| .id = HI6421_##_id, \ |
| .owner = THIS_MODULE, \ |
| .n_voltages = ARRAY_SIZE(v_table), \ |
| .volt_table = v_table, \ |
| .vsel_reg = HI6421_REG_TO_BUS_ADDR(vreg), \ |
| .vsel_mask = vmask, \ |
| .enable_reg = HI6421_REG_TO_BUS_ADDR(ereg), \ |
| .enable_mask = emask, \ |
| .enable_time = HI6421_LDO_ENABLE_TIME, \ |
| .off_on_delay = odelay, \ |
| }, \ |
| .mode_mask = ecomask, \ |
| .eco_microamp = ecoamp, \ |
| } |
| |
| /* HI6421 LDO1~3 are linear voltage regulators at fixed uV_step |
| * |
| * _id - LDO id name string |
| * _min_uV - minimum voltage supported in uV |
| * n_volt - number of votages available |
| * vstep - voltage increase in each linear step in uV |
| * vreg - voltage select register |
| * vmask - voltage select mask |
| * ereg - enable register |
| * emask - enable mask |
| * odelay - off/on delay time in uS |
| * ecomask - eco mode mask |
| * ecoamp - eco mode load uppler limit in uA |
| */ |
| #define HI6421_LDO_LINEAR(_id, _min_uV, n_volt, vstep, vreg, vmask, \ |
| ereg, emask, odelay, ecomask, ecoamp) \ |
| [HI6421_##_id] = { \ |
| .desc = { \ |
| .name = #_id, \ |
| .ops = &hi6421_ldo_linear_ops, \ |
| .type = REGULATOR_VOLTAGE, \ |
| .id = HI6421_##_id, \ |
| .owner = THIS_MODULE, \ |
| .min_uV = _min_uV, \ |
| .n_voltages = n_volt, \ |
| .uV_step = vstep, \ |
| .vsel_reg = HI6421_REG_TO_BUS_ADDR(vreg), \ |
| .vsel_mask = vmask, \ |
| .enable_reg = HI6421_REG_TO_BUS_ADDR(ereg), \ |
| .enable_mask = emask, \ |
| .enable_time = HI6421_LDO_ENABLE_TIME, \ |
| .off_on_delay = odelay, \ |
| }, \ |
| .mode_mask = ecomask, \ |
| .eco_microamp = ecoamp, \ |
| } |
| |
| /* HI6421 LDOAUDIO is a linear voltage regulator with two 4-step ranges |
| * |
| * _id - LDO id name string |
| * n_volt - number of votages available |
| * volt_ranges - array of regulator_linear_range |
| * vstep - voltage increase in each linear step in uV |
| * vreg - voltage select register |
| * vmask - voltage select mask |
| * ereg - enable register |
| * emask - enable mask |
| * odelay - off/on delay time in uS |
| * ecomask - eco mode mask |
| * ecoamp - eco mode load uppler limit in uA |
| */ |
| #define HI6421_LDO_LINEAR_RANGE(_id, n_volt, volt_ranges, vreg, vmask, \ |
| ereg, emask, odelay, ecomask, ecoamp) \ |
| [HI6421_##_id] = { \ |
| .desc = { \ |
| .name = #_id, \ |
| .ops = &hi6421_ldo_linear_range_ops, \ |
| .type = REGULATOR_VOLTAGE, \ |
| .id = HI6421_##_id, \ |
| .owner = THIS_MODULE, \ |
| .n_voltages = n_volt, \ |
| .linear_ranges = volt_ranges, \ |
| .n_linear_ranges = ARRAY_SIZE(volt_ranges), \ |
| .vsel_reg = HI6421_REG_TO_BUS_ADDR(vreg), \ |
| .vsel_mask = vmask, \ |
| .enable_reg = HI6421_REG_TO_BUS_ADDR(ereg), \ |
| .enable_mask = emask, \ |
| .enable_time = HI6421_LDO_ENABLE_TIME, \ |
| .off_on_delay = odelay, \ |
| }, \ |
| .mode_mask = ecomask, \ |
| .eco_microamp = ecoamp, \ |
| } |
| |
| /* HI6421 BUCK0/1/2 are linear voltage regulators at fixed uV_step |
| * |
| * _id - BUCK0/1/2 id name string |
| * vreg - voltage select register |
| * vmask - voltage select mask |
| * ereg - enable register |
| * emask - enable mask |
| * sleepmask - mask of sleep mode |
| * etime - enable time |
| * odelay - off/on delay time in uS |
| */ |
| #define HI6421_BUCK012(_id, vreg, vmask, ereg, emask, sleepmask, \ |
| etime, odelay) \ |
| [HI6421_##_id] = { \ |
| .desc = { \ |
| .name = #_id, \ |
| .ops = &hi6421_buck012_ops, \ |
| .type = REGULATOR_VOLTAGE, \ |
| .id = HI6421_##_id, \ |
| .owner = THIS_MODULE, \ |
| .min_uV = 700000, \ |
| .n_voltages = 128, \ |
| .uV_step = 7086, \ |
| .vsel_reg = HI6421_REG_TO_BUS_ADDR(vreg), \ |
| .vsel_mask = vmask, \ |
| .enable_reg = HI6421_REG_TO_BUS_ADDR(ereg), \ |
| .enable_mask = emask, \ |
| .enable_time = etime, \ |
| .off_on_delay = odelay, \ |
| }, \ |
| .mode_mask = sleepmask, \ |
| } |
| |
| /* HI6421 BUCK3/4/5 share similar configurations as LDOs, with exception |
| * that it supports SLEEP mode, so has different .ops. |
| * |
| * _id - LDO id name string |
| * v_table - voltage table |
| * vreg - voltage select register |
| * vmask - voltage select mask |
| * ereg - enable register |
| * emask - enable mask |
| * odelay - off/on delay time in uS |
| * sleepmask - mask of sleep mode |
| */ |
| #define HI6421_BUCK345(_id, v_table, vreg, vmask, ereg, emask, \ |
| odelay, sleepmask) \ |
| [HI6421_##_id] = { \ |
| .desc = { \ |
| .name = #_id, \ |
| .ops = &hi6421_buck345_ops, \ |
| .type = REGULATOR_VOLTAGE, \ |
| .id = HI6421_##_id, \ |
| .owner = THIS_MODULE, \ |
| .n_voltages = ARRAY_SIZE(v_table), \ |
| .volt_table = v_table, \ |
| .vsel_reg = HI6421_REG_TO_BUS_ADDR(vreg), \ |
| .vsel_mask = vmask, \ |
| .enable_reg = HI6421_REG_TO_BUS_ADDR(ereg), \ |
| .enable_mask = emask, \ |
| .enable_time = HI6421_LDO_ENABLE_TIME, \ |
| .off_on_delay = odelay, \ |
| }, \ |
| .mode_mask = sleepmask, \ |
| } |
| |
| /* HI6421 regulator information */ |
| static struct hi6421_regulator_info |
| hi6421_regulator_info[HI6421_NUM_REGULATORS] = { |
| HI6421_LDO(LDO0, ldo_0_voltages, 0x20, 0x07, 0x20, 0x10, |
| 10000, 0x20, 8000), |
| HI6421_LDO_LINEAR(LDO1, 1700000, 4, 100000, 0x21, 0x03, 0x21, 0x10, |
| 10000, 0x20, 5000), |
| HI6421_LDO_LINEAR(LDO2, 1050000, 8, 50000, 0x22, 0x07, 0x22, 0x10, |
| 20000, 0x20, 8000), |
| HI6421_LDO_LINEAR(LDO3, 1050000, 8, 50000, 0x23, 0x07, 0x23, 0x10, |
| 20000, 0x20, 8000), |
| HI6421_LDO(LDO4, ldo_0_voltages, 0x24, 0x07, 0x24, 0x10, |
| 20000, 0x20, 8000), |
| HI6421_LDO(LDO5, ldo_0_voltages, 0x25, 0x07, 0x25, 0x10, |
| 20000, 0x20, 8000), |
| HI6421_LDO(LDO6, ldo_0_voltages, 0x26, 0x07, 0x26, 0x10, |
| 20000, 0x20, 8000), |
| HI6421_LDO(LDO7, ldo_0_voltages, 0x27, 0x07, 0x27, 0x10, |
| 20000, 0x20, 5000), |
| HI6421_LDO(LDO8, ldo_8_voltages, 0x28, 0x07, 0x28, 0x10, |
| 20000, 0x20, 8000), |
| HI6421_LDO(LDO9, ldo_0_voltages, 0x29, 0x07, 0x29, 0x10, |
| 40000, 0x20, 8000), |
| HI6421_LDO(LDO10, ldo_0_voltages, 0x2a, 0x07, 0x2a, 0x10, |
| 40000, 0x20, 8000), |
| HI6421_LDO(LDO11, ldo_0_voltages, 0x2b, 0x07, 0x2b, 0x10, |
| 40000, 0x20, 8000), |
| HI6421_LDO(LDO12, ldo_0_voltages, 0x2c, 0x07, 0x2c, 0x10, |
| 40000, 0x20, 8000), |
| HI6421_LDO(LDO13, ldo_0_voltages, 0x2d, 0x07, 0x2d, 0x10, |
| 40000, 0x20, 8000), |
| HI6421_LDO(LDO14, ldo_0_voltages, 0x2e, 0x07, 0x2e, 0x10, |
| 40000, 0x20, 8000), |
| HI6421_LDO(LDO15, ldo_8_voltages, 0x2f, 0x07, 0x2f, 0x10, |
| 40000, 0x20, 8000), |
| HI6421_LDO(LDO16, ldo_0_voltages, 0x30, 0x07, 0x30, 0x10, |
| 40000, 0x20, 8000), |
| HI6421_LDO(LDO17, ldo_0_voltages, 0x31, 0x07, 0x31, 0x10, |
| 40000, 0x20, 8000), |
| HI6421_LDO(LDO18, ldo_0_voltages, 0x32, 0x07, 0x32, 0x10, |
| 40000, 0x20, 8000), |
| HI6421_LDO(LDO19, ldo_0_voltages, 0x33, 0x07, 0x33, 0x10, |
| 40000, 0x20, 8000), |
| HI6421_LDO(LDO20, ldo_0_voltages, 0x34, 0x07, 0x34, 0x10, |
| 40000, 0x20, 8000), |
| HI6421_LDO_LINEAR_RANGE(LDOAUDIO, 8, ldo_audio_volt_range, 0x36, |
| 0x70, 0x36, 0x01, 40000, 0x02, 5000), |
| HI6421_BUCK012(BUCK0, 0x0d, 0x7f, 0x0c, 0x01, 0x10, 400, 20000), |
| HI6421_BUCK012(BUCK1, 0x0f, 0x7f, 0x0e, 0x01, 0x10, 400, 20000), |
| HI6421_BUCK012(BUCK2, 0x11, 0x7f, 0x10, 0x01, 0x10, 350, 100), |
| HI6421_BUCK345(BUCK3, buck_3_voltages, 0x13, 0x07, 0x12, 0x01, |
| 20000, 0x10), |
| HI6421_BUCK345(BUCK4, buck_4_voltages, 0x15, 0x07, 0x14, 0x01, |
| 20000, 0x10), |
| HI6421_BUCK345(BUCK5, buck_5_voltages, 0x17, 0x07, 0x16, 0x01, |
| 20000, 0x10), |
| }; |
| |
| static int hi6421_regulator_enable(struct regulator_dev *rdev) |
| { |
| struct hi6421_regulator_pdata *pdata; |
| |
| pdata = dev_get_drvdata(rdev->dev.parent); |
| /* hi6421 spec requires regulator enablement must be serialized: |
| * - Because when BUCK, LDO switching from off to on, it will have |
| * a huge instantaneous current; so you can not turn on two or |
| * more LDO or BUCKs simultaneously, or it may burn the chip. |
| */ |
| mutex_lock(&pdata->lock); |
| |
| /* call regulator regmap helper */ |
| regulator_enable_regmap(rdev); |
| |
| mutex_unlock(&pdata->lock); |
| return 0; |
| } |
| |
| static unsigned int hi6421_regulator_ldo_get_mode(struct regulator_dev *rdev) |
| { |
| struct hi6421_regulator_info *info = rdev_get_drvdata(rdev); |
| u32 reg_val; |
| |
| regmap_read(rdev->regmap, rdev->desc->enable_reg, ®_val); |
| if (reg_val & info->mode_mask) |
| return REGULATOR_MODE_IDLE; |
| |
| return REGULATOR_MODE_NORMAL; |
| } |
| |
| static unsigned int hi6421_regulator_buck_get_mode(struct regulator_dev *rdev) |
| { |
| struct hi6421_regulator_info *info = rdev_get_drvdata(rdev); |
| u32 reg_val; |
| |
| regmap_read(rdev->regmap, rdev->desc->enable_reg, ®_val); |
| if (reg_val & info->mode_mask) |
| return REGULATOR_MODE_STANDBY; |
| |
| return REGULATOR_MODE_NORMAL; |
| } |
| |
| static int hi6421_regulator_ldo_set_mode(struct regulator_dev *rdev, |
| unsigned int mode) |
| { |
| struct hi6421_regulator_info *info = rdev_get_drvdata(rdev); |
| u32 new_mode; |
| |
| switch (mode) { |
| case REGULATOR_MODE_NORMAL: |
| new_mode = 0; |
| break; |
| case REGULATOR_MODE_IDLE: |
| new_mode = info->mode_mask; |
| break; |
| default: |
| return -EINVAL; |
| } |
| |
| /* set mode */ |
| regmap_update_bits(rdev->regmap, rdev->desc->enable_reg, |
| info->mode_mask, new_mode); |
| |
| return 0; |
| } |
| |
| static int hi6421_regulator_buck_set_mode(struct regulator_dev *rdev, |
| unsigned int mode) |
| { |
| struct hi6421_regulator_info *info = rdev_get_drvdata(rdev); |
| u32 new_mode; |
| |
| switch (mode) { |
| case REGULATOR_MODE_NORMAL: |
| new_mode = 0; |
| break; |
| case REGULATOR_MODE_STANDBY: |
| new_mode = info->mode_mask; |
| break; |
| default: |
| return -EINVAL; |
| } |
| |
| /* set mode */ |
| regmap_update_bits(rdev->regmap, rdev->desc->enable_reg, |
| info->mode_mask, new_mode); |
| |
| return 0; |
| } |
| |
| static unsigned int |
| hi6421_regulator_ldo_get_optimum_mode(struct regulator_dev *rdev, |
| int input_uV, int output_uV, int load_uA) |
| { |
| struct hi6421_regulator_info *info = rdev_get_drvdata(rdev); |
| |
| if (load_uA > info->eco_microamp) |
| return REGULATOR_MODE_NORMAL; |
| |
| return REGULATOR_MODE_IDLE; |
| } |
| |
| static const struct regulator_ops hi6421_ldo_ops = { |
| .is_enabled = regulator_is_enabled_regmap, |
| .enable = hi6421_regulator_enable, |
| .disable = regulator_disable_regmap, |
| .list_voltage = regulator_list_voltage_table, |
| .map_voltage = regulator_map_voltage_ascend, |
| .get_voltage_sel = regulator_get_voltage_sel_regmap, |
| .set_voltage_sel = regulator_set_voltage_sel_regmap, |
| .get_mode = hi6421_regulator_ldo_get_mode, |
| .set_mode = hi6421_regulator_ldo_set_mode, |
| .get_optimum_mode = hi6421_regulator_ldo_get_optimum_mode, |
| }; |
| |
| static const struct regulator_ops hi6421_ldo_linear_ops = { |
| .is_enabled = regulator_is_enabled_regmap, |
| .enable = hi6421_regulator_enable, |
| .disable = regulator_disable_regmap, |
| .list_voltage = regulator_list_voltage_linear, |
| .map_voltage = regulator_map_voltage_linear, |
| .get_voltage_sel = regulator_get_voltage_sel_regmap, |
| .set_voltage_sel = regulator_set_voltage_sel_regmap, |
| .get_mode = hi6421_regulator_ldo_get_mode, |
| .set_mode = hi6421_regulator_ldo_set_mode, |
| .get_optimum_mode = hi6421_regulator_ldo_get_optimum_mode, |
| }; |
| |
| static const struct regulator_ops hi6421_ldo_linear_range_ops = { |
| .is_enabled = regulator_is_enabled_regmap, |
| .enable = hi6421_regulator_enable, |
| .disable = regulator_disable_regmap, |
| .list_voltage = regulator_list_voltage_linear_range, |
| .map_voltage = regulator_map_voltage_linear_range, |
| .get_voltage_sel = regulator_get_voltage_sel_regmap, |
| .set_voltage_sel = regulator_set_voltage_sel_regmap, |
| .get_mode = hi6421_regulator_ldo_get_mode, |
| .set_mode = hi6421_regulator_ldo_set_mode, |
| .get_optimum_mode = hi6421_regulator_ldo_get_optimum_mode, |
| }; |
| |
| static const struct regulator_ops hi6421_buck012_ops = { |
| .is_enabled = regulator_is_enabled_regmap, |
| .enable = hi6421_regulator_enable, |
| .disable = regulator_disable_regmap, |
| .list_voltage = regulator_list_voltage_linear, |
| .map_voltage = regulator_map_voltage_linear, |
| .get_voltage_sel = regulator_get_voltage_sel_regmap, |
| .set_voltage_sel = regulator_set_voltage_sel_regmap, |
| .get_mode = hi6421_regulator_buck_get_mode, |
| .set_mode = hi6421_regulator_buck_set_mode, |
| }; |
| |
| static const struct regulator_ops hi6421_buck345_ops = { |
| .is_enabled = regulator_is_enabled_regmap, |
| .enable = hi6421_regulator_enable, |
| .disable = regulator_disable_regmap, |
| .list_voltage = regulator_list_voltage_table, |
| .map_voltage = regulator_map_voltage_ascend, |
| .get_voltage_sel = regulator_get_voltage_sel_regmap, |
| .set_voltage_sel = regulator_set_voltage_sel_regmap, |
| .get_mode = hi6421_regulator_buck_get_mode, |
| .set_mode = hi6421_regulator_buck_set_mode, |
| }; |
| |
| static int hi6421_regulator_register(struct platform_device *pdev, |
| struct regmap *rmap, |
| struct regulator_init_data *init_data, |
| int id, struct device_node *np) |
| { |
| struct hi6421_regulator_info *info = NULL; |
| struct regulator_config config = { }; |
| struct regulator_dev *rdev; |
| |
| /* assign per-regulator data */ |
| info = &hi6421_regulator_info[id]; |
| |
| config.dev = &pdev->dev; |
| config.init_data = init_data; |
| config.driver_data = info; |
| config.regmap = rmap; |
| config.of_node = np; |
| |
| /* register regulator with framework */ |
| rdev = devm_regulator_register(&pdev->dev, &info->desc, &config); |
| if (IS_ERR(rdev)) { |
| dev_err(&pdev->dev, "failed to register regulator %s\n", |
| info->desc.name); |
| return PTR_ERR(rdev); |
| } |
| |
| return 0; |
| } |
| |
| static int hi6421_regulator_probe(struct platform_device *pdev) |
| { |
| struct device *dev = &pdev->dev; |
| struct device_node *np; |
| struct hi6421_pmic *pmic; |
| struct hi6421_regulator_pdata *pdata; |
| int i, ret = 0; |
| |
| pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); |
| if (!pdata) |
| return -ENOMEM; |
| mutex_init(&pdata->lock); |
| platform_set_drvdata(pdev, pdata); |
| |
| np = of_get_child_by_name(dev->parent->of_node, "regulators"); |
| if (!np) |
| return -ENODEV; |
| |
| ret = of_regulator_match(dev, np, |
| hi6421_regulator_match, |
| ARRAY_SIZE(hi6421_regulator_match)); |
| of_node_put(np); |
| if (ret < 0) { |
| dev_err(dev, "Error parsing regulator init data: %d\n", ret); |
| return ret; |
| } |
| |
| pmic = dev_get_drvdata(dev->parent); |
| |
| for (i = 0; i < ARRAY_SIZE(hi6421_regulator_info); i++) { |
| ret = hi6421_regulator_register(pdev, pmic->regmap, |
| hi6421_regulator_match[i].init_data, i, |
| hi6421_regulator_match[i].of_node); |
| if (ret) |
| return ret; |
| } |
| |
| return 0; |
| } |
| |
| static const struct platform_device_id hi6421_regulator_table[] = { |
| { .name = "hi6421-regulator" }, |
| {}, |
| }; |
| MODULE_DEVICE_TABLE(platform, hi6421_regulator_table); |
| |
| static struct platform_driver hi6421_regulator_driver = { |
| .id_table = hi6421_regulator_table, |
| .driver = { |
| .name = "hi6421-regulator", |
| }, |
| .probe = hi6421_regulator_probe, |
| }; |
| module_platform_driver(hi6421_regulator_driver); |
| |
| MODULE_AUTHOR("Guodong Xu <guodong.xu@linaro.org>"); |
| MODULE_DESCRIPTION("Hi6421 regulator driver"); |
| MODULE_LICENSE("GPL v2"); |
