mirror of
https://github.com/AetherDroid/android_kernel_samsung_on5xelte.git
synced 2025-09-08 09:08:05 -04:00
Fixed MTP to work with TWRP
This commit is contained in:
awab228
commit
f6dfaef42e
50820 changed files with 20846062 additions and 0 deletions
325
include/linux/regulator/ab8500.h
Normal file
325
include/linux/regulator/ab8500.h
Normal file
|
|
@ -0,0 +1,325 @@
|
|||
/*
|
||||
* Copyright (C) ST-Ericsson SA 2010
|
||||
*
|
||||
* License Terms: GNU General Public License v2
|
||||
*
|
||||
* Authors: Sundar Iyer <sundar.iyer@stericsson.com> for ST-Ericsson
|
||||
* Bengt Jonsson <bengt.g.jonsson@stericsson.com> for ST-Ericsson
|
||||
* Daniel Willerud <daniel.willerud@stericsson.com> for ST-Ericsson
|
||||
*/
|
||||
|
||||
#ifndef __LINUX_MFD_AB8500_REGULATOR_H
|
||||
#define __LINUX_MFD_AB8500_REGULATOR_H
|
||||
|
||||
#include <linux/platform_device.h>
|
||||
|
||||
/* AB8500 regulators */
|
||||
enum ab8500_regulator_id {
|
||||
AB8500_LDO_AUX1,
|
||||
AB8500_LDO_AUX2,
|
||||
AB8500_LDO_AUX3,
|
||||
AB8500_LDO_INTCORE,
|
||||
AB8500_LDO_TVOUT,
|
||||
AB8500_LDO_AUDIO,
|
||||
AB8500_LDO_ANAMIC1,
|
||||
AB8500_LDO_ANAMIC2,
|
||||
AB8500_LDO_DMIC,
|
||||
AB8500_LDO_ANA,
|
||||
AB8500_NUM_REGULATORS,
|
||||
};
|
||||
|
||||
/* AB8505 regulators */
|
||||
enum ab8505_regulator_id {
|
||||
AB8505_LDO_AUX1,
|
||||
AB8505_LDO_AUX2,
|
||||
AB8505_LDO_AUX3,
|
||||
AB8505_LDO_AUX4,
|
||||
AB8505_LDO_AUX5,
|
||||
AB8505_LDO_AUX6,
|
||||
AB8505_LDO_INTCORE,
|
||||
AB8505_LDO_ADC,
|
||||
AB8505_LDO_USB,
|
||||
AB8505_LDO_AUDIO,
|
||||
AB8505_LDO_ANAMIC1,
|
||||
AB8505_LDO_ANAMIC2,
|
||||
AB8505_LDO_AUX8,
|
||||
AB8505_LDO_ANA,
|
||||
AB8505_SYSCLKREQ_2,
|
||||
AB8505_SYSCLKREQ_4,
|
||||
AB8505_NUM_REGULATORS,
|
||||
};
|
||||
|
||||
/* AB9540 regulators */
|
||||
enum ab9540_regulator_id {
|
||||
AB9540_LDO_AUX1,
|
||||
AB9540_LDO_AUX2,
|
||||
AB9540_LDO_AUX3,
|
||||
AB9540_LDO_AUX4,
|
||||
AB9540_LDO_INTCORE,
|
||||
AB9540_LDO_TVOUT,
|
||||
AB9540_LDO_USB,
|
||||
AB9540_LDO_AUDIO,
|
||||
AB9540_LDO_ANAMIC1,
|
||||
AB9540_LDO_ANAMIC2,
|
||||
AB9540_LDO_DMIC,
|
||||
AB9540_LDO_ANA,
|
||||
AB9540_SYSCLKREQ_2,
|
||||
AB9540_SYSCLKREQ_4,
|
||||
AB9540_NUM_REGULATORS,
|
||||
};
|
||||
|
||||
/* AB8540 regulators */
|
||||
enum ab8540_regulator_id {
|
||||
AB8540_LDO_AUX1,
|
||||
AB8540_LDO_AUX2,
|
||||
AB8540_LDO_AUX3,
|
||||
AB8540_LDO_AUX4,
|
||||
AB8540_LDO_AUX5,
|
||||
AB8540_LDO_AUX6,
|
||||
AB8540_LDO_INTCORE,
|
||||
AB8540_LDO_TVOUT,
|
||||
AB8540_LDO_AUDIO,
|
||||
AB8540_LDO_ANAMIC1,
|
||||
AB8540_LDO_ANAMIC2,
|
||||
AB8540_LDO_DMIC,
|
||||
AB8540_LDO_ANA,
|
||||
AB8540_LDO_SDIO,
|
||||
AB8540_SYSCLKREQ_2,
|
||||
AB8540_SYSCLKREQ_4,
|
||||
AB8540_NUM_REGULATORS,
|
||||
};
|
||||
|
||||
/* AB8500, AB8505, and AB9540 register initialization */
|
||||
struct ab8500_regulator_reg_init {
|
||||
int id;
|
||||
u8 mask;
|
||||
u8 value;
|
||||
};
|
||||
|
||||
#define INIT_REGULATOR_REGISTER(_id, _mask, _value) \
|
||||
{ \
|
||||
.id = _id, \
|
||||
.mask = _mask, \
|
||||
.value = _value, \
|
||||
}
|
||||
|
||||
/* AB8500 registers */
|
||||
enum ab8500_regulator_reg {
|
||||
AB8500_REGUREQUESTCTRL2,
|
||||
AB8500_REGUREQUESTCTRL3,
|
||||
AB8500_REGUREQUESTCTRL4,
|
||||
AB8500_REGUSYSCLKREQ1HPVALID1,
|
||||
AB8500_REGUSYSCLKREQ1HPVALID2,
|
||||
AB8500_REGUHWHPREQ1VALID1,
|
||||
AB8500_REGUHWHPREQ1VALID2,
|
||||
AB8500_REGUHWHPREQ2VALID1,
|
||||
AB8500_REGUHWHPREQ2VALID2,
|
||||
AB8500_REGUSWHPREQVALID1,
|
||||
AB8500_REGUSWHPREQVALID2,
|
||||
AB8500_REGUSYSCLKREQVALID1,
|
||||
AB8500_REGUSYSCLKREQVALID2,
|
||||
AB8500_REGUMISC1,
|
||||
AB8500_VAUDIOSUPPLY,
|
||||
AB8500_REGUCTRL1VAMIC,
|
||||
AB8500_VPLLVANAREGU,
|
||||
AB8500_VREFDDR,
|
||||
AB8500_EXTSUPPLYREGU,
|
||||
AB8500_VAUX12REGU,
|
||||
AB8500_VRF1VAUX3REGU,
|
||||
AB8500_VAUX1SEL,
|
||||
AB8500_VAUX2SEL,
|
||||
AB8500_VRF1VAUX3SEL,
|
||||
AB8500_REGUCTRL2SPARE,
|
||||
AB8500_REGUCTRLDISCH,
|
||||
AB8500_REGUCTRLDISCH2,
|
||||
AB8500_NUM_REGULATOR_REGISTERS,
|
||||
};
|
||||
|
||||
/* AB8505 registers */
|
||||
enum ab8505_regulator_reg {
|
||||
AB8505_REGUREQUESTCTRL1,
|
||||
AB8505_REGUREQUESTCTRL2,
|
||||
AB8505_REGUREQUESTCTRL3,
|
||||
AB8505_REGUREQUESTCTRL4,
|
||||
AB8505_REGUSYSCLKREQ1HPVALID1,
|
||||
AB8505_REGUSYSCLKREQ1HPVALID2,
|
||||
AB8505_REGUHWHPREQ1VALID1,
|
||||
AB8505_REGUHWHPREQ1VALID2,
|
||||
AB8505_REGUHWHPREQ2VALID1,
|
||||
AB8505_REGUHWHPREQ2VALID2,
|
||||
AB8505_REGUSWHPREQVALID1,
|
||||
AB8505_REGUSWHPREQVALID2,
|
||||
AB8505_REGUSYSCLKREQVALID1,
|
||||
AB8505_REGUSYSCLKREQVALID2,
|
||||
AB8505_REGUVAUX4REQVALID,
|
||||
AB8505_REGUMISC1,
|
||||
AB8505_VAUDIOSUPPLY,
|
||||
AB8505_REGUCTRL1VAMIC,
|
||||
AB8505_VSMPSAREGU,
|
||||
AB8505_VSMPSBREGU,
|
||||
AB8505_VSAFEREGU, /* NOTE! PRCMU register */
|
||||
AB8505_VPLLVANAREGU,
|
||||
AB8505_EXTSUPPLYREGU,
|
||||
AB8505_VAUX12REGU,
|
||||
AB8505_VRF1VAUX3REGU,
|
||||
AB8505_VSMPSASEL1,
|
||||
AB8505_VSMPSASEL2,
|
||||
AB8505_VSMPSASEL3,
|
||||
AB8505_VSMPSBSEL1,
|
||||
AB8505_VSMPSBSEL2,
|
||||
AB8505_VSMPSBSEL3,
|
||||
AB8505_VSAFESEL1, /* NOTE! PRCMU register */
|
||||
AB8505_VSAFESEL2, /* NOTE! PRCMU register */
|
||||
AB8505_VSAFESEL3, /* NOTE! PRCMU register */
|
||||
AB8505_VAUX1SEL,
|
||||
AB8505_VAUX2SEL,
|
||||
AB8505_VRF1VAUX3SEL,
|
||||
AB8505_VAUX4REQCTRL,
|
||||
AB8505_VAUX4REGU,
|
||||
AB8505_VAUX4SEL,
|
||||
AB8505_REGUCTRLDISCH,
|
||||
AB8505_REGUCTRLDISCH2,
|
||||
AB8505_REGUCTRLDISCH3,
|
||||
AB8505_CTRLVAUX5,
|
||||
AB8505_CTRLVAUX6,
|
||||
AB8505_NUM_REGULATOR_REGISTERS,
|
||||
};
|
||||
|
||||
/* AB9540 registers */
|
||||
enum ab9540_regulator_reg {
|
||||
AB9540_REGUREQUESTCTRL1,
|
||||
AB9540_REGUREQUESTCTRL2,
|
||||
AB9540_REGUREQUESTCTRL3,
|
||||
AB9540_REGUREQUESTCTRL4,
|
||||
AB9540_REGUSYSCLKREQ1HPVALID1,
|
||||
AB9540_REGUSYSCLKREQ1HPVALID2,
|
||||
AB9540_REGUHWHPREQ1VALID1,
|
||||
AB9540_REGUHWHPREQ1VALID2,
|
||||
AB9540_REGUHWHPREQ2VALID1,
|
||||
AB9540_REGUHWHPREQ2VALID2,
|
||||
AB9540_REGUSWHPREQVALID1,
|
||||
AB9540_REGUSWHPREQVALID2,
|
||||
AB9540_REGUSYSCLKREQVALID1,
|
||||
AB9540_REGUSYSCLKREQVALID2,
|
||||
AB9540_REGUVAUX4REQVALID,
|
||||
AB9540_REGUMISC1,
|
||||
AB9540_VAUDIOSUPPLY,
|
||||
AB9540_REGUCTRL1VAMIC,
|
||||
AB9540_VSMPS1REGU,
|
||||
AB9540_VSMPS2REGU,
|
||||
AB9540_VSMPS3REGU, /* NOTE! PRCMU register */
|
||||
AB9540_VPLLVANAREGU,
|
||||
AB9540_EXTSUPPLYREGU,
|
||||
AB9540_VAUX12REGU,
|
||||
AB9540_VRF1VAUX3REGU,
|
||||
AB9540_VSMPS1SEL1,
|
||||
AB9540_VSMPS1SEL2,
|
||||
AB9540_VSMPS1SEL3,
|
||||
AB9540_VSMPS2SEL1,
|
||||
AB9540_VSMPS2SEL2,
|
||||
AB9540_VSMPS2SEL3,
|
||||
AB9540_VSMPS3SEL1, /* NOTE! PRCMU register */
|
||||
AB9540_VSMPS3SEL2, /* NOTE! PRCMU register */
|
||||
AB9540_VAUX1SEL,
|
||||
AB9540_VAUX2SEL,
|
||||
AB9540_VRF1VAUX3SEL,
|
||||
AB9540_REGUCTRL2SPARE,
|
||||
AB9540_VAUX4REQCTRL,
|
||||
AB9540_VAUX4REGU,
|
||||
AB9540_VAUX4SEL,
|
||||
AB9540_REGUCTRLDISCH,
|
||||
AB9540_REGUCTRLDISCH2,
|
||||
AB9540_REGUCTRLDISCH3,
|
||||
AB9540_NUM_REGULATOR_REGISTERS,
|
||||
};
|
||||
|
||||
/* AB8540 registers */
|
||||
enum ab8540_regulator_reg {
|
||||
AB8540_REGUREQUESTCTRL1,
|
||||
AB8540_REGUREQUESTCTRL2,
|
||||
AB8540_REGUREQUESTCTRL3,
|
||||
AB8540_REGUREQUESTCTRL4,
|
||||
AB8540_REGUSYSCLKREQ1HPVALID1,
|
||||
AB8540_REGUSYSCLKREQ1HPVALID2,
|
||||
AB8540_REGUHWHPREQ1VALID1,
|
||||
AB8540_REGUHWHPREQ1VALID2,
|
||||
AB8540_REGUHWHPREQ2VALID1,
|
||||
AB8540_REGUHWHPREQ2VALID2,
|
||||
AB8540_REGUSWHPREQVALID1,
|
||||
AB8540_REGUSWHPREQVALID2,
|
||||
AB8540_REGUSYSCLKREQVALID1,
|
||||
AB8540_REGUSYSCLKREQVALID2,
|
||||
AB8540_REGUVAUX4REQVALID,
|
||||
AB8540_REGUVAUX5REQVALID,
|
||||
AB8540_REGUVAUX6REQVALID,
|
||||
AB8540_REGUVCLKBREQVALID,
|
||||
AB8540_REGUVRF1REQVALID,
|
||||
AB8540_REGUMISC1,
|
||||
AB8540_VAUDIOSUPPLY,
|
||||
AB8540_REGUCTRL1VAMIC,
|
||||
AB8540_VHSIC,
|
||||
AB8540_VSDIO,
|
||||
AB8540_VSMPS1REGU,
|
||||
AB8540_VSMPS2REGU,
|
||||
AB8540_VSMPS3REGU,
|
||||
AB8540_VPLLVANAREGU,
|
||||
AB8540_EXTSUPPLYREGU,
|
||||
AB8540_VAUX12REGU,
|
||||
AB8540_VRF1VAUX3REGU,
|
||||
AB8540_VSMPS1SEL1,
|
||||
AB8540_VSMPS1SEL2,
|
||||
AB8540_VSMPS1SEL3,
|
||||
AB8540_VSMPS2SEL1,
|
||||
AB8540_VSMPS2SEL2,
|
||||
AB8540_VSMPS2SEL3,
|
||||
AB8540_VSMPS3SEL1,
|
||||
AB8540_VSMPS3SEL2,
|
||||
AB8540_VAUX1SEL,
|
||||
AB8540_VAUX2SEL,
|
||||
AB8540_VRF1VAUX3SEL,
|
||||
AB8540_REGUCTRL2SPARE,
|
||||
AB8540_VAUX4REQCTRL,
|
||||
AB8540_VAUX4REGU,
|
||||
AB8540_VAUX4SEL,
|
||||
AB8540_VAUX5REQCTRL,
|
||||
AB8540_VAUX5REGU,
|
||||
AB8540_VAUX5SEL,
|
||||
AB8540_VAUX6REQCTRL,
|
||||
AB8540_VAUX6REGU,
|
||||
AB8540_VAUX6SEL,
|
||||
AB8540_VCLKBREQCTRL,
|
||||
AB8540_VCLKBREGU,
|
||||
AB8540_VCLKBSEL,
|
||||
AB8540_VRF1REQCTRL,
|
||||
AB8540_REGUCTRLDISCH,
|
||||
AB8540_REGUCTRLDISCH2,
|
||||
AB8540_REGUCTRLDISCH3,
|
||||
AB8540_REGUCTRLDISCH4,
|
||||
AB8540_VSIMSYSCLKCTRL,
|
||||
AB8540_VANAVPLLSEL,
|
||||
AB8540_NUM_REGULATOR_REGISTERS,
|
||||
};
|
||||
|
||||
/* AB8500 external regulators */
|
||||
struct ab8500_ext_regulator_cfg {
|
||||
bool hwreq; /* requires hw mode or high power mode */
|
||||
};
|
||||
|
||||
enum ab8500_ext_regulator_id {
|
||||
AB8500_EXT_SUPPLY1,
|
||||
AB8500_EXT_SUPPLY2,
|
||||
AB8500_EXT_SUPPLY3,
|
||||
AB8500_NUM_EXT_REGULATORS,
|
||||
};
|
||||
|
||||
/* AB8500 regulator platform data */
|
||||
struct ab8500_regulator_platform_data {
|
||||
int num_reg_init;
|
||||
struct ab8500_regulator_reg_init *reg_init;
|
||||
int num_regulator;
|
||||
struct regulator_init_data *regulator;
|
||||
int num_ext_regulator;
|
||||
struct regulator_init_data *ext_regulator;
|
||||
};
|
||||
|
||||
#endif
|
||||
74
include/linux/regulator/act8865.h
Normal file
74
include/linux/regulator/act8865.h
Normal file
|
|
@ -0,0 +1,74 @@
|
|||
/*
|
||||
* act8865.h -- Voltage regulation for active-semi act88xx PMUs
|
||||
*
|
||||
* Copyright (C) 2013 Atmel Corporation.
|
||||
*
|
||||
* 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; version 2 of the License.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*/
|
||||
|
||||
#ifndef __LINUX_REGULATOR_ACT8865_H
|
||||
#define __LINUX_REGULATOR_ACT8865_H
|
||||
|
||||
#include <linux/regulator/machine.h>
|
||||
|
||||
enum {
|
||||
ACT8865_ID_DCDC1,
|
||||
ACT8865_ID_DCDC2,
|
||||
ACT8865_ID_DCDC3,
|
||||
ACT8865_ID_LDO1,
|
||||
ACT8865_ID_LDO2,
|
||||
ACT8865_ID_LDO3,
|
||||
ACT8865_ID_LDO4,
|
||||
ACT8865_REG_NUM,
|
||||
};
|
||||
|
||||
enum {
|
||||
ACT8846_ID_REG1,
|
||||
ACT8846_ID_REG2,
|
||||
ACT8846_ID_REG3,
|
||||
ACT8846_ID_REG4,
|
||||
ACT8846_ID_REG5,
|
||||
ACT8846_ID_REG6,
|
||||
ACT8846_ID_REG7,
|
||||
ACT8846_ID_REG8,
|
||||
ACT8846_ID_REG9,
|
||||
ACT8846_ID_REG10,
|
||||
ACT8846_ID_REG11,
|
||||
ACT8846_ID_REG12,
|
||||
ACT8846_REG_NUM,
|
||||
};
|
||||
|
||||
enum {
|
||||
ACT8865,
|
||||
ACT8846,
|
||||
};
|
||||
|
||||
/**
|
||||
* act8865_regulator_data - regulator data
|
||||
* @id: regulator id
|
||||
* @name: regulator name
|
||||
* @platform_data: regulator init data
|
||||
*/
|
||||
struct act8865_regulator_data {
|
||||
int id;
|
||||
const char *name;
|
||||
struct regulator_init_data *platform_data;
|
||||
};
|
||||
|
||||
/**
|
||||
* act8865_platform_data - platform data for act8865
|
||||
* @num_regulators: number of regulators used
|
||||
* @regulators: pointer to regulators used
|
||||
*/
|
||||
struct act8865_platform_data {
|
||||
int num_regulators;
|
||||
struct act8865_regulator_data *regulators;
|
||||
};
|
||||
#endif
|
||||
556
include/linux/regulator/consumer.h
Normal file
556
include/linux/regulator/consumer.h
Normal file
|
|
@ -0,0 +1,556 @@
|
|||
/*
|
||||
* consumer.h -- SoC Regulator consumer 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 Consumer Interface.
|
||||
*
|
||||
* A Power Management Regulator framework for SoC based devices.
|
||||
* Features:-
|
||||
* o Voltage and current level control.
|
||||
* o Operating mode control.
|
||||
* o Regulator status.
|
||||
* o sysfs entries for showing client devices and status
|
||||
*
|
||||
* EXPERIMENTAL FEATURES:
|
||||
* Dynamic Regulator operating Mode Switching (DRMS) - allows regulators
|
||||
* to use most efficient operating mode depending upon voltage and load and
|
||||
* is transparent to client drivers.
|
||||
*
|
||||
* e.g. Devices x,y,z share regulator r. Device x and y draw 20mA each during
|
||||
* IO and 1mA at idle. Device z draws 100mA when under load and 5mA when
|
||||
* idling. Regulator r has > 90% efficiency in NORMAL mode at loads > 100mA
|
||||
* but this drops rapidly to 60% when below 100mA. Regulator r has > 90%
|
||||
* efficiency in IDLE mode at loads < 10mA. Thus regulator r will operate
|
||||
* in normal mode for loads > 10mA and in IDLE mode for load <= 10mA.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef __LINUX_REGULATOR_CONSUMER_H_
|
||||
#define __LINUX_REGULATOR_CONSUMER_H_
|
||||
|
||||
#include <linux/err.h>
|
||||
|
||||
struct device;
|
||||
struct notifier_block;
|
||||
struct regmap;
|
||||
|
||||
/*
|
||||
* Regulator operating modes.
|
||||
*
|
||||
* Regulators can run in a variety of different operating modes depending on
|
||||
* output load. This allows further system power savings by selecting the
|
||||
* best (and most efficient) regulator mode for a desired load.
|
||||
*
|
||||
* Most drivers will only care about NORMAL. The modes below are generic and
|
||||
* will probably not match the naming convention of your regulator data sheet
|
||||
* but should match the use cases in the datasheet.
|
||||
*
|
||||
* In order of power efficiency (least efficient at top).
|
||||
*
|
||||
* Mode Description
|
||||
* FAST Regulator can handle fast changes in it's load.
|
||||
* e.g. useful in CPU voltage & frequency scaling where
|
||||
* load can quickly increase with CPU frequency increases.
|
||||
*
|
||||
* NORMAL Normal regulator power supply mode. Most drivers will
|
||||
* use this mode.
|
||||
*
|
||||
* IDLE Regulator runs in a more efficient mode for light
|
||||
* loads. Can be used for devices that have a low power
|
||||
* requirement during periods of inactivity. This mode
|
||||
* may be more noisy than NORMAL and may not be able
|
||||
* to handle fast load switching.
|
||||
*
|
||||
* STANDBY Regulator runs in the most efficient mode for very
|
||||
* light loads. Can be used by devices when they are
|
||||
* in a sleep/standby state. This mode is likely to be
|
||||
* the most noisy and may not be able to handle fast load
|
||||
* switching.
|
||||
*
|
||||
* NOTE: Most regulators will only support a subset of these modes. Some
|
||||
* will only just support NORMAL.
|
||||
*
|
||||
* These modes can be OR'ed together to make up a mask of valid register modes.
|
||||
*/
|
||||
|
||||
#define REGULATOR_MODE_FAST 0x1
|
||||
#define REGULATOR_MODE_NORMAL 0x2
|
||||
#define REGULATOR_MODE_IDLE 0x4
|
||||
#define REGULATOR_MODE_STANDBY 0x8
|
||||
|
||||
/*
|
||||
* Regulator notifier events.
|
||||
*
|
||||
* UNDER_VOLTAGE Regulator output is under voltage.
|
||||
* OVER_CURRENT Regulator output current is too high.
|
||||
* REGULATION_OUT Regulator output is out of regulation.
|
||||
* FAIL Regulator output has failed.
|
||||
* OVER_TEMP Regulator over temp.
|
||||
* FORCE_DISABLE Regulator forcibly shut down by software.
|
||||
* VOLTAGE_CHANGE Regulator voltage changed.
|
||||
* Data passed is old voltage cast to (void *).
|
||||
* DISABLE Regulator was disabled.
|
||||
* PRE_VOLTAGE_CHANGE Regulator is about to have voltage changed.
|
||||
* Data passed is "struct pre_voltage_change_data"
|
||||
* ABORT_VOLTAGE_CHANGE Regulator voltage change failed for some reason.
|
||||
* Data passed is old voltage cast to (void *).
|
||||
*
|
||||
* NOTE: These events can be OR'ed together when passed into handler.
|
||||
*/
|
||||
|
||||
#define REGULATOR_EVENT_UNDER_VOLTAGE 0x01
|
||||
#define REGULATOR_EVENT_OVER_CURRENT 0x02
|
||||
#define REGULATOR_EVENT_REGULATION_OUT 0x04
|
||||
#define REGULATOR_EVENT_FAIL 0x08
|
||||
#define REGULATOR_EVENT_OVER_TEMP 0x10
|
||||
#define REGULATOR_EVENT_FORCE_DISABLE 0x20
|
||||
#define REGULATOR_EVENT_VOLTAGE_CHANGE 0x40
|
||||
#define REGULATOR_EVENT_DISABLE 0x80
|
||||
#define REGULATOR_EVENT_PRE_VOLTAGE_CHANGE 0x100
|
||||
#define REGULATOR_EVENT_ABORT_VOLTAGE_CHANGE 0x200
|
||||
|
||||
/**
|
||||
* struct pre_voltage_change_data - Data sent with PRE_VOLTAGE_CHANGE event
|
||||
*
|
||||
* @old_uV: Current voltage before change.
|
||||
* @min_uV: Min voltage we'll change to.
|
||||
* @max_uV: Max voltage we'll change to.
|
||||
*/
|
||||
struct pre_voltage_change_data {
|
||||
unsigned long old_uV;
|
||||
unsigned long min_uV;
|
||||
unsigned long max_uV;
|
||||
};
|
||||
|
||||
struct regulator;
|
||||
|
||||
/**
|
||||
* struct regulator_bulk_data - Data used for bulk regulator operations.
|
||||
*
|
||||
* @supply: The name of the supply. Initialised by the user before
|
||||
* using the bulk regulator APIs.
|
||||
* @consumer: The regulator consumer for the supply. This will be managed
|
||||
* by the bulk API.
|
||||
*
|
||||
* The regulator APIs provide a series of regulator_bulk_() API calls as
|
||||
* a convenience to consumers which require multiple supplies. This
|
||||
* structure is used to manage data for these calls.
|
||||
*/
|
||||
struct regulator_bulk_data {
|
||||
const char *supply;
|
||||
struct regulator *consumer;
|
||||
|
||||
/* private: Internal use */
|
||||
int ret;
|
||||
};
|
||||
|
||||
#if defined(CONFIG_REGULATOR)
|
||||
|
||||
/* regulator get and put */
|
||||
struct regulator *__must_check regulator_get(struct device *dev,
|
||||
const char *id);
|
||||
struct regulator *__must_check devm_regulator_get(struct device *dev,
|
||||
const char *id);
|
||||
struct regulator *__must_check regulator_get_exclusive(struct device *dev,
|
||||
const char *id);
|
||||
struct regulator *__must_check devm_regulator_get_exclusive(struct device *dev,
|
||||
const char *id);
|
||||
struct regulator *__must_check regulator_get_optional(struct device *dev,
|
||||
const char *id);
|
||||
struct regulator *__must_check devm_regulator_get_optional(struct device *dev,
|
||||
const char *id);
|
||||
void regulator_put(struct regulator *regulator);
|
||||
void devm_regulator_put(struct regulator *regulator);
|
||||
|
||||
int regulator_register_supply_alias(struct device *dev, const char *id,
|
||||
struct device *alias_dev,
|
||||
const char *alias_id);
|
||||
void regulator_unregister_supply_alias(struct device *dev, const char *id);
|
||||
|
||||
int regulator_bulk_register_supply_alias(struct device *dev,
|
||||
const char *const *id,
|
||||
struct device *alias_dev,
|
||||
const char *const *alias_id,
|
||||
int num_id);
|
||||
void regulator_bulk_unregister_supply_alias(struct device *dev,
|
||||
const char * const *id, int num_id);
|
||||
|
||||
int devm_regulator_register_supply_alias(struct device *dev, const char *id,
|
||||
struct device *alias_dev,
|
||||
const char *alias_id);
|
||||
void devm_regulator_unregister_supply_alias(struct device *dev,
|
||||
const char *id);
|
||||
|
||||
int devm_regulator_bulk_register_supply_alias(struct device *dev,
|
||||
const char *const *id,
|
||||
struct device *alias_dev,
|
||||
const char *const *alias_id,
|
||||
int num_id);
|
||||
void devm_regulator_bulk_unregister_supply_alias(struct device *dev,
|
||||
const char *const *id,
|
||||
int num_id);
|
||||
|
||||
/* regulator output control and status */
|
||||
int __must_check regulator_enable(struct regulator *regulator);
|
||||
int regulator_disable(struct regulator *regulator);
|
||||
int regulator_force_disable(struct regulator *regulator);
|
||||
int regulator_is_enabled(struct regulator *regulator);
|
||||
int regulator_disable_deferred(struct regulator *regulator, int ms);
|
||||
|
||||
int __must_check regulator_bulk_get(struct device *dev, int num_consumers,
|
||||
struct regulator_bulk_data *consumers);
|
||||
int __must_check devm_regulator_bulk_get(struct device *dev, int num_consumers,
|
||||
struct regulator_bulk_data *consumers);
|
||||
int __must_check regulator_bulk_enable(int num_consumers,
|
||||
struct regulator_bulk_data *consumers);
|
||||
int regulator_bulk_disable(int num_consumers,
|
||||
struct regulator_bulk_data *consumers);
|
||||
int regulator_bulk_force_disable(int num_consumers,
|
||||
struct regulator_bulk_data *consumers);
|
||||
void regulator_bulk_free(int num_consumers,
|
||||
struct regulator_bulk_data *consumers);
|
||||
|
||||
int regulator_can_change_voltage(struct regulator *regulator);
|
||||
int regulator_count_voltages(struct regulator *regulator);
|
||||
int regulator_list_voltage(struct regulator *regulator, unsigned selector);
|
||||
int regulator_is_supported_voltage(struct regulator *regulator,
|
||||
int min_uV, int max_uV);
|
||||
unsigned int regulator_get_linear_step(struct regulator *regulator);
|
||||
int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV);
|
||||
int regulator_set_voltage_time(struct regulator *regulator,
|
||||
int old_uV, int new_uV);
|
||||
int regulator_get_voltage(struct regulator *regulator);
|
||||
int regulator_sync_voltage(struct regulator *regulator);
|
||||
int regulator_set_current_limit(struct regulator *regulator,
|
||||
int min_uA, int max_uA);
|
||||
int regulator_get_current_limit(struct regulator *regulator);
|
||||
int regulator_get_max_support_voltage(struct regulator *regulator);
|
||||
int regulator_get_min_support_voltage(struct regulator *regulator);
|
||||
|
||||
int regulator_set_mode(struct regulator *regulator, unsigned int mode);
|
||||
unsigned int regulator_get_mode(struct regulator *regulator);
|
||||
int regulator_set_optimum_mode(struct regulator *regulator, int load_uA);
|
||||
|
||||
int regulator_allow_bypass(struct regulator *regulator, bool allow);
|
||||
|
||||
struct regmap *regulator_get_regmap(struct regulator *regulator);
|
||||
int regulator_get_hardware_vsel_register(struct regulator *regulator,
|
||||
unsigned *vsel_reg,
|
||||
unsigned *vsel_mask);
|
||||
int regulator_list_hardware_vsel(struct regulator *regulator,
|
||||
unsigned selector);
|
||||
|
||||
/* regulator notifier block */
|
||||
int regulator_register_notifier(struct regulator *regulator,
|
||||
struct notifier_block *nb);
|
||||
int regulator_unregister_notifier(struct regulator *regulator,
|
||||
struct notifier_block *nb);
|
||||
|
||||
/* driver data - core doesn't touch */
|
||||
void *regulator_get_drvdata(struct regulator *regulator);
|
||||
void regulator_set_drvdata(struct regulator *regulator, void *data);
|
||||
|
||||
#else
|
||||
|
||||
/*
|
||||
* Make sure client drivers will still build on systems with no software
|
||||
* controllable voltage or current regulators.
|
||||
*/
|
||||
static inline struct regulator *__must_check regulator_get(struct device *dev,
|
||||
const char *id)
|
||||
{
|
||||
/* Nothing except the stubbed out regulator API should be
|
||||
* looking at the value except to check if it is an error
|
||||
* value. Drivers are free to handle NULL specifically by
|
||||
* skipping all regulator API calls, but they don't have to.
|
||||
* Drivers which don't, should make sure they properly handle
|
||||
* corner cases of the API, such as regulator_get_voltage()
|
||||
* returning 0.
|
||||
*/
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static inline struct regulator *__must_check
|
||||
devm_regulator_get(struct device *dev, const char *id)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static inline struct regulator *__must_check
|
||||
regulator_get_exclusive(struct device *dev, const char *id)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static inline struct regulator *__must_check
|
||||
regulator_get_optional(struct device *dev, const char *id)
|
||||
{
|
||||
return ERR_PTR(-ENODEV);
|
||||
}
|
||||
|
||||
|
||||
static inline struct regulator *__must_check
|
||||
devm_regulator_get_optional(struct device *dev, const char *id)
|
||||
{
|
||||
return ERR_PTR(-ENODEV);
|
||||
}
|
||||
|
||||
static inline void regulator_put(struct regulator *regulator)
|
||||
{
|
||||
}
|
||||
|
||||
static inline void devm_regulator_put(struct regulator *regulator)
|
||||
{
|
||||
}
|
||||
|
||||
static inline int regulator_register_supply_alias(struct device *dev,
|
||||
const char *id,
|
||||
struct device *alias_dev,
|
||||
const char *alias_id)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline void regulator_unregister_supply_alias(struct device *dev,
|
||||
const char *id)
|
||||
{
|
||||
}
|
||||
|
||||
static inline int regulator_bulk_register_supply_alias(struct device *dev,
|
||||
const char *const *id,
|
||||
struct device *alias_dev,
|
||||
const char * const *alias_id,
|
||||
int num_id)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline void regulator_bulk_unregister_supply_alias(struct device *dev,
|
||||
const char * const *id,
|
||||
int num_id)
|
||||
{
|
||||
}
|
||||
|
||||
static inline int devm_regulator_register_supply_alias(struct device *dev,
|
||||
const char *id,
|
||||
struct device *alias_dev,
|
||||
const char *alias_id)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline void devm_regulator_unregister_supply_alias(struct device *dev,
|
||||
const char *id)
|
||||
{
|
||||
}
|
||||
|
||||
static inline int devm_regulator_bulk_register_supply_alias(struct device *dev,
|
||||
const char *const *id,
|
||||
struct device *alias_dev,
|
||||
const char *const *alias_id,
|
||||
int num_id)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline void devm_regulator_bulk_unregister_supply_alias(
|
||||
struct device *dev, const char *const *id, int num_id)
|
||||
{
|
||||
}
|
||||
|
||||
static inline int regulator_enable(struct regulator *regulator)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int regulator_disable(struct regulator *regulator)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int regulator_force_disable(struct regulator *regulator)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int regulator_disable_deferred(struct regulator *regulator,
|
||||
int ms)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int regulator_is_enabled(struct regulator *regulator)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
static inline int regulator_bulk_get(struct device *dev,
|
||||
int num_consumers,
|
||||
struct regulator_bulk_data *consumers)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int devm_regulator_bulk_get(struct device *dev, int num_consumers,
|
||||
struct regulator_bulk_data *consumers)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int regulator_bulk_enable(int num_consumers,
|
||||
struct regulator_bulk_data *consumers)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int regulator_bulk_disable(int num_consumers,
|
||||
struct regulator_bulk_data *consumers)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int regulator_bulk_force_disable(int num_consumers,
|
||||
struct regulator_bulk_data *consumers)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline void regulator_bulk_free(int num_consumers,
|
||||
struct regulator_bulk_data *consumers)
|
||||
{
|
||||
}
|
||||
|
||||
static inline int regulator_can_change_voltage(struct regulator *regulator)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int regulator_set_voltage(struct regulator *regulator,
|
||||
int min_uV, int max_uV)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int regulator_set_voltage_time(struct regulator *regulator,
|
||||
int old_uV, int new_uV)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int regulator_get_voltage(struct regulator *regulator)
|
||||
{
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
static inline int regulator_is_supported_voltage(struct regulator *regulator,
|
||||
int min_uV, int max_uV)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int regulator_set_current_limit(struct regulator *regulator,
|
||||
int min_uA, int max_uA)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int regulator_get_current_limit(struct regulator *regulator)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int regulator_set_mode(struct regulator *regulator,
|
||||
unsigned int mode)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline unsigned int regulator_get_mode(struct regulator *regulator)
|
||||
{
|
||||
return REGULATOR_MODE_NORMAL;
|
||||
}
|
||||
|
||||
static inline int regulator_set_optimum_mode(struct regulator *regulator,
|
||||
int load_uA)
|
||||
{
|
||||
return REGULATOR_MODE_NORMAL;
|
||||
}
|
||||
|
||||
static inline int regulator_allow_bypass(struct regulator *regulator,
|
||||
bool allow)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline struct regmap *regulator_get_regmap(struct regulator *regulator)
|
||||
{
|
||||
return ERR_PTR(-EOPNOTSUPP);
|
||||
}
|
||||
|
||||
static inline int regulator_get_hardware_vsel_register(struct regulator *regulator,
|
||||
unsigned *vsel_reg,
|
||||
unsigned *vsel_mask)
|
||||
{
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
|
||||
static inline int regulator_list_hardware_vsel(struct regulator *regulator,
|
||||
unsigned selector)
|
||||
{
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
|
||||
static inline int regulator_register_notifier(struct regulator *regulator,
|
||||
struct notifier_block *nb)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int regulator_unregister_notifier(struct regulator *regulator,
|
||||
struct notifier_block *nb)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline void *regulator_get_drvdata(struct regulator *regulator)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static inline void regulator_set_drvdata(struct regulator *regulator,
|
||||
void *data)
|
||||
{
|
||||
}
|
||||
|
||||
static inline int regulator_count_voltages(struct regulator *regulator)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
static inline int regulator_set_voltage_tol(struct regulator *regulator,
|
||||
int new_uV, int tol_uV)
|
||||
{
|
||||
if (regulator_set_voltage(regulator, new_uV, new_uV + tol_uV) == 0)
|
||||
return 0;
|
||||
else
|
||||
return regulator_set_voltage(regulator,
|
||||
new_uV - tol_uV, new_uV + tol_uV);
|
||||
}
|
||||
|
||||
static inline int regulator_is_supported_voltage_tol(struct regulator *regulator,
|
||||
int target_uV, int tol_uV)
|
||||
{
|
||||
return regulator_is_supported_voltage(regulator,
|
||||
target_uV - tol_uV,
|
||||
target_uV + tol_uV);
|
||||
}
|
||||
|
||||
#endif
|
||||
37
include/linux/regulator/da9211.h
Normal file
37
include/linux/regulator/da9211.h
Normal file
|
|
@ -0,0 +1,37 @@
|
|||
/*
|
||||
* da9211.h - Regulator device driver for DA9211/DA9213
|
||||
* Copyright (C) 2014 Dialog Semiconductor Ltd.
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Library General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*/
|
||||
|
||||
#ifndef __LINUX_REGULATOR_DA9211_H
|
||||
#define __LINUX_REGULATOR_DA9211_H
|
||||
|
||||
#include <linux/regulator/machine.h>
|
||||
|
||||
#define DA9211_MAX_REGULATORS 2
|
||||
|
||||
enum da9211_chip_id {
|
||||
DA9211,
|
||||
DA9213,
|
||||
};
|
||||
|
||||
struct da9211_pdata {
|
||||
/*
|
||||
* Number of buck
|
||||
* 1 : 4 phase 1 buck
|
||||
* 2 : 2 phase 2 buck
|
||||
*/
|
||||
int num_buck;
|
||||
struct regulator_init_data *init_data[DA9211_MAX_REGULATORS];
|
||||
};
|
||||
#endif
|
||||
45
include/linux/regulator/db8500-prcmu.h
Normal file
45
include/linux/regulator/db8500-prcmu.h
Normal file
|
|
@ -0,0 +1,45 @@
|
|||
/*
|
||||
* Copyright (C) ST-Ericsson SA 2010
|
||||
*
|
||||
* License Terms: GNU General Public License v2
|
||||
*
|
||||
* Author: Bengt Jonsson <bengt.g.jonsson@stericsson.com> for ST-Ericsson
|
||||
*
|
||||
* Interface to power domain regulators on DB8500
|
||||
*/
|
||||
|
||||
#ifndef __REGULATOR_H__
|
||||
#define __REGULATOR_H__
|
||||
|
||||
/* Number of DB8500 regulators and regulator enumeration */
|
||||
enum db8500_regulator_id {
|
||||
DB8500_REGULATOR_VAPE,
|
||||
DB8500_REGULATOR_VARM,
|
||||
DB8500_REGULATOR_VMODEM,
|
||||
DB8500_REGULATOR_VPLL,
|
||||
DB8500_REGULATOR_VSMPS1,
|
||||
DB8500_REGULATOR_VSMPS2,
|
||||
DB8500_REGULATOR_VSMPS3,
|
||||
DB8500_REGULATOR_VRF1,
|
||||
DB8500_REGULATOR_SWITCH_SVAMMDSP,
|
||||
DB8500_REGULATOR_SWITCH_SVAMMDSPRET,
|
||||
DB8500_REGULATOR_SWITCH_SVAPIPE,
|
||||
DB8500_REGULATOR_SWITCH_SIAMMDSP,
|
||||
DB8500_REGULATOR_SWITCH_SIAMMDSPRET,
|
||||
DB8500_REGULATOR_SWITCH_SIAPIPE,
|
||||
DB8500_REGULATOR_SWITCH_SGA,
|
||||
DB8500_REGULATOR_SWITCH_B2R2_MCDE,
|
||||
DB8500_REGULATOR_SWITCH_ESRAM12,
|
||||
DB8500_REGULATOR_SWITCH_ESRAM12RET,
|
||||
DB8500_REGULATOR_SWITCH_ESRAM34,
|
||||
DB8500_REGULATOR_SWITCH_ESRAM34RET,
|
||||
DB8500_NUM_REGULATORS
|
||||
};
|
||||
|
||||
/*
|
||||
* Exported interface for CPUIdle only. This function is called with all
|
||||
* interrupts turned off.
|
||||
*/
|
||||
int power_state_active_is_enabled(void);
|
||||
|
||||
#endif
|
||||
413
include/linux/regulator/driver.h
Normal file
413
include/linux/regulator/driver.h
Normal file
|
|
@ -0,0 +1,413 @@
|
|||
/*
|
||||
* 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/notifier.h>
|
||||
#include <linux/regulator/consumer.h>
|
||||
|
||||
struct regmap;
|
||||
struct regulator_dev;
|
||||
struct regulator_init_data;
|
||||
struct regulator_enable_gpio;
|
||||
|
||||
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,
|
||||
/* The regulator is enabled but not regulating */
|
||||
REGULATOR_STATUS_BYPASS,
|
||||
/* in case that any other status doesn't apply */
|
||||
REGULATOR_STATUS_UNDEFINED,
|
||||
};
|
||||
|
||||
/**
|
||||
* struct regulator_linear_range - specify linear voltage ranges
|
||||
*
|
||||
* Specify a range of voltages for regulator_map_linar_range() and
|
||||
* regulator_list_linear_range().
|
||||
*
|
||||
* @min_uV: Lowest voltage in range
|
||||
* @min_sel: Lowest selector for range
|
||||
* @max_sel: Highest selector for range
|
||||
* @uV_step: Step size
|
||||
*/
|
||||
struct regulator_linear_range {
|
||||
unsigned int min_uV;
|
||||
unsigned int min_sel;
|
||||
unsigned int max_sel;
|
||||
unsigned int uV_step;
|
||||
};
|
||||
|
||||
/* Initialize struct regulator_linear_range */
|
||||
#define REGULATOR_LINEAR_RANGE(_min_uV, _min_sel, _max_sel, _step_uV) \
|
||||
{ \
|
||||
.min_uV = _min_uV, \
|
||||
.min_sel = _min_sel, \
|
||||
.max_sel = _max_sel, \
|
||||
.uV_step = _step_uV, \
|
||||
}
|
||||
|
||||
/**
|
||||
* 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.
|
||||
* @set_voltage_sel: Set the voltage for the regulator using the specified
|
||||
* selector.
|
||||
* @map_voltage: Convert a voltage into a selector
|
||||
* @get_voltage: Return the currently configured voltage for the regulator.
|
||||
* @get_voltage_sel: Return the currently configured voltage selector 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.
|
||||
* The driver should select the current closest to max_uA.
|
||||
* @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.
|
||||
*
|
||||
* @set_bypass: Set the regulator in bypass mode.
|
||||
* @get_bypass: Get the regulator bypass mode state.
|
||||
*
|
||||
* @enable_time: Time taken for the regulator voltage output voltage to
|
||||
* stabilise after being enabled, in microseconds.
|
||||
* @set_ramp_delay: Set the ramp delay for the regulator. The driver should
|
||||
* select ramp delay equal to or less than(closest) ramp_delay.
|
||||
* @set_voltage_time_sel: Time taken for the regulator voltage output voltage
|
||||
* to stabilise after being set to a new value, in microseconds.
|
||||
* The function provides the from and to voltage selector, the
|
||||
* function should return the worst case.
|
||||
*
|
||||
* @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,
|
||||
unsigned *selector);
|
||||
int (*map_voltage)(struct regulator_dev *, int min_uV, int max_uV);
|
||||
int (*set_voltage_sel) (struct regulator_dev *, unsigned selector);
|
||||
int (*get_voltage) (struct regulator_dev *);
|
||||
int (*get_voltage_sel) (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 consumer.h) */
|
||||
int (*set_mode) (struct regulator_dev *, unsigned int mode);
|
||||
unsigned int (*get_mode) (struct regulator_dev *);
|
||||
|
||||
/* Time taken to set voltage on the regulator */
|
||||
int (*enable_time) (struct regulator_dev *);
|
||||
int (*disable_time) (struct regulator_dev *);
|
||||
int (*set_ramp_delay) (struct regulator_dev *, int ramp_delay);
|
||||
int (*set_voltage_time_sel) (struct regulator_dev *,
|
||||
unsigned int old_selector,
|
||||
unsigned int new_selector);
|
||||
|
||||
/* 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);
|
||||
|
||||
/* control and report on bypass mode */
|
||||
int (*set_bypass)(struct regulator_dev *dev, bool enable);
|
||||
int (*get_bypass)(struct regulator_dev *dev, bool *enable);
|
||||
|
||||
/* 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 consumer.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 - Static regulator descriptor
|
||||
*
|
||||
* Each regulator registered with the core is described with a
|
||||
* structure of this type and a struct regulator_config. This
|
||||
* structure contains the non-varying parts of the regulator
|
||||
* description.
|
||||
*
|
||||
* @name: Identifying name for the regulator.
|
||||
* @supply_name: Identifying the regulator supply
|
||||
* @of_match: Name used to identify regulator in DT.
|
||||
* @regulators_node: Name of node containing regulator definitions in DT.
|
||||
* @id: Numerical identifier for the regulator.
|
||||
* @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.
|
||||
*
|
||||
* @continuous_voltage_range: Indicates if the regulator can set any
|
||||
* voltage within constrains range.
|
||||
* @n_voltages: Number of selectors available for ops.list_voltage().
|
||||
*
|
||||
* @min_uV: Voltage given by the lowest selector (if linear mapping)
|
||||
* @uV_step: Voltage increase with each selector (if linear mapping)
|
||||
* @linear_min_sel: Minimal selector for starting linear mapping
|
||||
* @fixed_uV: Fixed voltage of rails.
|
||||
* @ramp_delay: Time to settle down after voltage change (unit: uV/us)
|
||||
* @linear_ranges: A constant table of possible voltage ranges.
|
||||
* @n_linear_ranges: Number of entries in the @linear_ranges table.
|
||||
* @volt_table: Voltage mapping table (if table based mapping)
|
||||
*
|
||||
* @vsel_reg: Register for selector when using regulator_regmap_X_voltage_
|
||||
* @vsel_mask: Mask for register bitfield used for selector
|
||||
* @apply_reg: Register for initiate voltage change on the output when
|
||||
* using regulator_set_voltage_sel_regmap
|
||||
* @apply_bit: Register bitfield used for initiate voltage change on the
|
||||
* output when using regulator_set_voltage_sel_regmap
|
||||
* @enable_reg: Register for control when using regmap enable/disable ops
|
||||
* @enable_mask: Mask for control when using regmap enable/disable ops
|
||||
* @enable_val: Enabling value for control when using regmap enable/disable ops
|
||||
* @disable_val: Disabling value for control when using regmap enable/disable ops
|
||||
* @enable_is_inverted: A flag to indicate set enable_mask bits to disable
|
||||
* when using regulator_enable_regmap and friends APIs.
|
||||
* @bypass_reg: Register for control when using regmap set_bypass
|
||||
* @bypass_mask: Mask for control when using regmap set_bypass
|
||||
* @bypass_val_on: Enabling value for control when using regmap set_bypass
|
||||
* @bypass_val_off: Disabling value for control when using regmap set_bypass
|
||||
*
|
||||
* @enable_time: Time taken for initial enable of regulator (in uS).
|
||||
* @off_on_delay: guard time (in uS), before re-enabling a regulator
|
||||
*/
|
||||
struct regulator_desc {
|
||||
const char *name;
|
||||
const char *supply_name;
|
||||
const char *of_match;
|
||||
const char *regulators_node;
|
||||
int id;
|
||||
bool continuous_voltage_range;
|
||||
unsigned n_voltages;
|
||||
const struct regulator_ops *ops;
|
||||
int irq;
|
||||
enum regulator_type type;
|
||||
struct module *owner;
|
||||
|
||||
unsigned int min_uV;
|
||||
unsigned int uV_step;
|
||||
unsigned int linear_min_sel;
|
||||
int fixed_uV;
|
||||
unsigned int ramp_delay;
|
||||
|
||||
const struct regulator_linear_range *linear_ranges;
|
||||
int n_linear_ranges;
|
||||
|
||||
const unsigned int *volt_table;
|
||||
|
||||
unsigned int vsel_reg;
|
||||
unsigned int vsel_mask;
|
||||
unsigned int apply_reg;
|
||||
unsigned int apply_bit;
|
||||
unsigned int enable_reg;
|
||||
unsigned int enable_mask;
|
||||
unsigned int enable_val;
|
||||
unsigned int disable_val;
|
||||
bool enable_is_inverted;
|
||||
unsigned int bypass_reg;
|
||||
unsigned int bypass_mask;
|
||||
unsigned int bypass_val_on;
|
||||
unsigned int bypass_val_off;
|
||||
|
||||
unsigned int enable_time;
|
||||
|
||||
unsigned int off_on_delay;
|
||||
unsigned int disable_time;
|
||||
};
|
||||
|
||||
/**
|
||||
* struct regulator_config - Dynamic regulator descriptor
|
||||
*
|
||||
* Each regulator registered with the core is described with a
|
||||
* structure of this type and a struct regulator_desc. This structure
|
||||
* contains the runtime variable parts of the regulator description.
|
||||
*
|
||||
* @dev: struct device for the regulator
|
||||
* @init_data: platform provided init data, passed through by driver
|
||||
* @driver_data: private regulator data
|
||||
* @of_node: OpenFirmware node to parse for device tree bindings (may be
|
||||
* NULL).
|
||||
* @regmap: regmap to use for core regmap helpers if dev_get_regulator() is
|
||||
* insufficient.
|
||||
* @ena_gpio: GPIO controlling regulator enable.
|
||||
* @ena_gpio_invert: Sense for GPIO enable control.
|
||||
* @ena_gpio_flags: Flags to use when calling gpio_request_one()
|
||||
*/
|
||||
struct regulator_config {
|
||||
struct device *dev;
|
||||
const struct regulator_init_data *init_data;
|
||||
void *driver_data;
|
||||
struct device_node *of_node;
|
||||
struct regmap *regmap;
|
||||
|
||||
int ena_gpio;
|
||||
unsigned int ena_gpio_invert:1;
|
||||
unsigned int ena_gpio_flags;
|
||||
};
|
||||
|
||||
/*
|
||||
* 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 {
|
||||
const struct regulator_desc *desc;
|
||||
int exclusive;
|
||||
u32 use_count;
|
||||
u32 open_count;
|
||||
u32 bypass_count;
|
||||
|
||||
/* lists we belong to */
|
||||
struct list_head list; /* list of all regulators */
|
||||
|
||||
/* lists we own */
|
||||
struct list_head consumer_list; /* consumers we supply */
|
||||
|
||||
struct blocking_notifier_head notifier;
|
||||
struct mutex mutex; /* consumer lock */
|
||||
struct module *owner;
|
||||
struct device dev;
|
||||
struct regulation_constraints *constraints;
|
||||
struct regulator *supply; /* for tree */
|
||||
struct regmap *regmap;
|
||||
|
||||
struct delayed_work disable_work;
|
||||
int deferred_disables;
|
||||
|
||||
void *reg_data; /* regulator_dev data */
|
||||
|
||||
struct dentry *debugfs;
|
||||
|
||||
struct regulator_enable_gpio *ena_pin;
|
||||
unsigned int ena_gpio_state:1;
|
||||
|
||||
/* time when this regulator was disabled last time */
|
||||
unsigned long last_off_jiffy;
|
||||
};
|
||||
|
||||
struct regulator_dev *
|
||||
regulator_register(const struct regulator_desc *regulator_desc,
|
||||
const struct regulator_config *config);
|
||||
struct regulator_dev *
|
||||
devm_regulator_register(struct device *dev,
|
||||
const struct regulator_desc *regulator_desc,
|
||||
const struct regulator_config *config);
|
||||
void regulator_unregister(struct regulator_dev *rdev);
|
||||
void devm_regulator_unregister(struct device *dev, 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);
|
||||
|
||||
int regulator_list_voltage_linear(struct regulator_dev *rdev,
|
||||
unsigned int selector);
|
||||
int regulator_list_voltage_linear_range(struct regulator_dev *rdev,
|
||||
unsigned int selector);
|
||||
int regulator_list_voltage_table(struct regulator_dev *rdev,
|
||||
unsigned int selector);
|
||||
int regulator_map_voltage_linear(struct regulator_dev *rdev,
|
||||
int min_uV, int max_uV);
|
||||
int regulator_map_voltage_linear_range(struct regulator_dev *rdev,
|
||||
int min_uV, int max_uV);
|
||||
int regulator_map_voltage_iterate(struct regulator_dev *rdev,
|
||||
int min_uV, int max_uV);
|
||||
int regulator_map_voltage_ascend(struct regulator_dev *rdev,
|
||||
int min_uV, int max_uV);
|
||||
int regulator_get_voltage_sel_regmap(struct regulator_dev *rdev);
|
||||
int regulator_set_voltage_sel_regmap(struct regulator_dev *rdev, unsigned sel);
|
||||
int regulator_is_enabled_regmap(struct regulator_dev *rdev);
|
||||
int regulator_enable_regmap(struct regulator_dev *rdev);
|
||||
int regulator_disable_regmap(struct regulator_dev *rdev);
|
||||
int regulator_set_voltage_time_sel(struct regulator_dev *rdev,
|
||||
unsigned int old_selector,
|
||||
unsigned int new_selector);
|
||||
int regulator_set_bypass_regmap(struct regulator_dev *rdev, bool enable);
|
||||
int regulator_get_bypass_regmap(struct regulator_dev *rdev, bool *enable);
|
||||
|
||||
void *regulator_get_init_drvdata(struct regulator_init_data *reg_init_data);
|
||||
|
||||
#endif
|
||||
61
include/linux/regulator/fan53555.h
Normal file
61
include/linux/regulator/fan53555.h
Normal file
|
|
@ -0,0 +1,61 @@
|
|||
/*
|
||||
* fan53555.h - Fairchild Regulator FAN53555 Driver
|
||||
*
|
||||
* Copyright (C) 2012 Marvell Technology Ltd.
|
||||
* Yunfan Zhang <yfzhang@marvell.com>
|
||||
*
|
||||
* This package 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.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef __FAN53555_H__
|
||||
#define __FAN53555_H__
|
||||
|
||||
/* VSEL ID */
|
||||
enum {
|
||||
FAN53555_VSEL_ID_0 = 0,
|
||||
FAN53555_VSEL_ID_1,
|
||||
};
|
||||
|
||||
/* Transition slew rate limiting from a low to high voltage.
|
||||
* -----------------------
|
||||
* Bin |Slew Rate(mV/uS)
|
||||
* ------|----------------
|
||||
* 000 | 64.00
|
||||
* ------|----------------
|
||||
* 001 | 32.00
|
||||
* ------|----------------
|
||||
* 010 | 16.00
|
||||
* ------|----------------
|
||||
* 011 | 8.00
|
||||
* ------|----------------
|
||||
* 100 | 4.00
|
||||
* ------|----------------
|
||||
* 101 | 2.00
|
||||
* ------|----------------
|
||||
* 110 | 1.00
|
||||
* ------|----------------
|
||||
* 111 | 0.50
|
||||
* -----------------------
|
||||
*/
|
||||
enum {
|
||||
FAN53555_SLEW_RATE_64MV = 0,
|
||||
FAN53555_SLEW_RATE_32MV,
|
||||
FAN53555_SLEW_RATE_16MV,
|
||||
FAN53555_SLEW_RATE_8MV,
|
||||
FAN53555_SLEW_RATE_4MV,
|
||||
FAN53555_SLEW_RATE_2MV,
|
||||
FAN53555_SLEW_RATE_1MV,
|
||||
FAN53555_SLEW_RATE_0_5MV,
|
||||
};
|
||||
|
||||
struct fan53555_platform_data {
|
||||
struct regulator_init_data *regulator;
|
||||
unsigned int slew_rate;
|
||||
/* Sleep VSEL ID */
|
||||
unsigned int sleep_vsel_id;
|
||||
};
|
||||
|
||||
#endif /* __FAN53555_H__ */
|
||||
77
include/linux/regulator/fixed.h
Normal file
77
include/linux/regulator/fixed.h
Normal file
|
|
@ -0,0 +1,77 @@
|
|||
/*
|
||||
* fixed.h
|
||||
*
|
||||
* Copyright 2008 Wolfson Microelectronics PLC.
|
||||
*
|
||||
* Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
|
||||
*
|
||||
* Copyright (c) 2009 Nokia Corporation
|
||||
* Roger Quadros <ext-roger.quadros@nokia.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License as
|
||||
* published by the Free Software Foundation; either version 2 of the
|
||||
* License, or (at your option) any later version.
|
||||
*/
|
||||
|
||||
#ifndef __REGULATOR_FIXED_H
|
||||
#define __REGULATOR_FIXED_H
|
||||
|
||||
struct regulator_init_data;
|
||||
|
||||
/**
|
||||
* struct fixed_voltage_config - fixed_voltage_config structure
|
||||
* @supply_name: Name of the regulator supply
|
||||
* @input_supply: Name of the input regulator supply
|
||||
* @microvolts: Output voltage of regulator
|
||||
* @gpio: GPIO to use for enable control
|
||||
* set to -EINVAL if not used
|
||||
* @startup_delay: Start-up time in microseconds
|
||||
* @gpio_is_open_drain: Gpio pin is open drain or normal type.
|
||||
* If it is open drain type then HIGH will be set
|
||||
* through PULL-UP with setting gpio as input
|
||||
* and low will be set as gpio-output with driven
|
||||
* to low. For non-open-drain case, the gpio will
|
||||
* will be in output and drive to low/high accordingly.
|
||||
* @enable_high: Polarity of enable GPIO
|
||||
* 1 = Active high, 0 = Active low
|
||||
* @enabled_at_boot: Whether regulator has been enabled at
|
||||
* boot or not. 1 = Yes, 0 = No
|
||||
* This is used to keep the regulator at
|
||||
* the default state
|
||||
* @init_data: regulator_init_data
|
||||
*
|
||||
* This structure contains fixed voltage regulator configuration
|
||||
* information that must be passed by platform code to the fixed
|
||||
* voltage regulator driver.
|
||||
*/
|
||||
struct fixed_voltage_config {
|
||||
const char *supply_name;
|
||||
const char *input_supply;
|
||||
int microvolts;
|
||||
int gpio;
|
||||
unsigned startup_delay;
|
||||
unsigned endup_delay;
|
||||
unsigned gpio_is_open_drain:1;
|
||||
unsigned enable_high:1;
|
||||
unsigned enabled_at_boot:1;
|
||||
struct regulator_init_data *init_data;
|
||||
};
|
||||
|
||||
struct regulator_consumer_supply;
|
||||
|
||||
#if IS_ENABLED(CONFIG_REGULATOR)
|
||||
struct platform_device *regulator_register_always_on(int id, const char *name,
|
||||
struct regulator_consumer_supply *supplies, int num_supplies, int uv);
|
||||
#else
|
||||
static inline struct platform_device *regulator_register_always_on(int id, const char *name,
|
||||
struct regulator_consumer_supply *supplies, int num_supplies, int uv)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
#endif
|
||||
|
||||
#define regulator_register_fixed(id, s, ns) regulator_register_always_on(id, \
|
||||
"fixed-dummy", s, ns, 0)
|
||||
|
||||
#endif
|
||||
87
include/linux/regulator/gpio-regulator.h
Normal file
87
include/linux/regulator/gpio-regulator.h
Normal file
|
|
@ -0,0 +1,87 @@
|
|||
/*
|
||||
* gpio-regulator.h
|
||||
*
|
||||
* Copyright 2011 Heiko Stuebner <heiko@sntech.de>
|
||||
*
|
||||
* based on fixed.h
|
||||
*
|
||||
* Copyright 2008 Wolfson Microelectronics PLC.
|
||||
*
|
||||
* Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
|
||||
*
|
||||
* Copyright (c) 2009 Nokia Corporation
|
||||
* Roger Quadros <ext-roger.quadros@nokia.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License as
|
||||
* published by the Free Software Foundation; either version 2 of the
|
||||
* License, or (at your option) any later version.
|
||||
*/
|
||||
|
||||
#ifndef __REGULATOR_GPIO_H
|
||||
#define __REGULATOR_GPIO_H
|
||||
|
||||
struct regulator_init_data;
|
||||
|
||||
enum regulator_type;
|
||||
|
||||
/**
|
||||
* struct gpio_regulator_state - state description
|
||||
* @value: microvolts or microamps
|
||||
* @gpios: bitfield of gpio target-states for the value
|
||||
*
|
||||
* This structure describes a supported setting of the regulator
|
||||
* and the necessary gpio-state to achieve it.
|
||||
*
|
||||
* The n-th bit in the bitfield describes the state of the n-th GPIO
|
||||
* from the gpios-array defined in gpio_regulator_config below.
|
||||
*/
|
||||
struct gpio_regulator_state {
|
||||
int value;
|
||||
int gpios;
|
||||
};
|
||||
|
||||
/**
|
||||
* struct gpio_regulator_config - config structure
|
||||
* @supply_name: Name of the regulator supply
|
||||
* @enable_gpio: GPIO to use for enable control
|
||||
* set to -EINVAL if not used
|
||||
* @enable_high: Polarity of enable GPIO
|
||||
* 1 = Active high, 0 = Active low
|
||||
* @enabled_at_boot: Whether regulator has been enabled at
|
||||
* boot or not. 1 = Yes, 0 = No
|
||||
* This is used to keep the regulator at
|
||||
* the default state
|
||||
* @startup_delay: Start-up time in microseconds
|
||||
* @gpios: Array containing the gpios needed to control
|
||||
* the setting of the regulator
|
||||
* @nr_gpios: Number of gpios
|
||||
* @states: Array of gpio_regulator_state entries describing
|
||||
* the gpio state for specific voltages
|
||||
* @nr_states: Number of states available
|
||||
* @regulator_type: either REGULATOR_CURRENT or REGULATOR_VOLTAGE
|
||||
* @init_data: regulator_init_data
|
||||
*
|
||||
* This structure contains gpio-voltage regulator configuration
|
||||
* information that must be passed by platform code to the
|
||||
* gpio-voltage regulator driver.
|
||||
*/
|
||||
struct gpio_regulator_config {
|
||||
const char *supply_name;
|
||||
|
||||
int enable_gpio;
|
||||
unsigned enable_high:1;
|
||||
unsigned enabled_at_boot:1;
|
||||
unsigned startup_delay;
|
||||
|
||||
struct gpio *gpios;
|
||||
int nr_gpios;
|
||||
|
||||
struct gpio_regulator_state *states;
|
||||
int nr_states;
|
||||
|
||||
enum regulator_type type;
|
||||
struct regulator_init_data *init_data;
|
||||
};
|
||||
|
||||
#endif
|
||||
51
include/linux/regulator/lp3971.h
Normal file
51
include/linux/regulator/lp3971.h
Normal file
|
|
@ -0,0 +1,51 @@
|
|||
/*
|
||||
* National Semiconductors LP3971 PMIC chip client interface
|
||||
*
|
||||
* Copyright (C) 2009 Samsung Electronics
|
||||
* Author: Marek Szyprowski <m.szyprowski@samsung.com>
|
||||
*
|
||||
* Based on wm8400.h
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#ifndef __LINUX_REGULATOR_LP3971_H
|
||||
#define __LINUX_REGULATOR_LP3971_H
|
||||
|
||||
#include <linux/regulator/machine.h>
|
||||
|
||||
#define LP3971_LDO1 0
|
||||
#define LP3971_LDO2 1
|
||||
#define LP3971_LDO3 2
|
||||
#define LP3971_LDO4 3
|
||||
#define LP3971_LDO5 4
|
||||
|
||||
#define LP3971_DCDC1 5
|
||||
#define LP3971_DCDC2 6
|
||||
#define LP3971_DCDC3 7
|
||||
|
||||
#define LP3971_NUM_REGULATORS 8
|
||||
|
||||
struct lp3971_regulator_subdev {
|
||||
int id;
|
||||
struct regulator_init_data *initdata;
|
||||
};
|
||||
|
||||
struct lp3971_platform_data {
|
||||
int num_regulators;
|
||||
struct lp3971_regulator_subdev *regulators;
|
||||
};
|
||||
|
||||
#endif
|
||||
48
include/linux/regulator/lp3972.h
Normal file
48
include/linux/regulator/lp3972.h
Normal file
|
|
@ -0,0 +1,48 @@
|
|||
/*
|
||||
* National Semiconductors LP3972 PMIC chip client interface
|
||||
*
|
||||
* Based on lp3971.h
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#ifndef __LINUX_REGULATOR_LP3972_H
|
||||
#define __LINUX_REGULATOR_LP3972_H
|
||||
|
||||
#include <linux/regulator/machine.h>
|
||||
|
||||
#define LP3972_LDO1 0
|
||||
#define LP3972_LDO2 1
|
||||
#define LP3972_LDO3 2
|
||||
#define LP3972_LDO4 3
|
||||
#define LP3972_LDO5 4
|
||||
|
||||
#define LP3972_DCDC1 5
|
||||
#define LP3972_DCDC2 6
|
||||
#define LP3972_DCDC3 7
|
||||
|
||||
#define LP3972_NUM_REGULATORS 8
|
||||
|
||||
struct lp3972_regulator_subdev {
|
||||
int id;
|
||||
struct regulator_init_data *initdata;
|
||||
};
|
||||
|
||||
struct lp3972_platform_data {
|
||||
int num_regulators;
|
||||
struct lp3972_regulator_subdev *regulators;
|
||||
};
|
||||
|
||||
#endif
|
||||
90
include/linux/regulator/lp872x.h
Normal file
90
include/linux/regulator/lp872x.h
Normal file
|
|
@ -0,0 +1,90 @@
|
|||
/*
|
||||
* Copyright 2012 Texas Instruments
|
||||
*
|
||||
* Author: Milo(Woogyom) Kim <milo.kim@ti.com>
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef __LP872X_REGULATOR_H__
|
||||
#define __LP872X_REGULATOR_H__
|
||||
|
||||
#include <linux/regulator/machine.h>
|
||||
#include <linux/platform_device.h>
|
||||
#include <linux/gpio.h>
|
||||
|
||||
#define LP872X_MAX_REGULATORS 9
|
||||
|
||||
enum lp872x_regulator_id {
|
||||
LP8720_ID_BASE,
|
||||
LP8720_ID_LDO1 = LP8720_ID_BASE,
|
||||
LP8720_ID_LDO2,
|
||||
LP8720_ID_LDO3,
|
||||
LP8720_ID_LDO4,
|
||||
LP8720_ID_LDO5,
|
||||
LP8720_ID_BUCK,
|
||||
|
||||
LP8725_ID_BASE,
|
||||
LP8725_ID_LDO1 = LP8725_ID_BASE,
|
||||
LP8725_ID_LDO2,
|
||||
LP8725_ID_LDO3,
|
||||
LP8725_ID_LDO4,
|
||||
LP8725_ID_LDO5,
|
||||
LP8725_ID_LILO1,
|
||||
LP8725_ID_LILO2,
|
||||
LP8725_ID_BUCK1,
|
||||
LP8725_ID_BUCK2,
|
||||
|
||||
LP872X_ID_MAX,
|
||||
};
|
||||
|
||||
enum lp872x_dvs_state {
|
||||
DVS_LOW = GPIOF_OUT_INIT_LOW,
|
||||
DVS_HIGH = GPIOF_OUT_INIT_HIGH,
|
||||
};
|
||||
|
||||
enum lp872x_dvs_sel {
|
||||
SEL_V1,
|
||||
SEL_V2,
|
||||
};
|
||||
|
||||
/**
|
||||
* lp872x_dvs
|
||||
* @gpio : gpio pin number for dvs control
|
||||
* @vsel : dvs selector for buck v1 or buck v2 register
|
||||
* @init_state : initial dvs pin state
|
||||
*/
|
||||
struct lp872x_dvs {
|
||||
int gpio;
|
||||
enum lp872x_dvs_sel vsel;
|
||||
enum lp872x_dvs_state init_state;
|
||||
};
|
||||
|
||||
/**
|
||||
* lp872x_regdata
|
||||
* @id : regulator id
|
||||
* @init_data : init data for each regulator
|
||||
*/
|
||||
struct lp872x_regulator_data {
|
||||
enum lp872x_regulator_id id;
|
||||
struct regulator_init_data *init_data;
|
||||
};
|
||||
|
||||
/**
|
||||
* lp872x_platform_data
|
||||
* @general_config : the value of LP872X_GENERAL_CFG register
|
||||
* @update_config : if LP872X_GENERAL_CFG register is updated, set true
|
||||
* @regulator_data : platform regulator id and init data
|
||||
* @dvs : dvs data for buck voltage control
|
||||
*/
|
||||
struct lp872x_platform_data {
|
||||
u8 general_config;
|
||||
bool update_config;
|
||||
struct lp872x_regulator_data regulator_data[LP872X_MAX_REGULATORS];
|
||||
struct lp872x_dvs *dvs;
|
||||
};
|
||||
|
||||
#endif
|
||||
210
include/linux/regulator/machine.h
Normal file
210
include/linux/regulator/machine.h
Normal file
|
|
@ -0,0 +1,210 @@
|
|||
/*
|
||||
* machine.h -- SoC Regulator support, machine/board driver API.
|
||||
*
|
||||
* 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 Machine/Board Interface.
|
||||
*/
|
||||
|
||||
#ifndef __LINUX_REGULATOR_MACHINE_H_
|
||||
#define __LINUX_REGULATOR_MACHINE_H_
|
||||
|
||||
#include <linux/regulator/consumer.h>
|
||||
#include <linux/suspend.h>
|
||||
|
||||
struct regulator;
|
||||
|
||||
/*
|
||||
* Regulator operation constraint flags. These flags are used to enable
|
||||
* certain regulator operations and can be OR'ed together.
|
||||
*
|
||||
* VOLTAGE: Regulator output voltage can be changed by software on this
|
||||
* board/machine.
|
||||
* CURRENT: Regulator output current can be changed by software on this
|
||||
* board/machine.
|
||||
* MODE: Regulator operating mode can be changed by software on this
|
||||
* board/machine.
|
||||
* STATUS: Regulator can be enabled and disabled.
|
||||
* DRMS: Dynamic Regulator Mode Switching is enabled for this regulator.
|
||||
* BYPASS: Regulator can be put into bypass mode
|
||||
*/
|
||||
|
||||
#define REGULATOR_CHANGE_VOLTAGE 0x1
|
||||
#define REGULATOR_CHANGE_CURRENT 0x2
|
||||
#define REGULATOR_CHANGE_MODE 0x4
|
||||
#define REGULATOR_CHANGE_STATUS 0x8
|
||||
#define REGULATOR_CHANGE_DRMS 0x10
|
||||
#define REGULATOR_CHANGE_BYPASS 0x20
|
||||
|
||||
/**
|
||||
* struct regulator_state - regulator state during low power system states
|
||||
*
|
||||
* This describes a regulators state during a system wide low power
|
||||
* state. One of enabled or disabled must be set for the
|
||||
* configuration to be applied.
|
||||
*
|
||||
* @uV: Operating voltage during suspend.
|
||||
* @mode: Operating mode during suspend.
|
||||
* @enabled: Enabled during suspend.
|
||||
* @disabled: Disabled during suspend.
|
||||
*/
|
||||
struct regulator_state {
|
||||
int uV; /* suspend voltage */
|
||||
unsigned int mode; /* suspend regulator operating mode */
|
||||
int enabled; /* is regulator enabled in this suspend state */
|
||||
int disabled; /* is the regulator disbled in this suspend state */
|
||||
};
|
||||
|
||||
/**
|
||||
* struct regulation_constraints - regulator operating constraints.
|
||||
*
|
||||
* This struct describes regulator and board/machine specific constraints.
|
||||
*
|
||||
* @name: Descriptive name for the constraints, used for display purposes.
|
||||
*
|
||||
* @min_uV: Smallest voltage consumers may set.
|
||||
* @max_uV: Largest voltage consumers may set.
|
||||
* @uV_offset: Offset applied to voltages from consumer to compensate for
|
||||
* voltage drops.
|
||||
*
|
||||
* @min_uA: Smallest current consumers may set.
|
||||
* @max_uA: Largest current consumers may set.
|
||||
*
|
||||
* @valid_modes_mask: Mask of modes which may be configured by consumers.
|
||||
* @valid_ops_mask: Operations which may be performed by consumers.
|
||||
*
|
||||
* @always_on: Set if the regulator should never be disabled.
|
||||
* @boot_on: Set if the regulator is enabled when the system is initially
|
||||
* started. If the regulator is not enabled by the hardware or
|
||||
* bootloader then it will be enabled when the constraints are
|
||||
* applied.
|
||||
* @apply_uV: Apply the voltage constraint when initialising.
|
||||
* @ramp_disable: Disable ramp delay when initialising or when setting voltage.
|
||||
*
|
||||
* @input_uV: Input voltage for regulator when supplied by another regulator.
|
||||
*
|
||||
* @state_disk: State for regulator when system is suspended in disk mode.
|
||||
* @state_mem: State for regulator when system is suspended in mem mode.
|
||||
* @state_standby: State for regulator when system is suspended in standby
|
||||
* mode.
|
||||
* @initial_state: Suspend state to set by default.
|
||||
* @initial_mode: Mode to set at startup.
|
||||
* @ramp_delay: Time to settle down after voltage change (unit: uV/us)
|
||||
* @enable_time: Turn-on time of the rails (unit: microseconds)
|
||||
*/
|
||||
struct regulation_constraints {
|
||||
|
||||
const char *name;
|
||||
|
||||
/* voltage output range (inclusive) - for voltage control */
|
||||
int min_uV;
|
||||
int max_uV;
|
||||
|
||||
int uV_offset;
|
||||
|
||||
/* current output range (inclusive) - for current control */
|
||||
int min_uA;
|
||||
int max_uA;
|
||||
|
||||
/* valid regulator operating modes for this machine */
|
||||
unsigned int valid_modes_mask;
|
||||
|
||||
/* valid operations for regulator on this machine */
|
||||
unsigned int valid_ops_mask;
|
||||
|
||||
/* regulator input voltage - only if supply is another regulator */
|
||||
int input_uV;
|
||||
|
||||
/* regulator suspend states for global PMIC STANDBY/HIBERNATE */
|
||||
struct regulator_state state_disk;
|
||||
struct regulator_state state_mem;
|
||||
struct regulator_state state_standby;
|
||||
suspend_state_t initial_state; /* suspend state to set at init */
|
||||
|
||||
/* mode to set on startup */
|
||||
unsigned int initial_mode;
|
||||
|
||||
unsigned int ramp_delay;
|
||||
unsigned int enable_time;
|
||||
|
||||
/* constraint flags */
|
||||
unsigned always_on:1; /* regulator never off when system is on */
|
||||
unsigned boot_on:1; /* bootloader/firmware enabled regulator */
|
||||
unsigned apply_uV:1; /* apply uV constraint if min == max */
|
||||
unsigned ramp_disable:1; /* disable ramp delay */
|
||||
|
||||
/* expected consumer
|
||||
* will not set lower voltage unless all consumer is registered
|
||||
*/
|
||||
unsigned int expected_consumer;
|
||||
};
|
||||
|
||||
/**
|
||||
* struct regulator_consumer_supply - supply -> device mapping
|
||||
*
|
||||
* This maps a supply name to a device. Use of dev_name allows support for
|
||||
* buses which make struct device available late such as I2C.
|
||||
*
|
||||
* @dev_name: Result of dev_name() for the consumer.
|
||||
* @supply: Name for the supply.
|
||||
*/
|
||||
struct regulator_consumer_supply {
|
||||
const char *dev_name; /* dev_name() for consumer */
|
||||
const char *supply; /* consumer supply - e.g. "vcc" */
|
||||
};
|
||||
|
||||
/* Initialize struct regulator_consumer_supply */
|
||||
#define REGULATOR_SUPPLY(_name, _dev_name) \
|
||||
{ \
|
||||
.supply = _name, \
|
||||
.dev_name = _dev_name, \
|
||||
}
|
||||
|
||||
/**
|
||||
* struct regulator_init_data - regulator platform initialisation data.
|
||||
*
|
||||
* Initialisation constraints, our supply and consumers supplies.
|
||||
*
|
||||
* @supply_regulator: Parent regulator. Specified using the regulator name
|
||||
* as it appears in the name field in sysfs, which can
|
||||
* be explicitly set using the constraints field 'name'.
|
||||
*
|
||||
* @constraints: Constraints. These must be specified for the regulator to
|
||||
* be usable.
|
||||
* @num_consumer_supplies: Number of consumer device supplies.
|
||||
* @consumer_supplies: Consumer device supply configuration.
|
||||
*
|
||||
* @regulator_init: Callback invoked when the regulator has been registered.
|
||||
* @driver_data: Data passed to regulator_init.
|
||||
*/
|
||||
struct regulator_init_data {
|
||||
const char *supply_regulator; /* or NULL for system supply */
|
||||
|
||||
struct regulation_constraints constraints;
|
||||
|
||||
int num_consumer_supplies;
|
||||
struct regulator_consumer_supply *consumer_supplies;
|
||||
|
||||
/* optional regulator machine specific init */
|
||||
int (*regulator_init)(void *driver_data);
|
||||
void *driver_data; /* core does not touch this */
|
||||
};
|
||||
|
||||
int regulator_suspend_prepare(suspend_state_t state);
|
||||
int regulator_suspend_finish(void);
|
||||
|
||||
#ifdef CONFIG_REGULATOR
|
||||
void regulator_has_full_constraints(void);
|
||||
#else
|
||||
static inline void regulator_has_full_constraints(void)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
63
include/linux/regulator/max1586.h
Normal file
63
include/linux/regulator/max1586.h
Normal file
|
|
@ -0,0 +1,63 @@
|
|||
/*
|
||||
* max1586.h -- Voltage regulation for the Maxim 1586
|
||||
*
|
||||
* Copyright (C) 2008 Robert Jarzmik
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#ifndef REGULATOR_MAX1586
|
||||
#define REGULATOR_MAX1586
|
||||
|
||||
#include <linux/regulator/machine.h>
|
||||
|
||||
#define MAX1586_V3 0
|
||||
#define MAX1586_V6 1
|
||||
|
||||
/* precalculated values for v3_gain */
|
||||
#define MAX1586_GAIN_NO_R24 1000000 /* 700000 .. 1475000 mV */
|
||||
#define MAX1586_GAIN_R24_3k32 1051098 /* 735768 .. 1550369 mV */
|
||||
#define MAX1586_GAIN_R24_5k11 1078648 /* 755053 .. 1591005 mV */
|
||||
#define MAX1586_GAIN_R24_7k5 1115432 /* 780802 .. 1645262 mV */
|
||||
|
||||
/**
|
||||
* max1586_subdev_data - regulator data
|
||||
* @id: regulator Id (either MAX1586_V3 or MAX1586_V6)
|
||||
* @name: regulator cute name (example for V3: "vcc_core")
|
||||
* @platform_data: regulator init data (constraints, supplies, ...)
|
||||
*/
|
||||
struct max1586_subdev_data {
|
||||
int id;
|
||||
const char *name;
|
||||
struct regulator_init_data *platform_data;
|
||||
};
|
||||
|
||||
/**
|
||||
* max1586_platform_data - platform data for max1586
|
||||
* @num_subdevs: number of regulators used (may be 1 or 2)
|
||||
* @subdevs: regulator used
|
||||
* At most, there will be a regulator for V3 and one for V6 voltages.
|
||||
* @v3_gain: gain on the V3 voltage output multiplied by 1e6.
|
||||
* This can be calculated as ((1 + R24/R25 + R24/185.5kOhm) * 1e6)
|
||||
* for an external resistor configuration as described in the
|
||||
* data sheet (R25=100kOhm).
|
||||
*/
|
||||
struct max1586_platform_data {
|
||||
int num_subdevs;
|
||||
struct max1586_subdev_data *subdevs;
|
||||
int v3_gain;
|
||||
};
|
||||
|
||||
#endif
|
||||
83
include/linux/regulator/max77838-regulator.h
Normal file
83
include/linux/regulator/max77838-regulator.h
Normal file
|
|
@ -0,0 +1,83 @@
|
|||
/*
|
||||
* linux/regulator/max77838-regulator.h
|
||||
*
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef __LINUX_MAX77838_REGULATOR_H
|
||||
#define __LINUX_MAX77838_REGULATOR_H
|
||||
|
||||
/*******************************************************************************
|
||||
* Useful Macros
|
||||
******************************************************************************/
|
||||
|
||||
#undef __CONST_FFS
|
||||
#define __CONST_FFS(_x) \
|
||||
((_x) & 0x0F ? ((_x) & 0x03 ? ((_x) & 0x01 ? 0 : 1) :\
|
||||
((_x) & 0x04 ? 2 : 3)) :\
|
||||
((_x) & 0x30 ? ((_x) & 0x10 ? 4 : 5) :\
|
||||
((_x) & 0x40 ? 6 : 7)))
|
||||
|
||||
#undef BIT_RSVD
|
||||
#define BIT_RSVD 0
|
||||
|
||||
#undef BITS
|
||||
#define BITS(_end, _start) \
|
||||
((BIT(_end) - BIT(_start)) + BIT(_end))
|
||||
|
||||
#undef __BITS_GET
|
||||
#define __BITS_GET(_word, _mask, _shift) \
|
||||
(((_word) & (_mask)) >> (_shift))
|
||||
|
||||
#undef BITS_GET
|
||||
#define BITS_GET(_word, _bit) \
|
||||
__BITS_GET(_word, _bit, FFS(_bit))
|
||||
|
||||
#undef __BITS_SET
|
||||
#define __BITS_SET(_word, _mask, _shift, _val) \
|
||||
(((_word) & ~(_mask)) | (((_val) << (_shift)) & (_mask)))
|
||||
|
||||
#undef BITS_SET
|
||||
#define BITS_SET(_word, _bit, _val) \
|
||||
__BITS_SET(_word, _bit, FFS(_bit), _val)
|
||||
|
||||
#undef BITS_MATCH
|
||||
#define BITS_MATCH(_word, _bit) \
|
||||
(((_word) & (_bit)) == (_bit))
|
||||
|
||||
|
||||
enum max77838_reg_id {
|
||||
MAX77838_LDO1 = 1,
|
||||
MAX77838_LDO2,
|
||||
MAX77838_LDO3,
|
||||
MAX77838_LDO4,
|
||||
MAX77838_LDO_MAX = MAX77838_LDO4,
|
||||
|
||||
MAX77838_BUCK,
|
||||
|
||||
MAX77838_REGULATORS = MAX77838_BUCK,
|
||||
};
|
||||
|
||||
struct max77838_regulator_data {
|
||||
int active_discharge_enable;
|
||||
|
||||
struct regulator_init_data *initdata;
|
||||
struct device_node *of_node;
|
||||
};
|
||||
|
||||
struct max77838_regulator_platform_data {
|
||||
int num_regulators;
|
||||
struct max77838_regulator_data *regulators;
|
||||
|
||||
int buck_ramp_up;
|
||||
int buck_ramp_down;
|
||||
int buck_fpwm;
|
||||
int buck_fsrad;
|
||||
|
||||
int uvlo_fall_threshold;
|
||||
};
|
||||
|
||||
#endif
|
||||
44
include/linux/regulator/max8649.h
Normal file
44
include/linux/regulator/max8649.h
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
/*
|
||||
* Interface of Maxim max8649
|
||||
*
|
||||
* Copyright (C) 2009-2010 Marvell International Ltd.
|
||||
* Haojian Zhuang <haojian.zhuang@marvell.com>
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef __LINUX_REGULATOR_MAX8649_H
|
||||
#define __LINUX_REGULATOR_MAX8649_H
|
||||
|
||||
#include <linux/regulator/machine.h>
|
||||
|
||||
enum {
|
||||
MAX8649_EXTCLK_26MHZ = 0,
|
||||
MAX8649_EXTCLK_13MHZ,
|
||||
MAX8649_EXTCLK_19MHZ, /* 19.2MHz */
|
||||
};
|
||||
|
||||
enum {
|
||||
MAX8649_RAMP_32MV = 0,
|
||||
MAX8649_RAMP_16MV,
|
||||
MAX8649_RAMP_8MV,
|
||||
MAX8649_RAMP_4MV,
|
||||
MAX8649_RAMP_2MV,
|
||||
MAX8649_RAMP_1MV,
|
||||
MAX8649_RAMP_0_5MV,
|
||||
MAX8649_RAMP_0_25MV,
|
||||
};
|
||||
|
||||
struct max8649_platform_data {
|
||||
struct regulator_init_data *regulator;
|
||||
|
||||
unsigned mode:2; /* bit[1:0] = VID1,VID0 */
|
||||
unsigned extclk_freq:2;
|
||||
unsigned extclk:1;
|
||||
unsigned ramp_timing:3;
|
||||
unsigned ramp_down:1;
|
||||
};
|
||||
|
||||
#endif /* __LINUX_REGULATOR_MAX8649_H */
|
||||
57
include/linux/regulator/max8660.h
Normal file
57
include/linux/regulator/max8660.h
Normal file
|
|
@ -0,0 +1,57 @@
|
|||
/*
|
||||
* max8660.h -- Voltage regulation for the Maxim 8660/8661
|
||||
*
|
||||
* Copyright (C) 2009 Wolfram Sang, Pengutronix e.K.
|
||||
*
|
||||
* 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; version 2 of the License.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#ifndef __LINUX_REGULATOR_MAX8660_H
|
||||
#define __LINUX_REGULATOR_MAX8660_H
|
||||
|
||||
#include <linux/regulator/machine.h>
|
||||
|
||||
enum {
|
||||
MAX8660_V3,
|
||||
MAX8660_V4,
|
||||
MAX8660_V5,
|
||||
MAX8660_V6,
|
||||
MAX8660_V7,
|
||||
MAX8660_V_END,
|
||||
};
|
||||
|
||||
/**
|
||||
* max8660_subdev_data - regulator subdev data
|
||||
* @id: regulator id
|
||||
* @name: regulator name
|
||||
* @platform_data: regulator init data
|
||||
*/
|
||||
struct max8660_subdev_data {
|
||||
int id;
|
||||
const char *name;
|
||||
struct regulator_init_data *platform_data;
|
||||
};
|
||||
|
||||
/**
|
||||
* max8660_platform_data - platform data for max8660
|
||||
* @num_subdevs: number of regulators used
|
||||
* @subdevs: pointer to regulators used
|
||||
* @en34_is_high: if EN34 is driven high, regulators cannot be en-/disabled.
|
||||
*/
|
||||
struct max8660_platform_data {
|
||||
int num_subdevs;
|
||||
struct max8660_subdev_data *subdevs;
|
||||
unsigned en34_is_high:1;
|
||||
};
|
||||
#endif
|
||||
135
include/linux/regulator/max8952.h
Normal file
135
include/linux/regulator/max8952.h
Normal file
|
|
@ -0,0 +1,135 @@
|
|||
/*
|
||||
* max8952.h - Voltage regulation for the Maxim 8952
|
||||
*
|
||||
* Copyright (C) 2010 Samsung Electrnoics
|
||||
* MyungJoo Ham <myungjoo.ham@samsung.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#ifndef REGULATOR_MAX8952
|
||||
#define REGULATOR_MAX8952
|
||||
|
||||
#include <linux/regulator/machine.h>
|
||||
|
||||
enum {
|
||||
MAX8952_DVS_MODE0,
|
||||
MAX8952_DVS_MODE1,
|
||||
MAX8952_DVS_MODE2,
|
||||
MAX8952_DVS_MODE3,
|
||||
};
|
||||
|
||||
enum {
|
||||
MAX8952_DVS_770mV = 0,
|
||||
MAX8952_DVS_780mV,
|
||||
MAX8952_DVS_790mV,
|
||||
MAX8952_DVS_800mV,
|
||||
MAX8952_DVS_810mV,
|
||||
MAX8952_DVS_820mV,
|
||||
MAX8952_DVS_830mV,
|
||||
MAX8952_DVS_840mV,
|
||||
MAX8952_DVS_850mV,
|
||||
MAX8952_DVS_860mV,
|
||||
MAX8952_DVS_870mV,
|
||||
MAX8952_DVS_880mV,
|
||||
MAX8952_DVS_890mV,
|
||||
MAX8952_DVS_900mV,
|
||||
MAX8952_DVS_910mV,
|
||||
MAX8952_DVS_920mV,
|
||||
MAX8952_DVS_930mV,
|
||||
MAX8952_DVS_940mV,
|
||||
MAX8952_DVS_950mV,
|
||||
MAX8952_DVS_960mV,
|
||||
MAX8952_DVS_970mV,
|
||||
MAX8952_DVS_980mV,
|
||||
MAX8952_DVS_990mV,
|
||||
MAX8952_DVS_1000mV,
|
||||
MAX8952_DVS_1010mV,
|
||||
MAX8952_DVS_1020mV,
|
||||
MAX8952_DVS_1030mV,
|
||||
MAX8952_DVS_1040mV,
|
||||
MAX8952_DVS_1050mV,
|
||||
MAX8952_DVS_1060mV,
|
||||
MAX8952_DVS_1070mV,
|
||||
MAX8952_DVS_1080mV,
|
||||
MAX8952_DVS_1090mV,
|
||||
MAX8952_DVS_1100mV,
|
||||
MAX8952_DVS_1110mV,
|
||||
MAX8952_DVS_1120mV,
|
||||
MAX8952_DVS_1130mV,
|
||||
MAX8952_DVS_1140mV,
|
||||
MAX8952_DVS_1150mV,
|
||||
MAX8952_DVS_1160mV,
|
||||
MAX8952_DVS_1170mV,
|
||||
MAX8952_DVS_1180mV,
|
||||
MAX8952_DVS_1190mV,
|
||||
MAX8952_DVS_1200mV,
|
||||
MAX8952_DVS_1210mV,
|
||||
MAX8952_DVS_1220mV,
|
||||
MAX8952_DVS_1230mV,
|
||||
MAX8952_DVS_1240mV,
|
||||
MAX8952_DVS_1250mV,
|
||||
MAX8952_DVS_1260mV,
|
||||
MAX8952_DVS_1270mV,
|
||||
MAX8952_DVS_1280mV,
|
||||
MAX8952_DVS_1290mV,
|
||||
MAX8952_DVS_1300mV,
|
||||
MAX8952_DVS_1310mV,
|
||||
MAX8952_DVS_1320mV,
|
||||
MAX8952_DVS_1330mV,
|
||||
MAX8952_DVS_1340mV,
|
||||
MAX8952_DVS_1350mV,
|
||||
MAX8952_DVS_1360mV,
|
||||
MAX8952_DVS_1370mV,
|
||||
MAX8952_DVS_1380mV,
|
||||
MAX8952_DVS_1390mV,
|
||||
MAX8952_DVS_1400mV,
|
||||
};
|
||||
|
||||
enum {
|
||||
MAX8952_SYNC_FREQ_26MHZ, /* Default */
|
||||
MAX8952_SYNC_FREQ_13MHZ,
|
||||
MAX8952_SYNC_FREQ_19_2MHZ,
|
||||
};
|
||||
|
||||
enum {
|
||||
MAX8952_RAMP_32mV_us = 0, /* Default */
|
||||
MAX8952_RAMP_16mV_us,
|
||||
MAX8952_RAMP_8mV_us,
|
||||
MAX8952_RAMP_4mV_us,
|
||||
MAX8952_RAMP_2mV_us,
|
||||
MAX8952_RAMP_1mV_us,
|
||||
MAX8952_RAMP_0_5mV_us,
|
||||
MAX8952_RAMP_0_25mV_us,
|
||||
};
|
||||
|
||||
#define MAX8952_NUM_DVS_MODE 4
|
||||
|
||||
struct max8952_platform_data {
|
||||
int gpio_vid0;
|
||||
int gpio_vid1;
|
||||
int gpio_en;
|
||||
|
||||
u32 default_mode;
|
||||
u32 dvs_mode[MAX8952_NUM_DVS_MODE]; /* MAX8952_DVS_MODEx_XXXXmV */
|
||||
|
||||
u32 sync_freq;
|
||||
u32 ramp_speed;
|
||||
|
||||
struct regulator_init_data *reg_data;
|
||||
};
|
||||
|
||||
|
||||
#endif /* REGULATOR_MAX8952 */
|
||||
72
include/linux/regulator/max8973-regulator.h
Normal file
72
include/linux/regulator/max8973-regulator.h
Normal file
|
|
@ -0,0 +1,72 @@
|
|||
/*
|
||||
* max8973-regulator.h -- MAXIM 8973 regulator
|
||||
*
|
||||
* Interface for regulator driver for MAXIM 8973 DC-DC step-down
|
||||
* switching regulator.
|
||||
*
|
||||
* Copyright (C) 2012 NVIDIA Corporation
|
||||
|
||||
* Author: Laxman Dewangan <ldewangan@nvidia.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
||||
* more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along
|
||||
* with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef __LINUX_REGULATOR_MAX8973_H
|
||||
#define __LINUX_REGULATOR_MAX8973_H
|
||||
|
||||
/*
|
||||
* Control flags for configuration of the device.
|
||||
* Client need to pass this information with ORed
|
||||
*/
|
||||
#define MAX8973_CONTROL_REMOTE_SENSE_ENABLE 0x00000001
|
||||
#define MAX8973_CONTROL_FALLING_SLEW_RATE_ENABLE 0x00000002
|
||||
#define MAX8973_CONTROL_OUTPUT_ACTIVE_DISCH_ENABLE 0x00000004
|
||||
#define MAX8973_CONTROL_BIAS_ENABLE 0x00000008
|
||||
#define MAX8973_CONTROL_PULL_DOWN_ENABLE 0x00000010
|
||||
#define MAX8973_CONTROL_FREQ_SHIFT_9PER_ENABLE 0x00000020
|
||||
|
||||
#define MAX8973_CONTROL_CLKADV_TRIP_DISABLED 0x00000000
|
||||
#define MAX8973_CONTROL_CLKADV_TRIP_75mV_PER_US 0x00010000
|
||||
#define MAX8973_CONTROL_CLKADV_TRIP_150mV_PER_US 0x00020000
|
||||
#define MAX8973_CONTROL_CLKADV_TRIP_75mV_PER_US_HIST_DIS 0x00030000
|
||||
|
||||
#define MAX8973_CONTROL_INDUCTOR_VALUE_NOMINAL 0x00000000
|
||||
#define MAX8973_CONTROL_INDUCTOR_VALUE_MINUS_30_PER 0x00100000
|
||||
#define MAX8973_CONTROL_INDUCTOR_VALUE_PLUS_30_PER 0x00200000
|
||||
#define MAX8973_CONTROL_INDUCTOR_VALUE_PLUS_60_PER 0x00300000
|
||||
|
||||
/*
|
||||
* struct max8973_regulator_platform_data - max8973 regulator platform data.
|
||||
*
|
||||
* @reg_init_data: The regulator init data.
|
||||
* @control_flags: Control flags which are ORed value of above flags to
|
||||
* configure device.
|
||||
* @enable_ext_control: Enable the voltage enable/disable through external
|
||||
* control signal from EN input pin. If it is false then
|
||||
* voltage output will be enabled/disabled through EN bit of
|
||||
* device register.
|
||||
* @dvs_gpio: GPIO for dvs. It should be -1 if this is tied with fixed logic.
|
||||
* @dvs_def_state: Default state of dvs. 1 if it is high else 0.
|
||||
*/
|
||||
struct max8973_regulator_platform_data {
|
||||
struct regulator_init_data *reg_init_data;
|
||||
unsigned long control_flags;
|
||||
bool enable_ext_control;
|
||||
int dvs_gpio;
|
||||
unsigned dvs_def_state:1;
|
||||
};
|
||||
|
||||
#endif /* __LINUX_REGULATOR_MAX8973_H */
|
||||
40
include/linux/regulator/of_regulator.h
Normal file
40
include/linux/regulator/of_regulator.h
Normal file
|
|
@ -0,0 +1,40 @@
|
|||
/*
|
||||
* OpenFirmware regulator support routines
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef __LINUX_OF_REG_H
|
||||
#define __LINUX_OF_REG_H
|
||||
|
||||
struct of_regulator_match {
|
||||
const char *name;
|
||||
void *driver_data;
|
||||
struct regulator_init_data *init_data;
|
||||
struct device_node *of_node;
|
||||
};
|
||||
|
||||
#if defined(CONFIG_OF)
|
||||
extern struct regulator_init_data
|
||||
*of_get_regulator_init_data(struct device *dev,
|
||||
struct device_node *node);
|
||||
extern int of_regulator_match(struct device *dev, struct device_node *node,
|
||||
struct of_regulator_match *matches,
|
||||
unsigned int num_matches);
|
||||
#else
|
||||
static inline struct regulator_init_data
|
||||
*of_get_regulator_init_data(struct device *dev,
|
||||
struct device_node *node)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static inline int of_regulator_match(struct device *dev,
|
||||
struct device_node *node,
|
||||
struct of_regulator_match *matches,
|
||||
unsigned int num_matches)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
#endif /* CONFIG_OF */
|
||||
|
||||
#endif /* __LINUX_OF_REG_H */
|
||||
58
include/linux/regulator/pfuze100.h
Normal file
58
include/linux/regulator/pfuze100.h
Normal file
|
|
@ -0,0 +1,58 @@
|
|||
/*
|
||||
* Copyright (C) 2011-2013 Freescale Semiconductor, Inc. All Rights Reserved.
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along
|
||||
* with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*/
|
||||
#ifndef __LINUX_REG_PFUZE100_H
|
||||
#define __LINUX_REG_PFUZE100_H
|
||||
|
||||
#define PFUZE100_SW1AB 0
|
||||
#define PFUZE100_SW1C 1
|
||||
#define PFUZE100_SW2 2
|
||||
#define PFUZE100_SW3A 3
|
||||
#define PFUZE100_SW3B 4
|
||||
#define PFUZE100_SW4 5
|
||||
#define PFUZE100_SWBST 6
|
||||
#define PFUZE100_VSNVS 7
|
||||
#define PFUZE100_VREFDDR 8
|
||||
#define PFUZE100_VGEN1 9
|
||||
#define PFUZE100_VGEN2 10
|
||||
#define PFUZE100_VGEN3 11
|
||||
#define PFUZE100_VGEN4 12
|
||||
#define PFUZE100_VGEN5 13
|
||||
#define PFUZE100_VGEN6 14
|
||||
#define PFUZE100_MAX_REGULATOR 15
|
||||
|
||||
#define PFUZE200_SW1AB 0
|
||||
#define PFUZE200_SW2 1
|
||||
#define PFUZE200_SW3A 2
|
||||
#define PFUZE200_SW3B 3
|
||||
#define PFUZE200_SWBST 4
|
||||
#define PFUZE200_VSNVS 5
|
||||
#define PFUZE200_VREFDDR 6
|
||||
#define PFUZE200_VGEN1 7
|
||||
#define PFUZE200_VGEN2 8
|
||||
#define PFUZE200_VGEN3 9
|
||||
#define PFUZE200_VGEN4 10
|
||||
#define PFUZE200_VGEN5 11
|
||||
#define PFUZE200_VGEN6 12
|
||||
|
||||
struct regulator_init_data;
|
||||
|
||||
struct pfuze_regulator_platform_data {
|
||||
struct regulator_init_data *init_data[PFUZE100_MAX_REGULATOR];
|
||||
};
|
||||
|
||||
#endif /* __LINUX_REG_PFUZE100_H */
|
||||
47
include/linux/regulator/tps51632-regulator.h
Normal file
47
include/linux/regulator/tps51632-regulator.h
Normal file
|
|
@ -0,0 +1,47 @@
|
|||
/*
|
||||
* tps51632-regulator.h -- TPS51632 regulator
|
||||
*
|
||||
* Interface for regulator driver for TPS51632 3-2-1 Phase D-Cap Step Down
|
||||
* Driverless Controller with serial VID control and DVFS.
|
||||
*
|
||||
* Copyright (C) 2012 NVIDIA Corporation
|
||||
|
||||
* Author: Laxman Dewangan <ldewangan@nvidia.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
||||
* more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along
|
||||
* with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef __LINUX_REGULATOR_TPS51632_H
|
||||
#define __LINUX_REGULATOR_TPS51632_H
|
||||
|
||||
/*
|
||||
* struct tps51632_regulator_platform_data - tps51632 regulator platform data.
|
||||
*
|
||||
* @reg_init_data: The regulator init data.
|
||||
* @enable_pwm_dvfs: Enable PWM DVFS or not.
|
||||
* @dvfs_step_20mV: Step for DVFS is 20mV or 10mV.
|
||||
* @max_voltage_uV: Maximum possible voltage in PWM-DVFS mode.
|
||||
* @base_voltage_uV: Base voltage when PWM-DVFS enabled.
|
||||
*/
|
||||
struct tps51632_regulator_platform_data {
|
||||
struct regulator_init_data *reg_init_data;
|
||||
bool enable_pwm_dvfs;
|
||||
bool dvfs_step_20mV;
|
||||
int max_voltage_uV;
|
||||
int base_voltage_uV;
|
||||
};
|
||||
|
||||
#endif /* __LINUX_REGULATOR_TPS51632_H */
|
||||
53
include/linux/regulator/tps62360.h
Normal file
53
include/linux/regulator/tps62360.h
Normal file
|
|
@ -0,0 +1,53 @@
|
|||
/*
|
||||
* tps62360.h -- TI tps62360
|
||||
*
|
||||
* Interface for regulator driver for TI TPS62360 Processor core supply
|
||||
*
|
||||
* Copyright (C) 2012 NVIDIA Corporation
|
||||
|
||||
* Author: Laxman Dewangan <ldewangan@nvidia.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
||||
* more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along
|
||||
* with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef __LINUX_REGULATOR_TPS62360_H
|
||||
#define __LINUX_REGULATOR_TPS62360_H
|
||||
|
||||
/*
|
||||
* struct tps62360_regulator_platform_data - tps62360 regulator platform data.
|
||||
*
|
||||
* @reg_init_data: The regulator init data.
|
||||
* @en_discharge: Enable discharge the output capacitor via internal
|
||||
* register.
|
||||
* @en_internal_pulldn: internal pull down enable or not.
|
||||
* @vsel0_gpio: Gpio number for vsel0. It should be -1 if this is tied with
|
||||
* fixed logic.
|
||||
* @vsel1_gpio: Gpio number for vsel1. It should be -1 if this is tied with
|
||||
* fixed logic.
|
||||
* @vsel0_def_state: Default state of vsel0. 1 if it is high else 0.
|
||||
* @vsel1_def_state: Default state of vsel1. 1 if it is high else 0.
|
||||
*/
|
||||
struct tps62360_regulator_platform_data {
|
||||
struct regulator_init_data *reg_init_data;
|
||||
bool en_discharge;
|
||||
bool en_internal_pulldn;
|
||||
int vsel0_gpio;
|
||||
int vsel1_gpio;
|
||||
int vsel0_def_state;
|
||||
int vsel1_def_state;
|
||||
};
|
||||
|
||||
#endif /* __LINUX_REGULATOR_TPS62360_H */
|
||||
32
include/linux/regulator/tps6507x.h
Normal file
32
include/linux/regulator/tps6507x.h
Normal file
|
|
@ -0,0 +1,32 @@
|
|||
/*
|
||||
* tps6507x.h -- Voltage regulation for the Texas Instruments TPS6507X
|
||||
*
|
||||
* Copyright (C) 2010 Texas Instruments, Inc.
|
||||
*
|
||||
* 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
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#ifndef REGULATOR_TPS6507X
|
||||
#define REGULATOR_TPS6507X
|
||||
|
||||
/**
|
||||
* tps6507x_reg_platform_data - platform data for tps6507x
|
||||
* @defdcdc_default: Defines whether DCDC high or the low register controls
|
||||
* output voltage by default. Valid for DCDC2 and DCDC3 outputs only.
|
||||
*/
|
||||
struct tps6507x_reg_platform_data {
|
||||
bool defdcdc_default;
|
||||
};
|
||||
|
||||
#endif
|
||||
25
include/linux/regulator/userspace-consumer.h
Normal file
25
include/linux/regulator/userspace-consumer.h
Normal file
|
|
@ -0,0 +1,25 @@
|
|||
#ifndef __REGULATOR_PLATFORM_CONSUMER_H_
|
||||
#define __REGULATOR_PLATFORM_CONSUMER_H_
|
||||
|
||||
struct regulator_consumer_supply;
|
||||
|
||||
/**
|
||||
* struct regulator_userspace_consumer_data - line consumer
|
||||
* initialisation data.
|
||||
*
|
||||
* @name: Name for the consumer line
|
||||
* @num_supplies: Number of supplies feeding the line
|
||||
* @supplies: Supplies configuration.
|
||||
* @init_on: Set if the regulators supplying the line should be
|
||||
* enabled during initialisation
|
||||
*/
|
||||
struct regulator_userspace_consumer_data {
|
||||
const char *name;
|
||||
|
||||
int num_supplies;
|
||||
struct regulator_bulk_data *supplies;
|
||||
|
||||
bool init_on;
|
||||
};
|
||||
|
||||
#endif /* __REGULATOR_PLATFORM_CONSUMER_H_ */
|
||||
Loading…
Add table
Add a link
Reference in a new issue