vasilito/RedBear-OS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

restore lost packages from 0.2.3 + fix overwritten 0.2.4 files

Browse Source 
- Restore 29 recipe symlinks (libdrm, qtbase, dbus, sddm, pipewire, etc.)
- Restore 33 patches (KDE, libdrm, mesa, pipewire, sddm, wireplumber)
- Restore 20+ local/scripts (audit, lint, test, build helpers)
- Restore src/cook/scheduler.rs, status.rs, gnu-config/
- Restore scripts/patch-inclusion-gate.sh, run_mini1.sh, validate-collision-log.sh
- Recover TLC source from HEAD (was overwritten by 0.2.3 checkout)
- Recover 11 local/docs plans from HEAD (were overwritten)
- Recover qt6-wayland-smoke symlink from HEAD
- Fix MOTD: remove garbled ASCII art, use clean text
- Update version: 0.2.0 -> 0.2.4 in os-release, motd, config
- Reduce filesystem_size: 1536 -> 512 MiB
- Add ABSOLUTE RULE to AGENTS.md: never delete/ignore packages
- Reduce pcid scheme log verbosity: info -> debug
This commit is contained in:
vasilito
2026-06-19 12:39:14 +03:00
parent ffbe098ef8
commit dc68054305
6418 changed files with 7066233 additions and 8670 deletions
Download Patch File Download Diff File Expand all files Collapse all files
local/recipes/gpu/amdgpu-source/include/linux/regulator/act8865.h
+82
View File
@@ -0,0 +1,82 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* act8865.h -- Voltage regulation for active-semi act88xx PMUs
*
* Copyright (C) 2013 Atmel Corporation.
*/
#ifndef __LINUX_REGULATOR_ACT8865_H
#define __LINUX_REGULATOR_ACT8865_H
#include <linux/regulator/machine.h>
enum {
ACT8600_ID_DCDC1,
ACT8600_ID_DCDC2,
ACT8600_ID_DCDC3,
ACT8600_ID_SUDCDC4,
ACT8600_ID_LDO5,
ACT8600_ID_LDO6,
ACT8600_ID_LDO7,
ACT8600_ID_LDO8,
ACT8600_ID_LDO9,
ACT8600_ID_LDO10,
};
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 {
ACT8600,
ACT8865,
ACT8846,
};
/**
* act8865_regulator_data - regulator data
* @id: regulator id
* @name: regulator name
* @init_data: regulator init data
* @of_node: device tree node (optional)
*/
struct act8865_regulator_data {
int id;
const char *name;
struct regulator_init_data *init_data;
struct device_node *of_node;
};
/**
* 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
local/recipes/gpu/amdgpu-source/include/linux/regulator/arizona-ldo1.h
+18
View File
@@ -0,0 +1,18 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Platform data for Arizona LDO1 regulator
*
* Copyright 2017 Cirrus Logic
*/
#ifndef ARIZONA_LDO1_H
#define ARIZONA_LDO1_H
struct regulator_init_data;
struct arizona_ldo1_pdata {
/** Regulator configuration for LDO1 */
const struct regulator_init_data *init_data;
};
#endif
local/recipes/gpu/amdgpu-source/include/linux/regulator/arizona-micsupp.h
+18
View File
@@ -0,0 +1,18 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Platform data for Arizona micsupp regulator
*
* Copyright 2017 Cirrus Logic
*/
#ifndef ARIZONA_MICSUPP_H
#define ARIZONA_MICSUPP_H
struct regulator_init_data;
struct arizona_micsupp_pdata {
/** Regulator configuration for micsupp */
const struct regulator_init_data *init_data;
};
#endif
local/recipes/gpu/amdgpu-source/include/linux/regulator/consumer.h
+745
View File
@@ -0,0 +1,745 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* consumer.h -- SoC Regulator consumer support.
*
* Copyright (C) 2007, 2008 Wolfson Microelectronics PLC.
*
* Author: Liam Girdwood <lrg@slimlogic.co.uk>
*
* 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>
#include <linux/suspend.h>
#include <regulator/regulator.h>
struct device;
struct notifier_block;
struct regmap;
struct regulator_dev;
/*
* 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_INVALID 0x0
#define REGULATOR_MODE_FAST 0x1
#define REGULATOR_MODE_NORMAL 0x2
#define REGULATOR_MODE_IDLE 0x4
#define REGULATOR_MODE_STANDBY 0x8
/*
* Regulator errors that can be queried using regulator_get_error_flags
*
* 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.
*
* NOTE: These errors can be OR'ed together.
*/
#define REGULATOR_ERROR_UNDER_VOLTAGE BIT(1)
#define REGULATOR_ERROR_OVER_CURRENT BIT(2)
#define REGULATOR_ERROR_REGULATION_OUT BIT(3)
#define REGULATOR_ERROR_FAIL BIT(4)
#define REGULATOR_ERROR_OVER_TEMP BIT(5)
#define REGULATOR_ERROR_UNDER_VOLTAGE_WARN BIT(6)
#define REGULATOR_ERROR_OVER_CURRENT_WARN BIT(7)
#define REGULATOR_ERROR_OVER_VOLTAGE_WARN BIT(8)
#define REGULATOR_ERROR_OVER_TEMP_WARN BIT(9)
/**
* 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.
* @init_load_uA: After getting the regulator, regulator_set_load() will be
* called with this load. Initialised by the user before
* using the bulk regulator APIs.
*
* 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;
int init_load_uA;
/* 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);
int devm_regulator_get_enable(struct device *dev, const char *id);
int devm_regulator_get_enable_optional(struct device *dev, const char *id);
int devm_regulator_get_enable_read_voltage(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);
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);
/* 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);
void devm_regulator_bulk_put(struct regulator_bulk_data *consumers);
int __must_check devm_regulator_bulk_get_exclusive(struct device *dev, int num_consumers,
struct regulator_bulk_data *consumers);
int __must_check devm_regulator_bulk_get_const(
struct device *dev, int num_consumers,
const struct regulator_bulk_data *in_consumers,
struct regulator_bulk_data **out_consumers);
int __must_check regulator_bulk_enable(int num_consumers,
struct regulator_bulk_data *consumers);
int devm_regulator_bulk_get_enable(struct device *dev, int num_consumers,
const char * const *id);
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_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_unclaimed_power_budget(struct regulator *regulator);
int regulator_request_power_budget(struct regulator *regulator,
unsigned int pw_req);
void regulator_free_power_budget(struct regulator *regulator,
unsigned int pw);
int regulator_set_mode(struct regulator *regulator, unsigned int mode);
unsigned int regulator_get_mode(struct regulator *regulator);
int regulator_get_error_flags(struct regulator *regulator,
unsigned int *flags);
int regulator_set_load(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);
int regulator_hardware_enable(struct regulator *regulator, bool enable);
/* regulator notifier block */
int regulator_register_notifier(struct regulator *regulator,
struct notifier_block *nb);
int devm_regulator_register_notifier(struct regulator *regulator,
struct notifier_block *nb);
int regulator_unregister_notifier(struct regulator *regulator,
struct notifier_block *nb);
void devm_regulator_unregister_notifier(struct regulator *regulator,
struct notifier_block *nb);
/* regulator suspend */
int regulator_suspend_enable(struct regulator_dev *rdev,
suspend_state_t state);
int regulator_suspend_disable(struct regulator_dev *rdev,
suspend_state_t state);
int regulator_set_suspend_voltage(struct regulator *regulator, int min_uV,
int max_uV, suspend_state_t state);
/* driver data - core doesn't touch */
void *regulator_get_drvdata(struct regulator *regulator);
void regulator_set_drvdata(struct regulator *regulator, void *data);
/* misc helpers */
void regulator_bulk_set_supply_names(struct regulator_bulk_data *consumers,
const char *const *supply_names,
unsigned int num_supplies);
bool regulator_is_equal(struct regulator *reg1, struct regulator *reg2);
#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 ERR_PTR(-ENODEV);
}
static inline struct regulator *__must_check
devm_regulator_get_exclusive(struct device *dev, const char *id)
{
return ERR_PTR(-ENODEV);
}
static inline int devm_regulator_get_enable(struct device *dev, const char *id)
{
return 0;
}
static inline int devm_regulator_get_enable_optional(struct device *dev,
const char *id)
{
return 0;
}
static inline int devm_regulator_get_enable_read_voltage(struct device *dev,
const char *id)
{
return -ENODEV;
}
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 void devm_regulator_bulk_put(struct regulator_bulk_data *consumers)
{
}
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 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 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 devm_regulator_bulk_get_const(
struct device *dev, int num_consumers,
const struct regulator_bulk_data *in_consumers,
struct regulator_bulk_data **out_consumers)
{
return 0;
}
static inline int regulator_bulk_enable(int num_consumers,
struct regulator_bulk_data *consumers)
{
return 0;
}
static inline int devm_regulator_bulk_get_enable(struct device *dev,
int num_consumers,
const char * const *id)
{
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_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_sync_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 unsigned int regulator_get_linear_step(struct regulator *regulator)
{
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_get_unclaimed_power_budget(struct regulator *regulator)
{
return INT_MAX;
}
static inline int regulator_request_power_budget(struct regulator *regulator,
unsigned int pw_req)
{
return -EOPNOTSUPP;
}
static inline void regulator_free_power_budget(struct regulator *regulator,
unsigned int pw)
{
}
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_get_error_flags(struct regulator *regulator,
unsigned int *flags)
{
return -EINVAL;
}
static inline int regulator_set_load(struct regulator *regulator, int load_uA)
{
return 0;
}
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_hardware_enable(struct regulator *regulator,
bool enable)
{
return -EOPNOTSUPP;
}
static inline int regulator_register_notifier(struct regulator *regulator,
struct notifier_block *nb)
{
return 0;
}
static inline int devm_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 int devm_regulator_unregister_notifier(struct regulator *regulator,
struct notifier_block *nb)
{
return 0;
}
static inline int regulator_suspend_enable(struct regulator_dev *rdev,
suspend_state_t state)
{
return -EINVAL;
}
static inline int regulator_suspend_disable(struct regulator_dev *rdev,
suspend_state_t state)
{
return -EINVAL;
}
static inline int regulator_set_suspend_voltage(struct regulator *regulator,
int min_uV, int max_uV,
suspend_state_t state)
{
return -EINVAL;
}
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;
}
static inline int regulator_list_voltage(struct regulator *regulator, unsigned selector)
{
return -EINVAL;
}
static inline void
regulator_bulk_set_supply_names(struct regulator_bulk_data *consumers,
const char *const *supply_names,
unsigned int num_supplies)
{
}
static inline bool
regulator_is_equal(struct regulator *reg1, struct regulator *reg2)
{
return false;
}
#endif
#if IS_ENABLED(CONFIG_OF) && IS_ENABLED(CONFIG_REGULATOR)
struct regulator *__must_check of_regulator_get(struct device *dev,
struct device_node *node,
const char *id);
struct regulator *__must_check devm_of_regulator_get(struct device *dev,
struct device_node *node,
const char *id);
struct regulator *__must_check of_regulator_get_optional(struct device *dev,
struct device_node *node,
const char *id);
struct regulator *__must_check devm_of_regulator_get_optional(struct device *dev,
struct device_node *node,
const char *id);
int __must_check of_regulator_bulk_get_all(struct device *dev, struct device_node *np,
struct regulator_bulk_data **consumers);
#else
static inline struct regulator *__must_check of_regulator_get_optional(struct device *dev,
struct device_node *node,
const char *id)
{
return ERR_PTR(-ENODEV);
}
static inline struct regulator *__must_check devm_of_regulator_get_optional(struct device *dev,
struct device_node *node,
const char *id)
{
return ERR_PTR(-ENODEV);
}
static inline int of_regulator_bulk_get_all(struct device *dev, struct device_node *np,
struct regulator_bulk_data **consumers)
{
return 0;
}
#endif
static inline int regulator_set_voltage_triplet(struct regulator *regulator,
int min_uV, int target_uV,
int max_uV)
{
if (regulator_set_voltage(regulator, target_uV, max_uV) == 0)
return 0;
return regulator_set_voltage(regulator, min_uV, max_uV);
}
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
local/recipes/gpu/amdgpu-source/include/linux/regulator/coupler.h
+101
View File
@@ -0,0 +1,101 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* coupler.h -- SoC Regulator support, coupler API.
*
* Regulator Coupler Interface.
*/
#ifndef __LINUX_REGULATOR_COUPLER_H_
#define __LINUX_REGULATOR_COUPLER_H_
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/suspend.h>
struct regulator_coupler;
struct regulator_dev;
/**
* struct regulator_coupler - customized regulator's coupler
*
* Regulator's coupler allows to customize coupling algorithm.
*
* @list: couplers list entry
* @attach_regulator: Callback invoked on creation of a coupled regulator,
* couples are unresolved at this point. The callee should
* check that it could handle the regulator and return 0 on
* success, -errno on failure and 1 if given regulator is
* not suitable for this coupler (case of having multiple
* regulators in a system). Callback shall be implemented.
* @detach_regulator: Callback invoked on destruction of a coupled regulator.
* This callback is optional and could be NULL.
* @balance_voltage: Callback invoked when voltage of a coupled regulator is
* changing. Called with all of the coupled rdev's being held
* under "consumer lock". The callee should perform voltage
* balancing, changing voltage of the coupled regulators as
* needed. It's up to the coupler to verify the voltage
* before changing it in hardware, i.e. coupler should
* check consumer's min/max and etc. This callback is
* optional and could be NULL, in which case a generic
* voltage balancer will be used.
*/
struct regulator_coupler {
struct list_head list;
int (*attach_regulator)(struct regulator_coupler *coupler,
struct regulator_dev *rdev);
int (*detach_regulator)(struct regulator_coupler *coupler,
struct regulator_dev *rdev);
int (*balance_voltage)(struct regulator_coupler *coupler,
struct regulator_dev *rdev,
suspend_state_t state);
};
#ifdef CONFIG_REGULATOR
int regulator_coupler_register(struct regulator_coupler *coupler);
int regulator_check_consumers(struct regulator_dev *rdev,
int *min_uV, int *max_uV,
suspend_state_t state);
int regulator_check_voltage(struct regulator_dev *rdev,
int *min_uV, int *max_uV);
int regulator_get_voltage_rdev(struct regulator_dev *rdev);
int regulator_set_voltage_rdev(struct regulator_dev *rdev,
int min_uV, int max_uV,
suspend_state_t state);
int regulator_do_balance_voltage(struct regulator_dev *rdev,
suspend_state_t state, bool skip_coupled);
#else
static inline int regulator_coupler_register(struct regulator_coupler *coupler)
{
return 0;
}
static inline int regulator_check_consumers(struct regulator_dev *rdev,
int *min_uV, int *max_uV,
suspend_state_t state)
{
return -EINVAL;
}
static inline int regulator_check_voltage(struct regulator_dev *rdev,
int *min_uV, int *max_uV)
{
return -EINVAL;
}
static inline int regulator_get_voltage_rdev(struct regulator_dev *rdev)
{
return -EINVAL;
}
static inline int regulator_set_voltage_rdev(struct regulator_dev *rdev,
int min_uV, int max_uV,
suspend_state_t state)
{
return -EINVAL;
}
static inline int regulator_do_balance_voltage(struct regulator_dev *rdev,
suspend_state_t state,
bool skip_coupled)
{
return -EINVAL;
}
#endif
#endif
local/recipes/gpu/amdgpu-source/include/linux/regulator/da9121.h
+36
View File
@@ -0,0 +1,36 @@
/* SPDX-License-Identifier: GPL-2.0+ */
/*
* DA9121 Single-channel dual-phase 10A buck converter
* DA9130 Single-channel dual-phase 10A buck converter (Automotive)
* DA9217 Single-channel dual-phase 6A buck converter
* DA9122 Dual-channel single-phase 5A buck converter
* DA9131 Dual-channel single-phase 5A buck converter (Automotive)
* DA9220 Dual-channel single-phase 3A buck converter
* DA9132 Dual-channel single-phase 3A buck converter (Automotive)
*
* Copyright (C) 2020 Dialog Semiconductor
*
* Authors: Adam Ward, Dialog Semiconductor
*/
#ifndef __LINUX_REGULATOR_DA9121_H
#define __LINUX_REGULATOR_DA9121_H
#include <linux/regulator/machine.h>
struct gpio_desc;
enum {
DA9121_IDX_BUCK1,
DA9121_IDX_BUCK2,
DA9121_IDX_MAX
};
struct da9121_pdata {
int num_buck;
struct gpio_desc *gpiod_ren[DA9121_IDX_MAX];
struct device_node *reg_node[DA9121_IDX_MAX];
struct regulator_init_data *init_data[DA9121_IDX_MAX];
};
#endif
local/recipes/gpu/amdgpu-source/include/linux/regulator/da9211.h
+39
View File
@@ -0,0 +1,39 @@
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* da9211.h - Regulator device driver for DA9211/DA9212
* /DA9213/DA9223/DA9214/DA9224/DA9215/DA9225
* Copyright (C) 2015 Dialog Semiconductor Ltd.
*/
#ifndef __LINUX_REGULATOR_DA9211_H
#define __LINUX_REGULATOR_DA9211_H
#include <linux/regulator/machine.h>
#define DA9211_MAX_REGULATORS 2
struct gpio_desc;
enum da9211_chip_id {
DA9211,
DA9212,
DA9213,
DA9223,
DA9214,
DA9224,
DA9215,
DA9225,
};
struct da9211_pdata {
/*
* Number of buck
* 1 : 4 phase 1 buck
* 2 : 2 phase 2 buck
*/
int num_buck;
struct gpio_desc *gpiod_ren[DA9211_MAX_REGULATORS];
struct device_node *reg_node[DA9211_MAX_REGULATORS];
struct regulator_init_data *init_data[DA9211_MAX_REGULATORS];
};
#endif
local/recipes/gpu/amdgpu-source/include/linux/regulator/db8500-prcmu.h
+38
View File
@@ -0,0 +1,38 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (C) ST-Ericsson SA 2010
*
* 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
};
#endif
local/recipes/gpu/amdgpu-source/include/linux/regulator/driver.h
+803
View File
@@ -0,0 +1,803 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* driver.h -- SoC Regulator driver support.
*
* Copyright (C) 2007, 2008 Wolfson Microelectronics PLC.
*
* Author: Liam Girdwood <lrg@slimlogic.co.uk>
*
* Regulator Driver Interface.
*/
#ifndef __LINUX_REGULATOR_DRIVER_H_
#define __LINUX_REGULATOR_DRIVER_H_
#include <linux/device.h>
#include <linux/linear_range.h>
#include <linux/notifier.h>
#include <linux/regulator/consumer.h>
#include <linux/ww_mutex.h>
struct gpio_desc;
struct regmap;
struct regulator_dev;
struct regulator_config;
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,
};
enum regulator_detection_severity {
/* Hardware shut down voltage outputs if condition is detected */
REGULATOR_SEVERITY_PROT,
/* Hardware is probably damaged/inoperable */
REGULATOR_SEVERITY_ERR,
/* Hardware is still recoverable but recovery action must be taken */
REGULATOR_SEVERITY_WARN,
};
/* Initialize struct linear_range for regulators */
#define REGULATOR_LINEAR_RANGE(_min_uV, _min_sel, _max_sel, _step_uV) \
LINEAR_RANGE(_min_uV, _min_sel, _max_sel, _step_uV)
/* Initialize struct linear_range using voltages, not selectors */
#define REGULATOR_LINEAR_VRANGE(_offs_uV, _min_uV, _max_uV, _step_uV) \
LINEAR_RANGE(_min_uV, ((_min_uV) - (_offs_uV)) / (_step_uV), \
((_max_uV) - (_offs_uV)) / (_step_uV), _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;
* return -ENOTRECOVERABLE if regulator can't be read at
* bootup and hasn't been set yet.
* @get_voltage_sel: Return the currently configured voltage selector for the
* regulator; return -ENOTRECOVERABLE if regulator can't
* be read at bootup and hasn't been set yet.
* @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_input_current_limit: Configure an input limit.
*
* @set_over_current_protection: Support enabling of and setting limits for over
* current situation detection. Detection can be configured for three
* levels of severity.
*
* - REGULATOR_SEVERITY_PROT should automatically shut down the regulator(s).
*
* - REGULATOR_SEVERITY_ERR should indicate that over-current situation is
* caused by an unrecoverable error but HW does not perform
* automatic shut down.
*
* - REGULATOR_SEVERITY_WARN should indicate situation where hardware is
* still believed to not be damaged but that a board sepcific
* recovery action is needed. If lim_uA is 0 the limit should not
* be changed but the detection should just be enabled/disabled as
* is requested.
*
* @set_over_voltage_protection: Support enabling of and setting limits for over
* voltage situation detection. Detection can be configured for same
* severities as over current protection. Units of uV.
* @set_under_voltage_protection: Support enabling of and setting limits for
* under voltage situation detection. Detection can be configured for same
* severities as over current protection. Units of uV.
* @set_thermal_protection: Support enabling of and setting limits for over
* temperature situation detection.Detection can be configured for same
* severities as over current protection. Units of degree Kelvin.
*
* @set_active_discharge: Set active discharge enable/disable of regulators.
*
* @set_mode: Set the configured operating mode for the regulator.
* @get_mode: Get the configured operating mode for the regulator.
* @get_error_flags: Get the current error(s) 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_load: Set the load for the regulator.
*
* @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: Time taken for the regulator voltage output voltage
* to stabilise after being set to a new value, in microseconds.
* The function receives the from and to voltage as input, it
* should return the worst case.
* @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 receives the from and to voltage selector as
* input, it should return the worst case.
* @set_soft_start: Enable soft start for the regulator.
*
* @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.
* @resume: Resume operation of suspended regulator.
* @set_pull_down: Configure the regulator to pull down when the regulator
* is disabled.
*
* 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 *);
int (*set_input_current_limit) (struct regulator_dev *, int lim_uA);
int (*set_over_current_protection)(struct regulator_dev *, int lim_uA,
int severity, bool enable);
int (*set_over_voltage_protection)(struct regulator_dev *, int lim_uV,
int severity, bool enable);
int (*set_under_voltage_protection)(struct regulator_dev *, int lim_uV,
int severity, bool enable);
int (*set_thermal_protection)(struct regulator_dev *, int lim,
int severity, bool enable);
int (*set_active_discharge)(struct regulator_dev *, bool enable);
/* 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 *);
/* retrieve current error flags on the regulator */
int (*get_error_flags)(struct regulator_dev *, unsigned int *flags);
/* Time taken to enable or set voltage on the regulator */
int (*enable_time) (struct regulator_dev *);
int (*set_ramp_delay) (struct regulator_dev *, int ramp_delay);
int (*set_voltage_time) (struct regulator_dev *, int old_uV,
int new_uV);
int (*set_voltage_time_sel) (struct regulator_dev *,
unsigned int old_selector,
unsigned int new_selector);
int (*set_soft_start) (struct regulator_dev *);
/* report regulator status ... most other accessors report
* control inputs, this reports results of combining inputs
* from Linux (and other sources) with the actual load.
* returns REGULATOR_STATUS_* or negative errno.
*/
int (*get_status)(struct regulator_dev *);
/* get most efficient regulator operating mode for load */
unsigned int (*get_optimum_mode) (struct regulator_dev *, int input_uV,
int output_uV, int load_uA);
/* set the load on the regulator */
int (*set_load)(struct regulator_dev *, 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);
int (*resume)(struct regulator_dev *rdev);
int (*set_pull_down) (struct regulator_dev *);
};
/*
* 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.
* @of_match_full_name: A flag to indicate that the of_match string, if
* present, should be matched against the node full_name.
* @regulators_node: Name of node containing regulator definitions in DT.
* @of_parse_cb: Optional callback called only if of_match is present.
* Will be called for each regulator parsed from DT, during
* init_data parsing.
* The regulator_config passed as argument to the callback will
* be a copy of config passed to regulator_register, valid only
* for this particular call. Callback may freely change the
* config but it cannot store it for later usage.
* Callback should return 0 on success or negative ERRNO
* indicating failure.
* @init_cb: Optional callback called after the parsing of init_data.
* Allows the regulator to perform runtime init if necessary,
* such as synching the regulator and the parsed constraints.
* Callback should return 0 on success or negative ERRNO
* indicating failure.
* @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().
* @n_current_limits: Number of selectors available for current limits
*
* @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)
* @min_dropout_uV: The minimum dropout voltage this regulator can handle
* @linear_ranges: A constant table of possible voltage ranges.
* @linear_range_selectors_bitfield: A constant table of voltage range
* selectors as bitfield values. If
* pickable ranges are used each range
* must have corresponding selector here.
* @n_linear_ranges: Number of entries in the @linear_ranges (and in
* linear_range_selectors_bitfield if used) table(s).
* @volt_table: Voltage mapping table (if table based mapping)
* @curr_table: Current limit mapping table (if table based mapping)
*
* @vsel_range_reg: Register for range selector when using pickable ranges
* and ``regulator_map_*_voltage_*_pickable`` functions.
* @vsel_range_mask: Mask for register bitfield used for range selector
* @range_applied_by_vsel: A flag to indicate that changes to vsel_range_reg
* are only effective after vsel_reg is written
* @vsel_reg: Register for selector when using ``regulator_map_*_voltage_*``
* @vsel_mask: Mask for register bitfield used for selector
* @vsel_step: Specify the resolution of selector stepping when setting
* voltage. If 0, then no stepping is done (requested selector is
* set directly), if >0 then the regulator API will ramp the
* voltage up/down gradually each time increasing/decreasing the
* selector by the specified step value.
* @csel_reg: Register for current limit selector using regmap set_current_limit
* @csel_mask: Mask for register bitfield used for current limit 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
* @active_discharge_off: Enabling value for control when using regmap
* set_active_discharge
* @active_discharge_on: Disabling value for control when using regmap
* set_active_discharge
* @active_discharge_mask: Mask for control when using regmap
* set_active_discharge
* @active_discharge_reg: Register for control when using regmap
* set_active_discharge
* @soft_start_reg: Register for control when using regmap set_soft_start
* @soft_start_mask: Mask for control when using regmap set_soft_start
* @soft_start_val_on: Enabling value for control when using regmap
* set_soft_start
* @pull_down_reg: Register for control when using regmap set_pull_down
* @pull_down_mask: Mask for control when using regmap set_pull_down
* @pull_down_val_on: Enabling value for control when using regmap
* set_pull_down
*
* @ramp_reg: Register for controlling the regulator ramp-rate.
* @ramp_mask: Bitmask for the ramp-rate control register.
* @ramp_delay_table: Table for mapping the regulator ramp-rate values. Values
* should be given in units of V/S (uV/uS). See the
* regulator_set_ramp_delay_regmap().
* @n_ramp_values: number of elements at @ramp_delay_table.
*
* @enable_time: Time taken for initial enable of regulator (in uS).
* @off_on_delay: guard time (in uS), before re-enabling a regulator
*
* @poll_enabled_time: The polling interval (in uS) to use while checking that
* the regulator was actually enabled. Max upto enable_time.
*
* @of_map_mode: Maps a hardware mode defined in a DeviceTree to a standard mode
*/
struct regulator_desc {
const char *name;
const char *supply_name;
const char *of_match;
bool of_match_full_name;
const char *regulators_node;
int (*of_parse_cb)(struct device_node *,
const struct regulator_desc *,
struct regulator_config *);
int (*init_cb)(struct regulator_dev *,
struct regulator_config *);
int id;
unsigned int continuous_voltage_range:1;
unsigned n_voltages;
unsigned int n_current_limits;
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;
int min_dropout_uV;
const struct linear_range *linear_ranges;
const unsigned int *linear_range_selectors_bitfield;
int n_linear_ranges;
const unsigned int *volt_table;
const unsigned int *curr_table;
unsigned int vsel_range_reg;
unsigned int vsel_range_mask;
bool range_applied_by_vsel;
unsigned int vsel_reg;
unsigned int vsel_mask;
unsigned int vsel_step;
unsigned int csel_reg;
unsigned int csel_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 active_discharge_on;
unsigned int active_discharge_off;
unsigned int active_discharge_mask;
unsigned int active_discharge_reg;
unsigned int soft_start_reg;
unsigned int soft_start_mask;
unsigned int soft_start_val_on;
unsigned int pull_down_reg;
unsigned int pull_down_mask;
unsigned int pull_down_val_on;
unsigned int ramp_reg;
unsigned int ramp_mask;
const unsigned int *ramp_delay_table;
unsigned int n_ramp_values;
unsigned int enable_time;
unsigned int off_on_delay;
unsigned int poll_enabled_time;
unsigned int (*of_map_mode)(unsigned int mode);
};
/**
* 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_regmap() is
* insufficient.
* @ena_gpiod: GPIO controlling regulator enable.
*/
struct regulator_config {
struct device *dev;
const struct regulator_init_data *init_data;
void *driver_data;
struct device_node *of_node;
struct regmap *regmap;
struct gpio_desc *ena_gpiod;
};
/**
* struct regulator_err_state - regulator error/notification status
*
* @rdev: Regulator which status the struct indicates.
* @notifs: Events which have occurred on the regulator.
* @errors: Errors which are active on the regulator.
* @possible_errs: Errors which can be signaled (by given IRQ).
*/
struct regulator_err_state {
struct regulator_dev *rdev;
unsigned long notifs;
unsigned long errors;
int possible_errs;
};
/**
* struct regulator_irq_data - regulator error/notification status data
*
* @states: Status structs for each of the associated regulators.
* @num_states: Amount of associated regulators.
* @data: Driver data pointer given at regulator_irq_desc.
* @opaque: Value storage for IC driver. Core does not update this. ICs
* may want to store status register value here at map_event and
* compare contents at 'renable' callback to see if new problems
* have been added to status. If that is the case it may be
* desirable to return REGULATOR_ERROR_CLEARED and not
* REGULATOR_ERROR_ON to allow IRQ fire again and to generate
* notifications also for the new issues.
*
* This structure is passed to 'map_event' and 'renable' callbacks for
* reporting regulator status to core.
*/
struct regulator_irq_data {
struct regulator_err_state *states;
int num_states;
void *data;
long opaque;
};
/**
* struct regulator_irq_desc - notification sender for IRQ based events.
*
* @name: The visible name for the IRQ
* @fatal_cnt: If this IRQ is used to signal HW damaging condition it may be
* best to shut-down regulator(s) or reboot the SOC if error
* handling is repeatedly failing. If fatal_cnt is given the IRQ
* handling is aborted if it fails for fatal_cnt times and die()
* callback (if populated) is called. If die() is not populated
* poweroff for the system is attempted in order to prevent any
* further damage.
* @reread_ms: The time which is waited before attempting to re-read status
* at the worker if IC reading fails. Immediate re-read is done
* if time is not specified.
* @irq_off_ms: The time which IRQ is kept disabled before re-evaluating the
* status for devices which keep IRQ disabled for duration of the
* error. If this is not given the IRQ is left enabled and renable
* is not called.
* @skip_off: If set to true the IRQ handler will attempt to check if any of
* the associated regulators are enabled prior to taking other
* actions. If no regulators are enabled and this is set to true
* a spurious IRQ is assumed and IRQ_NONE is returned.
* @high_prio: Boolean to indicate that high priority WQ should be used.
* @data: Driver private data pointer which will be passed as such to
* the renable, map_event and die callbacks in regulator_irq_data.
* @die: Protection callback. If IC status reading or recovery actions
* fail fatal_cnt times this callback is called or system is
* powered off. This callback should implement a final protection
* attempt like disabling the regulator. If protection succeeded
* die() may return 0. If anything else is returned the core
* assumes final protection failed and attempts to perform a
* poweroff as a last resort.
* @map_event: Driver callback to map IRQ status into regulator devices with
* events / errors. NOTE: callback MUST initialize both the
* errors and notifs for all rdevs which it signals having
* active events as core does not clean the map data.
* REGULATOR_FAILED_RETRY can be returned to indicate that the
* status reading from IC failed. If this is repeated for
* fatal_cnt times the core will call die() callback or power-off
* the system as a last resort to protect the HW.
* @renable: Optional callback to check status (if HW supports that) before
* re-enabling IRQ. If implemented this should clear the error
* flags so that errors fetched by regulator_get_error_flags()
* are updated. If callback is not implemented then errors are
* assumed to be cleared and IRQ is re-enabled.
* REGULATOR_FAILED_RETRY can be returned to
* indicate that the status reading from IC failed. If this is
* repeated for 'fatal_cnt' times the core will call die()
* callback or if die() is not populated then attempt to power-off
* the system as a last resort to protect the HW.
* Returning zero indicates that the problem in HW has been solved
* and IRQ will be re-enabled. Returning REGULATOR_ERROR_ON
* indicates the error condition is still active and keeps IRQ
* disabled. Please note that returning REGULATOR_ERROR_ON does
* not retrigger evaluating what events are active or resending
* notifications. If this is needed you probably want to return
* zero and allow IRQ to retrigger causing events to be
* re-evaluated and re-sent.
*
* This structure is used for registering regulator IRQ notification helper.
*/
struct regulator_irq_desc {
const char *name;
int fatal_cnt;
int reread_ms;
int irq_off_ms;
bool skip_off;
bool high_prio;
void *data;
int (*die)(struct regulator_irq_data *rid);
int (*map_event)(int irq, struct regulator_irq_data *rid,
unsigned long *dev_mask);
int (*renable)(struct regulator_irq_data *rid);
};
/*
* Return values for regulator IRQ helpers.
*/
enum {
REGULATOR_ERROR_CLEARED,
REGULATOR_FAILED_RETRY,
REGULATOR_ERROR_ON,
};
/*
* struct coupling_desc
*
* Describes coupling of regulators. Each regulator should have
* at least a pointer to itself in coupled_rdevs array.
* When a new coupled regulator is resolved, n_resolved is
* incremented.
*/
struct coupling_desc {
struct regulator_dev **coupled_rdevs;
struct regulator_coupler *coupler;
int n_resolved;
int n_coupled;
};
/*
* 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 coupling_desc coupling_desc;
struct blocking_notifier_head notifier;
struct ww_mutex mutex; /* consumer lock */
struct task_struct *mutex_owner;
int ref_cnt;
struct module *owner;
struct device dev;
struct device bdev;
struct regulation_constraints *constraints;
struct regulator *supply; /* for tree */
const char *supply_name;
struct regmap *regmap;
struct delayed_work disable_work;
void *reg_data; /* regulator_dev data */
struct dentry *debugfs;
struct regulator_enable_gpio *ena_pin;
unsigned int ena_gpio_state:1;
unsigned int constraints_pending:1;
unsigned int is_switch:1;
/* time when this regulator was disabled last time */
ktime_t last_off;
int cached_err;
bool use_cached_err;
spinlock_t err_lock;
int pw_requested_mW;
/* regulator notification forwarding */
struct notifier_block supply_fwd_nb;
};
/*
* Convert error flags to corresponding notifications.
*
* Can be used by drivers which use the notification helpers to
* find out correct notification flags based on the error flags. Drivers
* can avoid storing both supported notification and error flags which
* may save few bytes.
*/
static inline int regulator_err2notif(int err)
{
switch (err) {
case REGULATOR_ERROR_UNDER_VOLTAGE:
return REGULATOR_EVENT_UNDER_VOLTAGE;
case REGULATOR_ERROR_OVER_CURRENT:
return REGULATOR_EVENT_OVER_CURRENT;
case REGULATOR_ERROR_REGULATION_OUT:
return REGULATOR_EVENT_REGULATION_OUT;
case REGULATOR_ERROR_FAIL:
return REGULATOR_EVENT_FAIL;
case REGULATOR_ERROR_OVER_TEMP:
return REGULATOR_EVENT_OVER_TEMP;
case REGULATOR_ERROR_UNDER_VOLTAGE_WARN:
return REGULATOR_EVENT_UNDER_VOLTAGE_WARN;
case REGULATOR_ERROR_OVER_CURRENT_WARN:
return REGULATOR_EVENT_OVER_CURRENT_WARN;
case REGULATOR_ERROR_OVER_VOLTAGE_WARN:
return REGULATOR_EVENT_OVER_VOLTAGE_WARN;
case REGULATOR_ERROR_OVER_TEMP_WARN:
return REGULATOR_EVENT_OVER_TEMP_WARN;
}
return 0;
}
struct regulator_dev *
regulator_register(struct device *dev,
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);
int regulator_notifier_call_chain(struct regulator_dev *rdev,
unsigned long event, void *data);
void *devm_regulator_irq_helper(struct device *dev,
const struct regulator_irq_desc *d, int irq,
int irq_flags, int common_errs,
int *per_rdev_errs, struct regulator_dev **rdev,
int rdev_amount);
void *regulator_irq_helper(struct device *dev,
const struct regulator_irq_desc *d, int irq,
int irq_flags, int common_errs, int *per_rdev_errs,
struct regulator_dev **rdev, int rdev_amount);
void regulator_irq_helper_cancel(void **handle);
int regulator_irq_map_event_simple(int irq, struct regulator_irq_data *rid,
unsigned long *dev_mask);
void *rdev_get_drvdata(struct regulator_dev *rdev);
struct device *rdev_get_dev(struct regulator_dev *rdev);
struct regmap *rdev_get_regmap(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_pickable_linear_range(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_pickable_linear_range(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_pickable_regmap(struct regulator_dev *rdev);
int regulator_set_voltage_sel_pickable_regmap(struct regulator_dev *rdev,
unsigned int sel);
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);
int regulator_set_soft_start_regmap(struct regulator_dev *rdev);
int regulator_set_pull_down_regmap(struct regulator_dev *rdev);
int regulator_set_active_discharge_regmap(struct regulator_dev *rdev,
bool enable);
int regulator_set_current_limit_regmap(struct regulator_dev *rdev,
int min_uA, int max_uA);
int regulator_get_current_limit_regmap(struct regulator_dev *rdev);
void *regulator_get_init_drvdata(struct regulator_init_data *reg_init_data);
int regulator_find_closest_bigger(unsigned int target, const unsigned int *table,
unsigned int num_sel, unsigned int *sel);
int regulator_set_ramp_delay_regmap(struct regulator_dev *rdev, int ramp_delay);
int regulator_sync_voltage_rdev(struct regulator_dev *rdev);
/*
* Helper functions intended to be used by regulator drivers prior registering
* their regulators.
*/
int regulator_desc_list_voltage_linear_range(const struct regulator_desc *desc,
unsigned int selector);
int regulator_desc_list_voltage_linear(const struct regulator_desc *desc,
unsigned int selector);
#ifdef CONFIG_REGULATOR
const char *rdev_get_name(struct regulator_dev *rdev);
#else
static inline const char *rdev_get_name(struct regulator_dev *rdev)
{
return NULL;
}
#endif
#endif
local/recipes/gpu/amdgpu-source/include/linux/regulator/fan53555.h
+57
View File
@@ -0,0 +1,57 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* fan53555.h - Fairchild Regulator FAN53555 Driver
*
* Copyright (C) 2012 Marvell Technology Ltd.
* Yunfan Zhang <yfzhang@marvell.com>
*/
#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__ */
local/recipes/gpu/amdgpu-source/include/linux/regulator/fixed.h
+60
View File
@@ -0,0 +1,60 @@
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* 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>
*/
#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
* @startup_delay: Start-up time in microseconds
* @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;
unsigned startup_delay;
unsigned int off_on_delay;
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
local/recipes/gpu/amdgpu-source/include/linux/regulator/gpio-regulator.h
+81
View File
@@ -0,0 +1,81 @@
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* 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>
*/
#ifndef __REGULATOR_GPIO_H
#define __REGULATOR_GPIO_H
#include <linux/gpio/consumer.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
* @input_supply: Name of the input regulator supply
* @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
* @gflags: Array of GPIO configuration flags for initial
* states
* @ngpios: Number of GPIOs and configurations available
* @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;
const char *input_supply;
unsigned enabled_at_boot:1;
unsigned startup_delay;
enum gpiod_flags *gflags;
int ngpios;
struct gpio_regulator_state *states;
int nr_states;
enum regulator_type type;
struct regulator_init_data *init_data;
};
#endif
local/recipes/gpu/amdgpu-source/include/linux/regulator/lp3971.h
+38
View File
@@ -0,0 +1,38 @@
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* National Semiconductors LP3971 PMIC chip client interface
*
* Copyright (C) 2009 Samsung Electronics
* Author: Marek Szyprowski <m.szyprowski@samsung.com>
*
* Based on wm8400.h
*/
#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
local/recipes/gpu/amdgpu-source/include/linux/regulator/lp3972.h
+35
View File
@@ -0,0 +1,35 @@
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* National Semiconductors LP3972 PMIC chip client interface
*
* Based on lp3971.h
*/
#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
local/recipes/gpu/amdgpu-source/include/linux/regulator/lp872x.h
+86
View File
@@ -0,0 +1,86 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright 2012 Texas Instruments
*
* Author: Milo(Woogyom) Kim <milo.kim@ti.com>
*/
#ifndef __LP872X_REGULATOR_H__
#define __LP872X_REGULATOR_H__
#include <linux/regulator/machine.h>
#include <linux/platform_device.h>
#include <linux/gpio/consumer.h>
#define LP872X_MAX_REGULATORS 9
#define LP8720_ENABLE_DELAY 200
#define LP8725_ENABLE_DELAY 30000
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_sel {
SEL_V1,
SEL_V2,
};
/**
* lp872x_dvs
* @gpio : gpio descriptor for dvs control
* @vsel : dvs selector for buck v1 or buck v2 register
* @init_state : initial dvs pin state
*/
struct lp872x_dvs {
struct gpio_desc *gpio;
enum lp872x_dvs_sel vsel;
enum gpiod_flags 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
* @enable_gpio : gpio descriptor for enable control
*/
struct lp872x_platform_data {
u8 general_config;
bool update_config;
struct lp872x_regulator_data regulator_data[LP872X_MAX_REGULATORS];
struct lp872x_dvs *dvs;
struct gpio_desc *enable_gpio;
};
#endif
local/recipes/gpu/amdgpu-source/include/linux/regulator/machine.h
+309
View File
@@ -0,0 +1,309 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* machine.h -- SoC Regulator support, machine/board driver API.
*
* Copyright (C) 2007, 2008 Wolfson Microelectronics PLC.
*
* Author: Liam Girdwood <lrg@slimlogic.co.uk>
*
* 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
/*
* operations in suspend mode
* DO_NOTHING_IN_SUSPEND - the default value
* DISABLE_IN_SUSPEND - turn off regulator in suspend states
* ENABLE_IN_SUSPEND - keep regulator on in suspend states
*/
#define DO_NOTHING_IN_SUSPEND 0
#define DISABLE_IN_SUSPEND 1
#define ENABLE_IN_SUSPEND 2
/*
* Default time window (in milliseconds) following a critical under-voltage
* event during which less critical actions can be safely carried out by the
* system.
*/
#define REGULATOR_DEF_UV_LESS_CRITICAL_WINDOW_MS 10
/* Regulator active discharge flags */
enum regulator_active_discharge {
REGULATOR_ACTIVE_DISCHARGE_DEFAULT,
REGULATOR_ACTIVE_DISCHARGE_DISABLE,
REGULATOR_ACTIVE_DISCHARGE_ENABLE,
};
/**
* 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: Default operating voltage during suspend, it can be adjusted
* among <min_uV, max_uV>.
* @min_uV: Minimum suspend voltage may be set.
* @max_uV: Maximum suspend voltage may be set.
* @mode: Operating mode during suspend.
* @enabled: operations during suspend.
* - DO_NOTHING_IN_SUSPEND
* - DISABLE_IN_SUSPEND
* - ENABLE_IN_SUSPEND
* @changeable: Is this state can be switched between enabled/disabled,
*/
struct regulator_state {
int uV;
int min_uV;
int max_uV;
unsigned int mode;
int enabled;
bool changeable;
};
#define REGULATOR_NOTIF_LIMIT_DISABLE -1
#define REGULATOR_NOTIF_LIMIT_ENABLE -2
struct notification_limit {
int prot;
int err;
int warn;
};
/**
* 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.
* @ilim_uA: Maximum input current.
* @pw_budget_mW: Power budget for the regulator in mW.
* @system_load: Load that isn't captured by any consumer requests.
*
* @over_curr_limits: Limits for acting on over current.
* @over_voltage_limits: Limits for acting on over voltage.
* @under_voltage_limits: Limits for acting on under voltage.
* @temp_limits: Limits for acting on over temperature.
*
* @max_spread: Max possible spread between coupled regulators
* @max_uV_step: Max possible step change in voltage
* @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.
* @soft_start: Enable soft start so that voltage ramps slowly.
* @pull_down: Enable pull down when regulator is disabled.
* @system_critical: Set if the regulator is critical to system stability or
* functionality.
* @over_current_protection: Auto disable on over current event.
*
* @over_current_detection: Configure over current limits.
* @over_voltage_detection: Configure over voltage limits.
* @under_voltage_detection: Configure under voltage limits.
* @over_temp_detection: Configure over temperature limits.
*
* @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)
* @settling_time: Time to settle down after voltage change when voltage
* change is non-linear (unit: microseconds).
* @settling_time_up: Time to settle down after voltage increase when voltage
* change is non-linear (unit: microseconds).
* @settling_time_down : Time to settle down after voltage decrease when
* voltage change is non-linear (unit: microseconds).
* @active_discharge: Enable/disable active discharge. The enum
* regulator_active_discharge values are used for
* initialisation.
* @enable_time: Turn-on time of the rails (unit: microseconds)
* @uv_less_critical_window_ms: Specifies the time window (in milliseconds)
* following a critical under-voltage (UV) event
* during which less critical actions can be
* safely carried out by the system (for example
* logging). After this time window more critical
* actions should be done (for example prevent
* HW damage).
*/
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;
int ilim_uA;
int pw_budget_mW;
int system_load;
/* used for coupled regulators */
u32 *max_spread;
/* used for changing voltage in steps */
int max_uV_step;
/* 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;
struct notification_limit over_curr_limits;
struct notification_limit over_voltage_limits;
struct notification_limit under_voltage_limits;
struct notification_limit temp_limits;
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 settling_time;
unsigned int settling_time_up;
unsigned int settling_time_down;
unsigned int enable_time;
unsigned int uv_less_critical_window_ms;
unsigned int active_discharge;
/* 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 */
unsigned soft_start:1; /* ramp voltage slowly */
unsigned pull_down:1; /* pull down resistor when regulator off */
unsigned system_critical:1; /* critical to system stability */
unsigned over_current_protection:1; /* auto disable on over current */
unsigned over_current_detection:1; /* notify on over current */
unsigned over_voltage_detection:1; /* notify on over voltage */
unsigned under_voltage_detection:1; /* notify on under voltage */
unsigned over_temp_detection:1; /* notify on over temperature */
};
/**
* 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.
* @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 data */
void *driver_data; /* core does not touch this */
};
#ifdef CONFIG_REGULATOR
void regulator_has_full_constraints(void);
#else
static inline void regulator_has_full_constraints(void)
{
}
#endif
static inline int regulator_suspend_prepare(suspend_state_t state)
{
return 0;
}
static inline int regulator_suspend_finish(void)
{
return 0;
}
#endif
local/recipes/gpu/amdgpu-source/include/linux/regulator/max1586.h
+50
View File
@@ -0,0 +1,50 @@
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* max1586.h -- Voltage regulation for the Maxim 1586
*
* Copyright (C) 2008 Robert Jarzmik
*/
#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
local/recipes/gpu/amdgpu-source/include/linux/regulator/max8649.h
+41
View File
@@ -0,0 +1,41 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Interface of Maxim max8649
*
* Copyright (C) 2009-2010 Marvell International Ltd.
* Haojian Zhuang <haojian.zhuang@marvell.com>
*/
#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 */
local/recipes/gpu/amdgpu-source/include/linux/regulator/max8660.h
+45
View File
@@ -0,0 +1,45 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* max8660.h -- Voltage regulation for the Maxim 8660/8661
*
* Copyright (C) 2009 Wolfram Sang, Pengutronix e.K.
*/
#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
local/recipes/gpu/amdgpu-source/include/linux/regulator/max8952.h
+118
View File
@@ -0,0 +1,118 @@
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* max8952.h - Voltage regulation for the Maxim 8952
*
* Copyright (C) 2010 Samsung Electronics
* MyungJoo Ham <myungjoo.ham@samsung.com>
*/
#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 {
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 */
local/recipes/gpu/amdgpu-source/include/linux/regulator/max8973-regulator.h
+61
View File
@@ -0,0 +1,61 @@
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* 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>
*/
#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.
* @junction_temp_warning: Junction temp in millicelcius on which warning need
* to be set. Thermal functionality is only supported on
* MAX77621. The threshold warning supported by MAX77621
* are 120C and 140C.
* @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_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;
unsigned long junction_temp_warning;
bool enable_ext_control;
unsigned dvs_def_state:1;
};
#endif /* __LINUX_REGULATOR_MAX8973_H */
local/recipes/gpu/amdgpu-source/include/linux/regulator/mt6311.h
+21
View File
@@ -0,0 +1,21 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2015 MediaTek Inc.
* Author: Henry Chen <henryc.chen@mediatek.com>
*/
#ifndef __LINUX_REGULATOR_MT6311_H
#define __LINUX_REGULATOR_MT6311_H
#define MT6311_MAX_REGULATORS 2
enum {
MT6311_ID_VDVFS = 0,
MT6311_ID_VBIASN,
};
#define MT6311_E1_CID_CODE 0x10
#define MT6311_E2_CID_CODE 0x20
#define MT6311_E3_CID_CODE 0x30
#endif /* __LINUX_REGULATOR_MT6311_H */
local/recipes/gpu/amdgpu-source/include/linux/regulator/mt6315-regulator.h
+44
View File
@@ -0,0 +1,44 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#ifndef __LINUX_REGULATOR_MT6315_H
#define __LINUX_REGULATOR_MT6315_H
#define MT6315_RP 3
#define MT6315_PP 6
#define MT6315_SP 7
enum {
MT6315_VBUCK1 = 0,
MT6315_VBUCK2,
MT6315_VBUCK3,
MT6315_VBUCK4,
MT6315_VBUCK_MAX,
};
/* Register */
#define MT6315_TOP2_ELR7 0x139
#define MT6315_TOP_TMA_KEY 0x39F
#define MT6315_TOP_TMA_KEY_H 0x3A0
#define MT6315_BUCK_TOP_CON0 0x1440
#define MT6315_BUCK_TOP_CON1 0x1443
#define MT6315_BUCK_TOP_ELR0 0x1449
#define MT6315_BUCK_TOP_ELR2 0x144B
#define MT6315_BUCK_TOP_ELR4 0x144D
#define MT6315_BUCK_TOP_ELR6 0x144F
#define MT6315_VBUCK1_DBG0 0x1499
#define MT6315_VBUCK1_DBG4 0x149D
#define MT6315_VBUCK2_DBG0 0x1519
#define MT6315_VBUCK2_DBG4 0x151D
#define MT6315_VBUCK3_DBG0 0x1599
#define MT6315_VBUCK3_DBG4 0x159D
#define MT6315_VBUCK4_DBG0 0x1619
#define MT6315_VBUCK4_DBG4 0x161D
#define MT6315_BUCK_TOP_4PHASE_ANA_CON42 0x16B1
#define PROTECTION_KEY_H 0x9C
#define PROTECTION_KEY 0xEA
#endif /* __LINUX_REGULATOR_MT6315_H */
local/recipes/gpu/amdgpu-source/include/linux/regulator/mt6323-regulator.h
+44
View File
@@ -0,0 +1,44 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2016 MediaTek Inc.
* Author: Chen Zhong <chen.zhong@mediatek.com>
*/
#ifndef __LINUX_REGULATOR_MT6323_H
#define __LINUX_REGULATOR_MT6323_H
enum {
MT6323_ID_VPROC = 0,
MT6323_ID_VSYS,
MT6323_ID_VPA,
MT6323_ID_VTCXO,
MT6323_ID_VCN28,
MT6323_ID_VCN33_BT,
MT6323_ID_VCN33_WIFI,
MT6323_ID_VA,
MT6323_ID_VCAMA,
MT6323_ID_VIO28 = 9,
MT6323_ID_VUSB,
MT6323_ID_VMC,
MT6323_ID_VMCH,
MT6323_ID_VEMC3V3,
MT6323_ID_VGP1,
MT6323_ID_VGP2,
MT6323_ID_VGP3,
MT6323_ID_VCN18,
MT6323_ID_VSIM1,
MT6323_ID_VSIM2,
MT6323_ID_VRTC,
MT6323_ID_VCAMAF,
MT6323_ID_VIBR,
MT6323_ID_VRF18,
MT6323_ID_VM,
MT6323_ID_VIO18,
MT6323_ID_VCAMD,
MT6323_ID_VCAMIO,
MT6323_ID_RG_MAX,
};
#define MT6323_MAX_REGULATOR MT6323_ID_RG_MAX
#endif /* __LINUX_REGULATOR_MT6323_H */
local/recipes/gpu/amdgpu-source/include/linux/regulator/mt6331-regulator.h
+46
View File
@@ -0,0 +1,46 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2022 Collabora Ltd.
* Author: AngeloGioacchino Del Regno <angelogioacchino.delregno@collabora.com>
*/
#ifndef __LINUX_REGULATOR_MT6331_H
#define __LINUX_REGULATOR_MT6331_H
enum {
/* BUCK */
MT6331_ID_VDVFS11 = 0,
MT6331_ID_VDVFS12,
MT6331_ID_VDVFS13,
MT6331_ID_VDVFS14,
MT6331_ID_VCORE2,
MT6331_ID_VIO18,
/* LDO */
MT6331_ID_VTCXO1,
MT6331_ID_VTCXO2,
MT6331_ID_AVDD32_AUD,
MT6331_ID_VAUXA32,
MT6331_ID_VCAMA,
MT6331_ID_VIO28,
MT6331_ID_VCAM_AF,
MT6331_ID_VMC,
MT6331_ID_VMCH,
MT6331_ID_VEMC33,
MT6331_ID_VGP1,
MT6331_ID_VSIM1,
MT6331_ID_VSIM2,
MT6331_ID_VMIPI,
MT6331_ID_VIBR,
MT6331_ID_VGP4,
MT6331_ID_VCAMD,
MT6331_ID_VUSB10,
MT6331_ID_VCAM_IO,
MT6331_ID_VSRAM_DVFS1,
MT6331_ID_VGP2,
MT6331_ID_VGP3,
MT6331_ID_VRTC,
MT6331_ID_VDIG18,
MT6331_ID_VREG_MAX
};
#endif /* __LINUX_REGULATOR_MT6331_H */
local/recipes/gpu/amdgpu-source/include/linux/regulator/mt6332-regulator.h
+27
View File
@@ -0,0 +1,27 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2022 Collabora Ltd.
* Author: AngeloGioacchino Del Regno <angelogioacchino.delregno@collabora.com>
*/
#ifndef __LINUX_REGULATOR_MT6332_H
#define __LINUX_REGULATOR_MT6332_H
enum {
/* BUCK */
MT6332_ID_VDRAM = 0,
MT6332_ID_VDVFS2,
MT6332_ID_VPA,
MT6332_ID_VRF1,
MT6332_ID_VRF2,
MT6332_ID_VSBST,
/* LDO */
MT6332_ID_VAUXB32,
MT6332_ID_VBIF28,
MT6332_ID_VDIG18,
MT6332_ID_VSRAM_DVFS2,
MT6332_ID_VUSB33,
MT6332_ID_VREG_MAX
};
#endif /* __LINUX_REGULATOR_MT6332_H */
local/recipes/gpu/amdgpu-source/include/linux/regulator/mt6357-regulator.h
+51
View File
@@ -0,0 +1,51 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2022 MediaTek Inc.
*/
#ifndef __LINUX_REGULATOR_MT6357_H
#define __LINUX_REGULATOR_MT6357_H
enum {
/* Bucks */
MT6357_ID_VCORE,
MT6357_ID_VMODEM,
MT6357_ID_VPA,
MT6357_ID_VPROC,
MT6357_ID_VS1,
/* LDOs */
MT6357_ID_VAUX18,
MT6357_ID_VAUD28,
MT6357_ID_VCAMA,
MT6357_ID_VCAMD,
MT6357_ID_VCAMIO,
MT6357_ID_VCN18,
MT6357_ID_VCN28,
MT6357_ID_VCN33_BT,
MT6357_ID_VCN33_WIFI,
MT6357_ID_VDRAM,
MT6357_ID_VEFUSE,
MT6357_ID_VEMC,
MT6357_ID_VFE28,
MT6357_ID_VIBR,
MT6357_ID_VIO18,
MT6357_ID_VIO28,
MT6357_ID_VLDO28,
MT6357_ID_VMC,
MT6357_ID_VMCH,
MT6357_ID_VRF12,
MT6357_ID_VRF18,
MT6357_ID_VSIM1,
MT6357_ID_VSIM2,
MT6357_ID_VSRAM_OTHERS,
MT6357_ID_VSRAM_PROC,
MT6357_ID_VUSB33,
MT6357_ID_VXO22,
MT6357_ID_RG_MAX,
};
#define MT6357_MAX_REGULATOR MT6357_ID_RG_MAX
#endif /* __LINUX_REGULATOR_MT6357_H */
local/recipes/gpu/amdgpu-source/include/linux/regulator/mt6358-regulator.h
+98
View File
@@ -0,0 +1,98 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __LINUX_REGULATOR_MT6358_H
#define __LINUX_REGULATOR_MT6358_H
enum {
MT6358_ID_VDRAM1 = 0,
MT6358_ID_VCORE,
MT6358_ID_VPA,
MT6358_ID_VPROC11,
MT6358_ID_VPROC12,
MT6358_ID_VGPU,
MT6358_ID_VS2,
MT6358_ID_VMODEM,
MT6358_ID_VS1,
MT6358_ID_VDRAM2 = 9,
MT6358_ID_VSIM1,
MT6358_ID_VIBR,
MT6358_ID_VRF12,
MT6358_ID_VIO18,
MT6358_ID_VUSB,
MT6358_ID_VCAMIO,
MT6358_ID_VCAMD,
MT6358_ID_VCN18,
MT6358_ID_VFE28,
MT6358_ID_VSRAM_PROC11,
MT6358_ID_VCN28,
MT6358_ID_VSRAM_OTHERS,
MT6358_ID_VSRAM_GPU,
MT6358_ID_VXO22,
MT6358_ID_VEFUSE,
MT6358_ID_VAUX18,
MT6358_ID_VMCH,
MT6358_ID_VBIF28,
MT6358_ID_VSRAM_PROC12,
MT6358_ID_VCAMA1,
MT6358_ID_VEMC,
MT6358_ID_VIO28,
MT6358_ID_VA12,
MT6358_ID_VRF18,
MT6358_ID_VCN33,
MT6358_ID_VCAMA2,
MT6358_ID_VMC,
MT6358_ID_VLDO28,
MT6358_ID_VAUD28,
MT6358_ID_VSIM2,
MT6358_ID_RG_MAX,
};
enum {
MT6366_ID_VDRAM1 = 0,
MT6366_ID_VCORE,
MT6366_ID_VPA,
MT6366_ID_VPROC11,
MT6366_ID_VPROC12,
MT6366_ID_VGPU,
MT6366_ID_VS2,
MT6366_ID_VMODEM,
MT6366_ID_VS1,
MT6366_ID_VDRAM2,
MT6366_ID_VSIM1,
MT6366_ID_VIBR,
MT6366_ID_VRF12,
MT6366_ID_VIO18,
MT6366_ID_VUSB,
MT6366_ID_VCN18,
MT6366_ID_VFE28,
MT6366_ID_VSRAM_PROC11,
MT6366_ID_VCN28,
MT6366_ID_VSRAM_OTHERS,
MT6366_ID_VSRAM_GPU,
MT6366_ID_VXO22,
MT6366_ID_VEFUSE,
MT6366_ID_VAUX18,
MT6366_ID_VMCH,
MT6366_ID_VBIF28,
MT6366_ID_VSRAM_PROC12,
MT6366_ID_VEMC,
MT6366_ID_VIO28,
MT6366_ID_VA12,
MT6366_ID_VRF18,
MT6366_ID_VCN33,
MT6366_ID_VMC,
MT6366_ID_VAUD28,
MT6366_ID_VSIM2,
MT6366_ID_VM18,
MT6366_ID_VMDDR,
MT6366_ID_VSRAM_CORE,
MT6366_ID_RG_MAX,
};
#define MT6358_MAX_REGULATOR MT6358_ID_RG_MAX
#define MT6366_MAX_REGULATOR MT6366_ID_RG_MAX
#endif /* __LINUX_REGULATOR_MT6358_H */
local/recipes/gpu/amdgpu-source/include/linux/regulator/mt6359-regulator.h
+59
View File
@@ -0,0 +1,59 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#ifndef __LINUX_REGULATOR_MT6359_H
#define __LINUX_REGULATOR_MT6359_H
enum {
MT6359_ID_VS1 = 0,
MT6359_ID_VGPU11,
MT6359_ID_VMODEM,
MT6359_ID_VPU,
MT6359_ID_VCORE,
MT6359_ID_VS2,
MT6359_ID_VPA,
MT6359_ID_VPROC2,
MT6359_ID_VPROC1,
MT6359_ID_VCORE_SSHUB,
MT6359_ID_VGPU11_SSHUB = MT6359_ID_VCORE_SSHUB,
MT6359_ID_VAUD18 = 10,
MT6359_ID_VSIM1,
MT6359_ID_VIBR,
MT6359_ID_VRF12,
MT6359_ID_VUSB,
MT6359_ID_VSRAM_PROC2,
MT6359_ID_VIO18,
MT6359_ID_VCAMIO,
MT6359_ID_VCN18,
MT6359_ID_VFE28,
MT6359_ID_VCN13,
MT6359_ID_VCN33_1_BT,
MT6359_ID_VCN33_1_WIFI,
MT6359_ID_VAUX18,
MT6359_ID_VSRAM_OTHERS,
MT6359_ID_VEFUSE,
MT6359_ID_VXO22,
MT6359_ID_VRFCK,
MT6359_ID_VBIF28,
MT6359_ID_VIO28,
MT6359_ID_VEMC,
MT6359_ID_VCN33_2_BT,
MT6359_ID_VCN33_2_WIFI,
MT6359_ID_VA12,
MT6359_ID_VA09,
MT6359_ID_VRF18,
MT6359_ID_VSRAM_MD,
MT6359_ID_VUFS,
MT6359_ID_VM18,
MT6359_ID_VBBCK,
MT6359_ID_VSRAM_PROC1,
MT6359_ID_VSIM2,
MT6359_ID_VSRAM_OTHERS_SSHUB,
MT6359_ID_RG_MAX,
};
#define MT6359_MAX_REGULATOR MT6359_ID_RG_MAX
#endif /* __LINUX_REGULATOR_MT6359_H */
local/recipes/gpu/amdgpu-source/include/linux/regulator/mt6363-regulator.h
+330
View File
@@ -0,0 +1,330 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2024 MediaTek Inc.
* Copyright (c) 2025 Collabora Ltd
*/
#include <linux/bits.h>
#ifndef __LINUX_REGULATOR_MT6363_H
#define __LINUX_REGULATOR_MT6363_H
/* Register */
#define MT6363_TOP_TRAP 0x6
#define MT6363_TOP_TMA_KEY_L 0x36e
#define MT6363_RG_BUCK0_EN_ADDR 0x210
#define MT6363_RG_BUCK_VS2_EN_BIT 0
#define MT6363_RG_BUCK_VBUCK1_EN_BIT 1
#define MT6363_RG_BUCK_VBUCK2_EN_BIT 2
#define MT6363_RG_BUCK_VBUCK3_EN_BIT 3
#define MT6363_RG_BUCK_VBUCK4_EN_BIT 4
#define MT6363_RG_BUCK_VBUCK5_EN_BIT 5
#define MT6363_RG_BUCK_VBUCK6_EN_BIT 6
#define MT6363_RG_BUCK_VBUCK7_EN_BIT 7
#define MT6363_RG_BUCK1_EN_ADDR 0x213
#define MT6363_RG_BUCK_VS1_EN_BIT 0
#define MT6363_RG_BUCK_VS3_EN_BIT 1
#define MT6363_RG_LDO_VSRAM_DIGRF_EN_BIT 4
#define MT6363_RG_LDO_VSRAM_MDFE_EN_BIT 5
#define MT6363_RG_LDO_VSRAM_MODEM_EN_BIT 6
#define MT6363_RG_BUCK0_LP_ADDR 0x216
#define MT6363_RG_BUCK_VS2_LP_BIT 0
#define MT6363_RG_BUCK_VBUCK1_LP_BIT 1
#define MT6363_RG_BUCK_VBUCK2_LP_BIT 2
#define MT6363_RG_BUCK_VBUCK3_LP_BIT 3
#define MT6363_RG_BUCK_VBUCK4_LP_BIT 4
#define MT6363_RG_BUCK_VBUCK5_LP_BIT 5
#define MT6363_RG_BUCK_VBUCK6_LP_BIT 6
#define MT6363_RG_BUCK_VBUCK7_LP_BIT 7
#define MT6363_RG_BUCK1_LP_ADDR 0x219
#define MT6363_RG_BUCK_VS1_LP_BIT 0
#define MT6363_RG_BUCK_VS3_LP_BIT 1
#define MT6363_RG_LDO_VSRAM_DIGRF_LP_BIT 4
#define MT6363_RG_LDO_VSRAM_MDFE_LP_BIT 5
#define MT6363_RG_LDO_VSRAM_MODEM_LP_BIT 6
#define MT6363_RG_BUCK_VS2_VOSEL_ADDR 0x21c
#define MT6363_RG_BUCK_VS2_VOSEL_MASK GENMASK(7, 0)
#define MT6363_RG_BUCK_VBUCK1_VOSEL_ADDR 0x21d
#define MT6363_RG_BUCK_VBUCK1_VOSEL_MASK GENMASK(7, 0)
#define MT6363_RG_BUCK_VBUCK2_VOSEL_ADDR 0x21e
#define MT6363_RG_BUCK_VBUCK2_VOSEL_MASK GENMASK(7, 0)
#define MT6363_RG_BUCK_VBUCK3_VOSEL_ADDR 0x21f
#define MT6363_RG_BUCK_VBUCK3_VOSEL_MASK GENMASK(7, 0)
#define MT6363_RG_BUCK_VBUCK4_VOSEL_ADDR 0x220
#define MT6363_RG_BUCK_VBUCK4_VOSEL_MASK GENMASK(7, 0)
#define MT6363_RG_BUCK_VBUCK5_VOSEL_ADDR 0x221
#define MT6363_RG_BUCK_VBUCK5_VOSEL_MASK GENMASK(7, 0)
#define MT6363_RG_BUCK_VBUCK6_VOSEL_ADDR 0x222
#define MT6363_RG_BUCK_VBUCK6_VOSEL_MASK GENMASK(7, 0)
#define MT6363_RG_BUCK_VBUCK7_VOSEL_ADDR 0x223
#define MT6363_RG_BUCK_VBUCK7_VOSEL_MASK GENMASK(7, 0)
#define MT6363_RG_BUCK_VS1_VOSEL_ADDR 0x224
#define MT6363_RG_BUCK_VS1_VOSEL_MASK GENMASK(7, 0)
#define MT6363_RG_BUCK_VS3_VOSEL_ADDR 0x225
#define MT6363_RG_BUCK_VS3_VOSEL_MASK GENMASK(7, 0)
#define MT6363_RG_LDO_VSRAM_DIGRF_VOSEL_ADDR 0x228
#define MT6363_RG_LDO_VSRAM_DIGRF_VOSEL_MASK GENMASK(6, 0)
#define MT6363_RG_LDO_VSRAM_MDFE_VOSEL_ADDR 0x229
#define MT6363_RG_LDO_VSRAM_MDFE_VOSEL_MASK GENMASK(6, 0)
#define MT6363_RG_LDO_VSRAM_MODEM_VOSEL_ADDR 0x22a
#define MT6363_RG_LDO_VSRAM_MODEM_VOSEL_MASK GENMASK(6, 0)
#define MT6363_BUCK_TOP_KEY_PROT_LO 0x13fa
#define MT6363_BUCK_VS2_WDTDBG_VOSEL_ADDR 0x13fc
#define MT6363_BUCK_VBUCK1_WDTDBG_VOSEL_ADDR 0x13fd
#define MT6363_BUCK_VBUCK2_WDTDBG_VOSEL_ADDR 0x13fe
#define MT6363_BUCK_VBUCK3_WDTDBG_VOSEL_ADDR 0x13ff
#define MT6363_BUCK_VBUCK4_WDTDBG_VOSEL_ADDR 0x1400
#define MT6363_BUCK_VBUCK5_WDTDBG_VOSEL_ADDR 0x1401
#define MT6363_BUCK_VBUCK6_WDTDBG_VOSEL_ADDR 0x1402
#define MT6363_BUCK_VBUCK7_WDTDBG_VOSEL_ADDR 0x1403
#define MT6363_BUCK_VS1_WDTDBG_VOSEL_ADDR 0x1404
#define MT6363_BUCK_VS3_WDTDBG_VOSEL_ADDR 0x1405
#define MT6363_RG_BUCK_EFUSE_RSV1 0x1417
#define MT6363_RG_BUCK_EFUSE_RSV1_MASK GENMASK(7, 4)
#define MT6363_BUCK_VS2_OP_EN_0 0x145d
#define MT6363_BUCK_VS2_HW_LP_MODE 0x1468
#define MT6363_BUCK_VBUCK1_OP_EN_0 0x14dd
#define MT6363_BUCK_VBUCK1_HW_LP_MODE 0x14e8
#define MT6363_RG_BUCK_VBUCK1_SSHUB_EN_ADDR 0x14ea
#define MT6363_RG_BUCK_VBUCK1_SSHUB_VOSEL_ADDR 0x14eb
#define MT6363_RG_BUCK_VBUCK1_SSHUB_VOSEL_MASK GENMASK(7, 0)
#define MT6363_BUCK_VBUCK2_OP_EN_0 0x155d
#define MT6363_BUCK_VBUCK2_HW_LP_MODE 0x1568
#define MT6363_RG_BUCK_VBUCK2_SSHUB_EN_ADDR 0x156a
#define MT6363_RG_BUCK_VBUCK2_SSHUB_VOSEL_ADDR 0x156b
#define MT6363_RG_BUCK_VBUCK2_SSHUB_VOSEL_MASK GENMASK(7, 0)
#define MT6363_BUCK_VBUCK3_OP_EN_0 0x15dd
#define MT6363_BUCK_VBUCK3_HW_LP_MODE 0x15e8
#define MT6363_BUCK_VBUCK4_OP_EN_0 0x165d
#define MT6363_BUCK_VBUCK4_HW_LP_MODE 0x1668
#define MT6363_RG_BUCK_VBUCK4_SSHUB_EN_ADDR 0x166a
#define MT6363_RG_BUCK_VBUCK4_SSHUB_VOSEL_ADDR 0x166b
#define MT6363_RG_BUCK_VBUCK4_SSHUB_VOSEL_MASK GENMASK(7, 0)
#define MT6363_BUCK_VBUCK5_OP_EN_0 0x16dd
#define MT6363_BUCK_VBUCK5_HW_LP_MODE 0x16e8
#define MT6363_BUCK_VBUCK6_OP_EN_0 0x175d
#define MT6363_BUCK_VBUCK6_HW_LP_MODE 0x1768
#define MT6363_BUCK_VBUCK7_OP_EN_0 0x17dd
#define MT6363_BUCK_VBUCK7_HW_LP_MODE 0x17e8
#define MT6363_BUCK_VS1_OP_EN_0 0x185d
#define MT6363_BUCK_VS1_HW_LP_MODE 0x1868
#define MT6363_BUCK_VS3_OP_EN_0 0x18dd
#define MT6363_BUCK_VS3_HW_LP_MODE 0x18e8
#define MT6363_RG_VS1_FCCM_ADDR 0x1964
#define MT6363_RG_VS1_FCCM_BIT 0
#define MT6363_RG_VS3_FCCM_ADDR 0x1973
#define MT6363_RG_VS3_FCCM_BIT 0
#define MT6363_RG_BUCK0_FCCM_ADDR 0x1a02
#define MT6363_RG_VBUCK1_FCCM_BIT 0
#define MT6363_RG_VBUCK2_FCCM_BIT 1
#define MT6363_RG_VBUCK3_FCCM_BIT 2
#define MT6363_RG_VS2_FCCM_BIT 3
#define MT6363_RG_BUCK0_1_FCCM_ADDR 0x1a82
#define MT6363_RG_VBUCK4_FCCM_BIT 0
#define MT6363_RG_VBUCK5_FCCM_BIT 1
#define MT6363_RG_VBUCK6_FCCM_BIT 2
#define MT6363_RG_VBUCK7_FCCM_BIT 3
#define MT6363_RG_VCN13_VOSEL_ADDR 0x1b0f
#define MT6363_RG_VCN13_VOSEL_MASK GENMASK(3, 0)
#define MT6363_RG_VEMC_VOSEL_ADDR 0x1b10
#define MT6363_RG_VEMC_VOSEL_MASK GENMASK(3, 0)
#define MT6363_RG_VEMC_VOSEL_1_MASK GENMASK(7, 4)
#define MT6363_RG_LDO_VSRAM_CPUB_VOSEL_ADDR 0x1b14
#define MT6363_RG_LDO_VSRAM_CPUB_VOSEL_MASK GENMASK(6, 0)
#define MT6363_RG_LDO_VSRAM_CPUM_VOSEL_ADDR 0x1b15
#define MT6363_RG_LDO_VSRAM_CPUM_VOSEL_MASK GENMASK(6, 0)
#define MT6363_RG_LDO_VSRAM_CPUL_VOSEL_ADDR 0x1b16
#define MT6363_RG_LDO_VSRAM_CPUL_VOSEL_MASK GENMASK(6, 0)
#define MT6363_RG_LDO_VSRAM_APU_VOSEL_ADDR 0x1b17
#define MT6363_RG_LDO_VSRAM_APU_VOSEL_MASK GENMASK(6, 0)
#define MT6363_RG_VEMC_VOCAL_ADDR 0x1b1b
#define MT6363_RG_VEMC_VOCAL_MASK GENMASK(3, 0)
#define MT6363_RG_LDO_VCN15_ADDR 0x1b57
#define MT6363_RG_LDO_VCN15_EN_BIT 0
#define MT6363_RG_LDO_VCN15_LP_BIT 1
#define MT6363_LDO_VCN15_HW_LP_MODE 0x1b5b
#define MT6363_LDO_VCN15_OP_EN0 0x1b5c
#define MT6363_RG_LDO_VRF09_ADDR 0x1b65
#define MT6363_RG_LDO_VRF09_EN_BIT 0
#define MT6363_RG_LDO_VRF09_LP_BIT 1
#define MT6363_LDO_VRF09_HW_LP_MODE 0x1b69
#define MT6363_LDO_VRF09_OP_EN0 0x1b6a
#define MT6363_RG_LDO_VRF12_ADDR 0x1b73
#define MT6363_RG_LDO_VRF12_EN_BIT 0
#define MT6363_RG_LDO_VRF12_LP_BIT 1
#define MT6363_LDO_VRF12_HW_LP_MODE 0x1b77
#define MT6363_LDO_VRF12_OP_EN0 0x1b78
#define MT6363_RG_LDO_VRF13_ADDR 0x1b81
#define MT6363_RG_LDO_VRF13_EN_BIT 0
#define MT6363_RG_LDO_VRF13_LP_BIT 1
#define MT6363_LDO_VRF13_HW_LP_MODE 0x1b85
#define MT6363_LDO_VRF13_OP_EN0 0x1b86
#define MT6363_RG_LDO_VRF18_ADDR 0x1b8f
#define MT6363_RG_LDO_VRF18_EN_BIT 0
#define MT6363_RG_LDO_VRF18_LP_BIT 1
#define MT6363_LDO_VRF18_HW_LP_MODE 0x1b93
#define MT6363_LDO_VRF18_OP_EN0 0x1b94
#define MT6363_RG_LDO_VRFIO18_ADDR 0x1b9d
#define MT6363_RG_LDO_VRFIO18_EN_BIT 0
#define MT6363_RG_LDO_VRFIO18_LP_BIT 1
#define MT6363_LDO_VRFIO18_HW_LP_MODE 0x1ba1
#define MT6363_LDO_VRFIO18_OP_EN0 0x1ba2
#define MT6363_RG_LDO_VTREF18_ADDR 0x1bd7
#define MT6363_RG_LDO_VTREF18_EN_BIT 0
#define MT6363_RG_LDO_VTREF18_LP_BIT 1
#define MT6363_LDO_VTREF18_HW_LP_MODE 0x1bdb
#define MT6363_LDO_VTREF18_OP_EN0 0x1bdc
#define MT6363_RG_LDO_VAUX18_ADDR 0x1be5
#define MT6363_RG_LDO_VAUX18_EN_BIT 0
#define MT6363_RG_LDO_VAUX18_LP_BIT 1
#define MT6363_LDO_VAUX18_HW_LP_MODE 0x1be9
#define MT6363_LDO_VAUX18_OP_EN0 0x1bea
#define MT6363_RG_LDO_VEMC_ADDR 0x1bf3
#define MT6363_RG_LDO_VEMC_EN_BIT 0
#define MT6363_RG_LDO_VEMC_LP_BIT 1
#define MT6363_LDO_VEMC_HW_LP_MODE 0x1bf7
#define MT6363_LDO_VEMC_OP_EN0 0x1bf8
#define MT6363_RG_LDO_VUFS12_ADDR 0x1c01
#define MT6363_RG_LDO_VUFS12_EN_BIT 0
#define MT6363_RG_LDO_VUFS12_LP_BIT 1
#define MT6363_LDO_VUFS12_HW_LP_MODE 0x1c05
#define MT6363_LDO_VUFS12_OP_EN0 0x1c06
#define MT6363_RG_LDO_VUFS18_ADDR 0x1c0f
#define MT6363_RG_LDO_VUFS18_EN_BIT 0
#define MT6363_RG_LDO_VUFS18_LP_BIT 1
#define MT6363_LDO_VUFS18_HW_LP_MODE 0x1c13
#define MT6363_LDO_VUFS18_OP_EN0 0x1c14
#define MT6363_RG_LDO_VIO18_ADDR 0x1c1d
#define MT6363_RG_LDO_VIO18_EN_BIT 0
#define MT6363_RG_LDO_VIO18_LP_BIT 1
#define MT6363_LDO_VIO18_HW_LP_MODE 0x1c21
#define MT6363_LDO_VIO18_OP_EN0 0x1c22
#define MT6363_RG_LDO_VIO075_ADDR 0x1c57
#define MT6363_RG_LDO_VIO075_EN_BIT 0
#define MT6363_RG_LDO_VIO075_LP_BIT 1
#define MT6363_LDO_VIO075_HW_LP_MODE 0x1c5b
#define MT6363_LDO_VIO075_OP_EN0 0x1c5c
#define MT6363_RG_LDO_VA12_1_ADDR 0x1c65
#define MT6363_RG_LDO_VA12_1_EN_BIT 0
#define MT6363_RG_LDO_VA12_1_LP_BIT 1
#define MT6363_LDO_VA12_1_HW_LP_MODE 0x1c69
#define MT6363_LDO_VA12_1_OP_EN0 0x1c6a
#define MT6363_RG_LDO_VA12_2_ADDR 0x1c73
#define MT6363_RG_LDO_VA12_2_EN_BIT 0
#define MT6363_RG_LDO_VA12_2_LP_BIT 1
#define MT6363_LDO_VA12_2_HW_LP_MODE 0x1c77
#define MT6363_LDO_VA12_2_OP_EN0 0x1c78
#define MT6363_RG_LDO_VA15_ADDR 0x1c81
#define MT6363_RG_LDO_VA15_EN_BIT 0
#define MT6363_RG_LDO_VA15_LP_BIT 1
#define MT6363_LDO_VA15_HW_LP_MODE 0x1c85
#define MT6363_LDO_VA15_OP_EN0 0x1c86
#define MT6363_RG_LDO_VM18_ADDR 0x1c8f
#define MT6363_RG_LDO_VM18_EN_BIT 0
#define MT6363_RG_LDO_VM18_LP_BIT 1
#define MT6363_LDO_VM18_HW_LP_MODE 0x1c93
#define MT6363_LDO_VM18_OP_EN0 0x1c94
#define MT6363_RG_LDO_VCN13_ADDR 0x1cd7
#define MT6363_RG_LDO_VCN13_EN_BIT 0
#define MT6363_RG_LDO_VCN13_LP_BIT 1
#define MT6363_LDO_VCN13_HW_LP_MODE 0x1cdb
#define MT6363_LDO_VCN13_OP_EN0 0x1ce4
#define MT6363_LDO_VSRAM_DIGRF_HW_LP_MODE 0x1cf1
#define MT6363_LDO_VSRAM_DIGRF_OP_EN0 0x1cfa
#define MT6363_LDO_VSRAM_MDFE_HW_LP_MODE 0x1d5b
#define MT6363_LDO_VSRAM_MDFE_OP_EN0 0x1d64
#define MT6363_LDO_VSRAM_MODEM_HW_LP_MODE 0x1d76
#define MT6363_LDO_VSRAM_MODEM_OP_EN0 0x1d7f
#define MT6363_RG_LDO_VSRAM_CPUB_ADDR 0x1dd7
#define MT6363_RG_LDO_VSRAM_CPUB_EN_BIT 0
#define MT6363_RG_LDO_VSRAM_CPUB_LP_BIT 1
#define MT6363_LDO_VSRAM_CPUB_HW_LP_MODE 0x1ddb
#define MT6363_LDO_VSRAM_CPUB_OP_EN0 0x1de4
#define MT6363_RG_LDO_VSRAM_CPUM_ADDR 0x1ded
#define MT6363_RG_LDO_VSRAM_CPUM_EN_BIT 0
#define MT6363_RG_LDO_VSRAM_CPUM_LP_BIT 1
#define MT6363_LDO_VSRAM_CPUM_HW_LP_MODE 0x1df1
#define MT6363_LDO_VSRAM_CPUM_OP_EN0 0x1dfa
#define MT6363_RG_LDO_VSRAM_CPUL_ADDR 0x1e57
#define MT6363_RG_LDO_VSRAM_CPUL_EN_BIT 0
#define MT6363_RG_LDO_VSRAM_CPUL_LP_BIT 1
#define MT6363_LDO_VSRAM_CPUL_HW_LP_MODE 0x1e5b
#define MT6363_LDO_VSRAM_CPUL_OP_EN0 0x1e64
#define MT6363_RG_LDO_VSRAM_APU_ADDR 0x1e6d
#define MT6363_RG_LDO_VSRAM_APU_EN_BIT 0
#define MT6363_RG_LDO_VSRAM_APU_LP_BIT 1
#define MT6363_LDO_VSRAM_APU_HW_LP_MODE 0x1e71
#define MT6363_LDO_VSRAM_APU_OP_EN0 0x1e7a
#define MT6363_RG_VTREF18_VOCAL_ADDR 0x1ed8
#define MT6363_RG_VTREF18_VOCAL_MASK GENMASK(3, 0)
#define MT6363_RG_VTREF18_VOSEL_ADDR 0x1ed9
#define MT6363_RG_VTREF18_VOSEL_MASK GENMASK(3, 0)
#define MT6363_RG_VAUX18_VOCAL_ADDR 0x1edc
#define MT6363_RG_VAUX18_VOCAL_MASK GENMASK(3, 0)
#define MT6363_RG_VAUX18_VOSEL_ADDR 0x1edd
#define MT6363_RG_VAUX18_VOSEL_MASK GENMASK(3, 0)
#define MT6363_RG_VCN15_VOCAL_ADDR 0x1ee3
#define MT6363_RG_VCN15_VOCAL_MASK GENMASK(3, 0)
#define MT6363_RG_VCN15_VOSEL_ADDR 0x1ee4
#define MT6363_RG_VCN15_VOSEL_MASK GENMASK(3, 0)
#define MT6363_RG_VUFS18_VOCAL_ADDR 0x1ee7
#define MT6363_RG_VUFS18_VOCAL_MASK GENMASK(3, 0)
#define MT6363_RG_VUFS18_VOSEL_ADDR 0x1ee8
#define MT6363_RG_VUFS18_VOSEL_MASK GENMASK(3, 0)
#define MT6363_RG_VIO18_VOCAL_ADDR 0x1eeb
#define MT6363_RG_VIO18_VOCAL_MASK GENMASK(3, 0)
#define MT6363_RG_VIO18_VOSEL_ADDR 0x1eec
#define MT6363_RG_VIO18_VOSEL_MASK GENMASK(3, 0)
#define MT6363_RG_VM18_VOCAL_ADDR 0x1eef
#define MT6363_RG_VM18_VOCAL_MASK GENMASK(3, 0)
#define MT6363_RG_VM18_VOSEL_ADDR 0x1ef0
#define MT6363_RG_VM18_VOSEL_MASK GENMASK(3, 0)
#define MT6363_RG_VA15_VOCAL_ADDR 0x1ef3
#define MT6363_RG_VA15_VOCAL_MASK GENMASK(3, 0)
#define MT6363_RG_VA15_VOSEL_ADDR 0x1ef4
#define MT6363_RG_VA15_VOSEL_MASK GENMASK(3, 0)
#define MT6363_RG_VRF18_VOCAL_ADDR 0x1ef7
#define MT6363_RG_VRF18_VOCAL_MASK GENMASK(3, 0)
#define MT6363_RG_VRF18_VOSEL_ADDR 0x1ef8
#define MT6363_RG_VRF18_VOSEL_MASK GENMASK(3, 0)
#define MT6363_RG_VRFIO18_VOCAL_ADDR 0x1efb
#define MT6363_RG_VRFIO18_VOCAL_MASK GENMASK(3, 0)
#define MT6363_RG_VRFIO18_VOSEL_ADDR 0x1efc
#define MT6363_RG_VRFIO18_VOSEL_MASK GENMASK(3, 0)
#define MT6363_RG_VIO075_VOCFG_ADDR 0x1f01
#define MT6363_RG_VIO075_VOCAL_ADDR MT6363_RG_VIO075_VOCFG_ADDR
#define MT6363_RG_VIO075_VOCAL_MASK GENMASK(3, 0)
#define MT6363_RG_VIO075_VOSEL_ADDR MT6363_RG_VIO075_VOCFG_ADDR
#define MT6363_RG_VIO075_VOSEL_MASK GENMASK(6, 4)
#define MT6363_RG_VCN13_VOCAL_ADDR 0x1f58
#define MT6363_RG_VCN13_VOCAL_MASK GENMASK(3, 0)
#define MT6363_RG_VUFS12_VOCAL_ADDR 0x1f61
#define MT6363_RG_VUFS12_VOCAL_MASK GENMASK(3, 0)
#define MT6363_RG_VUFS12_VOSEL_ADDR 0x1f62
#define MT6363_RG_VUFS12_VOSEL_MASK GENMASK(3, 0)
#define MT6363_RG_VA12_1_VOCAL_ADDR 0x1f65
#define MT6363_RG_VA12_1_VOCAL_MASK GENMASK(3, 0)
#define MT6363_RG_VA12_1_VOSEL_ADDR 0x1f66
#define MT6363_RG_VA12_1_VOSEL_MASK GENMASK(3, 0)
#define MT6363_RG_VA12_2_VOCAL_ADDR 0x1f69
#define MT6363_RG_VA12_2_VOCAL_MASK GENMASK(3, 0)
#define MT6363_RG_VA12_2_VOSEL_ADDR 0x1f6a
#define MT6363_RG_VA12_2_VOSEL_MASK GENMASK(3, 0)
#define MT6363_RG_VRF12_VOCAL_ADDR 0x1f6d
#define MT6363_RG_VRF12_VOCAL_MASK GENMASK(3, 0)
#define MT6363_RG_VRF12_VOSEL_ADDR 0x1f6e
#define MT6363_RG_VRF12_VOSEL_MASK GENMASK(3, 0)
#define MT6363_RG_VRF13_VOCAL_ADDR 0x1f71
#define MT6363_RG_VRF13_VOCAL_MASK GENMASK(3, 0)
#define MT6363_RG_VRF13_VOSEL_ADDR 0x1f72
#define MT6363_RG_VRF13_VOSEL_MASK GENMASK(3, 0)
#define MT6363_RG_VRF09_VOCAL_ADDR 0x1f78
#define MT6363_RG_VRF09_VOCAL_MASK GENMASK(3, 0)
#define MT6363_RG_VRF09_VOSEL_ADDR 0x1f79
#define MT6363_RG_VRF09_VOSEL_MASK GENMASK(3, 0)
#define MT6363_ISINK_EN_CTRL0 0x21db
#define MT6363_ISINK_CTRL0_MASK GENMASK(7, 0)
#define MT6363_ISINK_EN_CTRL1 0x21dc
#define MT6363_ISINK_CTRL1_MASK GENMASK(7, 4)
#endif /* __LINUX_REGULATOR_MT6363_H */
local/recipes/gpu/amdgpu-source/include/linux/regulator/mt6380-regulator.h
+24
View File
@@ -0,0 +1,24 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2017 MediaTek Inc.
* Author: Chenglin Xu <chenglin.xu@mediatek.com>
*/
#ifndef __LINUX_REGULATOR_mt6380_H
#define __LINUX_REGULATOR_mt6380_H
enum {
MT6380_ID_VCPU = 0,
MT6380_ID_VCORE,
MT6380_ID_VRF,
MT6380_ID_VMLDO,
MT6380_ID_VALDO,
MT6380_ID_VPHYLDO,
MT6380_ID_VDDRLDO,
MT6380_ID_VTLDO,
MT6380_ID_RG_MAX,
};
#define MT6380_MAX_REGULATOR MT6380_ID_RG_MAX
#endif /* __LINUX_REGULATOR_mt6380_H */
local/recipes/gpu/amdgpu-source/include/linux/regulator/mt6397-regulator.h
+41
View File
@@ -0,0 +1,41 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2014 MediaTek Inc.
* Author: Flora Fu <flora.fu@mediatek.com>
*/
#ifndef __LINUX_REGULATOR_MT6397_H
#define __LINUX_REGULATOR_MT6397_H
enum {
MT6397_ID_VPCA15 = 0,
MT6397_ID_VPCA7,
MT6397_ID_VSRAMCA15,
MT6397_ID_VSRAMCA7,
MT6397_ID_VCORE,
MT6397_ID_VGPU,
MT6397_ID_VDRM,
MT6397_ID_VIO18 = 7,
MT6397_ID_VTCXO,
MT6397_ID_VA28,
MT6397_ID_VCAMA,
MT6397_ID_VIO28,
MT6397_ID_VUSB,
MT6397_ID_VMC,
MT6397_ID_VMCH,
MT6397_ID_VEMC3V3,
MT6397_ID_VGP1,
MT6397_ID_VGP2,
MT6397_ID_VGP3,
MT6397_ID_VGP4,
MT6397_ID_VGP5,
MT6397_ID_VGP6,
MT6397_ID_VIBR,
MT6397_ID_RG_MAX,
};
#define MT6397_MAX_REGULATOR MT6397_ID_RG_MAX
#define MT6397_REGULATOR_ID97 0x97
#define MT6397_REGULATOR_ID91 0x91
#endif /* __LINUX_REGULATOR_MT6397_H */
local/recipes/gpu/amdgpu-source/include/linux/regulator/of_regulator.h
+46
View File
@@ -0,0 +1,46 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* OpenFirmware regulator support routines
*
*/
#ifndef __LINUX_OF_REG_H
#define __LINUX_OF_REG_H
struct regulator_desc;
struct of_regulator_match {
const char *name;
void *driver_data;
struct regulator_init_data *init_data;
struct device_node *of_node;
const struct regulator_desc *desc;
};
#if defined(CONFIG_OF)
extern struct regulator_init_data
*of_get_regulator_init_data(struct device *dev,
struct device_node *node,
const struct regulator_desc *desc);
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,
const struct regulator_desc *desc)
{
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 */
local/recipes/gpu/amdgpu-source/include/linux/regulator/pca9450.h
+275
View File
@@ -0,0 +1,275 @@
/* SPDX-License-Identifier: GPL-2.0-or-later */
/* Copyright 2020 NXP. */
#ifndef __LINUX_REG_PCA9450_H__
#define __LINUX_REG_PCA9450_H__
#include <linux/regmap.h>
enum pca9450_chip_type {
PCA9450_TYPE_PCA9450A = 0,
PCA9450_TYPE_PCA9450BC,
PCA9450_TYPE_PCA9451A,
PCA9450_TYPE_PCA9452,
PCA9450_TYPE_AMOUNT,
};
enum {
PCA9450_BUCK1 = 0,
PCA9450_BUCK2,
PCA9450_BUCK3,
PCA9450_BUCK4,
PCA9450_BUCK5,
PCA9450_BUCK6,
PCA9450_LDO1,
PCA9450_LDO2,
PCA9450_LDO3,
PCA9450_LDO4,
PCA9450_LDO5,
PCA9450_REGULATOR_CNT,
};
enum {
PCA9450_DVS_LEVEL_RUN = 0,
PCA9450_DVS_LEVEL_STANDBY,
PCA9450_DVS_LEVEL_MAX,
};
#define PCA9450_RESTART_HANDLER_PRIORITY 130
#define PCA9450_BUCK1_VOLTAGE_NUM 0x80
#define PCA9450_BUCK2_VOLTAGE_NUM 0x80
#define PCA9450_BUCK3_VOLTAGE_NUM 0x80
#define PCA9450_BUCK4_VOLTAGE_NUM 0x80
#define PCA9450_BUCK5_VOLTAGE_NUM 0x80
#define PCA9450_BUCK6_VOLTAGE_NUM 0x80
#define PCA9450_LDO1_VOLTAGE_NUM 0x08
#define PCA9450_LDO2_VOLTAGE_NUM 0x08
#define PCA9450_LDO3_VOLTAGE_NUM 0x20
#define PCA9450_LDO4_VOLTAGE_NUM 0x20
#define PCA9450_LDO5_VOLTAGE_NUM 0x10
enum {
PCA9450_REG_DEV_ID = 0x00,
PCA9450_REG_INT1 = 0x01,
PCA9450_REG_INT1_MSK = 0x02,
PCA9450_REG_STATUS1 = 0x03,
PCA9450_REG_STATUS2 = 0x04,
PCA9450_REG_PWRON_STAT = 0x05,
PCA9450_REG_SWRST = 0x06,
PCA9450_REG_PWRCTRL = 0x07,
PCA9450_REG_RESET_CTRL = 0x08,
PCA9450_REG_CONFIG1 = 0x09,
PCA9450_REG_CONFIG2 = 0x0A,
PCA9450_REG_BUCK123_DVS = 0x0C,
PCA9450_REG_BUCK1OUT_LIMIT = 0x0D,
PCA9450_REG_BUCK2OUT_LIMIT = 0x0E,
PCA9450_REG_BUCK3OUT_LIMIT = 0x0F,
PCA9450_REG_BUCK1CTRL = 0x10,
PCA9450_REG_BUCK1OUT_DVS0 = 0x11,
PCA9450_REG_BUCK1OUT_DVS1 = 0x12,
PCA9450_REG_BUCK2CTRL = 0x13,
PCA9450_REG_BUCK2OUT_DVS0 = 0x14,
PCA9450_REG_BUCK2OUT_DVS1 = 0x15,
PCA9450_REG_BUCK3CTRL = 0x16,
PCA9450_REG_BUCK3OUT_DVS0 = 0x17,
PCA9450_REG_BUCK3OUT_DVS1 = 0x18,
PCA9450_REG_BUCK4CTRL = 0x19,
PCA9450_REG_BUCK4OUT = 0x1A,
PCA9450_REG_BUCK5CTRL = 0x1B,
PCA9450_REG_BUCK5OUT = 0x1C,
PCA9450_REG_BUCK6CTRL = 0x1D,
PCA9450_REG_BUCK6OUT = 0x1E,
PCA9450_REG_LDO_AD_CTRL = 0x20,
PCA9450_REG_LDO1CTRL = 0x21,
PCA9450_REG_LDO2CTRL = 0x22,
PCA9450_REG_LDO3CTRL = 0x23,
PCA9450_REG_LDO4CTRL = 0x24,
PCA9450_REG_LDO5CTRL_L = 0x25,
PCA9450_REG_LDO5CTRL_H = 0x26,
PCA9450_REG_LOADSW_CTRL = 0x2A,
PCA9450_REG_VRFLT1_STS = 0x2B,
PCA9450_REG_VRFLT2_STS = 0x2C,
PCA9450_REG_VRFLT1_MASK = 0x2D,
PCA9450_REG_VRFLT2_MASK = 0x2E,
PCA9450_MAX_REGISTER = 0x2F,
};
/* PCA9450 BUCK ENMODE bits */
#define BUCK_ENMODE_OFF 0x00
#define BUCK_ENMODE_ONREQ 0x01
#define BUCK_ENMODE_ONREQ_STBYREQ 0x02
#define BUCK_ENMODE_ON 0x03
/* PCA9450_REG_BUCK1_CTRL bits */
#define BUCK1_RAMP_MASK 0xC0
#define BUCK1_RAMP_25MV 0x0
#define BUCK1_RAMP_12P5MV 0x1
#define BUCK1_RAMP_6P25MV 0x2
#define BUCK1_RAMP_3P125MV 0x3
#define BUCK1_DVS_CTRL 0x10
#define BUCK1_AD 0x08
#define BUCK1_FPWM 0x04
#define BUCK1_ENMODE_MASK 0x03
/* PCA9450_REG_BUCK2_CTRL bits */
#define BUCK2_RAMP_MASK 0xC0
#define BUCK2_RAMP_25MV 0x0
#define BUCK2_RAMP_12P5MV 0x1
#define BUCK2_RAMP_6P25MV 0x2
#define BUCK2_RAMP_3P125MV 0x3
#define BUCK2_DVS_CTRL 0x10
#define BUCK2_AD 0x08
#define BUCK2_FPWM 0x04
#define BUCK2_ENMODE_MASK 0x03
/* PCA9450_REG_BUCK3_CTRL bits */
#define BUCK3_RAMP_MASK 0xC0
#define BUCK3_RAMP_25MV 0x0
#define BUCK3_RAMP_12P5MV 0x1
#define BUCK3_RAMP_6P25MV 0x2
#define BUCK3_RAMP_3P125MV 0x3
#define BUCK3_DVS_CTRL 0x10
#define BUCK3_AD 0x08
#define BUCK3_FPWM 0x04
#define BUCK3_ENMODE_MASK 0x03
/* PCA9450_REG_BUCK4_CTRL bits */
#define BUCK4_AD 0x08
#define BUCK4_FPWM 0x04
#define BUCK4_ENMODE_MASK 0x03
/* PCA9450_REG_BUCK5_CTRL bits */
#define BUCK5_AD 0x08
#define BUCK5_FPWM 0x04
#define BUCK5_ENMODE_MASK 0x03
/* PCA9450_REG_BUCK6_CTRL bits */
#define BUCK6_AD 0x08
#define BUCK6_FPWM 0x04
#define BUCK6_ENMODE_MASK 0x03
/* PCA9450_REG_BUCK123_PRESET_EN bit */
#define BUCK123_PRESET_EN 0x80
/* PCA9450_BUCK1OUT_DVS0 bits */
#define BUCK1OUT_DVS0_MASK 0x7F
#define BUCK1OUT_DVS0_DEFAULT 0x14
/* PCA9450_BUCK1OUT_DVS1 bits */
#define BUCK1OUT_DVS1_MASK 0x7F
#define BUCK1OUT_DVS1_DEFAULT 0x14
/* PCA9450_BUCK2OUT_DVS0 bits */
#define BUCK2OUT_DVS0_MASK 0x7F
#define BUCK2OUT_DVS0_DEFAULT 0x14
/* PCA9450_BUCK2OUT_DVS1 bits */
#define BUCK2OUT_DVS1_MASK 0x7F
#define BUCK2OUT_DVS1_DEFAULT 0x14
/* PCA9450_BUCK3OUT_DVS0 bits */
#define BUCK3OUT_DVS0_MASK 0x7F
#define BUCK3OUT_DVS0_DEFAULT 0x14
/* PCA9450_BUCK3OUT_DVS1 bits */
#define BUCK3OUT_DVS1_MASK 0x7F
#define BUCK3OUT_DVS1_DEFAULT 0x14
/* PCA9450_REG_BUCK4OUT bits */
#define BUCK4OUT_MASK 0x7F
#define BUCK4OUT_DEFAULT 0x6C
/* PCA9450_REG_BUCK5OUT bits */
#define BUCK5OUT_MASK 0x7F
#define BUCK5OUT_DEFAULT 0x30
/* PCA9450_REG_BUCK6OUT bits */
#define BUCK6OUT_MASK 0x7F
#define BUCK6OUT_DEFAULT 0x14
/* PCA9450_REG_LDO1_VOLT bits */
#define LDO1_EN_MASK 0xC0
#define LDO1OUT_MASK 0x07
/* PCA9450_REG_LDO2_VOLT bits */
#define LDO2_EN_MASK 0xC0
#define LDO2OUT_MASK 0x07
/* PCA9450_REG_LDO3_VOLT bits */
#define LDO3_EN_MASK 0xC0
#define LDO3OUT_MASK 0x1F
/* PCA9450_REG_LDO4_VOLT bits */
#define LDO4_EN_MASK 0xC0
#define LDO4OUT_MASK 0x1F
/* PCA9450_REG_LDO5_VOLT bits */
#define LDO5L_EN_MASK 0xC0
#define LDO5LOUT_MASK 0x0F
#define LDO5H_EN_MASK 0xC0
#define LDO5HOUT_MASK 0x0F
/* PCA9450_REG_IRQ bits */
#define IRQ_PWRON 0x80
#define IRQ_WDOGB 0x40
#define IRQ_RSVD 0x20
#define IRQ_VR_FLT1 0x10
#define IRQ_VR_FLT2 0x08
#define IRQ_LOWVSYS 0x04
#define IRQ_THERM_105 0x02
#define IRQ_THERM_125 0x01
/* PCA9450_REG_PWRCTRL bits */
#define T_ON_DEB_MASK 0xC0
#define T_ON_DEB_120US (0 << 6)
#define T_ON_DEB_20MS (1 << 6)
#define T_ON_DEB_100MS (2 << 6)
#define T_ON_DEB_750MS (3 << 6)
#define T_OFF_DEB_MASK 0x20
#define T_OFF_DEB_120US (0 << 5)
#define T_OFF_DEB_2MS (1 << 5)
#define T_ON_STEP_MASK 0x18
#define T_ON_STEP_1MS (0 << 3)
#define T_ON_STEP_2MS (1 << 3)
#define T_ON_STEP_4MS (2 << 3)
#define T_ON_STEP_8MS (3 << 3)
#define T_OFF_STEP_MASK 0x06
#define T_OFF_STEP_2MS (0 << 1)
#define T_OFF_STEP_4MS (1 << 1)
#define T_OFF_STEP_8MS (2 << 1)
#define T_OFF_STEP_16MS (3 << 1)
#define T_RESTART_MASK 0x01
#define T_RESTART_250MS 0
#define T_RESTART_500MS 1
/* PCA9450_REG_RESET_CTRL bits */
#define WDOG_B_CFG_MASK 0xC0
#define WDOG_B_CFG_NONE 0x00
#define WDOG_B_CFG_WARM 0x40
#define WDOG_B_CFG_COLD_LDO12 0x80
#define WDOG_B_CFG_COLD 0xC0
#define T_PMIC_RST_DEB_MASK 0x07
#define T_PMIC_RST_DEB_10MS 0x00
#define T_PMIC_RST_DEB_50MS 0x01
#define T_PMIC_RST_DEB_100MS 0x02
#define T_PMIC_RST_DEB_500MS 0x03
#define T_PMIC_RST_DEB_1S 0x04
#define T_PMIC_RST_DEB_2S 0x05
#define T_PMIC_RST_DEB_4S 0x06
#define T_PMIC_RST_DEB_8S 0x07
/* PCA9450_REG_CONFIG2 bits */
#define I2C_LT_MASK 0x03
#define I2C_LT_FORCE_DISABLE 0x00
#define I2C_LT_ON_STANDBY_RUN 0x01
#define I2C_LT_ON_RUN 0x02
#define I2C_LT_FORCE_ENABLE 0x03
/* PCA9450_REG_SW_RST command */
#define SW_RST_COMMAND 0x14
#endif /* __LINUX_REG_PCA9450_H__ */
local/recipes/gpu/amdgpu-source/include/linux/regulator/pfuze100.h
+66
View File
@@ -0,0 +1,66 @@
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* Copyright (C) 2011-2013 Freescale Semiconductor, Inc. All Rights Reserved.
*/
#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_COIN 15
#define PFUZE100_MAX_REGULATOR 16
#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
#define PFUZE200_COIN 13
#define PFUZE3000_SW1A 0
#define PFUZE3000_SW1B 1
#define PFUZE3000_SW2 2
#define PFUZE3000_SW3 3
#define PFUZE3000_SWBST 4
#define PFUZE3000_VSNVS 5
#define PFUZE3000_VREFDDR 6
#define PFUZE3000_VLDO1 7
#define PFUZE3000_VLDO2 8
#define PFUZE3000_VCCSD 9
#define PFUZE3000_V33 10
#define PFUZE3000_VLDO3 11
#define PFUZE3000_VLDO4 12
#define PFUZE3001_SW1 0
#define PFUZE3001_SW2 1
#define PFUZE3001_SW3 2
#define PFUZE3001_VSNVS 3
#define PFUZE3001_VLDO1 4
#define PFUZE3001_VLDO2 5
#define PFUZE3001_VCCSD 6
#define PFUZE3001_V33 7
#define PFUZE3001_VLDO3 8
#define PFUZE3001_VLDO4 9
#endif /* __LINUX_REG_PFUZE100_H */
local/recipes/gpu/amdgpu-source/include/linux/regulator/s2dos05.h
+73
View File
@@ -0,0 +1,73 @@
/* SPDX-License-Identifier: GPL-2.0+ */
// s2dos05.h
//
// Copyright (c) 2016 Samsung Electronics Co., Ltd
// http://www.samsung.com
// Copyright (C) 2024 Dzmitry Sankouski <dsankouski@gmail.com>
#ifndef __LINUX_S2DOS05_H
#define __LINUX_S2DOS05_H
// S2DOS05 registers
// Slave Addr : 0xC0
enum S2DOS05_reg {
S2DOS05_REG_DEV_ID,
S2DOS05_REG_TOPSYS_STAT,
S2DOS05_REG_STAT,
S2DOS05_REG_EN,
S2DOS05_REG_LDO1_CFG,
S2DOS05_REG_LDO2_CFG,
S2DOS05_REG_LDO3_CFG,
S2DOS05_REG_LDO4_CFG,
S2DOS05_REG_BUCK_CFG,
S2DOS05_REG_BUCK_VOUT,
S2DOS05_REG_IRQ_MASK = 0x0D,
S2DOS05_REG_SSD_TSD = 0x0E,
S2DOS05_REG_OCL = 0x10,
S2DOS05_REG_IRQ = 0x11
};
// S2DOS05 regulator ids
enum S2DOS05_regulators {
S2DOS05_LDO1,
S2DOS05_LDO2,
S2DOS05_LDO3,
S2DOS05_LDO4,
S2DOS05_BUCK1,
S2DOS05_REG_MAX,
};
#define S2DOS05_IRQ_PWRMT_MASK BIT(5)
#define S2DOS05_IRQ_TSD_MASK BIT(4)
#define S2DOS05_IRQ_SSD_MASK BIT(3)
#define S2DOS05_IRQ_SCP_MASK BIT(2)
#define S2DOS05_IRQ_UVLO_MASK BIT(1)
#define S2DOS05_IRQ_OCD_MASK BIT(0)
#define S2DOS05_BUCK_MIN1 506250
#define S2DOS05_LDO_MIN1 1500000
#define S2DOS05_LDO_MIN2 2700000
#define S2DOS05_BUCK_STEP1 6250
#define S2DOS05_LDO_STEP1 25000
#define S2DOS05_LDO_VSEL_MASK 0x7F
#define S2DOS05_LDO_FD_MASK 0x80
#define S2DOS05_BUCK_VSEL_MASK 0xFF
#define S2DOS05_BUCK_FD_MASK 0x08
#define S2DOS05_ENABLE_MASK_L1 BIT(0)
#define S2DOS05_ENABLE_MASK_L2 BIT(1)
#define S2DOS05_ENABLE_MASK_L3 BIT(2)
#define S2DOS05_ENABLE_MASK_L4 BIT(3)
#define S2DOS05_ENABLE_MASK_B1 BIT(4)
#define S2DOS05_RAMP_DELAY 12000
#define S2DOS05_ENABLE_TIME_LDO 50
#define S2DOS05_ENABLE_TIME_BUCK 350
#define S2DOS05_LDO_N_VOLTAGES (S2DOS05_LDO_VSEL_MASK + 1)
#define S2DOS05_BUCK_N_VOLTAGES (S2DOS05_BUCK_VSEL_MASK + 1)
#define S2DOS05_REGULATOR_MAX (S2DOS05_REG_MAX)
#endif // __LINUX_S2DOS05_H
local/recipes/gpu/amdgpu-source/include/linux/regulator/tps51632-regulator.h
+33
View File
@@ -0,0 +1,33 @@
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* 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>
*/
#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 */
local/recipes/gpu/amdgpu-source/include/linux/regulator/tps62360.h
+33
View File
@@ -0,0 +1,33 @@
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* 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>
*/
#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_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_def_state;
int vsel1_def_state;
};
#endif /* __LINUX_REGULATOR_TPS62360_H */
local/recipes/gpu/amdgpu-source/include/linux/regulator/tps6507x.h
+20
View File
@@ -0,0 +1,20 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* tps6507x.h -- Voltage regulation for the Texas Instruments TPS6507X
*
* Copyright (C) 2010 Texas Instruments, Inc.
*/
#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
local/recipes/gpu/amdgpu-source/include/linux/regulator/userspace-consumer.h
+27
View File
@@ -0,0 +1,27 @@
/* SPDX-License-Identifier: GPL-2.0 */
#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;
bool no_autoswitch;
};
#endif /* __REGULATOR_PLATFORM_CONSUMER_H_ */