2008-04-30 08:59:04 -06:00
|
|
|
/*
|
|
|
|
* core.c -- Voltage/Current Regulator framework.
|
|
|
|
*
|
|
|
|
* Copyright 2007, 2008 Wolfson Microelectronics PLC.
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
* Copyright 2008 SlimLogic Ltd.
|
2008-04-30 08:59:04 -06:00
|
|
|
*
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
* Author: Liam Girdwood <lrg@slimlogic.co.uk>
|
2008-04-30 08:59:04 -06:00
|
|
|
*
|
|
|
|
* 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/kernel.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/device.h>
|
|
|
|
#include <linux/err.h>
|
|
|
|
#include <linux/mutex.h>
|
|
|
|
#include <linux/suspend.h>
|
|
|
|
#include <linux/regulator/consumer.h>
|
|
|
|
#include <linux/regulator/driver.h>
|
|
|
|
#include <linux/regulator/machine.h>
|
|
|
|
|
|
|
|
#define REGULATOR_VERSION "0.5"
|
|
|
|
|
|
|
|
static DEFINE_MUTEX(regulator_list_mutex);
|
|
|
|
static LIST_HEAD(regulator_list);
|
|
|
|
static LIST_HEAD(regulator_map_list);
|
2009-03-16 13:36:34 -06:00
|
|
|
static int has_full_constraints;
|
2008-04-30 08:59:04 -06:00
|
|
|
|
2008-12-31 05:52:40 -07:00
|
|
|
/*
|
2008-04-30 08:59:04 -06:00
|
|
|
* struct regulator_map
|
|
|
|
*
|
|
|
|
* Used to provide symbolic supply names to devices.
|
|
|
|
*/
|
|
|
|
struct regulator_map {
|
|
|
|
struct list_head list;
|
2009-06-17 10:56:39 -06:00
|
|
|
const char *dev_name; /* The dev_name() for the consumer */
|
2008-04-30 08:59:04 -06:00
|
|
|
const char *supply;
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
struct regulator_dev *regulator;
|
2008-04-30 08:59:04 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* struct regulator
|
|
|
|
*
|
|
|
|
* One for each consumer device.
|
|
|
|
*/
|
|
|
|
struct regulator {
|
|
|
|
struct device *dev;
|
|
|
|
struct list_head list;
|
|
|
|
int uA_load;
|
|
|
|
int min_uV;
|
|
|
|
int max_uV;
|
|
|
|
char *supply_name;
|
|
|
|
struct device_attribute dev_attr;
|
|
|
|
struct regulator_dev *rdev;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int _regulator_is_enabled(struct regulator_dev *rdev);
|
|
|
|
static int _regulator_disable(struct regulator_dev *rdev);
|
|
|
|
static int _regulator_get_voltage(struct regulator_dev *rdev);
|
|
|
|
static int _regulator_get_current_limit(struct regulator_dev *rdev);
|
|
|
|
static unsigned int _regulator_get_mode(struct regulator_dev *rdev);
|
|
|
|
static void _notifier_call_chain(struct regulator_dev *rdev,
|
|
|
|
unsigned long event, void *data);
|
|
|
|
|
|
|
|
/* gets the regulator for a given consumer device */
|
|
|
|
static struct regulator *get_device_regulator(struct device *dev)
|
|
|
|
{
|
|
|
|
struct regulator *regulator = NULL;
|
|
|
|
struct regulator_dev *rdev;
|
|
|
|
|
|
|
|
mutex_lock(®ulator_list_mutex);
|
|
|
|
list_for_each_entry(rdev, ®ulator_list, list) {
|
|
|
|
mutex_lock(&rdev->mutex);
|
|
|
|
list_for_each_entry(regulator, &rdev->consumer_list, list) {
|
|
|
|
if (regulator->dev == dev) {
|
|
|
|
mutex_unlock(&rdev->mutex);
|
|
|
|
mutex_unlock(®ulator_list_mutex);
|
|
|
|
return regulator;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mutex_unlock(&rdev->mutex);
|
|
|
|
}
|
|
|
|
mutex_unlock(®ulator_list_mutex);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Platform voltage constraint check */
|
|
|
|
static int regulator_check_voltage(struct regulator_dev *rdev,
|
|
|
|
int *min_uV, int *max_uV)
|
|
|
|
{
|
|
|
|
BUG_ON(*min_uV > *max_uV);
|
|
|
|
|
|
|
|
if (!rdev->constraints) {
|
|
|
|
printk(KERN_ERR "%s: no constraints for %s\n", __func__,
|
|
|
|
rdev->desc->name);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) {
|
|
|
|
printk(KERN_ERR "%s: operation not allowed for %s\n",
|
|
|
|
__func__, rdev->desc->name);
|
|
|
|
return -EPERM;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*max_uV > rdev->constraints->max_uV)
|
|
|
|
*max_uV = rdev->constraints->max_uV;
|
|
|
|
if (*min_uV < rdev->constraints->min_uV)
|
|
|
|
*min_uV = rdev->constraints->min_uV;
|
|
|
|
|
|
|
|
if (*min_uV > *max_uV)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* current constraint check */
|
|
|
|
static int regulator_check_current_limit(struct regulator_dev *rdev,
|
|
|
|
int *min_uA, int *max_uA)
|
|
|
|
{
|
|
|
|
BUG_ON(*min_uA > *max_uA);
|
|
|
|
|
|
|
|
if (!rdev->constraints) {
|
|
|
|
printk(KERN_ERR "%s: no constraints for %s\n", __func__,
|
|
|
|
rdev->desc->name);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_CURRENT)) {
|
|
|
|
printk(KERN_ERR "%s: operation not allowed for %s\n",
|
|
|
|
__func__, rdev->desc->name);
|
|
|
|
return -EPERM;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*max_uA > rdev->constraints->max_uA)
|
|
|
|
*max_uA = rdev->constraints->max_uA;
|
|
|
|
if (*min_uA < rdev->constraints->min_uA)
|
|
|
|
*min_uA = rdev->constraints->min_uA;
|
|
|
|
|
|
|
|
if (*min_uA > *max_uA)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* operating mode constraint check */
|
|
|
|
static int regulator_check_mode(struct regulator_dev *rdev, int mode)
|
|
|
|
{
|
2008-11-16 12:46:56 -07:00
|
|
|
switch (mode) {
|
|
|
|
case REGULATOR_MODE_FAST:
|
|
|
|
case REGULATOR_MODE_NORMAL:
|
|
|
|
case REGULATOR_MODE_IDLE:
|
|
|
|
case REGULATOR_MODE_STANDBY:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2008-04-30 08:59:04 -06:00
|
|
|
if (!rdev->constraints) {
|
|
|
|
printk(KERN_ERR "%s: no constraints for %s\n", __func__,
|
|
|
|
rdev->desc->name);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_MODE)) {
|
|
|
|
printk(KERN_ERR "%s: operation not allowed for %s\n",
|
|
|
|
__func__, rdev->desc->name);
|
|
|
|
return -EPERM;
|
|
|
|
}
|
|
|
|
if (!(rdev->constraints->valid_modes_mask & mode)) {
|
|
|
|
printk(KERN_ERR "%s: invalid mode %x for %s\n",
|
|
|
|
__func__, mode, rdev->desc->name);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* dynamic regulator mode switching constraint check */
|
|
|
|
static int regulator_check_drms(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
if (!rdev->constraints) {
|
|
|
|
printk(KERN_ERR "%s: no constraints for %s\n", __func__,
|
|
|
|
rdev->desc->name);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS)) {
|
|
|
|
printk(KERN_ERR "%s: operation not allowed for %s\n",
|
|
|
|
__func__, rdev->desc->name);
|
|
|
|
return -EPERM;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t device_requested_uA_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct regulator *regulator;
|
|
|
|
|
|
|
|
regulator = get_device_regulator(dev);
|
|
|
|
if (regulator == NULL)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return sprintf(buf, "%d\n", regulator->uA_load);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t regulator_uV_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 08:59:04 -06:00
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
mutex_lock(&rdev->mutex);
|
|
|
|
ret = sprintf(buf, "%d\n", _regulator_get_voltage(rdev));
|
|
|
|
mutex_unlock(&rdev->mutex);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2008-11-11 18:39:02 -07:00
|
|
|
static DEVICE_ATTR(microvolts, 0444, regulator_uV_show, NULL);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
|
|
|
static ssize_t regulator_uA_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
|
|
|
return sprintf(buf, "%d\n", _regulator_get_current_limit(rdev));
|
|
|
|
}
|
2008-11-11 18:39:02 -07:00
|
|
|
static DEVICE_ATTR(microamps, 0444, regulator_uA_show, NULL);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
2008-10-10 08:33:20 -06:00
|
|
|
static ssize_t regulator_name_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
|
|
|
const char *name;
|
|
|
|
|
2009-08-03 11:49:54 -06:00
|
|
|
if (rdev->constraints && rdev->constraints->name)
|
2008-10-10 08:33:20 -06:00
|
|
|
name = rdev->constraints->name;
|
|
|
|
else if (rdev->desc->name)
|
|
|
|
name = rdev->desc->name;
|
|
|
|
else
|
|
|
|
name = "";
|
|
|
|
|
|
|
|
return sprintf(buf, "%s\n", name);
|
|
|
|
}
|
|
|
|
|
2008-11-11 18:38:53 -07:00
|
|
|
static ssize_t regulator_print_opmode(char *buf, int mode)
|
2008-04-30 08:59:04 -06:00
|
|
|
{
|
|
|
|
switch (mode) {
|
|
|
|
case REGULATOR_MODE_FAST:
|
|
|
|
return sprintf(buf, "fast\n");
|
|
|
|
case REGULATOR_MODE_NORMAL:
|
|
|
|
return sprintf(buf, "normal\n");
|
|
|
|
case REGULATOR_MODE_IDLE:
|
|
|
|
return sprintf(buf, "idle\n");
|
|
|
|
case REGULATOR_MODE_STANDBY:
|
|
|
|
return sprintf(buf, "standby\n");
|
|
|
|
}
|
|
|
|
return sprintf(buf, "unknown\n");
|
|
|
|
}
|
|
|
|
|
2008-11-11 18:38:53 -07:00
|
|
|
static ssize_t regulator_opmode_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
2008-04-30 08:59:04 -06:00
|
|
|
{
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
2008-11-11 18:38:53 -07:00
|
|
|
return regulator_print_opmode(buf, _regulator_get_mode(rdev));
|
|
|
|
}
|
2008-11-11 18:39:02 -07:00
|
|
|
static DEVICE_ATTR(opmode, 0444, regulator_opmode_show, NULL);
|
2008-11-11 18:38:53 -07:00
|
|
|
|
|
|
|
static ssize_t regulator_print_state(char *buf, int state)
|
|
|
|
{
|
2008-04-30 08:59:04 -06:00
|
|
|
if (state > 0)
|
|
|
|
return sprintf(buf, "enabled\n");
|
|
|
|
else if (state == 0)
|
|
|
|
return sprintf(buf, "disabled\n");
|
|
|
|
else
|
|
|
|
return sprintf(buf, "unknown\n");
|
|
|
|
}
|
|
|
|
|
2008-11-11 18:38:53 -07:00
|
|
|
static ssize_t regulator_state_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2009-08-03 11:49:56 -06:00
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
mutex_lock(&rdev->mutex);
|
|
|
|
ret = regulator_print_state(buf, _regulator_is_enabled(rdev));
|
|
|
|
mutex_unlock(&rdev->mutex);
|
2008-11-11 18:38:53 -07:00
|
|
|
|
2009-08-03 11:49:56 -06:00
|
|
|
return ret;
|
2008-11-11 18:38:53 -07:00
|
|
|
}
|
2008-11-11 18:39:02 -07:00
|
|
|
static DEVICE_ATTR(state, 0444, regulator_state_show, NULL);
|
2008-11-11 18:38:53 -07:00
|
|
|
|
2009-01-15 00:03:17 -07:00
|
|
|
static ssize_t regulator_status_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
|
|
|
int status;
|
|
|
|
char *label;
|
|
|
|
|
|
|
|
status = rdev->desc->ops->get_status(rdev);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
|
|
|
|
switch (status) {
|
|
|
|
case REGULATOR_STATUS_OFF:
|
|
|
|
label = "off";
|
|
|
|
break;
|
|
|
|
case REGULATOR_STATUS_ON:
|
|
|
|
label = "on";
|
|
|
|
break;
|
|
|
|
case REGULATOR_STATUS_ERROR:
|
|
|
|
label = "error";
|
|
|
|
break;
|
|
|
|
case REGULATOR_STATUS_FAST:
|
|
|
|
label = "fast";
|
|
|
|
break;
|
|
|
|
case REGULATOR_STATUS_NORMAL:
|
|
|
|
label = "normal";
|
|
|
|
break;
|
|
|
|
case REGULATOR_STATUS_IDLE:
|
|
|
|
label = "idle";
|
|
|
|
break;
|
|
|
|
case REGULATOR_STATUS_STANDBY:
|
|
|
|
label = "standby";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -ERANGE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return sprintf(buf, "%s\n", label);
|
|
|
|
}
|
|
|
|
static DEVICE_ATTR(status, 0444, regulator_status_show, NULL);
|
|
|
|
|
2008-04-30 08:59:04 -06:00
|
|
|
static ssize_t regulator_min_uA_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
|
|
|
if (!rdev->constraints)
|
|
|
|
return sprintf(buf, "constraint not defined\n");
|
|
|
|
|
|
|
|
return sprintf(buf, "%d\n", rdev->constraints->min_uA);
|
|
|
|
}
|
2008-11-11 18:39:02 -07:00
|
|
|
static DEVICE_ATTR(min_microamps, 0444, regulator_min_uA_show, NULL);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
|
|
|
static ssize_t regulator_max_uA_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
|
|
|
if (!rdev->constraints)
|
|
|
|
return sprintf(buf, "constraint not defined\n");
|
|
|
|
|
|
|
|
return sprintf(buf, "%d\n", rdev->constraints->max_uA);
|
|
|
|
}
|
2008-11-11 18:39:02 -07:00
|
|
|
static DEVICE_ATTR(max_microamps, 0444, regulator_max_uA_show, NULL);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
|
|
|
static ssize_t regulator_min_uV_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
|
|
|
if (!rdev->constraints)
|
|
|
|
return sprintf(buf, "constraint not defined\n");
|
|
|
|
|
|
|
|
return sprintf(buf, "%d\n", rdev->constraints->min_uV);
|
|
|
|
}
|
2008-11-11 18:39:02 -07:00
|
|
|
static DEVICE_ATTR(min_microvolts, 0444, regulator_min_uV_show, NULL);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
|
|
|
static ssize_t regulator_max_uV_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
|
|
|
if (!rdev->constraints)
|
|
|
|
return sprintf(buf, "constraint not defined\n");
|
|
|
|
|
|
|
|
return sprintf(buf, "%d\n", rdev->constraints->max_uV);
|
|
|
|
}
|
2008-11-11 18:39:02 -07:00
|
|
|
static DEVICE_ATTR(max_microvolts, 0444, regulator_max_uV_show, NULL);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
|
|
|
static ssize_t regulator_total_uA_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 08:59:04 -06:00
|
|
|
struct regulator *regulator;
|
|
|
|
int uA = 0;
|
|
|
|
|
|
|
|
mutex_lock(&rdev->mutex);
|
|
|
|
list_for_each_entry(regulator, &rdev->consumer_list, list)
|
|
|
|
uA += regulator->uA_load;
|
|
|
|
mutex_unlock(&rdev->mutex);
|
|
|
|
return sprintf(buf, "%d\n", uA);
|
|
|
|
}
|
2008-11-11 18:39:02 -07:00
|
|
|
static DEVICE_ATTR(requested_microamps, 0444, regulator_total_uA_show, NULL);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
|
|
|
static ssize_t regulator_num_users_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 08:59:04 -06:00
|
|
|
return sprintf(buf, "%d\n", rdev->use_count);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t regulator_type_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
|
|
|
switch (rdev->desc->type) {
|
|
|
|
case REGULATOR_VOLTAGE:
|
|
|
|
return sprintf(buf, "voltage\n");
|
|
|
|
case REGULATOR_CURRENT:
|
|
|
|
return sprintf(buf, "current\n");
|
|
|
|
}
|
|
|
|
return sprintf(buf, "unknown\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t regulator_suspend_mem_uV_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
|
|
|
return sprintf(buf, "%d\n", rdev->constraints->state_mem.uV);
|
|
|
|
}
|
2008-11-11 18:39:02 -07:00
|
|
|
static DEVICE_ATTR(suspend_mem_microvolts, 0444,
|
|
|
|
regulator_suspend_mem_uV_show, NULL);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
|
|
|
static ssize_t regulator_suspend_disk_uV_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
|
|
|
return sprintf(buf, "%d\n", rdev->constraints->state_disk.uV);
|
|
|
|
}
|
2008-11-11 18:39:02 -07:00
|
|
|
static DEVICE_ATTR(suspend_disk_microvolts, 0444,
|
|
|
|
regulator_suspend_disk_uV_show, NULL);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
|
|
|
static ssize_t regulator_suspend_standby_uV_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
|
|
|
return sprintf(buf, "%d\n", rdev->constraints->state_standby.uV);
|
|
|
|
}
|
2008-11-11 18:39:02 -07:00
|
|
|
static DEVICE_ATTR(suspend_standby_microvolts, 0444,
|
|
|
|
regulator_suspend_standby_uV_show, NULL);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
|
|
|
static ssize_t regulator_suspend_mem_mode_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
2008-11-11 18:38:53 -07:00
|
|
|
return regulator_print_opmode(buf,
|
|
|
|
rdev->constraints->state_mem.mode);
|
2008-04-30 08:59:04 -06:00
|
|
|
}
|
2008-11-11 18:39:02 -07:00
|
|
|
static DEVICE_ATTR(suspend_mem_mode, 0444,
|
|
|
|
regulator_suspend_mem_mode_show, NULL);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
|
|
|
static ssize_t regulator_suspend_disk_mode_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
2008-11-11 18:38:53 -07:00
|
|
|
return regulator_print_opmode(buf,
|
|
|
|
rdev->constraints->state_disk.mode);
|
2008-04-30 08:59:04 -06:00
|
|
|
}
|
2008-11-11 18:39:02 -07:00
|
|
|
static DEVICE_ATTR(suspend_disk_mode, 0444,
|
|
|
|
regulator_suspend_disk_mode_show, NULL);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
|
|
|
static ssize_t regulator_suspend_standby_mode_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
2008-11-11 18:38:53 -07:00
|
|
|
return regulator_print_opmode(buf,
|
|
|
|
rdev->constraints->state_standby.mode);
|
2008-04-30 08:59:04 -06:00
|
|
|
}
|
2008-11-11 18:39:02 -07:00
|
|
|
static DEVICE_ATTR(suspend_standby_mode, 0444,
|
|
|
|
regulator_suspend_standby_mode_show, NULL);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
|
|
|
static ssize_t regulator_suspend_mem_state_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
2008-11-11 18:38:53 -07:00
|
|
|
return regulator_print_state(buf,
|
|
|
|
rdev->constraints->state_mem.enabled);
|
2008-04-30 08:59:04 -06:00
|
|
|
}
|
2008-11-11 18:39:02 -07:00
|
|
|
static DEVICE_ATTR(suspend_mem_state, 0444,
|
|
|
|
regulator_suspend_mem_state_show, NULL);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
|
|
|
static ssize_t regulator_suspend_disk_state_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
2008-11-11 18:38:53 -07:00
|
|
|
return regulator_print_state(buf,
|
|
|
|
rdev->constraints->state_disk.enabled);
|
2008-04-30 08:59:04 -06:00
|
|
|
}
|
2008-11-11 18:39:02 -07:00
|
|
|
static DEVICE_ATTR(suspend_disk_state, 0444,
|
|
|
|
regulator_suspend_disk_state_show, NULL);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
|
|
|
static ssize_t regulator_suspend_standby_state_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
2008-11-11 18:38:53 -07:00
|
|
|
return regulator_print_state(buf,
|
|
|
|
rdev->constraints->state_standby.enabled);
|
2008-04-30 08:59:04 -06:00
|
|
|
}
|
2008-11-11 18:39:02 -07:00
|
|
|
static DEVICE_ATTR(suspend_standby_state, 0444,
|
|
|
|
regulator_suspend_standby_state_show, NULL);
|
|
|
|
|
2008-10-10 08:33:20 -06:00
|
|
|
|
2008-11-11 18:39:02 -07:00
|
|
|
/*
|
|
|
|
* These are the only attributes are present for all regulators.
|
|
|
|
* Other attributes are a function of regulator functionality.
|
|
|
|
*/
|
2008-04-30 08:59:04 -06:00
|
|
|
static struct device_attribute regulator_dev_attrs[] = {
|
2008-10-10 08:33:20 -06:00
|
|
|
__ATTR(name, 0444, regulator_name_show, NULL),
|
2008-04-30 08:59:04 -06:00
|
|
|
__ATTR(num_users, 0444, regulator_num_users_show, NULL),
|
|
|
|
__ATTR(type, 0444, regulator_type_show, NULL),
|
|
|
|
__ATTR_NULL,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void regulator_dev_release(struct device *dev)
|
|
|
|
{
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 08:59:04 -06:00
|
|
|
kfree(rdev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct class regulator_class = {
|
|
|
|
.name = "regulator",
|
|
|
|
.dev_release = regulator_dev_release,
|
|
|
|
.dev_attrs = regulator_dev_attrs,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Calculate the new optimum regulator operating mode based on the new total
|
|
|
|
* consumer load. All locks held by caller */
|
|
|
|
static void drms_uA_update(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
struct regulator *sibling;
|
|
|
|
int current_uA = 0, output_uV, input_uV, err;
|
|
|
|
unsigned int mode;
|
|
|
|
|
|
|
|
err = regulator_check_drms(rdev);
|
|
|
|
if (err < 0 || !rdev->desc->ops->get_optimum_mode ||
|
2009-04-08 04:52:39 -06:00
|
|
|
!rdev->desc->ops->get_voltage || !rdev->desc->ops->set_mode)
|
|
|
|
return;
|
2008-04-30 08:59:04 -06:00
|
|
|
|
|
|
|
/* get output voltage */
|
|
|
|
output_uV = rdev->desc->ops->get_voltage(rdev);
|
|
|
|
if (output_uV <= 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* get input voltage */
|
|
|
|
if (rdev->supply && rdev->supply->desc->ops->get_voltage)
|
|
|
|
input_uV = rdev->supply->desc->ops->get_voltage(rdev->supply);
|
|
|
|
else
|
|
|
|
input_uV = rdev->constraints->input_uV;
|
|
|
|
if (input_uV <= 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* calc total requested load */
|
|
|
|
list_for_each_entry(sibling, &rdev->consumer_list, list)
|
|
|
|
current_uA += sibling->uA_load;
|
|
|
|
|
|
|
|
/* now get the optimum mode for our new total regulator load */
|
|
|
|
mode = rdev->desc->ops->get_optimum_mode(rdev, input_uV,
|
|
|
|
output_uV, current_uA);
|
|
|
|
|
|
|
|
/* check the new mode is allowed */
|
|
|
|
err = regulator_check_mode(rdev, mode);
|
|
|
|
if (err == 0)
|
|
|
|
rdev->desc->ops->set_mode(rdev, mode);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int suspend_set_state(struct regulator_dev *rdev,
|
|
|
|
struct regulator_state *rstate)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
/* enable & disable are mandatory for suspend control */
|
|
|
|
if (!rdev->desc->ops->set_suspend_enable ||
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
!rdev->desc->ops->set_suspend_disable) {
|
|
|
|
printk(KERN_ERR "%s: no way to set suspend state\n",
|
|
|
|
__func__);
|
2008-04-30 08:59:04 -06:00
|
|
|
return -EINVAL;
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
}
|
2008-04-30 08:59:04 -06:00
|
|
|
|
|
|
|
if (rstate->enabled)
|
|
|
|
ret = rdev->desc->ops->set_suspend_enable(rdev);
|
|
|
|
else
|
|
|
|
ret = rdev->desc->ops->set_suspend_disable(rdev);
|
|
|
|
if (ret < 0) {
|
|
|
|
printk(KERN_ERR "%s: failed to enabled/disable\n", __func__);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rdev->desc->ops->set_suspend_voltage && rstate->uV > 0) {
|
|
|
|
ret = rdev->desc->ops->set_suspend_voltage(rdev, rstate->uV);
|
|
|
|
if (ret < 0) {
|
|
|
|
printk(KERN_ERR "%s: failed to set voltage\n",
|
|
|
|
__func__);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rdev->desc->ops->set_suspend_mode && rstate->mode > 0) {
|
|
|
|
ret = rdev->desc->ops->set_suspend_mode(rdev, rstate->mode);
|
|
|
|
if (ret < 0) {
|
|
|
|
printk(KERN_ERR "%s: failed to set mode\n", __func__);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* locks held by caller */
|
|
|
|
static int suspend_prepare(struct regulator_dev *rdev, suspend_state_t state)
|
|
|
|
{
|
|
|
|
if (!rdev->constraints)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
switch (state) {
|
|
|
|
case PM_SUSPEND_STANDBY:
|
|
|
|
return suspend_set_state(rdev,
|
|
|
|
&rdev->constraints->state_standby);
|
|
|
|
case PM_SUSPEND_MEM:
|
|
|
|
return suspend_set_state(rdev,
|
|
|
|
&rdev->constraints->state_mem);
|
|
|
|
case PM_SUSPEND_MAX:
|
|
|
|
return suspend_set_state(rdev,
|
|
|
|
&rdev->constraints->state_disk);
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void print_constraints(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
struct regulation_constraints *constraints = rdev->constraints;
|
|
|
|
char buf[80];
|
|
|
|
int count;
|
|
|
|
|
|
|
|
if (rdev->desc->type == REGULATOR_VOLTAGE) {
|
|
|
|
if (constraints->min_uV == constraints->max_uV)
|
|
|
|
count = sprintf(buf, "%d mV ",
|
|
|
|
constraints->min_uV / 1000);
|
|
|
|
else
|
|
|
|
count = sprintf(buf, "%d <--> %d mV ",
|
|
|
|
constraints->min_uV / 1000,
|
|
|
|
constraints->max_uV / 1000);
|
|
|
|
} else {
|
|
|
|
if (constraints->min_uA == constraints->max_uA)
|
|
|
|
count = sprintf(buf, "%d mA ",
|
|
|
|
constraints->min_uA / 1000);
|
|
|
|
else
|
|
|
|
count = sprintf(buf, "%d <--> %d mA ",
|
|
|
|
constraints->min_uA / 1000,
|
|
|
|
constraints->max_uA / 1000);
|
|
|
|
}
|
|
|
|
if (constraints->valid_modes_mask & REGULATOR_MODE_FAST)
|
|
|
|
count += sprintf(buf + count, "fast ");
|
|
|
|
if (constraints->valid_modes_mask & REGULATOR_MODE_NORMAL)
|
|
|
|
count += sprintf(buf + count, "normal ");
|
|
|
|
if (constraints->valid_modes_mask & REGULATOR_MODE_IDLE)
|
|
|
|
count += sprintf(buf + count, "idle ");
|
|
|
|
if (constraints->valid_modes_mask & REGULATOR_MODE_STANDBY)
|
|
|
|
count += sprintf(buf + count, "standby");
|
|
|
|
|
|
|
|
printk(KERN_INFO "regulator: %s: %s\n", rdev->desc->name, buf);
|
|
|
|
}
|
|
|
|
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
/**
|
|
|
|
* set_machine_constraints - sets regulator constraints
|
2008-12-31 05:52:41 -07:00
|
|
|
* @rdev: regulator source
|
2008-12-31 05:52:42 -07:00
|
|
|
* @constraints: constraints to apply
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
*
|
|
|
|
* Allows platform initialisation code to define and constrain
|
|
|
|
* regulator circuits e.g. valid voltage/current ranges, etc. NOTE:
|
|
|
|
* Constraints *must* be set by platform code in order for some
|
|
|
|
* regulator operations to proceed i.e. set_voltage, set_current_limit,
|
|
|
|
* set_mode.
|
|
|
|
*/
|
|
|
|
static int set_machine_constraints(struct regulator_dev *rdev,
|
|
|
|
struct regulation_constraints *constraints)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
2008-09-09 09:21:19 -06:00
|
|
|
const char *name;
|
2008-09-09 09:21:20 -06:00
|
|
|
struct regulator_ops *ops = rdev->desc->ops;
|
2008-09-09 09:21:19 -06:00
|
|
|
|
|
|
|
if (constraints->name)
|
|
|
|
name = constraints->name;
|
|
|
|
else if (rdev->desc->name)
|
|
|
|
name = rdev->desc->name;
|
|
|
|
else
|
|
|
|
name = "regulator";
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
|
2009-02-26 12:48:36 -07:00
|
|
|
/* constrain machine-level voltage specs to fit
|
|
|
|
* the actual range supported by this regulator.
|
|
|
|
*/
|
|
|
|
if (ops->list_voltage && rdev->desc->n_voltages) {
|
|
|
|
int count = rdev->desc->n_voltages;
|
|
|
|
int i;
|
|
|
|
int min_uV = INT_MAX;
|
|
|
|
int max_uV = INT_MIN;
|
|
|
|
int cmin = constraints->min_uV;
|
|
|
|
int cmax = constraints->max_uV;
|
|
|
|
|
2009-04-28 04:09:38 -06:00
|
|
|
/* it's safe to autoconfigure fixed-voltage supplies
|
|
|
|
and the constraints are used by list_voltage. */
|
2009-02-26 12:48:36 -07:00
|
|
|
if (count == 1 && !cmin) {
|
2009-04-28 04:09:38 -06:00
|
|
|
cmin = 1;
|
2009-02-26 12:48:36 -07:00
|
|
|
cmax = INT_MAX;
|
2009-04-28 04:09:38 -06:00
|
|
|
constraints->min_uV = cmin;
|
|
|
|
constraints->max_uV = cmax;
|
2009-02-26 12:48:36 -07:00
|
|
|
}
|
|
|
|
|
2009-03-10 10:28:36 -06:00
|
|
|
/* voltage constraints are optional */
|
|
|
|
if ((cmin == 0) && (cmax == 0))
|
|
|
|
goto out;
|
|
|
|
|
2009-02-26 12:48:36 -07:00
|
|
|
/* else require explicit machine-level constraints */
|
2009-03-10 10:28:36 -06:00
|
|
|
if (cmin <= 0 || cmax <= 0 || cmax < cmin) {
|
2009-02-26 12:48:36 -07:00
|
|
|
pr_err("%s: %s '%s' voltage constraints\n",
|
|
|
|
__func__, "invalid", name);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* initial: [cmin..cmax] valid, [min_uV..max_uV] not */
|
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
int value;
|
|
|
|
|
|
|
|
value = ops->list_voltage(rdev, i);
|
|
|
|
if (value <= 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* maybe adjust [min_uV..max_uV] */
|
|
|
|
if (value >= cmin && value < min_uV)
|
|
|
|
min_uV = value;
|
|
|
|
if (value <= cmax && value > max_uV)
|
|
|
|
max_uV = value;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* final: [min_uV..max_uV] valid iff constraints valid */
|
|
|
|
if (max_uV < min_uV) {
|
|
|
|
pr_err("%s: %s '%s' voltage constraints\n",
|
|
|
|
__func__, "unsupportable", name);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* use regulator's subset of machine constraints */
|
|
|
|
if (constraints->min_uV < min_uV) {
|
|
|
|
pr_debug("%s: override '%s' %s, %d -> %d\n",
|
|
|
|
__func__, name, "min_uV",
|
|
|
|
constraints->min_uV, min_uV);
|
|
|
|
constraints->min_uV = min_uV;
|
|
|
|
}
|
|
|
|
if (constraints->max_uV > max_uV) {
|
|
|
|
pr_debug("%s: override '%s' %s, %d -> %d\n",
|
|
|
|
__func__, name, "max_uV",
|
|
|
|
constraints->max_uV, max_uV);
|
|
|
|
constraints->max_uV = max_uV;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
rdev->constraints = constraints;
|
|
|
|
|
|
|
|
/* do we need to apply the constraint voltage */
|
|
|
|
if (rdev->constraints->apply_uV &&
|
|
|
|
rdev->constraints->min_uV == rdev->constraints->max_uV &&
|
2008-09-09 09:21:20 -06:00
|
|
|
ops->set_voltage) {
|
|
|
|
ret = ops->set_voltage(rdev,
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
rdev->constraints->min_uV, rdev->constraints->max_uV);
|
|
|
|
if (ret < 0) {
|
2008-09-09 09:21:19 -06:00
|
|
|
printk(KERN_ERR "%s: failed to apply %duV constraint to %s\n",
|
|
|
|
__func__,
|
|
|
|
rdev->constraints->min_uV, name);
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
rdev->constraints = NULL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* do we need to setup our suspend state */
|
2008-09-09 09:21:19 -06:00
|
|
|
if (constraints->initial_state) {
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
ret = suspend_prepare(rdev, constraints->initial_state);
|
2008-09-09 09:21:19 -06:00
|
|
|
if (ret < 0) {
|
|
|
|
printk(KERN_ERR "%s: failed to set suspend state for %s\n",
|
|
|
|
__func__, name);
|
|
|
|
rdev->constraints = NULL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
|
2009-02-26 12:24:19 -07:00
|
|
|
if (constraints->initial_mode) {
|
|
|
|
if (!ops->set_mode) {
|
|
|
|
printk(KERN_ERR "%s: no set_mode operation for %s\n",
|
|
|
|
__func__, name);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ops->set_mode(rdev, constraints->initial_mode);
|
|
|
|
if (ret < 0) {
|
|
|
|
printk(KERN_ERR
|
|
|
|
"%s: failed to set initial mode for %s: %d\n",
|
|
|
|
__func__, name, ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-03-02 09:32:46 -07:00
|
|
|
/* If the constraints say the regulator should be on at this point
|
|
|
|
* and we have control then make sure it is enabled.
|
|
|
|
*/
|
|
|
|
if ((constraints->always_on || constraints->boot_on) && ops->enable) {
|
2008-09-09 09:21:20 -06:00
|
|
|
ret = ops->enable(rdev);
|
|
|
|
if (ret < 0) {
|
|
|
|
printk(KERN_ERR "%s: failed to enable %s\n",
|
|
|
|
__func__, name);
|
|
|
|
rdev->constraints = NULL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
print_constraints(rdev);
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* set_supply - set regulator supply regulator
|
2008-12-31 05:52:41 -07:00
|
|
|
* @rdev: regulator name
|
|
|
|
* @supply_rdev: supply regulator name
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
*
|
|
|
|
* Called by platform initialisation code to set the supply regulator for this
|
|
|
|
* regulator. This ensures that a regulators supply will also be enabled by the
|
|
|
|
* core if it's child is enabled.
|
|
|
|
*/
|
|
|
|
static int set_supply(struct regulator_dev *rdev,
|
|
|
|
struct regulator_dev *supply_rdev)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = sysfs_create_link(&rdev->dev.kobj, &supply_rdev->dev.kobj,
|
|
|
|
"supply");
|
|
|
|
if (err) {
|
|
|
|
printk(KERN_ERR
|
|
|
|
"%s: could not add device link %s err %d\n",
|
|
|
|
__func__, supply_rdev->dev.kobj.name, err);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
rdev->supply = supply_rdev;
|
|
|
|
list_add(&rdev->slist, &supply_rdev->supply_list);
|
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* set_consumer_device_supply: Bind a regulator to a symbolic supply
|
2008-12-31 05:52:41 -07:00
|
|
|
* @rdev: regulator source
|
|
|
|
* @consumer_dev: device the supply applies to
|
2009-06-17 10:56:39 -06:00
|
|
|
* @consumer_dev_name: dev_name() string for device supply applies to
|
2008-12-31 05:52:41 -07:00
|
|
|
* @supply: symbolic name for supply
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
*
|
|
|
|
* Allows platform initialisation code to map physical regulator
|
|
|
|
* sources to symbolic names for supplies for use by devices. Devices
|
|
|
|
* should use these symbolic names to request regulators, avoiding the
|
|
|
|
* need to provide board-specific regulator names as platform data.
|
2009-06-17 10:56:39 -06:00
|
|
|
*
|
|
|
|
* Only one of consumer_dev and consumer_dev_name may be specified.
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
*/
|
|
|
|
static int set_consumer_device_supply(struct regulator_dev *rdev,
|
2009-06-17 10:56:39 -06:00
|
|
|
struct device *consumer_dev, const char *consumer_dev_name,
|
|
|
|
const char *supply)
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
{
|
|
|
|
struct regulator_map *node;
|
2009-07-21 09:00:26 -06:00
|
|
|
int has_dev;
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
|
2009-06-17 10:56:39 -06:00
|
|
|
if (consumer_dev && consumer_dev_name)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!consumer_dev_name && consumer_dev)
|
|
|
|
consumer_dev_name = dev_name(consumer_dev);
|
|
|
|
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
if (supply == NULL)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2009-07-21 09:00:26 -06:00
|
|
|
if (consumer_dev_name != NULL)
|
|
|
|
has_dev = 1;
|
|
|
|
else
|
|
|
|
has_dev = 0;
|
|
|
|
|
2008-12-31 05:54:19 -07:00
|
|
|
list_for_each_entry(node, ®ulator_map_list, list) {
|
2009-06-17 10:56:39 -06:00
|
|
|
if (consumer_dev_name != node->dev_name)
|
2008-12-31 05:54:19 -07:00
|
|
|
continue;
|
|
|
|
if (strcmp(node->supply, supply) != 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
dev_dbg(consumer_dev, "%s/%s is '%s' supply; fail %s/%s\n",
|
|
|
|
dev_name(&node->regulator->dev),
|
|
|
|
node->regulator->desc->name,
|
|
|
|
supply,
|
|
|
|
dev_name(&rdev->dev), rdev->desc->name);
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
|
2009-07-21 09:00:26 -06:00
|
|
|
node = kzalloc(sizeof(struct regulator_map), GFP_KERNEL);
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
if (node == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
node->regulator = rdev;
|
|
|
|
node->supply = supply;
|
|
|
|
|
2009-07-21 09:00:26 -06:00
|
|
|
if (has_dev) {
|
|
|
|
node->dev_name = kstrdup(consumer_dev_name, GFP_KERNEL);
|
|
|
|
if (node->dev_name == NULL) {
|
|
|
|
kfree(node);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2009-06-17 10:56:39 -06:00
|
|
|
}
|
|
|
|
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
list_add(&node->list, ®ulator_map_list);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void unset_consumer_device_supply(struct regulator_dev *rdev,
|
2009-06-17 10:56:39 -06:00
|
|
|
const char *consumer_dev_name, struct device *consumer_dev)
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
{
|
|
|
|
struct regulator_map *node, *n;
|
|
|
|
|
2009-06-17 10:56:39 -06:00
|
|
|
if (consumer_dev && !consumer_dev_name)
|
|
|
|
consumer_dev_name = dev_name(consumer_dev);
|
|
|
|
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
list_for_each_entry_safe(node, n, ®ulator_map_list, list) {
|
2009-06-17 10:56:39 -06:00
|
|
|
if (rdev != node->regulator)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (consumer_dev_name && node->dev_name &&
|
|
|
|
strcmp(consumer_dev_name, node->dev_name))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
list_del(&node->list);
|
|
|
|
kfree(node->dev_name);
|
|
|
|
kfree(node);
|
|
|
|
return;
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-22 07:00:29 -07:00
|
|
|
static void unset_regulator_supplies(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
struct regulator_map *node, *n;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(node, n, ®ulator_map_list, list) {
|
|
|
|
if (rdev == node->regulator) {
|
|
|
|
list_del(&node->list);
|
2009-06-17 10:56:39 -06:00
|
|
|
kfree(node->dev_name);
|
2009-01-22 07:00:29 -07:00
|
|
|
kfree(node);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-30 08:59:04 -06:00
|
|
|
#define REG_STR_SIZE 32
|
|
|
|
|
|
|
|
static struct regulator *create_regulator(struct regulator_dev *rdev,
|
|
|
|
struct device *dev,
|
|
|
|
const char *supply_name)
|
|
|
|
{
|
|
|
|
struct regulator *regulator;
|
|
|
|
char buf[REG_STR_SIZE];
|
|
|
|
int err, size;
|
|
|
|
|
|
|
|
regulator = kzalloc(sizeof(*regulator), GFP_KERNEL);
|
|
|
|
if (regulator == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
mutex_lock(&rdev->mutex);
|
|
|
|
regulator->rdev = rdev;
|
|
|
|
list_add(®ulator->list, &rdev->consumer_list);
|
|
|
|
|
|
|
|
if (dev) {
|
|
|
|
/* create a 'requested_microamps_name' sysfs entry */
|
|
|
|
size = scnprintf(buf, REG_STR_SIZE, "microamps_requested_%s",
|
|
|
|
supply_name);
|
|
|
|
if (size >= REG_STR_SIZE)
|
|
|
|
goto overflow_err;
|
|
|
|
|
|
|
|
regulator->dev = dev;
|
|
|
|
regulator->dev_attr.attr.name = kstrdup(buf, GFP_KERNEL);
|
|
|
|
if (regulator->dev_attr.attr.name == NULL)
|
|
|
|
goto attr_name_err;
|
|
|
|
|
|
|
|
regulator->dev_attr.attr.owner = THIS_MODULE;
|
|
|
|
regulator->dev_attr.attr.mode = 0444;
|
|
|
|
regulator->dev_attr.show = device_requested_uA_show;
|
|
|
|
err = device_create_file(dev, ®ulator->dev_attr);
|
|
|
|
if (err < 0) {
|
|
|
|
printk(KERN_WARNING "%s: could not add regulator_dev"
|
|
|
|
" load sysfs\n", __func__);
|
|
|
|
goto attr_name_err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* also add a link to the device sysfs entry */
|
|
|
|
size = scnprintf(buf, REG_STR_SIZE, "%s-%s",
|
|
|
|
dev->kobj.name, supply_name);
|
|
|
|
if (size >= REG_STR_SIZE)
|
|
|
|
goto attr_err;
|
|
|
|
|
|
|
|
regulator->supply_name = kstrdup(buf, GFP_KERNEL);
|
|
|
|
if (regulator->supply_name == NULL)
|
|
|
|
goto attr_err;
|
|
|
|
|
|
|
|
err = sysfs_create_link(&rdev->dev.kobj, &dev->kobj,
|
|
|
|
buf);
|
|
|
|
if (err) {
|
|
|
|
printk(KERN_WARNING
|
|
|
|
"%s: could not add device link %s err %d\n",
|
|
|
|
__func__, dev->kobj.name, err);
|
|
|
|
device_remove_file(dev, ®ulator->dev_attr);
|
|
|
|
goto link_name_err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mutex_unlock(&rdev->mutex);
|
|
|
|
return regulator;
|
|
|
|
link_name_err:
|
|
|
|
kfree(regulator->supply_name);
|
|
|
|
attr_err:
|
|
|
|
device_remove_file(regulator->dev, ®ulator->dev_attr);
|
|
|
|
attr_name_err:
|
|
|
|
kfree(regulator->dev_attr.attr.name);
|
|
|
|
overflow_err:
|
|
|
|
list_del(®ulator->list);
|
|
|
|
kfree(regulator);
|
|
|
|
mutex_unlock(&rdev->mutex);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-07-21 09:00:23 -06:00
|
|
|
/* Internal regulator request function */
|
|
|
|
static struct regulator *_regulator_get(struct device *dev, const char *id,
|
|
|
|
int exclusive)
|
2008-04-30 08:59:04 -06:00
|
|
|
{
|
|
|
|
struct regulator_dev *rdev;
|
|
|
|
struct regulator_map *map;
|
|
|
|
struct regulator *regulator = ERR_PTR(-ENODEV);
|
2009-06-17 10:56:39 -06:00
|
|
|
const char *devname = NULL;
|
2009-07-21 09:00:23 -06:00
|
|
|
int ret;
|
2008-04-30 08:59:04 -06:00
|
|
|
|
|
|
|
if (id == NULL) {
|
|
|
|
printk(KERN_ERR "regulator: get() with no identifier\n");
|
|
|
|
return regulator;
|
|
|
|
}
|
|
|
|
|
2009-06-17 10:56:39 -06:00
|
|
|
if (dev)
|
|
|
|
devname = dev_name(dev);
|
|
|
|
|
2008-04-30 08:59:04 -06:00
|
|
|
mutex_lock(®ulator_list_mutex);
|
|
|
|
|
|
|
|
list_for_each_entry(map, ®ulator_map_list, list) {
|
2009-06-17 10:56:39 -06:00
|
|
|
/* If the mapping has a device set up it must match */
|
|
|
|
if (map->dev_name &&
|
|
|
|
(!devname || strcmp(map->dev_name, devname)))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (strcmp(map->supply, id) == 0) {
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
rdev = map->regulator;
|
2008-04-30 08:59:04 -06:00
|
|
|
goto found;
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
}
|
2008-04-30 08:59:04 -06:00
|
|
|
}
|
|
|
|
mutex_unlock(®ulator_list_mutex);
|
|
|
|
return regulator;
|
|
|
|
|
|
|
|
found:
|
2009-07-21 09:00:23 -06:00
|
|
|
if (rdev->exclusive) {
|
|
|
|
regulator = ERR_PTR(-EPERM);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (exclusive && rdev->open_count) {
|
|
|
|
regulator = ERR_PTR(-EBUSY);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
if (!try_module_get(rdev->owner))
|
|
|
|
goto out;
|
|
|
|
|
2008-04-30 08:59:04 -06:00
|
|
|
regulator = create_regulator(rdev, dev, id);
|
|
|
|
if (regulator == NULL) {
|
|
|
|
regulator = ERR_PTR(-ENOMEM);
|
|
|
|
module_put(rdev->owner);
|
|
|
|
}
|
|
|
|
|
2009-07-21 09:00:23 -06:00
|
|
|
rdev->open_count++;
|
|
|
|
if (exclusive) {
|
|
|
|
rdev->exclusive = 1;
|
|
|
|
|
|
|
|
ret = _regulator_is_enabled(rdev);
|
|
|
|
if (ret > 0)
|
|
|
|
rdev->use_count = 1;
|
|
|
|
else
|
|
|
|
rdev->use_count = 0;
|
|
|
|
}
|
|
|
|
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
out:
|
2008-04-30 08:59:04 -06:00
|
|
|
mutex_unlock(®ulator_list_mutex);
|
2009-07-21 09:00:23 -06:00
|
|
|
|
2008-04-30 08:59:04 -06:00
|
|
|
return regulator;
|
|
|
|
}
|
2009-07-21 09:00:23 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_get - lookup and obtain a reference to a regulator.
|
|
|
|
* @dev: device for regulator "consumer"
|
|
|
|
* @id: Supply name or regulator ID.
|
|
|
|
*
|
|
|
|
* Returns a struct regulator corresponding to the regulator producer,
|
|
|
|
* or IS_ERR() condition containing errno.
|
|
|
|
*
|
|
|
|
* Use of supply names configured via regulator_set_device_supply() is
|
|
|
|
* strongly encouraged. It is recommended that the supply name used
|
|
|
|
* should match the name used for the supply and/or the relevant
|
|
|
|
* device pins in the datasheet.
|
|
|
|
*/
|
|
|
|
struct regulator *regulator_get(struct device *dev, const char *id)
|
|
|
|
{
|
|
|
|
return _regulator_get(dev, id, 0);
|
|
|
|
}
|
2008-04-30 08:59:04 -06:00
|
|
|
EXPORT_SYMBOL_GPL(regulator_get);
|
|
|
|
|
2009-07-21 09:00:23 -06:00
|
|
|
/**
|
|
|
|
* regulator_get_exclusive - obtain exclusive access to a regulator.
|
|
|
|
* @dev: device for regulator "consumer"
|
|
|
|
* @id: Supply name or regulator ID.
|
|
|
|
*
|
|
|
|
* Returns a struct regulator corresponding to the regulator producer,
|
|
|
|
* or IS_ERR() condition containing errno. Other consumers will be
|
|
|
|
* unable to obtain this reference is held and the use count for the
|
|
|
|
* regulator will be initialised to reflect the current state of the
|
|
|
|
* regulator.
|
|
|
|
*
|
|
|
|
* This is intended for use by consumers which cannot tolerate shared
|
|
|
|
* use of the regulator such as those which need to force the
|
|
|
|
* regulator off for correct operation of the hardware they are
|
|
|
|
* controlling.
|
|
|
|
*
|
|
|
|
* Use of supply names configured via regulator_set_device_supply() is
|
|
|
|
* strongly encouraged. It is recommended that the supply name used
|
|
|
|
* should match the name used for the supply and/or the relevant
|
|
|
|
* device pins in the datasheet.
|
|
|
|
*/
|
|
|
|
struct regulator *regulator_get_exclusive(struct device *dev, const char *id)
|
|
|
|
{
|
|
|
|
return _regulator_get(dev, id, 1);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_get_exclusive);
|
|
|
|
|
2008-04-30 08:59:04 -06:00
|
|
|
/**
|
|
|
|
* regulator_put - "free" the regulator source
|
|
|
|
* @regulator: regulator source
|
|
|
|
*
|
|
|
|
* Note: drivers must ensure that all regulator_enable calls made on this
|
|
|
|
* regulator source are balanced by regulator_disable calls prior to calling
|
|
|
|
* this function.
|
|
|
|
*/
|
|
|
|
void regulator_put(struct regulator *regulator)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev;
|
|
|
|
|
|
|
|
if (regulator == NULL || IS_ERR(regulator))
|
|
|
|
return;
|
|
|
|
|
|
|
|
mutex_lock(®ulator_list_mutex);
|
|
|
|
rdev = regulator->rdev;
|
|
|
|
|
|
|
|
/* remove any sysfs entries */
|
|
|
|
if (regulator->dev) {
|
|
|
|
sysfs_remove_link(&rdev->dev.kobj, regulator->supply_name);
|
|
|
|
kfree(regulator->supply_name);
|
|
|
|
device_remove_file(regulator->dev, ®ulator->dev_attr);
|
|
|
|
kfree(regulator->dev_attr.attr.name);
|
|
|
|
}
|
|
|
|
list_del(®ulator->list);
|
|
|
|
kfree(regulator);
|
|
|
|
|
2009-07-21 09:00:23 -06:00
|
|
|
rdev->open_count--;
|
|
|
|
rdev->exclusive = 0;
|
|
|
|
|
2008-04-30 08:59:04 -06:00
|
|
|
module_put(rdev->owner);
|
|
|
|
mutex_unlock(®ulator_list_mutex);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_put);
|
|
|
|
|
2009-08-03 11:49:57 -06:00
|
|
|
static int _regulator_can_change_status(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
if (!rdev->constraints)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_STATUS)
|
|
|
|
return 1;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-30 08:59:04 -06:00
|
|
|
/* locks held by regulator_enable() */
|
|
|
|
static int _regulator_enable(struct regulator_dev *rdev)
|
|
|
|
{
|
2009-08-03 11:49:57 -06:00
|
|
|
int ret;
|
2008-04-30 08:59:04 -06:00
|
|
|
|
|
|
|
/* do we need to enable the supply regulator first */
|
|
|
|
if (rdev->supply) {
|
|
|
|
ret = _regulator_enable(rdev->supply);
|
|
|
|
if (ret < 0) {
|
|
|
|
printk(KERN_ERR "%s: failed to enable %s: %d\n",
|
|
|
|
__func__, rdev->desc->name, ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check voltage and requested load before enabling */
|
2009-08-03 11:49:57 -06:00
|
|
|
if (rdev->constraints &&
|
|
|
|
(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS))
|
|
|
|
drms_uA_update(rdev);
|
2008-04-30 08:59:04 -06:00
|
|
|
|
2009-08-03 11:49:57 -06:00
|
|
|
if (rdev->use_count == 0) {
|
|
|
|
/* The regulator may on if it's not switchable or left on */
|
|
|
|
ret = _regulator_is_enabled(rdev);
|
|
|
|
if (ret == -EINVAL || ret == 0) {
|
|
|
|
if (!_regulator_can_change_status(rdev))
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
if (rdev->desc->ops->enable) {
|
|
|
|
ret = rdev->desc->ops->enable(rdev);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
} else {
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2009-08-26 04:54:04 -06:00
|
|
|
} else if (ret < 0) {
|
2009-08-03 11:49:57 -06:00
|
|
|
printk(KERN_ERR "%s: is_enabled() failed for %s: %d\n",
|
2008-04-30 08:59:04 -06:00
|
|
|
__func__, rdev->desc->name, ret);
|
|
|
|
return ret;
|
|
|
|
}
|
2009-08-26 04:54:04 -06:00
|
|
|
/* Fallthrough on positive return values - already enabled */
|
2008-04-30 08:59:04 -06:00
|
|
|
}
|
|
|
|
|
2009-08-03 11:49:57 -06:00
|
|
|
rdev->use_count++;
|
|
|
|
|
|
|
|
return 0;
|
2008-04-30 08:59:04 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_enable - enable regulator output
|
|
|
|
* @regulator: regulator source
|
|
|
|
*
|
2008-12-31 05:52:43 -07:00
|
|
|
* Request that the regulator be enabled with the regulator output at
|
|
|
|
* the predefined voltage or current value. Calls to regulator_enable()
|
|
|
|
* must be balanced with calls to regulator_disable().
|
|
|
|
*
|
2008-04-30 08:59:04 -06:00
|
|
|
* NOTE: the output value can be set by other drivers, boot loader or may be
|
2008-12-31 05:52:43 -07:00
|
|
|
* hardwired in the regulator.
|
2008-04-30 08:59:04 -06:00
|
|
|
*/
|
|
|
|
int regulator_enable(struct regulator *regulator)
|
|
|
|
{
|
2008-11-16 12:44:46 -07:00
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
|
|
|
int ret = 0;
|
2008-04-30 08:59:04 -06:00
|
|
|
|
2008-11-16 12:44:46 -07:00
|
|
|
mutex_lock(&rdev->mutex);
|
2009-03-11 18:43:34 -06:00
|
|
|
ret = _regulator_enable(rdev);
|
2008-11-16 12:44:46 -07:00
|
|
|
mutex_unlock(&rdev->mutex);
|
2008-04-30 08:59:04 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_enable);
|
|
|
|
|
|
|
|
/* locks held by regulator_disable() */
|
|
|
|
static int _regulator_disable(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
2009-03-11 18:43:34 -06:00
|
|
|
if (WARN(rdev->use_count <= 0,
|
|
|
|
"unbalanced disables for %s\n",
|
|
|
|
rdev->desc->name))
|
|
|
|
return -EIO;
|
|
|
|
|
2008-04-30 08:59:04 -06:00
|
|
|
/* are we the last user and permitted to disable ? */
|
2009-10-13 06:06:50 -06:00
|
|
|
if (rdev->use_count == 1 &&
|
|
|
|
(rdev->constraints && !rdev->constraints->always_on)) {
|
2008-04-30 08:59:04 -06:00
|
|
|
|
|
|
|
/* we are last user */
|
2009-08-03 11:49:57 -06:00
|
|
|
if (_regulator_can_change_status(rdev) &&
|
|
|
|
rdev->desc->ops->disable) {
|
2008-04-30 08:59:04 -06:00
|
|
|
ret = rdev->desc->ops->disable(rdev);
|
|
|
|
if (ret < 0) {
|
|
|
|
printk(KERN_ERR "%s: failed to disable %s\n",
|
|
|
|
__func__, rdev->desc->name);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* decrease our supplies ref count and disable if required */
|
|
|
|
if (rdev->supply)
|
|
|
|
_regulator_disable(rdev->supply);
|
|
|
|
|
|
|
|
rdev->use_count = 0;
|
|
|
|
} else if (rdev->use_count > 1) {
|
|
|
|
|
|
|
|
if (rdev->constraints &&
|
|
|
|
(rdev->constraints->valid_ops_mask &
|
|
|
|
REGULATOR_CHANGE_DRMS))
|
|
|
|
drms_uA_update(rdev);
|
|
|
|
|
|
|
|
rdev->use_count--;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_disable - disable regulator output
|
|
|
|
* @regulator: regulator source
|
|
|
|
*
|
2008-12-31 05:52:43 -07:00
|
|
|
* Disable the regulator output voltage or current. Calls to
|
|
|
|
* regulator_enable() must be balanced with calls to
|
|
|
|
* regulator_disable().
|
2008-12-31 05:52:41 -07:00
|
|
|
*
|
2008-04-30 08:59:04 -06:00
|
|
|
* NOTE: this will only disable the regulator output if no other consumer
|
2008-12-31 05:52:43 -07:00
|
|
|
* devices have it enabled, the regulator device supports disabling and
|
|
|
|
* machine constraints permit this operation.
|
2008-04-30 08:59:04 -06:00
|
|
|
*/
|
|
|
|
int regulator_disable(struct regulator *regulator)
|
|
|
|
{
|
2008-11-16 12:44:46 -07:00
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
|
|
|
int ret = 0;
|
2008-04-30 08:59:04 -06:00
|
|
|
|
2008-11-16 12:44:46 -07:00
|
|
|
mutex_lock(&rdev->mutex);
|
2009-03-11 18:43:34 -06:00
|
|
|
ret = _regulator_disable(rdev);
|
2008-11-16 12:44:46 -07:00
|
|
|
mutex_unlock(&rdev->mutex);
|
2008-04-30 08:59:04 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_disable);
|
|
|
|
|
|
|
|
/* locks held by regulator_force_disable() */
|
|
|
|
static int _regulator_force_disable(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
/* force disable */
|
|
|
|
if (rdev->desc->ops->disable) {
|
|
|
|
/* ah well, who wants to live forever... */
|
|
|
|
ret = rdev->desc->ops->disable(rdev);
|
|
|
|
if (ret < 0) {
|
|
|
|
printk(KERN_ERR "%s: failed to force disable %s\n",
|
|
|
|
__func__, rdev->desc->name);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
/* notify other consumers that power has been forced off */
|
|
|
|
_notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE,
|
|
|
|
NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* decrease our supplies ref count and disable if required */
|
|
|
|
if (rdev->supply)
|
|
|
|
_regulator_disable(rdev->supply);
|
|
|
|
|
|
|
|
rdev->use_count = 0;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_force_disable - force disable regulator output
|
|
|
|
* @regulator: regulator source
|
|
|
|
*
|
|
|
|
* Forcibly disable the regulator output voltage or current.
|
|
|
|
* NOTE: this *will* disable the regulator output even if other consumer
|
|
|
|
* devices have it enabled. This should be used for situations when device
|
|
|
|
* damage will likely occur if the regulator is not disabled (e.g. over temp).
|
|
|
|
*/
|
|
|
|
int regulator_force_disable(struct regulator *regulator)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
mutex_lock(®ulator->rdev->mutex);
|
|
|
|
regulator->uA_load = 0;
|
|
|
|
ret = _regulator_force_disable(regulator->rdev);
|
|
|
|
mutex_unlock(®ulator->rdev->mutex);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_force_disable);
|
|
|
|
|
|
|
|
static int _regulator_is_enabled(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
/* sanity check */
|
2009-08-03 11:49:56 -06:00
|
|
|
if (!rdev->desc->ops->is_enabled)
|
|
|
|
return -EINVAL;
|
2008-04-30 08:59:04 -06:00
|
|
|
|
2009-08-03 11:49:56 -06:00
|
|
|
return rdev->desc->ops->is_enabled(rdev);
|
2008-04-30 08:59:04 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_is_enabled - is the regulator output enabled
|
|
|
|
* @regulator: regulator source
|
|
|
|
*
|
2008-11-16 12:44:46 -07:00
|
|
|
* Returns positive if the regulator driver backing the source/client
|
|
|
|
* has requested that the device be enabled, zero if it hasn't, else a
|
|
|
|
* negative errno code.
|
|
|
|
*
|
|
|
|
* Note that the device backing this regulator handle can have multiple
|
|
|
|
* users, so it might be enabled even if regulator_enable() was never
|
|
|
|
* called for this particular source.
|
2008-04-30 08:59:04 -06:00
|
|
|
*/
|
|
|
|
int regulator_is_enabled(struct regulator *regulator)
|
|
|
|
{
|
2009-08-03 11:49:56 -06:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
mutex_lock(®ulator->rdev->mutex);
|
|
|
|
ret = _regulator_is_enabled(regulator->rdev);
|
|
|
|
mutex_unlock(®ulator->rdev->mutex);
|
|
|
|
|
|
|
|
return ret;
|
2008-04-30 08:59:04 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_is_enabled);
|
|
|
|
|
2009-02-26 12:48:36 -07:00
|
|
|
/**
|
|
|
|
* regulator_count_voltages - count regulator_list_voltage() selectors
|
|
|
|
* @regulator: regulator source
|
|
|
|
*
|
|
|
|
* Returns number of selectors, or negative errno. Selectors are
|
|
|
|
* numbered starting at zero, and typically correspond to bitfields
|
|
|
|
* in hardware registers.
|
|
|
|
*/
|
|
|
|
int regulator_count_voltages(struct regulator *regulator)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
|
|
|
|
|
|
|
return rdev->desc->n_voltages ? : -EINVAL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_count_voltages);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_list_voltage - enumerate supported voltages
|
|
|
|
* @regulator: regulator source
|
|
|
|
* @selector: identify voltage to list
|
|
|
|
* Context: can sleep
|
|
|
|
*
|
|
|
|
* Returns a voltage that can be passed to @regulator_set_voltage(),
|
|
|
|
* zero if this selector code can't be used on this sytem, or a
|
|
|
|
* negative errno.
|
|
|
|
*/
|
|
|
|
int regulator_list_voltage(struct regulator *regulator, unsigned selector)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
|
|
|
struct regulator_ops *ops = rdev->desc->ops;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!ops->list_voltage || selector >= rdev->desc->n_voltages)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
mutex_lock(&rdev->mutex);
|
|
|
|
ret = ops->list_voltage(rdev, selector);
|
|
|
|
mutex_unlock(&rdev->mutex);
|
|
|
|
|
|
|
|
if (ret > 0) {
|
|
|
|
if (ret < rdev->constraints->min_uV)
|
|
|
|
ret = 0;
|
|
|
|
else if (ret > rdev->constraints->max_uV)
|
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_list_voltage);
|
|
|
|
|
2009-07-21 09:00:24 -06:00
|
|
|
/**
|
|
|
|
* regulator_is_supported_voltage - check if a voltage range can be supported
|
|
|
|
*
|
|
|
|
* @regulator: Regulator to check.
|
|
|
|
* @min_uV: Minimum required voltage in uV.
|
|
|
|
* @max_uV: Maximum required voltage in uV.
|
|
|
|
*
|
|
|
|
* Returns a boolean or a negative error code.
|
|
|
|
*/
|
|
|
|
int regulator_is_supported_voltage(struct regulator *regulator,
|
|
|
|
int min_uV, int max_uV)
|
|
|
|
{
|
|
|
|
int i, voltages, ret;
|
|
|
|
|
|
|
|
ret = regulator_count_voltages(regulator);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
voltages = ret;
|
|
|
|
|
|
|
|
for (i = 0; i < voltages; i++) {
|
|
|
|
ret = regulator_list_voltage(regulator, i);
|
|
|
|
|
|
|
|
if (ret >= min_uV && ret <= max_uV)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-30 08:59:04 -06:00
|
|
|
/**
|
|
|
|
* regulator_set_voltage - set regulator output voltage
|
|
|
|
* @regulator: regulator source
|
|
|
|
* @min_uV: Minimum required voltage in uV
|
|
|
|
* @max_uV: Maximum acceptable voltage in uV
|
|
|
|
*
|
|
|
|
* Sets a voltage regulator to the desired output voltage. This can be set
|
|
|
|
* during any regulator state. IOW, regulator can be disabled or enabled.
|
|
|
|
*
|
|
|
|
* If the regulator is enabled then the voltage will change to the new value
|
|
|
|
* immediately otherwise if the regulator is disabled the regulator will
|
|
|
|
* output at the new voltage when enabled.
|
|
|
|
*
|
|
|
|
* NOTE: If the regulator is shared between several devices then the lowest
|
|
|
|
* request voltage that meets the system constraints will be used.
|
2008-12-31 05:52:41 -07:00
|
|
|
* Regulator system constraints must be set for this regulator before
|
2008-04-30 08:59:04 -06:00
|
|
|
* calling this function otherwise this call will fail.
|
|
|
|
*/
|
|
|
|
int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
mutex_lock(&rdev->mutex);
|
|
|
|
|
|
|
|
/* sanity check */
|
|
|
|
if (!rdev->desc->ops->set_voltage) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* constraints check */
|
|
|
|
ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
regulator->min_uV = min_uV;
|
|
|
|
regulator->max_uV = max_uV;
|
|
|
|
ret = rdev->desc->ops->set_voltage(rdev, min_uV, max_uV);
|
|
|
|
|
|
|
|
out:
|
2009-01-19 11:20:58 -07:00
|
|
|
_notifier_call_chain(rdev, REGULATOR_EVENT_VOLTAGE_CHANGE, NULL);
|
2008-04-30 08:59:04 -06:00
|
|
|
mutex_unlock(&rdev->mutex);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_set_voltage);
|
|
|
|
|
|
|
|
static int _regulator_get_voltage(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
/* sanity check */
|
|
|
|
if (rdev->desc->ops->get_voltage)
|
|
|
|
return rdev->desc->ops->get_voltage(rdev);
|
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_get_voltage - get regulator output voltage
|
|
|
|
* @regulator: regulator source
|
|
|
|
*
|
|
|
|
* This returns the current regulator voltage in uV.
|
|
|
|
*
|
|
|
|
* NOTE: If the regulator is disabled it will return the voltage value. This
|
|
|
|
* function should not be used to determine regulator state.
|
|
|
|
*/
|
|
|
|
int regulator_get_voltage(struct regulator *regulator)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
mutex_lock(®ulator->rdev->mutex);
|
|
|
|
|
|
|
|
ret = _regulator_get_voltage(regulator->rdev);
|
|
|
|
|
|
|
|
mutex_unlock(®ulator->rdev->mutex);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_get_voltage);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_set_current_limit - set regulator output current limit
|
|
|
|
* @regulator: regulator source
|
|
|
|
* @min_uA: Minimuum supported current in uA
|
|
|
|
* @max_uA: Maximum supported current in uA
|
|
|
|
*
|
|
|
|
* Sets current sink to the desired output current. This can be set during
|
|
|
|
* any regulator state. IOW, regulator can be disabled or enabled.
|
|
|
|
*
|
|
|
|
* If the regulator is enabled then the current will change to the new value
|
|
|
|
* immediately otherwise if the regulator is disabled the regulator will
|
|
|
|
* output at the new current when enabled.
|
|
|
|
*
|
|
|
|
* NOTE: Regulator system constraints must be set for this regulator before
|
|
|
|
* calling this function otherwise this call will fail.
|
|
|
|
*/
|
|
|
|
int regulator_set_current_limit(struct regulator *regulator,
|
|
|
|
int min_uA, int max_uA)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
mutex_lock(&rdev->mutex);
|
|
|
|
|
|
|
|
/* sanity check */
|
|
|
|
if (!rdev->desc->ops->set_current_limit) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* constraints check */
|
|
|
|
ret = regulator_check_current_limit(rdev, &min_uA, &max_uA);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = rdev->desc->ops->set_current_limit(rdev, min_uA, max_uA);
|
|
|
|
out:
|
|
|
|
mutex_unlock(&rdev->mutex);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_set_current_limit);
|
|
|
|
|
|
|
|
static int _regulator_get_current_limit(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
mutex_lock(&rdev->mutex);
|
|
|
|
|
|
|
|
/* sanity check */
|
|
|
|
if (!rdev->desc->ops->get_current_limit) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = rdev->desc->ops->get_current_limit(rdev);
|
|
|
|
out:
|
|
|
|
mutex_unlock(&rdev->mutex);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_get_current_limit - get regulator output current
|
|
|
|
* @regulator: regulator source
|
|
|
|
*
|
|
|
|
* This returns the current supplied by the specified current sink in uA.
|
|
|
|
*
|
|
|
|
* NOTE: If the regulator is disabled it will return the current value. This
|
|
|
|
* function should not be used to determine regulator state.
|
|
|
|
*/
|
|
|
|
int regulator_get_current_limit(struct regulator *regulator)
|
|
|
|
{
|
|
|
|
return _regulator_get_current_limit(regulator->rdev);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_get_current_limit);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_set_mode - set regulator operating mode
|
|
|
|
* @regulator: regulator source
|
|
|
|
* @mode: operating mode - one of the REGULATOR_MODE constants
|
|
|
|
*
|
|
|
|
* Set regulator operating mode to increase regulator efficiency or improve
|
|
|
|
* regulation performance.
|
|
|
|
*
|
|
|
|
* NOTE: Regulator system constraints must be set for this regulator before
|
|
|
|
* calling this function otherwise this call will fail.
|
|
|
|
*/
|
|
|
|
int regulator_set_mode(struct regulator *regulator, unsigned int mode)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
mutex_lock(&rdev->mutex);
|
|
|
|
|
|
|
|
/* sanity check */
|
|
|
|
if (!rdev->desc->ops->set_mode) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* constraints check */
|
|
|
|
ret = regulator_check_mode(rdev, mode);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = rdev->desc->ops->set_mode(rdev, mode);
|
|
|
|
out:
|
|
|
|
mutex_unlock(&rdev->mutex);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_set_mode);
|
|
|
|
|
|
|
|
static unsigned int _regulator_get_mode(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
mutex_lock(&rdev->mutex);
|
|
|
|
|
|
|
|
/* sanity check */
|
|
|
|
if (!rdev->desc->ops->get_mode) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = rdev->desc->ops->get_mode(rdev);
|
|
|
|
out:
|
|
|
|
mutex_unlock(&rdev->mutex);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_get_mode - get regulator operating mode
|
|
|
|
* @regulator: regulator source
|
|
|
|
*
|
|
|
|
* Get the current regulator operating mode.
|
|
|
|
*/
|
|
|
|
unsigned int regulator_get_mode(struct regulator *regulator)
|
|
|
|
{
|
|
|
|
return _regulator_get_mode(regulator->rdev);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_get_mode);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_set_optimum_mode - set regulator optimum operating mode
|
|
|
|
* @regulator: regulator source
|
|
|
|
* @uA_load: load current
|
|
|
|
*
|
|
|
|
* Notifies the regulator core of a new device load. This is then used by
|
|
|
|
* DRMS (if enabled by constraints) to set the most efficient regulator
|
|
|
|
* operating mode for the new regulator loading.
|
|
|
|
*
|
|
|
|
* Consumer devices notify their supply regulator of the maximum power
|
|
|
|
* they will require (can be taken from device datasheet in the power
|
|
|
|
* consumption tables) when they change operational status and hence power
|
|
|
|
* state. Examples of operational state changes that can affect power
|
|
|
|
* consumption are :-
|
|
|
|
*
|
|
|
|
* o Device is opened / closed.
|
|
|
|
* o Device I/O is about to begin or has just finished.
|
|
|
|
* o Device is idling in between work.
|
|
|
|
*
|
|
|
|
* This information is also exported via sysfs to userspace.
|
|
|
|
*
|
|
|
|
* DRMS will sum the total requested load on the regulator and change
|
|
|
|
* to the most efficient operating mode if platform constraints allow.
|
|
|
|
*
|
|
|
|
* Returns the new regulator mode or error.
|
|
|
|
*/
|
|
|
|
int regulator_set_optimum_mode(struct regulator *regulator, int uA_load)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
|
|
|
struct regulator *consumer;
|
|
|
|
int ret, output_uV, input_uV, total_uA_load = 0;
|
|
|
|
unsigned int mode;
|
|
|
|
|
|
|
|
mutex_lock(&rdev->mutex);
|
|
|
|
|
|
|
|
regulator->uA_load = uA_load;
|
|
|
|
ret = regulator_check_drms(rdev);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
|
|
|
/* sanity check */
|
|
|
|
if (!rdev->desc->ops->get_optimum_mode)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* get output voltage */
|
|
|
|
output_uV = rdev->desc->ops->get_voltage(rdev);
|
|
|
|
if (output_uV <= 0) {
|
|
|
|
printk(KERN_ERR "%s: invalid output voltage found for %s\n",
|
|
|
|
__func__, rdev->desc->name);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* get input voltage */
|
|
|
|
if (rdev->supply && rdev->supply->desc->ops->get_voltage)
|
|
|
|
input_uV = rdev->supply->desc->ops->get_voltage(rdev->supply);
|
|
|
|
else
|
|
|
|
input_uV = rdev->constraints->input_uV;
|
|
|
|
if (input_uV <= 0) {
|
|
|
|
printk(KERN_ERR "%s: invalid input voltage found for %s\n",
|
|
|
|
__func__, rdev->desc->name);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* calc total requested load for this regulator */
|
|
|
|
list_for_each_entry(consumer, &rdev->consumer_list, list)
|
|
|
|
total_uA_load += consumer->uA_load;
|
|
|
|
|
|
|
|
mode = rdev->desc->ops->get_optimum_mode(rdev,
|
|
|
|
input_uV, output_uV,
|
|
|
|
total_uA_load);
|
2008-11-16 12:46:56 -07:00
|
|
|
ret = regulator_check_mode(rdev, mode);
|
|
|
|
if (ret < 0) {
|
2008-04-30 08:59:04 -06:00
|
|
|
printk(KERN_ERR "%s: failed to get optimum mode for %s @"
|
|
|
|
" %d uA %d -> %d uV\n", __func__, rdev->desc->name,
|
|
|
|
total_uA_load, input_uV, output_uV);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = rdev->desc->ops->set_mode(rdev, mode);
|
2008-11-16 12:46:56 -07:00
|
|
|
if (ret < 0) {
|
2008-04-30 08:59:04 -06:00
|
|
|
printk(KERN_ERR "%s: failed to set optimum mode %x for %s\n",
|
|
|
|
__func__, mode, rdev->desc->name);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
ret = mode;
|
|
|
|
out:
|
|
|
|
mutex_unlock(&rdev->mutex);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_set_optimum_mode);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_register_notifier - register regulator event notifier
|
|
|
|
* @regulator: regulator source
|
2008-12-31 05:52:41 -07:00
|
|
|
* @nb: notifier block
|
2008-04-30 08:59:04 -06:00
|
|
|
*
|
|
|
|
* Register notifier block to receive regulator events.
|
|
|
|
*/
|
|
|
|
int regulator_register_notifier(struct regulator *regulator,
|
|
|
|
struct notifier_block *nb)
|
|
|
|
{
|
|
|
|
return blocking_notifier_chain_register(®ulator->rdev->notifier,
|
|
|
|
nb);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_register_notifier);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_unregister_notifier - unregister regulator event notifier
|
|
|
|
* @regulator: regulator source
|
2008-12-31 05:52:41 -07:00
|
|
|
* @nb: notifier block
|
2008-04-30 08:59:04 -06:00
|
|
|
*
|
|
|
|
* Unregister regulator event notifier block.
|
|
|
|
*/
|
|
|
|
int regulator_unregister_notifier(struct regulator *regulator,
|
|
|
|
struct notifier_block *nb)
|
|
|
|
{
|
|
|
|
return blocking_notifier_chain_unregister(®ulator->rdev->notifier,
|
|
|
|
nb);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_unregister_notifier);
|
|
|
|
|
2009-01-19 11:20:58 -07:00
|
|
|
/* notify regulator consumers and downstream regulator consumers.
|
|
|
|
* Note mutex must be held by caller.
|
|
|
|
*/
|
2008-04-30 08:59:04 -06:00
|
|
|
static void _notifier_call_chain(struct regulator_dev *rdev,
|
|
|
|
unsigned long event, void *data)
|
|
|
|
{
|
|
|
|
struct regulator_dev *_rdev;
|
|
|
|
|
|
|
|
/* call rdev chain first */
|
|
|
|
blocking_notifier_call_chain(&rdev->notifier, event, NULL);
|
|
|
|
|
|
|
|
/* now notify regulator we supply */
|
2009-01-19 11:20:58 -07:00
|
|
|
list_for_each_entry(_rdev, &rdev->supply_list, slist) {
|
|
|
|
mutex_lock(&_rdev->mutex);
|
|
|
|
_notifier_call_chain(_rdev, event, data);
|
|
|
|
mutex_unlock(&_rdev->mutex);
|
|
|
|
}
|
2008-04-30 08:59:04 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_bulk_get - get multiple regulator consumers
|
|
|
|
*
|
|
|
|
* @dev: Device to supply
|
|
|
|
* @num_consumers: Number of consumers to register
|
|
|
|
* @consumers: Configuration of consumers; clients are stored here.
|
|
|
|
*
|
|
|
|
* @return 0 on success, an errno on failure.
|
|
|
|
*
|
|
|
|
* This helper function allows drivers to get several regulator
|
|
|
|
* consumers in one operation. If any of the regulators cannot be
|
|
|
|
* acquired then any regulators that were allocated will be freed
|
|
|
|
* before returning to the caller.
|
|
|
|
*/
|
|
|
|
int regulator_bulk_get(struct device *dev, int num_consumers,
|
|
|
|
struct regulator_bulk_data *consumers)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
for (i = 0; i < num_consumers; i++)
|
|
|
|
consumers[i].consumer = NULL;
|
|
|
|
|
|
|
|
for (i = 0; i < num_consumers; i++) {
|
|
|
|
consumers[i].consumer = regulator_get(dev,
|
|
|
|
consumers[i].supply);
|
|
|
|
if (IS_ERR(consumers[i].consumer)) {
|
|
|
|
dev_err(dev, "Failed to get supply '%s'\n",
|
|
|
|
consumers[i].supply);
|
|
|
|
ret = PTR_ERR(consumers[i].consumer);
|
|
|
|
consumers[i].consumer = NULL;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
|
|
|
for (i = 0; i < num_consumers && consumers[i].consumer; i++)
|
|
|
|
regulator_put(consumers[i].consumer);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_bulk_get);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_bulk_enable - enable multiple regulator consumers
|
|
|
|
*
|
|
|
|
* @num_consumers: Number of consumers
|
|
|
|
* @consumers: Consumer data; clients are stored here.
|
|
|
|
* @return 0 on success, an errno on failure
|
|
|
|
*
|
|
|
|
* This convenience API allows consumers to enable multiple regulator
|
|
|
|
* clients in a single API call. If any consumers cannot be enabled
|
|
|
|
* then any others that were enabled will be disabled again prior to
|
|
|
|
* return.
|
|
|
|
*/
|
|
|
|
int regulator_bulk_enable(int num_consumers,
|
|
|
|
struct regulator_bulk_data *consumers)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
for (i = 0; i < num_consumers; i++) {
|
|
|
|
ret = regulator_enable(consumers[i].consumer);
|
|
|
|
if (ret != 0)
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
|
|
|
printk(KERN_ERR "Failed to enable %s\n", consumers[i].supply);
|
|
|
|
for (i = 0; i < num_consumers; i++)
|
|
|
|
regulator_disable(consumers[i].consumer);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_bulk_enable);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_bulk_disable - disable multiple regulator consumers
|
|
|
|
*
|
|
|
|
* @num_consumers: Number of consumers
|
|
|
|
* @consumers: Consumer data; clients are stored here.
|
|
|
|
* @return 0 on success, an errno on failure
|
|
|
|
*
|
|
|
|
* This convenience API allows consumers to disable multiple regulator
|
|
|
|
* clients in a single API call. If any consumers cannot be enabled
|
|
|
|
* then any others that were disabled will be disabled again prior to
|
|
|
|
* return.
|
|
|
|
*/
|
|
|
|
int regulator_bulk_disable(int num_consumers,
|
|
|
|
struct regulator_bulk_data *consumers)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
for (i = 0; i < num_consumers; i++) {
|
|
|
|
ret = regulator_disable(consumers[i].consumer);
|
|
|
|
if (ret != 0)
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
|
|
|
printk(KERN_ERR "Failed to disable %s\n", consumers[i].supply);
|
|
|
|
for (i = 0; i < num_consumers; i++)
|
|
|
|
regulator_enable(consumers[i].consumer);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_bulk_disable);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_bulk_free - free multiple regulator consumers
|
|
|
|
*
|
|
|
|
* @num_consumers: Number of consumers
|
|
|
|
* @consumers: Consumer data; clients are stored here.
|
|
|
|
*
|
|
|
|
* This convenience API allows consumers to free multiple regulator
|
|
|
|
* clients in a single API call.
|
|
|
|
*/
|
|
|
|
void regulator_bulk_free(int num_consumers,
|
|
|
|
struct regulator_bulk_data *consumers)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < num_consumers; i++) {
|
|
|
|
regulator_put(consumers[i].consumer);
|
|
|
|
consumers[i].consumer = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_bulk_free);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_notifier_call_chain - call regulator event notifier
|
2008-12-31 05:52:41 -07:00
|
|
|
* @rdev: regulator source
|
2008-04-30 08:59:04 -06:00
|
|
|
* @event: notifier block
|
2008-12-31 05:52:41 -07:00
|
|
|
* @data: callback-specific data.
|
2008-04-30 08:59:04 -06:00
|
|
|
*
|
|
|
|
* Called by regulator drivers to notify clients a regulator event has
|
|
|
|
* occurred. We also notify regulator clients downstream.
|
2009-01-19 11:20:58 -07:00
|
|
|
* Note lock must be held by caller.
|
2008-04-30 08:59:04 -06:00
|
|
|
*/
|
|
|
|
int regulator_notifier_call_chain(struct regulator_dev *rdev,
|
|
|
|
unsigned long event, void *data)
|
|
|
|
{
|
|
|
|
_notifier_call_chain(rdev, event, data);
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_notifier_call_chain);
|
|
|
|
|
2009-08-04 12:09:52 -06:00
|
|
|
/**
|
|
|
|
* regulator_mode_to_status - convert a regulator mode into a status
|
|
|
|
*
|
|
|
|
* @mode: Mode to convert
|
|
|
|
*
|
|
|
|
* Convert a regulator mode into a status.
|
|
|
|
*/
|
|
|
|
int regulator_mode_to_status(unsigned int mode)
|
|
|
|
{
|
|
|
|
switch (mode) {
|
|
|
|
case REGULATOR_MODE_FAST:
|
|
|
|
return REGULATOR_STATUS_FAST;
|
|
|
|
case REGULATOR_MODE_NORMAL:
|
|
|
|
return REGULATOR_STATUS_NORMAL;
|
|
|
|
case REGULATOR_MODE_IDLE:
|
|
|
|
return REGULATOR_STATUS_IDLE;
|
|
|
|
case REGULATOR_STATUS_STANDBY:
|
|
|
|
return REGULATOR_STATUS_STANDBY;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_mode_to_status);
|
|
|
|
|
2008-11-11 18:39:02 -07:00
|
|
|
/*
|
|
|
|
* To avoid cluttering sysfs (and memory) with useless state, only
|
|
|
|
* create attributes that can be meaningfully displayed.
|
|
|
|
*/
|
|
|
|
static int add_regulator_attributes(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
struct device *dev = &rdev->dev;
|
|
|
|
struct regulator_ops *ops = rdev->desc->ops;
|
|
|
|
int status = 0;
|
|
|
|
|
|
|
|
/* some attributes need specific methods to be displayed */
|
|
|
|
if (ops->get_voltage) {
|
|
|
|
status = device_create_file(dev, &dev_attr_microvolts);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
if (ops->get_current_limit) {
|
|
|
|
status = device_create_file(dev, &dev_attr_microamps);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
if (ops->get_mode) {
|
|
|
|
status = device_create_file(dev, &dev_attr_opmode);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
if (ops->is_enabled) {
|
|
|
|
status = device_create_file(dev, &dev_attr_state);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
}
|
2009-01-15 00:03:17 -07:00
|
|
|
if (ops->get_status) {
|
|
|
|
status = device_create_file(dev, &dev_attr_status);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
}
|
2008-11-11 18:39:02 -07:00
|
|
|
|
|
|
|
/* some attributes are type-specific */
|
|
|
|
if (rdev->desc->type == REGULATOR_CURRENT) {
|
|
|
|
status = device_create_file(dev, &dev_attr_requested_microamps);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* all the other attributes exist to support constraints;
|
|
|
|
* don't show them if there are no constraints, or if the
|
|
|
|
* relevant supporting methods are missing.
|
|
|
|
*/
|
|
|
|
if (!rdev->constraints)
|
|
|
|
return status;
|
|
|
|
|
|
|
|
/* constraints need specific supporting methods */
|
|
|
|
if (ops->set_voltage) {
|
|
|
|
status = device_create_file(dev, &dev_attr_min_microvolts);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
status = device_create_file(dev, &dev_attr_max_microvolts);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
if (ops->set_current_limit) {
|
|
|
|
status = device_create_file(dev, &dev_attr_min_microamps);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
status = device_create_file(dev, &dev_attr_max_microamps);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* suspend mode constraints need multiple supporting methods */
|
|
|
|
if (!(ops->set_suspend_enable && ops->set_suspend_disable))
|
|
|
|
return status;
|
|
|
|
|
|
|
|
status = device_create_file(dev, &dev_attr_suspend_standby_state);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
status = device_create_file(dev, &dev_attr_suspend_mem_state);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
status = device_create_file(dev, &dev_attr_suspend_disk_state);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
|
|
|
|
if (ops->set_suspend_voltage) {
|
|
|
|
status = device_create_file(dev,
|
|
|
|
&dev_attr_suspend_standby_microvolts);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
status = device_create_file(dev,
|
|
|
|
&dev_attr_suspend_mem_microvolts);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
status = device_create_file(dev,
|
|
|
|
&dev_attr_suspend_disk_microvolts);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ops->set_suspend_mode) {
|
|
|
|
status = device_create_file(dev,
|
|
|
|
&dev_attr_suspend_standby_mode);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
status = device_create_file(dev,
|
|
|
|
&dev_attr_suspend_mem_mode);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
status = device_create_file(dev,
|
|
|
|
&dev_attr_suspend_disk_mode);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2008-04-30 08:59:04 -06:00
|
|
|
/**
|
|
|
|
* regulator_register - register regulator
|
2008-12-31 05:52:41 -07:00
|
|
|
* @regulator_desc: regulator to register
|
|
|
|
* @dev: struct device for the regulator
|
2009-01-19 06:37:02 -07:00
|
|
|
* @init_data: platform provided init data, passed through by driver
|
2008-12-31 05:52:41 -07:00
|
|
|
* @driver_data: private regulator data
|
2008-04-30 08:59:04 -06:00
|
|
|
*
|
|
|
|
* Called by regulator drivers to register a regulator.
|
|
|
|
* Returns 0 on success.
|
|
|
|
*/
|
|
|
|
struct regulator_dev *regulator_register(struct regulator_desc *regulator_desc,
|
2009-01-19 06:37:02 -07:00
|
|
|
struct device *dev, struct regulator_init_data *init_data,
|
|
|
|
void *driver_data)
|
2008-04-30 08:59:04 -06:00
|
|
|
{
|
|
|
|
static atomic_t regulator_no = ATOMIC_INIT(0);
|
|
|
|
struct regulator_dev *rdev;
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
int ret, i;
|
2008-04-30 08:59:04 -06:00
|
|
|
|
|
|
|
if (regulator_desc == NULL)
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
|
|
|
|
if (regulator_desc->name == NULL || regulator_desc->ops == NULL)
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
|
2009-04-13 19:04:47 -06:00
|
|
|
if (regulator_desc->type != REGULATOR_VOLTAGE &&
|
|
|
|
regulator_desc->type != REGULATOR_CURRENT)
|
2008-04-30 08:59:04 -06:00
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
|
2008-09-09 09:21:18 -06:00
|
|
|
if (!init_data)
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
|
2008-04-30 08:59:04 -06:00
|
|
|
rdev = kzalloc(sizeof(struct regulator_dev), GFP_KERNEL);
|
|
|
|
if (rdev == NULL)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
mutex_lock(®ulator_list_mutex);
|
|
|
|
|
|
|
|
mutex_init(&rdev->mutex);
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
rdev->reg_data = driver_data;
|
2008-04-30 08:59:04 -06:00
|
|
|
rdev->owner = regulator_desc->owner;
|
|
|
|
rdev->desc = regulator_desc;
|
|
|
|
INIT_LIST_HEAD(&rdev->consumer_list);
|
|
|
|
INIT_LIST_HEAD(&rdev->supply_list);
|
|
|
|
INIT_LIST_HEAD(&rdev->list);
|
|
|
|
INIT_LIST_HEAD(&rdev->slist);
|
|
|
|
BLOCKING_INIT_NOTIFIER_HEAD(&rdev->notifier);
|
|
|
|
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
/* preform any regulator specific init */
|
|
|
|
if (init_data->regulator_init) {
|
|
|
|
ret = init_data->regulator_init(rdev->reg_data);
|
2008-11-11 18:38:53 -07:00
|
|
|
if (ret < 0)
|
|
|
|
goto clean;
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* register with sysfs */
|
2008-04-30 08:59:04 -06:00
|
|
|
rdev->dev.class = ®ulator_class;
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
rdev->dev.parent = dev;
|
regulator: struct device - replace bus_id with dev_name(), dev_set_name()
This patch is part of a larger patch series which will remove
the "char bus_id[20]" name string from struct device. The device
name is managed in the kobject anyway, and without any size
limitation, and just needlessly copied into "struct device".
To set and read the device name dev_name(dev) and dev_set_name(dev)
must be used. If your code uses static kobjects, which it shouldn't
do, "const char *init_name" can be used to statically provide the
name the registered device should have. At registration time, the
init_name field is cleared, to enforce the use of dev_name(dev) to
access the device name at a later time.
We need to get rid of all occurrences of bus_id in the entire tree
to be able to enable the new interface. Please apply this patch,
and possibly convert any remaining remaining occurrences of bus_id.
We want to submit a patch to -next, which will remove bus_id from
"struct device", to find the remaining pieces to convert, and finally
switch over to the new api, which will remove the 20 bytes array
and does no longer have a size limitation.
Thanks,
Kay
From: Kay Sievers <kay.sievers@vrfy.org>
Subject: regulator: struct device - replace bus_id with dev_name(), dev_set_name()
Cc: Liam Girdwood <lrg@slimlogic.co.uk>
Acked-by: Greg Kroah-Hartman <gregkh@suse.de>
Signed-Off-By: Kay Sievers <kay.sievers@vrfy.org>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-11-01 20:55:10 -06:00
|
|
|
dev_set_name(&rdev->dev, "regulator.%d",
|
|
|
|
atomic_inc_return(®ulator_no) - 1);
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
ret = device_register(&rdev->dev);
|
2008-11-11 18:38:53 -07:00
|
|
|
if (ret != 0)
|
|
|
|
goto clean;
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
|
|
|
|
dev_set_drvdata(&rdev->dev, rdev);
|
|
|
|
|
2008-11-25 05:53:53 -07:00
|
|
|
/* set regulator constraints */
|
|
|
|
ret = set_machine_constraints(rdev, &init_data->constraints);
|
|
|
|
if (ret < 0)
|
|
|
|
goto scrub;
|
|
|
|
|
2008-11-11 18:39:02 -07:00
|
|
|
/* add attributes supported by this regulator */
|
|
|
|
ret = add_regulator_attributes(rdev);
|
|
|
|
if (ret < 0)
|
|
|
|
goto scrub;
|
|
|
|
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
/* set supply regulator if it exists */
|
|
|
|
if (init_data->supply_regulator_dev) {
|
|
|
|
ret = set_supply(rdev,
|
|
|
|
dev_get_drvdata(init_data->supply_regulator_dev));
|
2008-11-11 18:38:53 -07:00
|
|
|
if (ret < 0)
|
|
|
|
goto scrub;
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* add consumers devices */
|
|
|
|
for (i = 0; i < init_data->num_consumer_supplies; i++) {
|
|
|
|
ret = set_consumer_device_supply(rdev,
|
|
|
|
init_data->consumer_supplies[i].dev,
|
2009-06-17 10:56:39 -06:00
|
|
|
init_data->consumer_supplies[i].dev_name,
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
init_data->consumer_supplies[i].supply);
|
|
|
|
if (ret < 0) {
|
|
|
|
for (--i; i >= 0; i--)
|
|
|
|
unset_consumer_device_supply(rdev,
|
2009-06-17 10:56:39 -06:00
|
|
|
init_data->consumer_supplies[i].dev_name,
|
|
|
|
init_data->consumer_supplies[i].dev);
|
2008-11-11 18:38:53 -07:00
|
|
|
goto scrub;
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
}
|
2008-04-30 08:59:04 -06:00
|
|
|
}
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
|
|
|
|
list_add(&rdev->list, ®ulator_list);
|
|
|
|
out:
|
2008-04-30 08:59:04 -06:00
|
|
|
mutex_unlock(®ulator_list_mutex);
|
|
|
|
return rdev;
|
2008-11-11 18:38:53 -07:00
|
|
|
|
|
|
|
scrub:
|
|
|
|
device_unregister(&rdev->dev);
|
2009-04-25 05:28:36 -06:00
|
|
|
/* device core frees rdev */
|
|
|
|
rdev = ERR_PTR(ret);
|
|
|
|
goto out;
|
|
|
|
|
2008-11-11 18:38:53 -07:00
|
|
|
clean:
|
|
|
|
kfree(rdev);
|
|
|
|
rdev = ERR_PTR(ret);
|
|
|
|
goto out;
|
2008-04-30 08:59:04 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_register);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_unregister - unregister regulator
|
2008-12-31 05:52:41 -07:00
|
|
|
* @rdev: regulator to unregister
|
2008-04-30 08:59:04 -06:00
|
|
|
*
|
|
|
|
* Called by regulator drivers to unregister a regulator.
|
|
|
|
*/
|
|
|
|
void regulator_unregister(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
if (rdev == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
mutex_lock(®ulator_list_mutex);
|
2009-07-21 09:00:25 -06:00
|
|
|
WARN_ON(rdev->open_count);
|
2009-01-22 07:00:29 -07:00
|
|
|
unset_regulator_supplies(rdev);
|
2008-04-30 08:59:04 -06:00
|
|
|
list_del(&rdev->list);
|
|
|
|
if (rdev->supply)
|
|
|
|
sysfs_remove_link(&rdev->dev.kobj, "supply");
|
|
|
|
device_unregister(&rdev->dev);
|
|
|
|
mutex_unlock(®ulator_list_mutex);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_unregister);
|
|
|
|
|
|
|
|
/**
|
2008-12-31 05:52:43 -07:00
|
|
|
* regulator_suspend_prepare - prepare regulators for system wide suspend
|
2008-04-30 08:59:04 -06:00
|
|
|
* @state: system suspend state
|
|
|
|
*
|
|
|
|
* Configure each regulator with it's suspend operating parameters for state.
|
|
|
|
* This will usually be called by machine suspend code prior to supending.
|
|
|
|
*/
|
|
|
|
int regulator_suspend_prepare(suspend_state_t state)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
/* ON is handled by regulator active state */
|
|
|
|
if (state == PM_SUSPEND_ON)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
mutex_lock(®ulator_list_mutex);
|
|
|
|
list_for_each_entry(rdev, ®ulator_list, list) {
|
|
|
|
|
|
|
|
mutex_lock(&rdev->mutex);
|
|
|
|
ret = suspend_prepare(rdev, state);
|
|
|
|
mutex_unlock(&rdev->mutex);
|
|
|
|
|
|
|
|
if (ret < 0) {
|
|
|
|
printk(KERN_ERR "%s: failed to prepare %s\n",
|
|
|
|
__func__, rdev->desc->name);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
mutex_unlock(®ulator_list_mutex);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_suspend_prepare);
|
|
|
|
|
2009-03-16 13:36:34 -06:00
|
|
|
/**
|
|
|
|
* regulator_has_full_constraints - the system has fully specified constraints
|
|
|
|
*
|
|
|
|
* Calling this function will cause the regulator API to disable all
|
|
|
|
* regulators which have a zero use count and don't have an always_on
|
|
|
|
* constraint in a late_initcall.
|
|
|
|
*
|
|
|
|
* The intention is that this will become the default behaviour in a
|
|
|
|
* future kernel release so users are encouraged to use this facility
|
|
|
|
* now.
|
|
|
|
*/
|
|
|
|
void regulator_has_full_constraints(void)
|
|
|
|
{
|
|
|
|
has_full_constraints = 1;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_has_full_constraints);
|
|
|
|
|
2008-04-30 08:59:04 -06:00
|
|
|
/**
|
|
|
|
* rdev_get_drvdata - get rdev regulator driver data
|
2008-12-31 05:52:41 -07:00
|
|
|
* @rdev: regulator
|
2008-04-30 08:59:04 -06:00
|
|
|
*
|
|
|
|
* Get rdev regulator driver private data. This call can be used in the
|
|
|
|
* regulator driver context.
|
|
|
|
*/
|
|
|
|
void *rdev_get_drvdata(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
return rdev->reg_data;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rdev_get_drvdata);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_get_drvdata - get regulator driver data
|
|
|
|
* @regulator: regulator
|
|
|
|
*
|
|
|
|
* Get regulator driver private data. This call can be used in the consumer
|
|
|
|
* driver context when non API regulator specific functions need to be called.
|
|
|
|
*/
|
|
|
|
void *regulator_get_drvdata(struct regulator *regulator)
|
|
|
|
{
|
|
|
|
return regulator->rdev->reg_data;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_get_drvdata);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_set_drvdata - set regulator driver data
|
|
|
|
* @regulator: regulator
|
|
|
|
* @data: data
|
|
|
|
*/
|
|
|
|
void regulator_set_drvdata(struct regulator *regulator, void *data)
|
|
|
|
{
|
|
|
|
regulator->rdev->reg_data = data;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_set_drvdata);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_get_id - get regulator ID
|
2008-12-31 05:52:41 -07:00
|
|
|
* @rdev: regulator
|
2008-04-30 08:59:04 -06:00
|
|
|
*/
|
|
|
|
int rdev_get_id(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
return rdev->desc->id;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rdev_get_id);
|
|
|
|
|
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: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 06:22:20 -06:00
|
|
|
struct device *rdev_get_dev(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
return &rdev->dev;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rdev_get_dev);
|
|
|
|
|
|
|
|
void *regulator_get_init_drvdata(struct regulator_init_data *reg_init_data)
|
|
|
|
{
|
|
|
|
return reg_init_data->driver_data;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_get_init_drvdata);
|
|
|
|
|
2008-04-30 08:59:04 -06:00
|
|
|
static int __init regulator_init(void)
|
|
|
|
{
|
|
|
|
printk(KERN_INFO "regulator: core version %s\n", REGULATOR_VERSION);
|
|
|
|
return class_register(®ulator_class);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* init early to allow our consumers to complete system booting */
|
|
|
|
core_initcall(regulator_init);
|
2009-03-16 13:36:34 -06:00
|
|
|
|
|
|
|
static int __init regulator_init_complete(void)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev;
|
|
|
|
struct regulator_ops *ops;
|
|
|
|
struct regulation_constraints *c;
|
|
|
|
int enabled, ret;
|
|
|
|
const char *name;
|
|
|
|
|
|
|
|
mutex_lock(®ulator_list_mutex);
|
|
|
|
|
|
|
|
/* If we have a full configuration then disable any regulators
|
|
|
|
* which are not in use or always_on. This will become the
|
|
|
|
* default behaviour in the future.
|
|
|
|
*/
|
|
|
|
list_for_each_entry(rdev, ®ulator_list, list) {
|
|
|
|
ops = rdev->desc->ops;
|
|
|
|
c = rdev->constraints;
|
|
|
|
|
2009-08-03 11:49:55 -06:00
|
|
|
if (c && c->name)
|
2009-03-16 13:36:34 -06:00
|
|
|
name = c->name;
|
|
|
|
else if (rdev->desc->name)
|
|
|
|
name = rdev->desc->name;
|
|
|
|
else
|
|
|
|
name = "regulator";
|
|
|
|
|
2009-08-03 11:49:55 -06:00
|
|
|
if (!ops->disable || (c && c->always_on))
|
2009-03-16 13:36:34 -06:00
|
|
|
continue;
|
|
|
|
|
|
|
|
mutex_lock(&rdev->mutex);
|
|
|
|
|
|
|
|
if (rdev->use_count)
|
|
|
|
goto unlock;
|
|
|
|
|
|
|
|
/* If we can't read the status assume it's on. */
|
|
|
|
if (ops->is_enabled)
|
|
|
|
enabled = ops->is_enabled(rdev);
|
|
|
|
else
|
|
|
|
enabled = 1;
|
|
|
|
|
|
|
|
if (!enabled)
|
|
|
|
goto unlock;
|
|
|
|
|
|
|
|
if (has_full_constraints) {
|
|
|
|
/* We log since this may kill the system if it
|
|
|
|
* goes wrong. */
|
|
|
|
printk(KERN_INFO "%s: disabling %s\n",
|
|
|
|
__func__, name);
|
|
|
|
ret = ops->disable(rdev);
|
|
|
|
if (ret != 0) {
|
|
|
|
printk(KERN_ERR
|
|
|
|
"%s: couldn't disable %s: %d\n",
|
|
|
|
__func__, name, ret);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* The intention is that in future we will
|
|
|
|
* assume that full constraints are provided
|
|
|
|
* so warn even if we aren't going to do
|
|
|
|
* anything here.
|
|
|
|
*/
|
|
|
|
printk(KERN_WARNING
|
|
|
|
"%s: incomplete constraints, leaving %s on\n",
|
|
|
|
__func__, name);
|
|
|
|
}
|
|
|
|
|
|
|
|
unlock:
|
|
|
|
mutex_unlock(&rdev->mutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(®ulator_list_mutex);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
late_initcall(regulator_init_complete);
|