cregit-Linux how code gets into the kernel

Release 4.14 drivers/regulator/hi6421-regulator.c

/*
 * 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; }

Contributors

PersonTokensPropCommitsCommitProp
Guodong Xu53100.00%1100.00%
Total53100.00%1100.00%


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, &reg_val); if (reg_val & info->mode_mask) return REGULATOR_MODE_IDLE; return REGULATOR_MODE_NORMAL; }

Contributors

PersonTokensPropCommitsCommitProp
Guodong Xu55100.00%1100.00%
Total55100.00%1100.00%


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, &reg_val); if (reg_val & info->mode_mask) return REGULATOR_MODE_STANDBY; return REGULATOR_MODE_NORMAL; }

Contributors

PersonTokensPropCommitsCommitProp
Guodong Xu55100.00%1100.00%
Total55100.00%1100.00%


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; }

Contributors

PersonTokensPropCommitsCommitProp
Guodong Xu80100.00%1100.00%
Total80100.00%1100.00%


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; }

Contributors

PersonTokensPropCommitsCommitProp
Guodong Xu80100.00%1100.00%
Total80100.00%1100.00%


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; }

Contributors

PersonTokensPropCommitsCommitProp
Guodong Xu4497.78%150.00%
Baoyou Xie12.22%150.00%
Total45100.00%2100.00%

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; }

Contributors

PersonTokensPropCommitsCommitProp
Guodong Xu13494.37%150.00%
Axel Lin85.63%150.00%
Total142100.00%2100.00%


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; }

Contributors

PersonTokensPropCommitsCommitProp
Guodong Xu212100.00%1100.00%
Total212100.00%1100.00%

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");

Overall Contributors

PersonTokensPropCommitsCommitProp
Guodong Xu231499.23%233.33%
Axel Lin170.73%350.00%
Baoyou Xie10.04%116.67%
Total2332100.00%6100.00%
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.