Commit a5766f11 authored by Liam Girdwood's avatar Liam Girdwood
Browse files

regulator: core - Rework machine API to remove string based functions. 



This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.

The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.

e.g. regulator LDO2 (supplying codec and sim) platform data.

/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
	.dev	= &platform_audio_device.dev,
	.supply	= "codec_avdd",
},
{
	.dev	= &platform_sim_device.dev,
	.supply	= "sim_vcc",
}
};

/* regulator LDO2 constraints  */
static struct regulator_init_data ldo2_data = {
	.constraints = {
		.min_uV = 3300000,
		.max_uV = 3300000,
		.valid_modes_mask = REGULATOR_MODE_NORMAL,
		.apply_uV = 1,
	},
	.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
	.consumer_supplies = ldo2_consumers,
};

/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
	.name = "wm8350-regulator",
	.id = WM8350_LDO_2,
	.dev = {
		.platform_data = &ldo2_data,
	},
},
};

Changes in detail:-

  o Removed all const char* regulator config functions in machine API.
  o Created new struct regulator_init_data to contain regulator
    machine configuration constraints and consmuers.
  o Changed set_supply(), set_machine_constraints(),
    set_consumer_device_supply() to remove their string identifier
    parameters. Also made them static and moved functions nearer top of
    core.c.
  o Removed no longer used inline func to_rdev()
  o Added regulator_get_init_drvdata() to retrieve init data.
  o Added struct device* as parameter to regulator_register().
  o Changed my email address.

Signed-off-by: default avatarEric Miao <eric.miao@marvell.com>
Signed-off-by: default avatarMark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: default avatarLiam Girdwood <lrg@slimlogic.co.uk>
parent a447c093

Documentation/power/regulator/machine.txt

+66 −74
Original line number Diff line number Diff line
@@ -2,17 +2,8 @@ Regulator Machine Driver Interface 
===================================



The regulator machine driver interface is intended for board/machine specific

initialisation code to configure the regulator subsystem. Typical things that

machine drivers would do are :-

initialisation code to configure the regulator subsystem.



 1. Regulator -> Device mapping.

 2. Regulator supply configuration.

 3. Power Domain constraint setting.







1. Regulator -> device mapping

==============================

Consider the following machine :-



  Regulator-1 -+-> Regulator-2 --> [Consumer A @ 1.8 - 2.0V]
@@ -21,81 +12,82 @@ Consider the following machine :- 


The drivers for consumers A & B must be mapped to the correct regulator in

order to control their power supply. This mapping can be achieved in machine

initialisation code by calling :-

initialisation code by creating a struct regulator_consumer_supply for

each regulator.



struct regulator_consumer_supply {

	struct device *dev;	/* consumer */

	const char *supply;	/* consumer supply - e.g. "vcc" */

};



int regulator_set_device_supply(const char *regulator, struct device *dev,

				const char *supply);

e.g. for the machine above



and is shown with the following code :-

static struct regulator_consumer_supply regulator1_consumers[] = {

{

	.dev	= &platform_consumerB_device.dev,

	.supply	= "Vcc",

},};



regulator_set_device_supply("Regulator-1", devB, "Vcc");

regulator_set_device_supply("Regulator-2", devA, "Vcc");

static struct regulator_consumer_supply regulator2_consumers[] = {

{

	.dev	= &platform_consumerA_device.dev,

	.supply	= "Vcc",

},};



This maps Regulator-1 to the 'Vcc' supply for Consumer B and maps Regulator-2

to the 'Vcc' supply for Consumer A.



Constraints can now be registered by defining a struct regulator_init_data

for each regulator power domain. This structure also maps the consumers

to their supply regulator :-



2. Regulator supply configuration.

==================================

Consider the following machine (again) :-



  Regulator-1 -+-> Regulator-2 --> [Consumer A @ 1.8 - 2.0V]

               |

               +-> [Consumer B @ 3.3V]



Regulator-1 supplies power to Regulator-2. This relationship must be registered

with the core so that Regulator-1 is also enabled when Consumer A enables it's

supply (Regulator-2).



This relationship can be register with the core via :-



int regulator_set_supply(const char *regulator, const char *regulator_supply);



In this example we would use the following code :-



regulator_set_supply("Regulator-2", "Regulator-1");



Relationships can be queried by calling :-



const char *regulator_get_supply(const char *regulator);





3. Power Domain constraint setting.

===================================

Each power domain within a system has physical constraints on voltage and

current. This must be defined in software so that the power domain is always

operated within specifications.



Consider the following machine (again) :-



  Regulator-1 -+-> Regulator-2 --> [Consumer A @ 1.8 - 2.0V]

               |

               +-> [Consumer B @ 3.3V]



This gives us two regulators and two power domains:



                   Domain 1: Regulator-2, Consumer B.

                   Domain 2: Consumer A.



Constraints can be registered by calling :-



int regulator_set_platform_constraints(const char *regulator,

	struct regulation_constraints *constraints);



The example is defined as follows :-



struct regulation_constraints domain_1 = {

static struct regulator_init_data regulator1_data = {

	.constraints = {

		.min_uV = 3300000,

		.max_uV = 3300000,

		.valid_modes_mask = REGULATOR_MODE_NORMAL,

	},

	.num_consumer_supplies = ARRAY_SIZE(regulator1_consumers),

	.consumer_supplies = regulator1_consumers,

};



struct regulation_constraints domain_2 = {

Regulator-1 supplies power to Regulator-2. This relationship must be registered

with the core so that Regulator-1 is also enabled when Consumer A enables it's

supply (Regulator-2). The supply regulator is set by the supply_regulator_dev

field below:-



static struct regulator_init_data regulator2_data = {

	.supply_regulator_dev = &platform_regulator1_device.dev,

	.constraints = {

		.min_uV = 1800000,

		.max_uV = 2000000,

		.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,

		.valid_modes_mask = REGULATOR_MODE_NORMAL,

	},

	.num_consumer_supplies = ARRAY_SIZE(regulator2_consumers),

	.consumer_supplies = regulator2_consumers,

};



Finally the regulator devices must be registered in the usual manner.



static struct platform_device regulator_devices[] = {

{

	.name = "regulator",

	.id = DCDC_1,

	.dev = {

		.platform_data = &regulator1_data,

	},

},

{

	.name = "regulator",

	.id = DCDC_2,

	.dev = {

		.platform_data = &regulator2_data,

	},

},

};

/* register regulator 1 device */

platform_device_register(&wm8350_regulator_devices[0]);



regulator_set_platform_constraints("Regulator-1", &domain_1);

regulator_set_platform_constraints("Regulator-2", &domain_2);
 
/* register regulator 2 device */

platform_device_register(&wm8350_regulator_devices[1]);

Documentation/power/regulator/regulator.txt

+4 −4
Original line number Diff line number Diff line
@@ -10,11 +10,11 @@ Registration 


Drivers can register a regulator by calling :-



struct regulator_dev *regulator_register(struct regulator_desc *regulator_desc,

					  void *reg_data);

struct regulator_dev *regulator_register(struct device *dev,

	struct regulator_desc *regulator_desc);



This will register the regulators capabilities and operations the regulator

core. The core does not touch reg_data (private to regulator driver).

This will register the regulators capabilities and operations to the regulator

core.



Regulators can be unregistered by calling :-

drivers/regulator/bq24022.c

+9 −12
Original line number Diff line number Diff line
@@ -18,13 +18,13 @@ 
#include <linux/regulator/bq24022.h>

#include <linux/regulator/driver.h>





static int bq24022_set_current_limit(struct regulator_dev *rdev,

					int min_uA, int max_uA)

{

	struct platform_device *pdev = rdev_get_drvdata(rdev);

	struct bq24022_mach_info *pdata = pdev->dev.platform_data;

	struct bq24022_mach_info *pdata = rdev_get_drvdata(rdev);



	dev_dbg(&pdev->dev, "setting current limit to %s mA\n",

	dev_dbg(rdev_get_dev(rdev), "setting current limit to %s mA\n",

		max_uA >= 500000 ? "500" : "100");



	/* REVISIT: maybe return error if min_uA != 0 ? */
@@ -34,18 +34,16 @@ static int bq24022_set_current_limit(struct regulator_dev *rdev, 


static int bq24022_get_current_limit(struct regulator_dev *rdev)

{

	struct platform_device *pdev = rdev_get_drvdata(rdev);

	struct bq24022_mach_info *pdata = pdev->dev.platform_data;

	struct bq24022_mach_info *pdata = rdev_get_drvdata(rdev);



	return gpio_get_value(pdata->gpio_iset2) ? 500000 : 100000;

}



static int bq24022_enable(struct regulator_dev *rdev)

{

	struct platform_device *pdev = rdev_get_drvdata(rdev);

	struct bq24022_mach_info *pdata = pdev->dev.platform_data;

	struct bq24022_mach_info *pdata = rdev_get_drvdata(rdev);



	dev_dbg(&pdev->dev, "enabling charger\n");

	dev_dbg(rdev_get_dev(rdev), "enabling charger\n");



	gpio_set_value(pdata->gpio_nce, 0);

	return 0;
@@ -53,10 +51,9 @@ static int bq24022_enable(struct regulator_dev *rdev) 


static int bq24022_disable(struct regulator_dev *rdev)

{

	struct platform_device *pdev = rdev_get_drvdata(rdev);

	struct bq24022_mach_info *pdata = pdev->dev.platform_data;

	struct bq24022_mach_info *pdata = rdev_get_drvdata(rdev);



	dev_dbg(&pdev->dev, "disabling charger\n");

	dev_dbg(rdev_get_dev(rdev), "disabling charger\n");



	gpio_set_value(pdata->gpio_nce, 1);

	return 0;
@@ -108,7 +105,7 @@ static int __init bq24022_probe(struct platform_device *pdev) 
	ret = gpio_direction_output(pdata->gpio_iset2, 0);

	ret = gpio_direction_output(pdata->gpio_nce, 1);



	bq24022 = regulator_register(&bq24022_desc, pdev);

	bq24022 = regulator_register(&bq24022_desc, &pdev->dev, pdata);

	if (IS_ERR(bq24022)) {

		dev_dbg(&pdev->dev, "couldn't register regulator\n");

		ret = PTR_ERR(bq24022);

drivers/regulator/core.c

+226 −231

File changed.

Preview size limit exceeded, changes collapsed.

include/linux/regulator/driver.h

+5 −3
Original line number Diff line number Diff line
@@ -18,8 +18,8 @@ 
#include <linux/device.h>

#include <linux/regulator/consumer.h>



struct regulator_constraints;

struct regulator_dev;

struct regulator_init_data;



/**

 * struct regulator_ops - regulator operations.
@@ -85,15 +85,17 @@ struct regulator_desc { 
	struct module *owner;

};





struct regulator_dev *regulator_register(struct regulator_desc *regulator_desc,

					  void *reg_data);

	struct device *dev, void *driver_data);

void regulator_unregister(struct regulator_dev *rdev);



int regulator_notifier_call_chain(struct regulator_dev *rdev,

				  unsigned long event, void *data);



void *rdev_get_drvdata(struct regulator_dev *rdev);

struct device *rdev_get_dev(struct regulator_dev *rdev);

int rdev_get_id(struct regulator_dev *rdev);



void *regulator_get_init_drvdata(struct regulator_init_data *reg_init_data);



#endif

CRA Git | Maintained and supported by SUSTech CRA and CCSE