mirror of
https://github.com/edk2-porting/linux-next.git
synced 2024-12-21 19:53:59 +08:00
31aae2beeb
Regulators may sometimes take longer to enable than the control operation used to do so, either because the regulator has ramp rate control used to limit inrush current or because the control operation is very fast (GPIO being the most common example of this). In order to ensure that consumers do not rely on the regulator before it is enabled provide an enable_time() operation and have the core delay for that time before returning to the caller. This is implemented as a function since the ramp rate may be specified in voltage per unit time and therefore the time depend on the configuration. In future it would be desirable to allow the bulk operations to run the delays for multiple enables in parallel but this is not currently supported. Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
210 lines
6.9 KiB
C
210 lines
6.9 KiB
C
/*
|
|
* driver.h -- SoC Regulator driver support.
|
|
*
|
|
* Copyright (C) 2007, 2008 Wolfson Microelectronics PLC.
|
|
*
|
|
* Author: Liam Girdwood <lrg@slimlogic.co.uk>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* Regulator Driver Interface.
|
|
*/
|
|
|
|
#ifndef __LINUX_REGULATOR_DRIVER_H_
|
|
#define __LINUX_REGULATOR_DRIVER_H_
|
|
|
|
#include <linux/device.h>
|
|
#include <linux/regulator/consumer.h>
|
|
|
|
struct regulator_dev;
|
|
struct regulator_init_data;
|
|
|
|
enum regulator_status {
|
|
REGULATOR_STATUS_OFF,
|
|
REGULATOR_STATUS_ON,
|
|
REGULATOR_STATUS_ERROR,
|
|
/* fast/normal/idle/standby are flavors of "on" */
|
|
REGULATOR_STATUS_FAST,
|
|
REGULATOR_STATUS_NORMAL,
|
|
REGULATOR_STATUS_IDLE,
|
|
REGULATOR_STATUS_STANDBY,
|
|
};
|
|
|
|
/**
|
|
* struct regulator_ops - regulator operations.
|
|
*
|
|
* @enable: Configure the regulator as enabled.
|
|
* @disable: Configure the regulator as disabled.
|
|
* @is_enabled: Return 1 if the regulator is enabled, 0 if not.
|
|
* May also return negative errno.
|
|
*
|
|
* @set_voltage: Set the voltage for the regulator within the range specified.
|
|
* The driver should select the voltage closest to min_uV.
|
|
* @get_voltage: Return the currently configured voltage for the regulator.
|
|
* @list_voltage: Return one of the supported voltages, in microvolts; zero
|
|
* if the selector indicates a voltage that is unusable on this system;
|
|
* or negative errno. Selectors range from zero to one less than
|
|
* regulator_desc.n_voltages. Voltages may be reported in any order.
|
|
*
|
|
* @set_current_limit: Configure a limit for a current-limited regulator.
|
|
* @get_current_limit: Get the configured limit for a current-limited regulator.
|
|
*
|
|
* @set_mode: Set the configured operating mode for the regulator.
|
|
* @get_mode: Get the configured operating mode for the regulator.
|
|
* @get_status: Return actual (not as-configured) status of regulator, as a
|
|
* REGULATOR_STATUS value (or negative errno)
|
|
* @get_optimum_mode: Get the most efficient operating mode for the regulator
|
|
* when running with the specified parameters.
|
|
*
|
|
* @enable_time: Time taken for the regulator voltage output voltage to
|
|
* stabalise after being enabled, in microseconds.
|
|
*
|
|
* @set_suspend_voltage: Set the voltage for the regulator when the system
|
|
* is suspended.
|
|
* @set_suspend_enable: Mark the regulator as enabled when the system is
|
|
* suspended.
|
|
* @set_suspend_disable: Mark the regulator as disabled when the system is
|
|
* suspended.
|
|
* @set_suspend_mode: Set the operating mode for the regulator when the
|
|
* system is suspended.
|
|
*
|
|
* This struct describes regulator operations which can be implemented by
|
|
* regulator chip drivers.
|
|
*/
|
|
struct regulator_ops {
|
|
|
|
/* enumerate supported voltages */
|
|
int (*list_voltage) (struct regulator_dev *, unsigned selector);
|
|
|
|
/* get/set regulator voltage */
|
|
int (*set_voltage) (struct regulator_dev *, int min_uV, int max_uV);
|
|
int (*get_voltage) (struct regulator_dev *);
|
|
|
|
/* get/set regulator current */
|
|
int (*set_current_limit) (struct regulator_dev *,
|
|
int min_uA, int max_uA);
|
|
int (*get_current_limit) (struct regulator_dev *);
|
|
|
|
/* enable/disable regulator */
|
|
int (*enable) (struct regulator_dev *);
|
|
int (*disable) (struct regulator_dev *);
|
|
int (*is_enabled) (struct regulator_dev *);
|
|
|
|
/* get/set regulator operating mode (defined in regulator.h) */
|
|
int (*set_mode) (struct regulator_dev *, unsigned int mode);
|
|
unsigned int (*get_mode) (struct regulator_dev *);
|
|
|
|
/* Time taken to enable the regulator */
|
|
int (*enable_time) (struct regulator_dev *);
|
|
|
|
/* report regulator status ... most other accessors report
|
|
* control inputs, this reports results of combining inputs
|
|
* from Linux (and other sources) with the actual load.
|
|
* returns REGULATOR_STATUS_* or negative errno.
|
|
*/
|
|
int (*get_status)(struct regulator_dev *);
|
|
|
|
/* get most efficient regulator operating mode for load */
|
|
unsigned int (*get_optimum_mode) (struct regulator_dev *, int input_uV,
|
|
int output_uV, int load_uA);
|
|
|
|
/* the operations below are for configuration of regulator state when
|
|
* its parent PMIC enters a global STANDBY/HIBERNATE state */
|
|
|
|
/* set regulator suspend voltage */
|
|
int (*set_suspend_voltage) (struct regulator_dev *, int uV);
|
|
|
|
/* enable/disable regulator in suspend state */
|
|
int (*set_suspend_enable) (struct regulator_dev *);
|
|
int (*set_suspend_disable) (struct regulator_dev *);
|
|
|
|
/* set regulator suspend operating mode (defined in regulator.h) */
|
|
int (*set_suspend_mode) (struct regulator_dev *, unsigned int mode);
|
|
};
|
|
|
|
/*
|
|
* Regulators can either control voltage or current.
|
|
*/
|
|
enum regulator_type {
|
|
REGULATOR_VOLTAGE,
|
|
REGULATOR_CURRENT,
|
|
};
|
|
|
|
/**
|
|
* struct regulator_desc - Regulator descriptor
|
|
*
|
|
* Each regulator registered with the core is described with a structure of
|
|
* this type.
|
|
*
|
|
* @name: Identifying name for the regulator.
|
|
* @id: Numerical identifier for the regulator.
|
|
* @n_voltages: Number of selectors available for ops.list_voltage().
|
|
* @ops: Regulator operations table.
|
|
* @irq: Interrupt number for the regulator.
|
|
* @type: Indicates if the regulator is a voltage or current regulator.
|
|
* @owner: Module providing the regulator, used for refcounting.
|
|
*/
|
|
struct regulator_desc {
|
|
const char *name;
|
|
int id;
|
|
unsigned n_voltages;
|
|
struct regulator_ops *ops;
|
|
int irq;
|
|
enum regulator_type type;
|
|
struct module *owner;
|
|
};
|
|
|
|
/*
|
|
* struct regulator_dev
|
|
*
|
|
* Voltage / Current regulator class device. One for each
|
|
* regulator.
|
|
*
|
|
* This should *not* be used directly by anything except the regulator
|
|
* core and notification injection (which should take the mutex and do
|
|
* no other direct access).
|
|
*/
|
|
struct regulator_dev {
|
|
struct regulator_desc *desc;
|
|
int use_count;
|
|
int open_count;
|
|
int exclusive;
|
|
|
|
/* lists we belong to */
|
|
struct list_head list; /* list of all regulators */
|
|
struct list_head slist; /* list of supplied regulators */
|
|
|
|
/* lists we own */
|
|
struct list_head consumer_list; /* consumers we supply */
|
|
struct list_head supply_list; /* regulators we supply */
|
|
|
|
struct blocking_notifier_head notifier;
|
|
struct mutex mutex; /* consumer lock */
|
|
struct module *owner;
|
|
struct device dev;
|
|
struct regulation_constraints *constraints;
|
|
struct regulator_dev *supply; /* for tree */
|
|
|
|
void *reg_data; /* regulator_dev data */
|
|
};
|
|
|
|
struct regulator_dev *regulator_register(struct regulator_desc *regulator_desc,
|
|
struct device *dev, struct regulator_init_data *init_data,
|
|
void *driver_data);
|
|
void regulator_unregister(struct regulator_dev *rdev);
|
|
|
|
int regulator_notifier_call_chain(struct regulator_dev *rdev,
|
|
unsigned long event, void *data);
|
|
|
|
void *rdev_get_drvdata(struct regulator_dev *rdev);
|
|
struct device *rdev_get_dev(struct regulator_dev *rdev);
|
|
int rdev_get_id(struct regulator_dev *rdev);
|
|
|
|
int regulator_mode_to_status(unsigned int);
|
|
|
|
void *regulator_get_init_drvdata(struct regulator_init_data *reg_init_data);
|
|
|
|
#endif
|