Release 4.7 drivers/regulator/da9055-regulator.c

Directory: drivers/regulator
/*
* Regulator driver for DA9055 PMIC
*
* Copyright(c) 2012 Dialog Semiconductor Ltd.
*
* Author: David Dajun Chen <dchen@diasemi.com>
*
* 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.
*
*/

#include <linux/module.h>
#include <linux/init.h>
#include <linux/err.h>
#include <linux/gpio.h>
#include <linux/platform_device.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/machine.h>
#include <linux/of.h>
#include <linux/regulator/of_regulator.h>

#include <linux/mfd/da9055/core.h>
#include <linux/mfd/da9055/reg.h>
#include <linux/mfd/da9055/pdata.h>


#define DA9055_MIN_UA		0

#define DA9055_MAX_UA		3


#define DA9055_LDO_MODE_SYNC	0

#define DA9055_LDO_MODE_SLEEP	1


#define DA9055_BUCK_MODE_SLEEP	1

#define DA9055_BUCK_MODE_SYNC	2

#define DA9055_BUCK_MODE_AUTO	3

/* DA9055 REGULATOR IDs */

#define DA9055_ID_BUCK1	0

#define DA9055_ID_BUCK2	1

#define DA9055_ID_LDO1		2

#define DA9055_ID_LDO2		3

#define DA9055_ID_LDO3		4

#define DA9055_ID_LDO4		5

#define DA9055_ID_LDO5		6

#define DA9055_ID_LDO6		7

/* DA9055 BUCK current limit */

static const int da9055_current_limits[] = { 500000, 600000, 700000, 800000 };


struct da9055_conf_reg {
	
int reg;
	
int sel_mask;
	
int en_mask;
};


struct da9055_volt_reg {
	
int reg_a;
	
int reg_b;
	
int sl_shift;
	
int v_mask;
};


struct da9055_mode_reg {
	
int reg;
	
int mask;
	
int shift;
};


struct da9055_regulator_info {
	
struct regulator_desc reg_desc;
	
struct da9055_conf_reg conf;
	
struct da9055_volt_reg volt;
	
struct da9055_mode_reg mode;
};


struct da9055_regulator {
	
struct da9055 *da9055;
	
struct da9055_regulator_info *info;
	
struct regulator_dev *rdev;
	
enum gpio_select reg_rselect;
};



static unsigned int da9055_buck_get_mode(struct regulator_dev *rdev)
{
	struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
	struct da9055_regulator_info *info = regulator->info;
	int ret, mode = 0;

	ret = da9055_reg_read(regulator->da9055, info->mode.reg);
	if (ret < 0)
		return ret;

	switch ((ret & info->mode.mask) >> info->mode.shift) {
	case DA9055_BUCK_MODE_SYNC:
		mode = REGULATOR_MODE_FAST;
		break;
	case DA9055_BUCK_MODE_AUTO:
		mode = REGULATOR_MODE_NORMAL;
		break;
	case DA9055_BUCK_MODE_SLEEP:
		mode = REGULATOR_MODE_STANDBY;
		break;
	}

	return mode;
}

Contributors
Person Tokens Prop Commits CommitProp
ashish jangam ashish jangam 109 100.00% 1 100.00%
Total 109 100.00% 1 100.00%



static int da9055_buck_set_mode(struct regulator_dev *rdev,
					unsigned int mode)
{
	struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
	struct da9055_regulator_info *info = regulator->info;
	int val = 0;

	switch (mode) {
	case REGULATOR_MODE_FAST:
		val = DA9055_BUCK_MODE_SYNC << info->mode.shift;
		break;
	case REGULATOR_MODE_NORMAL:
		val = DA9055_BUCK_MODE_AUTO << info->mode.shift;
		break;
	case REGULATOR_MODE_STANDBY:
		val = DA9055_BUCK_MODE_SLEEP << info->mode.shift;
		break;
	}

	return da9055_reg_update(regulator->da9055, info->mode.reg,
				 info->mode.mask, val);
}

Contributors
Person Tokens Prop Commits CommitProp
ashish jangam ashish jangam 109 100.00% 1 100.00%
Total 109 100.00% 1 100.00%



static unsigned int da9055_ldo_get_mode(struct regulator_dev *rdev)
{
	struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
	struct da9055_regulator_info *info = regulator->info;
	int ret;

	ret = da9055_reg_read(regulator->da9055, info->volt.reg_b);
	if (ret < 0)
		return ret;

	if (ret >> info->volt.sl_shift)
		return REGULATOR_MODE_STANDBY;
	else
		return REGULATOR_MODE_NORMAL;
}

Contributors
Person Tokens Prop Commits CommitProp
ashish jangam ashish jangam 75 100.00% 1 100.00%
Total 75 100.00% 1 100.00%



static int da9055_ldo_set_mode(struct regulator_dev *rdev, unsigned int mode)
{
	struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
	struct da9055_regulator_info *info = regulator->info;
	struct da9055_volt_reg volt = info->volt;
	int val = 0;

	switch (mode) {
	case REGULATOR_MODE_NORMAL:
	case REGULATOR_MODE_FAST:
		val = DA9055_LDO_MODE_SYNC;
		break;
	case REGULATOR_MODE_STANDBY:
		val = DA9055_LDO_MODE_SLEEP;
		break;
	}

	return da9055_reg_update(regulator->da9055, volt.reg_b,
				 1 << volt.sl_shift,
				 val << volt.sl_shift);
}

Contributors
Person Tokens Prop Commits CommitProp
ashish jangam ashish jangam 96 100.00% 1 100.00%
Total 96 100.00% 1 100.00%



static int da9055_buck_get_current_limit(struct regulator_dev *rdev)
{
	struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
	struct da9055_regulator_info *info = regulator->info;
	int ret;

	ret = da9055_reg_read(regulator->da9055, DA9055_REG_BUCK_LIM);
	if (ret < 0)
		return ret;

	ret &= info->mode.mask;
	return da9055_current_limits[ret >> info->mode.shift];
}

Contributors
Person Tokens Prop Commits CommitProp
ashish jangam ashish jangam 73 100.00% 1 100.00%
Total 73 100.00% 1 100.00%



static int da9055_buck_set_current_limit(struct regulator_dev *rdev, int min_uA,
					 int max_uA)
{
	struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
	struct da9055_regulator_info *info = regulator->info;
	int i;

	for (i = ARRAY_SIZE(da9055_current_limits) - 1; i >= 0; i--) {
		if ((min_uA <= da9055_current_limits[i]) &&
		    (da9055_current_limits[i] <= max_uA))
			return da9055_reg_update(regulator->da9055,
						 DA9055_REG_BUCK_LIM,
						 info->mode.mask,
						 i << info->mode.shift);
	}

	return -EINVAL;
}

Contributors
Person Tokens Prop Commits CommitProp
ashish jangam ashish jangam 83 77.57% 1 50.00%
axel lin axel lin 24 22.43% 1 50.00%
Total 107 100.00% 2 100.00%



static int da9055_regulator_get_voltage_sel(struct regulator_dev *rdev)
{
	struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
	struct da9055_regulator_info *info = regulator->info;
	struct da9055_volt_reg volt = info->volt;
	int ret, sel;

	/*
         * There are two voltage register set A & B for voltage ramping but
         * either one of then can be active therefore we first determine
         * the active register set.
         */
	ret = da9055_reg_read(regulator->da9055, info->conf.reg);
	if (ret < 0)
		return ret;

	ret &= info->conf.sel_mask;

	/* Get the voltage for the active register set A/B */
	if (ret == DA9055_REGUALTOR_SET_A)
		ret = da9055_reg_read(regulator->da9055, volt.reg_a);
	else
		ret = da9055_reg_read(regulator->da9055, volt.reg_b);

	if (ret < 0)
		return ret;

	sel = (ret & volt.v_mask);
	return sel;
}

Contributors
Person Tokens Prop Commits CommitProp
ashish jangam ashish jangam 132 100.00% 1 100.00%
Total 132 100.00% 1 100.00%



static int da9055_regulator_set_voltage_sel(struct regulator_dev *rdev,
					    unsigned int selector)
{
	struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
	struct da9055_regulator_info *info = regulator->info;
	int ret;

	/*
         * Regulator register set A/B is not selected through GPIO therefore
         * we use default register set A for voltage ramping.
         */
	if (regulator->reg_rselect == NO_GPIO) {
		/* Select register set A */
		ret = da9055_reg_update(regulator->da9055, info->conf.reg,
					info->conf.sel_mask, DA9055_SEL_REG_A);
		if (ret < 0)
			return ret;

		/* Set the voltage */
		return da9055_reg_update(regulator->da9055, info->volt.reg_a,
					 info->volt.v_mask, selector);
	}

	/*
         * Here regulator register set A/B is selected through GPIO.
         * Therefore we first determine the selected register set A/B and
         * then set the desired voltage for that register set A/B.
         */
	ret = da9055_reg_read(regulator->da9055, info->conf.reg);
	if (ret < 0)
		return ret;

	ret &= info->conf.sel_mask;

	/* Set the voltage */
	if (ret == DA9055_REGUALTOR_SET_A)
		return da9055_reg_update(regulator->da9055, info->volt.reg_a,
					 info->volt.v_mask, selector);
	else
		return da9055_reg_update(regulator->da9055, info->volt.reg_b,
					 info->volt.v_mask, selector);
}

Contributors
Person Tokens Prop Commits CommitProp
ashish jangam ashish jangam 159 84.13% 1 50.00%
axel lin axel lin 30 15.87% 1 50.00%
Total 189 100.00% 2 100.00%



static int da9055_regulator_set_suspend_voltage(struct regulator_dev *rdev,
						int uV)
{
	struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
	struct da9055_regulator_info *info = regulator->info;
	int ret;

	/* Select register set B for suspend voltage ramping. */
	if (regulator->reg_rselect == NO_GPIO) {
		ret = da9055_reg_update(regulator->da9055, info->conf.reg,
					info->conf.sel_mask, DA9055_SEL_REG_B);
		if (ret < 0)
			return ret;
	}

	ret = regulator_map_voltage_linear(rdev, uV, uV);
	if (ret < 0)
		return ret;

	return da9055_reg_update(regulator->da9055, info->volt.reg_b,
				 info->volt.v_mask, ret);
}

Contributors
Person Tokens Prop Commits CommitProp
ashish jangam ashish jangam 110 90.91% 1 33.33%
axel lin axel lin 11 9.09% 2 66.67%
Total 121 100.00% 3 100.00%



static int da9055_suspend_enable(struct regulator_dev *rdev)
{
	struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
	struct da9055_regulator_info *info = regulator->info;

	/* Select register set B for voltage ramping. */
	if (regulator->reg_rselect == NO_GPIO)
		return da9055_reg_update(regulator->da9055, info->conf.reg,
					info->conf.sel_mask, DA9055_SEL_REG_B);
	else
		return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
ashish jangam ashish jangam 65 100.00% 1 100.00%
Total 65 100.00% 1 100.00%



static int da9055_suspend_disable(struct regulator_dev *rdev)
{
	struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
	struct da9055_regulator_info *info = regulator->info;

	/* Diselect register set B. */
	if (regulator->reg_rselect == NO_GPIO)
		return da9055_reg_update(regulator->da9055, info->conf.reg,
					info->conf.sel_mask, DA9055_SEL_REG_A);
	else
		return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
ashish jangam ashish jangam 65 100.00% 1 100.00%
Total 65 100.00% 1 100.00%


static const struct regulator_ops da9055_buck_ops = {
	.get_mode = da9055_buck_get_mode,
	.set_mode = da9055_buck_set_mode,

	.get_current_limit = da9055_buck_get_current_limit,
	.set_current_limit = da9055_buck_set_current_limit,

	.get_voltage_sel = da9055_regulator_get_voltage_sel,
	.set_voltage_sel = da9055_regulator_set_voltage_sel,
	.list_voltage = regulator_list_voltage_linear,
	.map_voltage = regulator_map_voltage_linear,
	.is_enabled = regulator_is_enabled_regmap,
	.enable = regulator_enable_regmap,
	.disable = regulator_disable_regmap,

	.set_suspend_voltage = da9055_regulator_set_suspend_voltage,
	.set_suspend_enable = da9055_suspend_enable,
	.set_suspend_disable = da9055_suspend_disable,
	.set_suspend_mode = da9055_buck_set_mode,
};


static const struct regulator_ops da9055_ldo_ops = {
	.get_mode = da9055_ldo_get_mode,
	.set_mode = da9055_ldo_set_mode,

	.get_voltage_sel = da9055_regulator_get_voltage_sel,
	.set_voltage_sel = da9055_regulator_set_voltage_sel,
	.list_voltage = regulator_list_voltage_linear,
	.map_voltage = regulator_map_voltage_linear,
	.is_enabled = regulator_is_enabled_regmap,
	.enable = regulator_enable_regmap,
	.disable = regulator_disable_regmap,

	.set_suspend_voltage = da9055_regulator_set_suspend_voltage,
	.set_suspend_enable = da9055_suspend_enable,
	.set_suspend_disable = da9055_suspend_disable,
	.set_suspend_mode = da9055_ldo_set_mode,

};


#define DA9055_LDO(_id, step, min, max, vbits, voffset) \
{\
        .reg_desc = {\
                .name = #_id,\
                .ops = &da9055_ldo_ops,\
                .type = REGULATOR_VOLTAGE,\
                .id = DA9055_ID_##_id,\
                .n_voltages = (max - min) / step + 1 + (voffset), \
                .enable_reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \
                .enable_mask = 1, \
                .min_uV = (min) * 1000,\
                .uV_step = (step) * 1000,\
                .linear_min_sel = (voffset),\
                .owner = THIS_MODULE,\
        },\
        .conf = {\
                .reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \
                .sel_mask = (1 << 4),\
                .en_mask = 1,\
        },\
        .volt = {\
                .reg_a = DA9055_REG_VBCORE_A + DA9055_ID_##_id, \
                .reg_b = DA9055_REG_VBCORE_B + DA9055_ID_##_id, \
                .sl_shift = 7,\
                .v_mask = (1 << (vbits)) - 1,\
        },\
}


#define DA9055_BUCK(_id, step, min, max, vbits, voffset, mbits, sbits) \
{\
        .reg_desc = {\
                .name = #_id,\
                .ops = &da9055_buck_ops,\
                .type = REGULATOR_VOLTAGE,\
                .id = DA9055_ID_##_id,\
                .n_voltages = (max - min) / step + 1 + (voffset), \
                .enable_reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \
                .enable_mask = 1,\
                .min_uV = (min) * 1000,\
                .uV_step = (step) * 1000,\
                .linear_min_sel = (voffset),\
                .owner = THIS_MODULE,\
        },\
        .conf = {\
                .reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \
                .sel_mask = (1 << 4),\
                .en_mask = 1,\
        },\
        .volt = {\
                .reg_a = DA9055_REG_VBCORE_A + DA9055_ID_##_id, \
                .reg_b = DA9055_REG_VBCORE_B + DA9055_ID_##_id, \
                .sl_shift = 7,\
                .v_mask = (1 << (vbits)) - 1,\
        },\
        .mode = {\
                .reg = DA9055_REG_BCORE_MODE,\
                .mask = (mbits),\
                .shift = (sbits),\
        },\
}


static struct da9055_regulator_info da9055_regulator_info[] = {
	DA9055_BUCK(BUCK1, 25, 725, 2075, 6, 9, 0xc, 2),
	DA9055_BUCK(BUCK2, 25, 925, 2500, 6, 0, 3, 0),
	DA9055_LDO(LDO1, 50, 900, 3300, 6, 2),
	DA9055_LDO(LDO2, 50, 900, 3300, 6, 3),
	DA9055_LDO(LDO3, 50, 900, 3300, 6, 2),
	DA9055_LDO(LDO4, 50, 900, 3300, 6, 2),
	DA9055_LDO(LDO5, 50, 900, 2750, 6, 2),
	DA9055_LDO(LDO6, 20, 900, 3300, 7, 0),
};

/*
 * Configures regulator to be controlled either through GPIO 1 or 2.
 * GPIO can control regulator state and/or select the regulator register
 * set A/B for voltage ramping.
 */


static int da9055_gpio_init(struct da9055_regulator *regulator,
			    struct regulator_config *config,
			    struct da9055_pdata *pdata, int id)
{
	struct da9055_regulator_info *info = regulator->info;
	int ret = 0;

	if (!pdata)
		return 0;

	if (pdata->gpio_ren && pdata->gpio_ren[id]) {
		char name[18];
		int gpio_mux = pdata->gpio_ren[id];

		config->ena_gpio = pdata->ena_gpio[id];
		config->ena_gpio_flags = GPIOF_OUT_INIT_HIGH;
		config->ena_gpio_invert = 1;

		/*
                 * GPI pin is muxed with regulator to control the
                 * regulator state.
                 */
		sprintf(name, "DA9055 GPI %d", gpio_mux);
		ret = devm_gpio_request_one(config->dev, gpio_mux, GPIOF_DIR_IN,
					    name);
		if (ret < 0)
			goto err;

		/*
                 * Let the regulator know that its state is controlled
                 * through GPI.
                 */
		ret = da9055_reg_update(regulator->da9055, info->conf.reg,
					DA9055_E_GPI_MASK,
					pdata->reg_ren[id]
					<< DA9055_E_GPI_SHIFT);
		if (ret < 0)
			goto err;
	}

	if (pdata->gpio_rsel && pdata->gpio_rsel[id]) {
		char name[18];
		int gpio_mux = pdata->gpio_rsel[id];

		regulator->reg_rselect = pdata->reg_rsel[id];

		/*
                 * GPI pin is muxed with regulator to select the
                 * regulator register set A/B for voltage ramping.
                 */
		sprintf(name, "DA9055 GPI %d", gpio_mux);
		ret = devm_gpio_request_one(config->dev, gpio_mux, GPIOF_DIR_IN,
					    name);
		if (ret < 0)
			goto err;

		/*
                 * Let the regulator know that its register set A/B
                 * will be selected through GPI for voltage ramping.
                 */
		ret = da9055_reg_update(regulator->da9055, info->conf.reg,
					DA9055_V_GPI_MASK,
					pdata->reg_rsel[id]
					<< DA9055_V_GPI_SHIFT);
	}

err:
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
ashish jangam ashish jangam 269 96.76% 1 33.33%
adam thomson adam thomson 8 2.88% 1 33.33%
axel lin axel lin 1 0.36% 1 33.33%
Total 278 100.00% 3 100.00%



static irqreturn_t da9055_ldo5_6_oc_irq(int irq, void *data)
{
	struct da9055_regulator *regulator = data;

	regulator_notifier_call_chain(regulator->rdev,
				      REGULATOR_EVENT_OVER_CURRENT, NULL);

	return IRQ_HANDLED;
}

Contributors
Person Tokens Prop Commits CommitProp
ashish jangam ashish jangam 34 100.00% 1 100.00%
Total 34 100.00% 1 100.00%



static inline struct da9055_regulator_info *find_regulator_info(int id)
{
	struct da9055_regulator_info *info;
	int i;

	for (i = 0; i < ARRAY_SIZE(da9055_regulator_info); i++) {
		info = &da9055_regulator_info[i];
		if (info->reg_desc.id == id)
			return info;
	}

	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
ashish jangam ashish jangam 62 100.00% 1 100.00%
Total 62 100.00% 1 100.00%

#ifdef CONFIG_OF

static struct of_regulator_match da9055_reg_matches[] = {
	{ .name = "BUCK1", },
	{ .name = "BUCK2", },
	{ .name = "LDO1", },
	{ .name = "LDO2", },
	{ .name = "LDO3", },
	{ .name = "LDO4", },
	{ .name = "LDO5", },
	{ .name = "LDO6", },
};



static int da9055_regulator_dt_init(struct platform_device *pdev,
				    struct da9055_regulator *regulator,
				    struct regulator_config *config,
				    int regid)
{
	struct device_node *nproot, *np;
	int ret;

	nproot = of_node_get(pdev->dev.parent->of_node);
	if (!nproot)
		return -ENODEV;

	np = of_get_child_by_name(nproot, "regulators");
	if (!np)
		return -ENODEV;

	ret = of_regulator_match(&pdev->dev, np, &da9055_reg_matches[regid], 1);
	of_node_put(nproot);
	if (ret < 0) {
		dev_err(&pdev->dev, "Error matching regulator: %d\n", ret);
		return ret;
	}

	config->init_data = da9055_reg_matches[regid].init_data;
	config->of_node = da9055_reg_matches[regid].of_node;

	if (!config->of_node)
		return -ENODEV;

	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
adam thomson adam thomson 157 98.74% 1 33.33%
sachin kamat sachin kamat 2 1.26% 2 66.67%
Total 159 100.00% 3 100.00%

#else


static inline int da9055_regulator_dt_init(struct platform_device *pdev,
				       struct da9055_regulator *regulator,
				       struct regulator_config *config,
				       int regid)
{
	return -ENODEV;
}
Contributors
Person Tokens Prop Commits CommitProp
seongjae park seongjae park 20 68.97% 1 50.00%
adam thomson adam thomson 9 31.03% 1 50.00%
Total 29 100.00% 2 100.00%

#endif /* CONFIG_OF */



static int da9055_regulator_probe(struct platform_device *pdev)
{
	struct regulator_config config = { };
	struct da9055_regulator *regulator;
	struct da9055 *da9055 = dev_get_drvdata(pdev->dev.parent);
	struct da9055_pdata *pdata = dev_get_platdata(da9055->dev);
	int ret, irq;

	regulator = devm_kzalloc(&pdev->dev, sizeof(struct da9055_regulator),
				 GFP_KERNEL);
	if (!regulator)
		return -ENOMEM;

	regulator->info = find_regulator_info(pdev->id);
	if (regulator->info == NULL) {
		dev_err(&pdev->dev, "invalid regulator ID specified\n");
		return -EINVAL;
	}

	regulator->da9055 = da9055;
	config.dev = &pdev->dev;
	config.driver_data = regulator;
	config.regmap = da9055->regmap;

	if (pdata && pdata->regulators) {
		config.init_data = pdata->regulators[pdev->id];
	} else {
		ret = da9055_regulator_dt_init(pdev, regulator, &config,
					       pdev->id);
		if (ret < 0)
			return ret;
	}

	ret = da9055_gpio_init(regulator, &config, pdata, pdev->id);
	if (ret < 0)
		return ret;

	regulator->rdev = devm_regulator_register(&pdev->dev,
						  &regulator->info->reg_desc,
						  &config);
	if (IS_ERR(regulator->rdev)) {
		dev_err(&pdev->dev, "Failed to register regulator %s\n",
			regulator->info->reg_desc.name);
		return PTR_ERR(regulator->rdev);
	}

	/* Only LDO 5 and 6 has got the over current interrupt */
	if (pdev->id == DA9055_ID_LDO5 || pdev->id ==  DA9055_ID_LDO6) {
		irq = platform_get_irq_byname(pdev, "REGULATOR");
		if (irq < 0)
			return irq;

		ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
						da9055_ldo5_6_oc_irq,
						IRQF_TRIGGER_HIGH |
						IRQF_ONESHOT |
						IRQF_PROBE_SHARED,
						pdev->name, regulator);
		if (ret != 0) {
			if (ret != -EBUSY) {
				dev_err(&pdev->dev,
				"Failed to request Regulator IRQ %d: %d\n",
				irq, ret);
				return ret;
			}
		}
	}

	platform_set_drvdata(pdev, regulator);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
ashish jangam ashish jangam 336 87.05% 1 20.00%
adam thomson adam thomson 37 9.59% 2 40.00%
axel lin axel lin 10 2.59% 1 20.00%
jingoo han jingoo han 3 0.78% 1 20.00%
Total 386 100.00% 5 100.00%


static struct platform_driver da9055_regulator_driver = {
	.probe = da9055_regulator_probe,
	.driver = {
		.name = "da9055-regulator",
        },
};



static int __init da9055_regulator_init(void)
{
	return platform_driver_register(&da9055_regulator_driver);
}
Contributors
Person Tokens Prop Commits CommitProp
ashish jangam ashish jangam 16 100.00% 1 100.00%
Total 16 100.00% 1 100.00%


subsys_initcall(da9055_regulator_init);



static void __exit da9055_regulator_exit(void)
{
	platform_driver_unregister(&da9055_regulator_driver);
}
Contributors
Person Tokens Prop Commits CommitProp
ashish jangam ashish jangam 15 100.00% 1 100.00%
Total 15 100.00% 1 100.00%


module_exit(da9055_regulator_exit);

MODULE_AUTHOR("David Dajun Chen <dchen@diasemi.com>");
MODULE_DESCRIPTION("Power Regulator driver for Dialog DA9055 PMIC");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:da9055-regulator");
Overall Contributors
Person Tokens Prop Commits CommitProp
ashish jangam ashish jangam 2384 85.69% 1 7.14%
adam thomson adam thomson 289 10.39% 2 14.29%
axel lin axel lin 82 2.95% 6 42.86%
seongjae park seongjae park 20 0.72% 1 7.14%
jingoo han jingoo han 3 0.11% 1 7.14%
julia lawall julia lawall 2 0.07% 1 7.14%
sachin kamat sachin kamat 2 0.07% 2 14.29%
Total 2782 100.00% 14 100.00%
  Directory: drivers/regulator

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
ashish jangam	ashish jangam	109	100.00%	1	100.00%
	Total	109	100.00%	1	100.00%
cregit-Linux how code gets into the kernel

Release 4.7 drivers/regulator/da9055-regulator.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
