blob: 778f4824bdf614bedaf5d671ad27bdac0fbf92d5 [file] [log] [blame]
/*
* Copyright (c) 2015-2017, The Linux Foundation. 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 version 2 and
* only 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.
*/
#ifndef __REGULATOR_CPR3_REGULATOR_H__
#define __REGULATOR_CPR3_REGULATOR_H__
#include <linux/clk.h>
#include <linux/mutex.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/types.h>
#include <linux/power/qcom/apm.h>
#include <linux/regulator/driver.h>
struct cpr3_controller;
struct cpr3_thread;
/**
* struct cpr3_fuse_param - defines one contiguous segment of a fuse parameter
* that is contained within a given row.
* @row: Fuse row number
* @bit_start: The first bit within the row of the fuse parameter segment
* @bit_end: The last bit within the row of the fuse parameter segment
*
* Each fuse row is 64 bits in length. bit_start and bit_end may take values
* from 0 to 63. bit_start must be less than or equal to bit_end.
*/
struct cpr3_fuse_param {
unsigned int row;
unsigned int bit_start;
unsigned int bit_end;
};
/* Each CPR3 sensor has 16 ring oscillators */
#define CPR3_RO_COUNT 16
/* The maximum number of sensors that can be present on a single CPR loop. */
#define CPR3_MAX_SENSOR_COUNT 256
/* This constant is used when allocating array printing buffers. */
#define MAX_CHARS_PER_INT 10
/**
* struct cpr4_sdelta - CPR4 controller specific data structure for the sdelta
* adjustment table which is used to adjust the VDD supply
* voltage automatically based upon the temperature and/or
* the number of online CPU cores.
* @allow_core_count_adj: Core count adjustments are allowed.
* @allow_temp_adj: Temperature based adjustments are allowed.
* @max_core_count: Maximum number of cores considered for core count
* adjustment logic.
* @temp_band_count: Number of temperature bands considered for temperature
* based adjustment logic.
* @cap_volt: CAP in uV to apply to SDELTA margins with multiple
* cpr3-regulators defined for single controller.
* @table: SDELTA table with per-online-core and temperature based
* adjustments of size (max_core_count * temp_band_count)
* Outer: core count
* Inner: temperature band
* Each element has units of VDD supply steps. Positive
* values correspond to a reduction in voltage and negative
* value correspond to an increase (this follows the SDELTA
* register semantics).
* @allow_boost: Voltage boost allowed.
* @boost_num_cores: The number of online cores at which the boost voltage
* adjustments will be applied
* @boost_table: SDELTA table with boost voltage adjustments of size
* temp_band_count. Each element has units of VDD supply
* steps. Positive values correspond to a reduction in
* voltage and negative value correspond to an increase
* (this follows the SDELTA register semantics).
*/
struct cpr4_sdelta {
bool allow_core_count_adj;
bool allow_temp_adj;
int max_core_count;
int temp_band_count;
int cap_volt;
int *table;
bool allow_boost;
int boost_num_cores;
int *boost_table;
};
/**
* struct cpr3_corner - CPR3 virtual voltage corner data structure
* @floor_volt: CPR closed-loop floor voltage in microvolts
* @ceiling_volt: CPR closed-loop ceiling voltage in microvolts
* @open_loop_volt: CPR open-loop voltage (i.e. initial voltage) in
* microvolts
* @last_volt: Last known settled CPR closed-loop voltage which is used
* when switching to a new corner
* @abs_ceiling_volt: The absolute CPR closed-loop ceiling voltage in
* microvolts. This is used to limit the ceiling_volt
* value when it is increased as a result of aging
* adjustment.
* @unaged_floor_volt: The CPR closed-loop floor voltage in microvolts before
* any aging adjustment is performed
* @unaged_ceiling_volt: The CPR closed-loop ceiling voltage in microvolts
* before any aging adjustment is performed
* @unaged_open_loop_volt: The CPR open-loop voltage (i.e. initial voltage) in
* microvolts before any aging adjusment is performed
* @system_volt: The system-supply voltage in microvolts or corners or
* levels
* @mem_acc_volt: The mem-acc-supply voltage in corners
* @proc_freq: Processor frequency in Hertz. For CPR rev. 3 and 4
* conrollers, this field is only used by platform specific
* CPR3 driver for interpolation. For CPRh-compliant
* controllers, this frequency is also utilized by the
* clock driver to determine the corner to CPU clock
* frequency mappings.
* @cpr_fuse_corner: Fused corner index associated with this virtual corner
* (only used by platform specific CPR3 driver for
* mapping purposes)
* @target_quot: Array of target quotient values to use for each ring
* oscillator (RO) for this corner. A value of 0 should be
* specified as the target quotient for each RO that is
* unused by this corner.
* @ro_scale: Array of CPR ring oscillator (RO) scaling factors. The
* scaling factor for each RO is defined from RO0 to RO15
* with units of QUOT/V. A value of 0 may be specified for
* an RO that is unused.
* @ro_mask: Bitmap where each of the 16 LSBs indicate if the
* corresponding ROs should be masked for this corner
* @irq_en: Bitmap of the CPR interrupts to enable for this corner
* @aging_derate: The amount to derate the aging voltage adjustment
* determined for the reference corner in units of uV/mV.
* E.g. a value of 900 would imply that the adjustment for
* this corner should be 90% (900/1000) of that for the
* reference corner.
* @use_open_loop: Boolean indicating that open-loop (i.e CPR disabled) as
* opposed to closed-loop operation must be used for this
* corner on CPRh controllers.
* @ldo_mode_allowed: Boolean which indicates if LDO mode is allowed for this
* corner. This field is applicable for CPR4 controllers
* that manage LDO300 supply regulator.
* @sdelta: The CPR4 controller specific data for this corner. This
* field is applicable for CPR4 controllers.
*
* The value of last_volt is initialized inside of the cpr3_regulator_register()
* call with the open_loop_volt value. It can later be updated to the settled
* VDD supply voltage. The values for unaged_floor_volt, unaged_ceiling_volt,
* and unaged_open_loop_volt are initialized inside of cpr3_regulator_register()
* if ctrl->aging_required == true. These three values must be pre-initialized
* if cpr3_regulator_register() is called with ctrl->aging_required == false and
* ctrl->aging_succeeded == true.
*
* The values of ro_mask and irq_en are initialized inside of the
* cpr3_regulator_register() call.
*/
struct cpr3_corner {
int floor_volt;
int ceiling_volt;
int open_loop_volt;
int last_volt;
int abs_ceiling_volt;
int unaged_floor_volt;
int unaged_ceiling_volt;
int unaged_open_loop_volt;
int system_volt;
int mem_acc_volt;
u32 proc_freq;
int cpr_fuse_corner;
u32 target_quot[CPR3_RO_COUNT];
u32 ro_scale[CPR3_RO_COUNT];
u32 ro_mask;
u32 irq_en;
int aging_derate;
bool use_open_loop;
bool ldo_mode_allowed;
struct cpr4_sdelta *sdelta;
};
/**
* struct cprh_corner_band - CPRh controller specific data structure which
* encapsulates the range of corners and the SDELTA
* adjustment table to be applied to the corners within
* the min and max bounds of the corner band.
* @corner: Corner number which defines the corner band boundary
* @sdelta: The SDELTA adjustment table which contains core-count
* and temp based margin adjustments that are applicable
* to the corner band.
*/
struct cprh_corner_band {
int corner;
struct cpr4_sdelta *sdelta;
};
/**
* enum cpr3_ldo_type - Constants which define the LDO supply regulator
* types used to manage the subsystem component rail voltage.
* %CPR3_LDO_KRYO: Kryo LDO regulator used to sub-regulate the HMSS
* per-cluster voltage.
* %CPR3_LDO300: LDO regulator used to sub-regulate the GFX voltage.
*/
enum cpr3_ldo_type {
CPR3_LDO_KRYO = 0,
CPR3_LDO300 = 1,
};
/**
* struct cpr3_regulator - CPR3 logical regulator instance associated with a
* given CPR3 hardware thread
* @of_node: Device node associated with the device tree child node
* of this CPR3 regulator
* @thread: Pointer to the CPR3 thread which manages this CPR3
* regulator
* @name: Unique name for this CPR3 regulator which is filled
* using the device tree regulator-name property
* @rdesc: Regulator description for this CPR3 regulator
* @rdev: Regulator device pointer for the regulator registered
* for this CPR3 regulator
* @mem_acc_regulator: Pointer to the optional mem-acc supply regulator used
* to manage memory circuitry settings based upon CPR3
* regulator output voltage.
* @ldo_regulator: Pointer to the LDO supply regulator used to manage
* per-cluster LDO voltage and bypass state
* @ldo_regulator_bypass: Cached copy of the LDO regulator bypass state
* @ldo_ret_regulator: Pointer to the LDO retention supply regulator used to
* manage LDO retention bypass state
* @corner: Array of all corners supported by this CPR3 regulator
* @corner_count: The number of elements in the corner array
* @corner_band: Array of all corner bands supported by CPRh compatible
* controllers
* @corner_band_count: The number of elements in the corner band array
* @platform_fuses: Pointer to platform specific CPR fuse data (only used by
* platform specific CPR3 driver)
* @speed_bin_fuse: Value read from the speed bin fuse parameter
* @speed_bins_supported: The number of speed bins supported by the device tree
* configuration for this CPR3 regulator
* @cpr_rev_fuse: Value read from the CPR fusing revision fuse parameter
* @fuse_combo: Platform specific enum value identifying the specific
* combination of fuse values found on a given chip
* @fuse_combos_supported: The number of fuse combinations supported by the
* device tree configuration for this CPR3 regulator
* @fuse_corner_count: Number of corners defined by fuse parameters
* @fuse_corner_map: Array of length fuse_corner_count which specifies the
* highest corner associated with each fuse corner. Note
* that each element must correspond to a valid corner
* and that element values must be strictly increasing.
* Also, it is acceptable for the lowest fuse corner to map
* to a corner other than the lowest. Likewise, it is
* acceptable for the highest fuse corner to map to a
* corner other than the highest.
* @fuse_combo_corner_sum: The sum of the corner counts across all fuse combos
* @fuse_combo_offset: The device tree property array offset for the selected
* fuse combo
* @speed_bin_corner_sum: The sum of the corner counts across all speed bins
* This may be specified as 0 if per speed bin parsing
* support is not required.
* @speed_bin_offset: The device tree property array offset for the selected
* speed bin
* @fuse_combo_corner_band_sum: The sum of the corner band counts across all
* fuse combos
* @fuse_combo_corner_band_offset: The device tree property array offset for
* the corner band count corresponding to the selected
* fuse combo
* @speed_bin_corner_band_sum: The sum of the corner band counts across all
* speed bins. This may be specified as 0 if per speed bin
* parsing support is not required
* @speed_bin_corner_band_offset: The device tree property array offset for the
* corner band count corresponding to the selected speed
* bin
* @pd_bypass_mask: Bit mask of power domains associated with this CPR3
* regulator
* @dynamic_floor_corner: Index identifying the voltage corner for the CPR3
* regulator whose last_volt value should be used as the
* global CPR floor voltage if all of the power domains
* associated with this CPR3 regulator are bypassed
* @uses_dynamic_floor: Boolean flag indicating that dynamic_floor_corner should
* be utilized for the CPR3 regulator
* @current_corner: Index identifying the currently selected voltage corner
* for the CPR3 regulator or less than 0 if no corner has
* been requested
* @last_closed_loop_corner: Index identifying the last voltage corner for the
* CPR3 regulator which was configured when operating in
* CPR closed-loop mode or less than 0 if no corner has
* been requested. CPR registers are only written to when
* using closed-loop mode.
* @aggregated: Boolean flag indicating that this CPR3 regulator
* participated in the last aggregation event
* @debug_corner: Index identifying voltage corner used for displaying
* corner configuration values in debugfs
* @ldo_type: LDO regulator type.
* @ldo_min_headroom_volt: Minimum voltage difference in microvolts required
* between the VDD supply voltage and the LDO output in
* order for the LDO operate
* @ldo_max_headroom_volt: Maximum voltage difference in microvolts between
* the input and output of the active LDO hardware to
* maintain optimum operability.
* @ldo_adjust_volt: Voltage in microvolts used to offset margin assigned
* to IR drop between PMIC and CPU
* @ldo_ret_volt: The lowest supported CPU retention voltage in
* microvolts. This voltage may vary part-to-part based
* upon the value of hardware fuses.
* @ldo_max_volt: The maximum physically supported LDO voltage in
* microvolts
* @ldo_mode_allowed: Boolean which indicates if LDO mode is allowed for this
* CPR3 regulator
* @vreg_enabled: Boolean defining the enable state of the CPR3
* regulator's regulator within the regulator framework.
* @aging_allowed: Boolean defining if CPR aging adjustments are allowed
* for this CPR3 regulator given the fuse combo of the
* device
* @aging_allow_open_loop_adj: Boolean defining if the open-loop voltage of each
* corner of this regulator should be adjusted as a result
* of an aging measurement. This flag can be set to false
* when the open-loop voltage adjustments have been
* specified such that they include the maximum possible
* aging adjustment. This flag is only used if
* aging_allowed == true.
* @aging_corner: The corner that should be configured for this regulator
* when an aging measurement is performed.
* @aging_max_adjust_volt: The maximum aging voltage margin in microvolts that
* may be added to the target quotients of this regulator.
* A value of 0 may be specified if this regulator does not
* require any aging adjustment.
* @allow_core_count_adj: Core count adjustments are allowed for this regulator.
* @allow_temp_adj: Temperature based adjustments are allowed for this
* regulator.
* @max_core_count: Maximum number of cores considered for core count
* adjustment logic.
* @allow_boost: Voltage boost allowed for this regulator.
*
* This structure contains both configuration and runtime state data. The
* elements current_corner, last_closed_loop_corner, aggregated, debug_corner,
* ldo_mode_allowed, and vreg_enabled are state variables.
*/
struct cpr3_regulator {
struct device_node *of_node;
struct cpr3_thread *thread;
const char *name;
struct regulator_desc rdesc;
struct regulator_dev *rdev;
struct regulator *mem_acc_regulator;
struct regulator *ldo_regulator;
bool ldo_regulator_bypass;
struct regulator *ldo_ret_regulator;
struct cpr3_corner *corner;
int corner_count;
struct cprh_corner_band *corner_band;
u32 corner_band_count;
void *platform_fuses;
int speed_bin_fuse;
int speed_bins_supported;
int cpr_rev_fuse;
int fuse_combo;
int fuse_combos_supported;
int fuse_corner_count;
int *fuse_corner_map;
int fuse_combo_corner_sum;
int fuse_combo_offset;
int speed_bin_corner_sum;
int speed_bin_offset;
int fuse_combo_corner_band_sum;
int fuse_combo_corner_band_offset;
int speed_bin_corner_band_sum;
int speed_bin_corner_band_offset;
u32 pd_bypass_mask;
int dynamic_floor_corner;
bool uses_dynamic_floor;
int current_corner;
int last_closed_loop_corner;
bool aggregated;
int debug_corner;
enum cpr3_ldo_type ldo_type;
int ldo_min_headroom_volt;
int ldo_max_headroom_volt;
int ldo_adjust_volt;
int ldo_ret_volt;
int ldo_max_volt;
bool ldo_mode_allowed;
bool vreg_enabled;
bool aging_allowed;
bool aging_allow_open_loop_adj;
int aging_corner;
int aging_max_adjust_volt;
bool allow_core_count_adj;
bool allow_temp_adj;
int max_core_count;
bool allow_boost;
};
/**
* struct cpr3_thread - CPR3 hardware thread data structure
* @thread_id: Hardware thread ID
* @of_node: Device node associated with the device tree child node
* of this CPR3 thread
* @ctrl: Pointer to the CPR3 controller which manages this thread
* @vreg: Array of CPR3 regulators handled by the CPR3 thread
* @vreg_count: Number of elements in the vreg array
* @aggr_corner: CPR corner containing the in process aggregated voltage
* and target quotient configurations which will be applied
* @last_closed_loop_aggr_corner: CPR corner containing the most recent
* configurations which were written into hardware
* registers when operating in closed loop mode (i.e. with
* CPR enabled)
* @consecutive_up: The number of consecutive CPR step up events needed to
* to trigger an up interrupt
* @consecutive_down: The number of consecutive CPR step down events needed to
* to trigger a down interrupt
* @up_threshold: The number CPR error steps required to generate an up
* event
* @down_threshold: The number CPR error steps required to generate a down
* event
*
* This structure contains both configuration and runtime state data. The
* elements aggr_corner and last_closed_loop_aggr_corner are state variables.
*/
struct cpr3_thread {
u32 thread_id;
struct device_node *of_node;
struct cpr3_controller *ctrl;
struct cpr3_regulator *vreg;
int vreg_count;
struct cpr3_corner aggr_corner;
struct cpr3_corner last_closed_loop_aggr_corner;
u32 consecutive_up;
u32 consecutive_down;
u32 up_threshold;
u32 down_threshold;
};
/* Per CPR controller data */
/**
* enum cpr3_mem_acc_corners - Constants which define the number of mem-acc
* regulator corners available in the mem-acc corner map array.
* %CPR3_MEM_ACC_LOW_CORNER: Index in mem-acc corner map array mapping to the
* mem-acc regulator corner
* to be used for low voltage vdd supply
* %CPR3_MEM_ACC_HIGH_CORNER: Index in mem-acc corner map array mapping to the
* mem-acc regulator corner to be used for high
* voltage vdd supply
* %CPR3_MEM_ACC_CORNERS: Number of elements in the mem-acc corner map
* array
*/
enum cpr3_mem_acc_corners {
CPR3_MEM_ACC_LOW_CORNER = 0,
CPR3_MEM_ACC_HIGH_CORNER = 1,
CPR3_MEM_ACC_CORNERS = 2,
};
/**
* enum cpr3_count_mode - CPR3 controller count mode which defines the
* method that CPR sensor data is acquired
* %CPR3_COUNT_MODE_ALL_AT_ONCE_MIN: Capture all CPR sensor readings
* simultaneously and report the minimum
* value seen in successive measurements
* %CPR3_COUNT_MODE_ALL_AT_ONCE_MAX: Capture all CPR sensor readings
* simultaneously and report the maximum
* value seen in successive measurements
* %CPR3_COUNT_MODE_STAGGERED: Read one sensor at a time in a
* sequential fashion
* %CPR3_COUNT_MODE_ALL_AT_ONCE_AGE: Capture all CPR aging sensor readings
* simultaneously.
*/
enum cpr3_count_mode {
CPR3_COUNT_MODE_ALL_AT_ONCE_MIN = 0,
CPR3_COUNT_MODE_ALL_AT_ONCE_MAX = 1,
CPR3_COUNT_MODE_STAGGERED = 2,
CPR3_COUNT_MODE_ALL_AT_ONCE_AGE = 3,
};
/**
* enum cpr_controller_type - supported CPR controller hardware types
* %CPR_CTRL_TYPE_CPR3: HW has CPR3 controller
* %CPR_CTRL_TYPE_CPR4: HW has CPR4 controller
* %CPR_CTRL_TYPE_CPRH: HW has CPRh controller
*/
enum cpr_controller_type {
CPR_CTRL_TYPE_CPR3,
CPR_CTRL_TYPE_CPR4,
CPR_CTRL_TYPE_CPRH,
};
/**
* struct cpr3_aging_sensor_info - CPR3 aging sensor information
* @sensor_id The index of the CPR3 sensor to be used in the aging
* measurement.
* @ro_scale The CPR ring oscillator (RO) scaling factor for the
* aging sensor with units of QUOT/V.
* @init_quot_diff: The fused quotient difference between aged and un-aged
* paths that was measured at manufacturing time.
* @measured_quot_diff: The quotient difference measured at runtime.
* @bypass_mask: Bit mask of the CPR sensors that must be bypassed during
* the aging measurement for this sensor
*
* This structure contains both configuration and runtime state data. The
* element measured_quot_diff is a state variable.
*/
struct cpr3_aging_sensor_info {
u32 sensor_id;
u32 ro_scale;
int init_quot_diff;
int measured_quot_diff;
u32 bypass_mask[CPR3_MAX_SENSOR_COUNT / 32];
};
/**
* struct cpr3_reg_info - Register information data structure
* @name: Register name
* @addr: Register physical address
* @value: Register content
* @virt_addr: Register virtual address
*
* This data structure is used to dump some critical register contents
* when the device crashes due to a kernel panic.
*/
struct cpr3_reg_info {
const char *name;
u32 addr;
u32 value;
void __iomem *virt_addr;
};
/**
* struct cpr3_panic_regs_info - Data structure to dump critical register
* contents.
* @reg_count: Number of elements in the regs array
* @regs: Array of critical registers information
*
* This data structure is used to dump critical register contents when
* the device crashes due to a kernel panic.
*/
struct cpr3_panic_regs_info {
int reg_count;
struct cpr3_reg_info *regs;
};
/**
* struct cpr3_controller - CPR3 controller data structure
* @dev: Device pointer for the CPR3 controller device
* @name: Unique name for the CPR3 controller
* @ctrl_id: Controller ID corresponding to the VDD supply number
* that this CPR3 controller manages.
* @cpr_ctrl_base: Virtual address of the CPR3 controller base register
* @fuse_base: Virtual address of fuse row 0
* @saw_base: Virtual address of the SAW module base register. This
* is used for CPR controllers that support HW closed-loop
* on platforms which lack an SPM.
* @aging_possible_reg: Virtual address of an optional platform-specific
* register that must be ready to determine if it is
* possible to perform an aging measurement.
* @list: list head used in a global cpr3-regulator list so that
* cpr3-regulator structs can be found easily in RAM dumps
* @thread: Array of CPR3 threads managed by the CPR3 controller
* @thread_count: Number of elements in the thread array
* @sensor_owner: Array of thread IDs indicating which thread owns a given
* CPR sensor
* @sensor_count: The number of CPR sensors found on the CPR loop managed
* by this CPR controller. Must be equal to the number of
* elements in the sensor_owner array
* @soc_revision: Revision number of the SoC. This may be unused by
* platforms that do not have different behavior for
* different SoC revisions.
* @cpr_hw_version: CPR controller version register value
* @lock: Mutex lock used to ensure mutual exclusion between
* all of the threads associated with the controller
* @vdd_regulator: Pointer to the VDD supply regulator which this CPR3
* controller manages
* @system_regulator: Pointer to the optional system-supply regulator upon
* which the VDD supply regulator depends.
* @mem_acc_regulator: Pointer to the optional mem-acc supply regulator used
* to manage memory circuitry settings based upon the
* VDD supply output voltage.
* @vdd_limit_regulator: Pointer to the VDD supply limit regulator which is used
* for hardware closed-loop in order specify ceiling and
* floor voltage limits (platform specific)
* @system_supply_max_volt: Voltage in microvolts which corresponds to the
* absolute ceiling voltage of the system-supply
* @mem_acc_threshold_volt: mem-acc threshold voltage in microvolts
* @mem_acc_corner_map: mem-acc regulator corners mapping to low and high
* voltage mem-acc settings for the memories powered by
* this CPR3 controller and its associated CPR3 regulators
* @mem_acc_crossover_volt: Voltage in microvolts corresponding to the voltage
* that the VDD supply must be set to while a MEM ACC
* switch is in progress. This element must be initialized
* for CPRh controllers when a MEM ACC threshold voltage is
* defined.
* @core_clk: Pointer to the CPR3 controller core clock
* @iface_clk: Pointer to the CPR3 interface clock (platform specific)
* @bus_clk: Pointer to the CPR3 bus clock (platform specific)
* @irq: CPR interrupt number
* @irq_affinity_mask: The cpumask for the CPUs which the CPR interrupt should
* have affinity for
* @cpu_hotplug_notifier: CPU hotplug notifier used to reset IRQ affinity when a
* CPU is brought back online
* @ceiling_irq: Interrupt number for the interrupt that is triggered
* when hardware closed-loop attempts to exceed the ceiling
* voltage
* @apm: Handle to the array power mux (APM)
* @apm_threshold_volt: Voltage in microvolts which defines the threshold
* voltage to determine the APM supply selection for
* each corner
* @apm_crossover_volt: Voltage in microvolts corresponding to the voltage that
* the VDD supply must be set to while an APM switch is in
* progress. This element must be initialized for CPRh
* controllers when an APM threshold voltage is defined
* @apm_adj_volt: Minimum difference between APM threshold voltage and
* open-loop voltage which allows the APM threshold voltage
* to be used as a ceiling
* @apm_high_supply: APM supply to configure if VDD voltage is greater than
* or equal to the APM threshold voltage
* @apm_low_supply: APM supply to configure if the VDD voltage is less than
* the APM threshold voltage
* @base_volt: Minimum voltage in microvolts supported by the VDD
* supply managed by this CPR controller
* @corner_switch_delay_time: The delay time in nanoseconds used by the CPR
* controller to wait for voltage settling before
* acknowledging the OSM block after corner changes
* @cpr_clock_rate: CPR reference clock frequency in Hz.
* @sensor_time: The time in nanoseconds that each sensor takes to
* perform a measurement.
* @loop_time: The time in nanoseconds between consecutive CPR
* measurements.
* @up_down_delay_time: The time to delay in nanoseconds between consecutive CPR
* measurements when the last measurement recommended
* increasing or decreasing the vdd-supply voltage.
* (platform specific)
* @idle_clocks: Number of CPR reference clock ticks that the CPR
* controller waits in transitional states.
* @step_quot_init_min: The default minimum CPR step quotient value. The step
* quotient is the number of additional ring oscillator
* ticks observed when increasing one step in vdd-supply
* output voltage.
* @step_quot_init_max: The default maximum CPR step quotient value.
* @step_volt: Step size in microvolts between available set points
* of the VDD supply
* @down_error_step_limit: CPR4 hardware closed-loop down error step limit which
* defines the maximum number of VDD supply regulator steps
* that the voltage may be reduced as the result of a
* single CPR measurement.
* @up_error_step_limit: CPR4 hardware closed-loop up error step limit which
* defines the maximum number of VDD supply regulator steps
* that the voltage may be increased as the result of a
* single CPR measurement.
* @acd_adj_down_step_limit: Limits the number of PMIC steps to go down within
* a given corner due to all ACD adjustments on some CPRh
* controllers.
* @acd_adj_up_step_limit: Limits the number of PMIC steps to go up within a
* given corner due to all ACD adjustments on some CPRh
* controllers.
* @acd_adj_down_step_size: ACD step size in units of PMIC steps used for
* target quotient adjustment due to an ACD down
* recommendation.
* @acd_adj_up_step_size: ACD step size in units of PMIC steps used for
* target quotient adjustment due to an ACD up
* recommendation.
* @acd_notwait_for_cl_settled: Boolean which indicates ACD down recommendations
* do not need to wait for CPR closed-loop to settle.
* @acd_adj_avg_fast_update: Boolean which indicates if CPR should issue
* immediate voltage updates on ACD requests.
* @acd_avg_enabled: Boolean defining the enable state of the ACD AVG
* feature.
* @count_mode: CPR controller count mode
* @count_repeat: Number of times to perform consecutive sensor
* measurements when using all-at-once count modes.
* @proc_clock_throttle: Defines the processor clock frequency throttling
* register value to use. This can be used to reduce the
* clock frequency when a power domain exits a low power
* mode until CPR settles at a new voltage.
* (platform specific)
* @cpr_allowed_hw: Boolean which indicates if closed-loop CPR operation is
* permitted for a given chip based upon hardware fuse
* values
* @cpr_allowed_sw: Boolean which indicates if closed-loop CPR operation is
* permitted based upon software policies
* @supports_hw_closed_loop: Boolean which indicates if this CPR3/4 controller
* physically supports hardware closed-loop CPR operation
* @use_hw_closed_loop: Boolean which indicates that this controller will be
* using hardware closed-loop operation in place of
* software closed-loop operation.
* @ctrl_type: CPR controller type
* @saw_use_unit_mV: Boolean which indicates the unit used in SAW PVC
* interface is mV.
* @aggr_corner: CPR corner containing the most recently aggregated
* voltage configurations which are being used currently
* @cpr_enabled: Boolean which indicates that the CPR controller is
* enabled and operating in closed-loop mode. CPR clocks
* have been prepared and enabled whenever this flag is
* true.
* @last_corner_was_closed_loop: Boolean indicating if the last known corners
* were updated during closed loop operation.
* @cpr_suspended: Boolean which indicates that CPR has been temporarily
* disabled while enterring system suspend.
* @debugfs: Pointer to the debugfs directory of this CPR3 controller
* @aging_ref_volt: Reference voltage in microvolts to configure when
* performing CPR aging measurements.
* @aging_vdd_mode: vdd-supply regulator mode to configure before performing
* a CPR aging measurement. It should be one of
* REGULATOR_MODE_*.
* @aging_complete_vdd_mode: vdd-supply regulator mode to configure after
* performing a CPR aging measurement. It should be one of
* REGULATOR_MODE_*.
* @aging_ref_adjust_volt: The reference aging voltage margin in microvolts that
* should be added to the target quotients of the
* regulators managed by this controller after derating.
* @aging_required: Flag which indicates that a CPR aging measurement still
* needs to be performed for this CPR3 controller.
* @aging_succeeded: Flag which indicates that a CPR aging measurement has
* completed successfully.
* @aging_failed: Flag which indicates that a CPR aging measurement has
* failed to complete successfully.
* @aging_sensor: Array of CPR3 aging sensors which are used to perform
* aging measurements at a runtime.
* @aging_sensor_count: Number of elements in the aging_sensor array
* @aging_possible_mask: Optional bitmask used to mask off the
* aging_possible_reg register.
* @aging_possible_val: Optional value that the masked aging_possible_reg
* register must have in order for a CPR aging measurement
* to be possible.
* @ignore_invalid_fuses: Flag which indicates that invalid fuse parameter
* values should be ignored. This is used on simulator
* targets which do not initialize fuse parameters.
* @step_quot_fixed: Fixed step quotient value used for target quotient
* adjustment if use_dynamic_step_quot is not set.
* This parameter is only relevant for CPR4 controllers
* when using the per-online-core or per-temperature
* adjustments.
* @initial_temp_band: Temperature band used for calculation of base-line
* target quotients (fused).
* @use_dynamic_step_quot: Boolean value which indicates that margin adjustment
* of target quotient will be based on the step quotient
* calculated dynamically in hardware for each RO.
* @allow_core_count_adj: Core count adjustments are allowed for this controller
* @allow_temp_adj: Temperature based adjustments are allowed for
* this controller
* @allow_boost: Voltage boost allowed for this controller.
* @temp_band_count: Number of temperature bands used for temperature based
* adjustment logic
* @temp_points: Array of temperature points in decidegrees Celsius used
* to specify the ranges for selected temperature bands.
* The array must have (temp_band_count - 1) elements
* allocated.
* @temp_sensor_id_start: Start ID of temperature sensors used for temperature
* based adjustments.
* @temp_sensor_id_end: End ID of temperature sensors used for temperature
* based adjustments.
* @voltage_settling_time: The time in nanoseconds that it takes for the
* VDD supply voltage to settle after being increased or
* decreased by step_volt microvolts which is used when
* SDELTA voltage margin adjustments are applied.
* @panic_regs_info: Array of panic registers information which provides the
* list of registers to dump when the device crashes.
* @panic_notifier: Notifier block registered to global panic notifier list.
* @support_ldo300_vreg: Boolean value which indicates that this CPR controller
* manages an underlying LDO regulator of type LDO300.
* @reset_step_quot_loop_en: Boolean value which indicates that this CPR
* controller should be configured to reset step_quot on
* each loop_en = 0 transition. This configuration allows
* the CPR controller to first use the default step_quot
* and then later switch to the run-time calibrated
* step_quot.
*
* This structure contains both configuration and runtime state data. The
* elements cpr_allowed_sw, use_hw_closed_loop, aggr_corner, cpr_enabled,
* last_corner_was_closed_loop, cpr_suspended, aging_ref_adjust_volt,
* aging_required, aging_succeeded, and aging_failed are state variables.
*
* The apm* elements do not need to be initialized if the VDD supply managed by
* the CPR3 controller does not utilize an APM.
*
* The elements step_quot_fixed, initial_temp_band, allow_core_count_adj,
* allow_temp_adj and temp* need to be initialized for CPR4 controllers which
* are using per-online-core or per-temperature adjustments.
*/
struct cpr3_controller {
struct device *dev;
const char *name;
int ctrl_id;
void __iomem *cpr_ctrl_base;
void __iomem *fuse_base;
void __iomem *saw_base;
void __iomem *aging_possible_reg;
struct list_head list;
struct cpr3_thread *thread;
int thread_count;
u8 *sensor_owner;
int sensor_count;
int soc_revision;
u32 cpr_hw_version;
struct mutex lock;
struct regulator *vdd_regulator;
struct regulator *system_regulator;
struct regulator *mem_acc_regulator;
struct regulator *vdd_limit_regulator;
int system_supply_max_volt;
int mem_acc_threshold_volt;
int mem_acc_corner_map[CPR3_MEM_ACC_CORNERS];
int mem_acc_crossover_volt;
struct clk *core_clk;
struct clk *iface_clk;
struct clk *bus_clk;
int irq;
struct cpumask irq_affinity_mask;
struct notifier_block cpu_hotplug_notifier;
int ceiling_irq;
struct msm_apm_ctrl_dev *apm;
int apm_threshold_volt;
int apm_crossover_volt;
int apm_adj_volt;
enum msm_apm_supply apm_high_supply;
enum msm_apm_supply apm_low_supply;
int base_volt;
u32 corner_switch_delay_time;
u32 cpr_clock_rate;
u32 sensor_time;
u32 loop_time;
u32 up_down_delay_time;
u32 idle_clocks;
u32 step_quot_init_min;
u32 step_quot_init_max;
int step_volt;
u32 down_error_step_limit;
u32 up_error_step_limit;
u32 acd_adj_down_step_limit;
u32 acd_adj_up_step_limit;
u32 acd_adj_down_step_size;
u32 acd_adj_up_step_size;
bool acd_notwait_for_cl_settled;
bool acd_adj_avg_fast_update;
bool acd_avg_enabled;
enum cpr3_count_mode count_mode;
u32 count_repeat;
u32 proc_clock_throttle;
bool cpr_allowed_hw;
bool cpr_allowed_sw;
bool supports_hw_closed_loop;
bool use_hw_closed_loop;
enum cpr_controller_type ctrl_type;
bool saw_use_unit_mV;
struct cpr3_corner aggr_corner;
bool cpr_enabled;
bool last_corner_was_closed_loop;
bool cpr_suspended;
struct dentry *debugfs;
int aging_ref_volt;
unsigned int aging_vdd_mode;
unsigned int aging_complete_vdd_mode;
int aging_ref_adjust_volt;
bool aging_required;
bool aging_succeeded;
bool aging_failed;
struct cpr3_aging_sensor_info *aging_sensor;
int aging_sensor_count;
u32 aging_possible_mask;
u32 aging_possible_val;
bool ignore_invalid_fuses;
u32 step_quot_fixed;
u32 initial_temp_band;
bool use_dynamic_step_quot;
bool allow_core_count_adj;
bool allow_temp_adj;
bool allow_boost;
int temp_band_count;
int *temp_points;
u32 temp_sensor_id_start;
u32 temp_sensor_id_end;
u32 voltage_settling_time;
struct cpr3_panic_regs_info *panic_regs_info;
struct notifier_block panic_notifier;
bool support_ldo300_vreg;
bool reset_step_quot_loop_en;
};
/* Used for rounding voltages to the closest physically available set point. */
#define CPR3_ROUND(n, d) (DIV_ROUND_UP(n, d) * (d))
#define cpr3_err(cpr3_thread, message, ...) \
pr_err("%s: " message, (cpr3_thread)->name, ##__VA_ARGS__)
#define cpr3_info(cpr3_thread, message, ...) \
pr_info("%s: " message, (cpr3_thread)->name, ##__VA_ARGS__)
#define cpr3_debug(cpr3_thread, message, ...) \
pr_debug("%s: " message, (cpr3_thread)->name, ##__VA_ARGS__)
/*
* Offset subtracted from voltage corner values passed in from the regulator
* framework in order to get internal voltage corner values. This is needed
* since the regulator framework treats 0 as an error value at regulator
* registration time.
*/
#define CPR3_CORNER_OFFSET 1
#ifdef CONFIG_REGULATOR_CPR3
int cpr3_regulator_register(struct platform_device *pdev,
struct cpr3_controller *ctrl);
int cpr3_regulator_unregister(struct cpr3_controller *ctrl);
int cpr3_regulator_suspend(struct cpr3_controller *ctrl);
int cpr3_regulator_resume(struct cpr3_controller *ctrl);
int cpr3_allocate_threads(struct cpr3_controller *ctrl, u32 min_thread_id,
u32 max_thread_id);
int cpr3_map_fuse_base(struct cpr3_controller *ctrl,
struct platform_device *pdev);
int cpr3_read_fuse_param(void __iomem *fuse_base_addr,
const struct cpr3_fuse_param *param, u64 *param_value);
int cpr3_convert_open_loop_voltage_fuse(int ref_volt, int step_volt, u32 fuse,
int fuse_len);
u64 cpr3_interpolate(u64 x1, u64 y1, u64 x2, u64 y2, u64 x);
int cpr3_parse_array_property(struct cpr3_regulator *vreg,
const char *prop_name, int tuple_size, u32 *out);
int cpr3_parse_corner_array_property(struct cpr3_regulator *vreg,
const char *prop_name, int tuple_size, u32 *out);
int cpr3_parse_corner_band_array_property(struct cpr3_regulator *vreg,
const char *prop_name, int tuple_size, u32 *out);
int cpr3_parse_common_corner_data(struct cpr3_regulator *vreg);
int cpr3_parse_thread_u32(struct cpr3_thread *thread, const char *propname,
u32 *out_value, u32 value_min, u32 value_max);
int cpr3_parse_ctrl_u32(struct cpr3_controller *ctrl, const char *propname,
u32 *out_value, u32 value_min, u32 value_max);
int cpr3_parse_common_thread_data(struct cpr3_thread *thread);
int cpr3_parse_common_ctrl_data(struct cpr3_controller *ctrl);
int cpr3_limit_open_loop_voltages(struct cpr3_regulator *vreg);
void cpr3_open_loop_voltage_as_ceiling(struct cpr3_regulator *vreg);
int cpr3_limit_floor_voltages(struct cpr3_regulator *vreg);
void cpr3_print_quots(struct cpr3_regulator *vreg);
int cpr3_adjust_fused_open_loop_voltages(struct cpr3_regulator *vreg,
int *fuse_volt);
int cpr3_adjust_open_loop_voltages(struct cpr3_regulator *vreg);
int cpr3_quot_adjustment(int ro_scale, int volt_adjust);
int cpr3_voltage_adjustment(int ro_scale, int quot_adjust);
int cpr3_parse_closed_loop_voltage_adjustments(struct cpr3_regulator *vreg,
u64 *ro_sel, int *volt_adjust,
int *volt_adjust_fuse, int *ro_scale);
int cpr4_parse_core_count_temp_voltage_adj(struct cpr3_regulator *vreg,
bool use_corner_band);
int cpr3_apm_init(struct cpr3_controller *ctrl);
int cpr3_mem_acc_init(struct cpr3_regulator *vreg);
void cprh_adjust_voltages_for_apm(struct cpr3_regulator *vreg);
void cprh_adjust_voltages_for_mem_acc(struct cpr3_regulator *vreg);
int cpr3_adjust_target_quotients(struct cpr3_regulator *vreg,
int *fuse_volt_adjust);
int cpr3_parse_fuse_combo_map(struct cpr3_regulator *vreg, u64 *fuse_val,
int fuse_count);
#else
static inline int cpr3_regulator_register(struct platform_device *pdev,
struct cpr3_controller *ctrl)
{
return -ENXIO;
}
static inline int cpr3_regulator_unregister(struct cpr3_controller *ctrl)
{
return -ENXIO;
}
static inline int cpr3_regulator_suspend(struct cpr3_controller *ctrl)
{
return -ENXIO;
}
static inline int cpr3_regulator_resume(struct cpr3_controller *ctrl)
{
return -ENXIO;
}
static inline int cpr3_get_thread_name(struct cpr3_thread *thread,
struct device_node *thread_node)
{
return -EPERM;
}
static inline int cpr3_allocate_threads(struct cpr3_controller *ctrl,
u32 min_thread_id, u32 max_thread_id)
{
return -EPERM;
}
static inline int cpr3_map_fuse_base(struct cpr3_controller *ctrl,
struct platform_device *pdev)
{
return -ENXIO;
}
static inline int cpr3_read_fuse_param(void __iomem *fuse_base_addr,
const struct cpr3_fuse_param *param, u64 *param_value)
{
return -EPERM;
}
static inline int cpr3_convert_open_loop_voltage_fuse(int ref_volt,
int step_volt, u32 fuse, int fuse_len)
{
return -EPERM;
}
static inline u64 cpr3_interpolate(u64 x1, u64 y1, u64 x2, u64 y2, u64 x)
{
return 0;
}
static inline int cpr3_parse_array_property(struct cpr3_regulator *vreg,
const char *prop_name, int tuple_size, u32 *out)
{
return -EPERM;
}
static inline int cpr3_parse_corner_array_property(struct cpr3_regulator *vreg,
const char *prop_name, int tuple_size, u32 *out)
{
return -EPERM;
}
static inline int cpr3_parse_corner_band_array_property(
struct cpr3_regulator *vreg, const char *prop_name,
int tuple_size, u32 *out)
{
return -EPERM;
}
static inline int cpr3_parse_common_corner_data(struct cpr3_regulator *vreg)
{
return -EPERM;
}
static inline int cpr3_parse_thread_u32(struct cpr3_thread *thread,
const char *propname, u32 *out_value, u32 value_min,
u32 value_max)
{
return -EPERM;
}
static inline int cpr3_parse_ctrl_u32(struct cpr3_controller *ctrl,
const char *propname, u32 *out_value, u32 value_min,
u32 value_max)
{
return -EPERM;
}
static inline int cpr3_parse_common_thread_data(struct cpr3_thread *thread)
{
return -EPERM;
}
static inline int cpr3_parse_common_ctrl_data(struct cpr3_controller *ctrl)
{
return -EPERM;
}
static inline int cpr3_limit_open_loop_voltages(struct cpr3_regulator *vreg)
{
return -EPERM;
}
static inline void cpr3_open_loop_voltage_as_ceiling(
struct cpr3_regulator *vreg)
{
}
static inline int cpr3_limit_floor_voltages(struct cpr3_regulator *vreg)
{
return -EPERM;
}
static inline void cpr3_print_quots(struct cpr3_regulator *vreg)
{
}
static inline int cpr3_adjust_fused_open_loop_voltages(
struct cpr3_regulator *vreg, int *fuse_volt)
{
return -EPERM;
}
static inline int cpr3_adjust_open_loop_voltages(struct cpr3_regulator *vreg)
{
return -EPERM;
}
static inline int cpr3_quot_adjustment(int ro_scale, int volt_adjust)
{
return 0;
}
static inline int cpr3_voltage_adjustment(int ro_scale, int quot_adjust)
{
return 0;
}
static inline int cpr3_parse_closed_loop_voltage_adjustments(
struct cpr3_regulator *vreg, u64 *ro_sel,
int *volt_adjust, int *volt_adjust_fuse, int *ro_scale)
{
return 0;
}
static inline int cpr4_parse_core_count_temp_voltage_adj(
struct cpr3_regulator *vreg, bool use_corner_band)
{
return 0;
}
static inline int cpr3_apm_init(struct cpr3_controller *ctrl)
{
return 0;
}
static inline int cpr3_mem_acc_init(struct cpr3_regulator *vreg)
{
return 0;
}
static inline void cprh_adjust_voltages_for_apm(struct cpr3_regulator *vreg)
{
}
static inline void cprh_adjust_voltages_for_mem_acc(struct cpr3_regulator *vreg)
{
}
static inline int cpr3_adjust_target_quotients(struct cpr3_regulator *vreg,
int *fuse_volt_adjust)
{
return 0;
}
static int cpr3_parse_fuse_combo_map(struct cpr3_regulator *vreg, u64 *fuse_val,
int fuse_count)
{
return -EPERM;
}
#endif /* CONFIG_REGULATOR_CPR3 */
#endif /* __REGULATOR_CPR_REGULATOR_H__ */