samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Garpu 0
Kode Masalah Tarik Permintaan Actions Packages Projects Rilis Wiki Kegiatan

Merge "video: driver: add power domain and opp table support for video"

Telusuri Sumber
This commit is contained in:
qctecmdr
2023-01-28 00:56:41 -08:00
committed by Gerrit - the friendly Code Review server
orang tua f71e472d68 ab9b1a112b
melakukan 54c8d7570d
15 mengubah file dengan 899 tambahan dan 319 penghapusan
Download Patch File Download Diff File Expand all files Collapse all files

13
driver/platform/common/inc/msm_vidc_platform.h
Melihat File

@@ -48,6 +48,10 @@ struct bw_table {
u32 max_kbps;
};
struct pd_table {
const char *name;
};
struct regulator_table {
const char *name;
bool hw_trigger;
@@ -195,6 +199,10 @@ struct msm_vidc_platform_data {
unsigned int bw_tbl_size;
const struct regulator_table *regulator_tbl;
unsigned int regulator_tbl_size;
const struct pd_table *pd_tbl;
unsigned int pd_tbl_size;
const char **opp_tbl;
unsigned int opp_tbl_size;
const struct clk_table *clk_tbl;
unsigned int clk_tbl_size;
const struct clk_rst_table *clk_rst_tbl;
@@ -241,11 +249,6 @@ static inline bool is_mmrm_supported(struct msm_vidc_core *core)
return !!core->platform->data.supports_mmrm;
}
static inline bool is_regulator_supported(struct msm_vidc_core *core)
{
return !!core->platform->data.regulator_tbl_size;
}
int msm_vidc_init_platform(struct platform_device *pdev);
int msm_vidc_deinit_platform(struct platform_device *pdev);

9
driver/platform/common/src/msm_vidc_platform.c
Melihat File

@@ -214,6 +214,15 @@ static int msm_vidc_init_ops(struct msm_vidc_core *core)
core->media_device_ops = &msm_v4l2_media_ops;
core->v4l2_m2m_ops = &msm_v4l2_m2m_ops;
core->mem_ops = get_mem_ops();
if (!core->mem_ops) {
d_vpr_e("%s: invalid memory ops\n", __func__);
return -EINVAL;
}
core->res_ops = get_resources_ops();
if (!core->res_ops) {
d_vpr_e("%s: invalid resource ops\n", __func__);
return -EINVAL;
}
return 0;
}

10
driver/platform/kalama/src/msm_vidc_kalama.c
Melihat File

@@ -17,6 +17,7 @@
#include "msm_vidc_internal.h"
#include "msm_vidc_control_ext.h"
#include "msm_vidc_memory_ext.h"
#include "resources_ext.h"
#include "msm_vidc_iris3.h"
#include "hfi_property.h"
#include "hfi_command.h"
@@ -2659,6 +2660,15 @@ static int msm_vidc_init_data(struct msm_vidc_core *core, struct device *dev)
core->platform->data = kalama_data;
core->mem_ops = get_mem_ops_ext();
if (!core->mem_ops) {
d_vpr_e("%s: invalid memory ext ops\n", __func__);
return -EINVAL;
}
core->res_ops = get_res_ops_ext();
if (!core->res_ops) {
d_vpr_e("%s: invalid resource ext ops\n", __func__);
return -EINVAL;
}
rc = msm_vidc_kalama_check_ddr_type();
if (rc)
return rc;

10
driver/platform/pineapple/src/msm_vidc_pineapple.c
Melihat File

@@ -17,6 +17,7 @@
#include "msm_vidc_internal.h"
#include "msm_vidc_control_ext.h"
#include "msm_vidc_memory_ext.h"
#include "resources_ext.h"
#include "msm_vidc_iris33.h"
#include "hfi_property.h"
#include "hfi_command.h"
@@ -2663,6 +2664,15 @@ static int msm_vidc_init_data(struct msm_vidc_core *core, struct device *dev)
}
core->mem_ops = get_mem_ops_ext();
if (!core->mem_ops) {
d_vpr_e("%s: invalid memory ext ops\n", __func__);
return -EINVAL;
}
core->res_ops = get_res_ops_ext();
if (!core->res_ops) {
d_vpr_e("%s: invalid resource ext ops\n", __func__);
return -EINVAL;
}
rc = msm_vidc_pineapple_check_ddr_type();
if (rc)
return rc;

1
driver/platform/pineapple/src/pineapple.c
Melihat File

@@ -1771,6 +1771,7 @@ static int msm_vidc_init_data(struct msm_vidc_core *core)
d_vpr_h("%s: initialize pineapple data\n", __func__);
core->platform->data = pineapple_data;
rc = msm_vidc_pineapple_check_ddr_type();
if (rc)
return rc;

10
driver/platform/waipio/src/msm_vidc_waipio.c
Melihat File

@@ -2140,6 +2140,16 @@ static int msm_vidc_init_data(struct msm_vidc_core *core)
d_vpr_h("%s: initialize waipio data\n", __func__);
core->platform->data = waipio_data;
core->mem_ops = get_mem_ops_ext();
if (!core->mem_ops) {
d_vpr_e("%s: invalid memory ext ops\n", __func__);
return -EINVAL;
}
core->res_ops = get_res_ops_ext();
if (!core->res_ops) {
d_vpr_e("%s: invalid resource ext ops\n", __func__);
return -EINVAL;
}
return rc;
}

17
driver/platform/waipio/src/waipio.c
Melihat File

@@ -1668,6 +1668,15 @@ static const struct bw_table waipio_bw_table[] = {
{ "venus-ddr", 1000, 15000000 },
};
/* name */
static const struct pd_table waipio_pd_table[] = {
{ "iris-ctl" },
{ "vcodec" },
};
/* name */
static const char * const waipio_opp_table[] = { "mx", "mmcx", NULL };
/* name, clock id, scaling */
static const struct clk_table waipio_clk_table[] = {
{ "gcc_video_axi0", GCC_VIDEO_AXI0_CLK, 0 },
@@ -1701,8 +1710,6 @@ static const struct msm_vidc_platform_data waipio_data = {
/* resources dependent on other module */
.bw_tbl = waipio_bw_table,
.bw_tbl_size = ARRAY_SIZE(waipio_bw_table),
.regulator_tbl = NULL,
.regulator_tbl_size = 0,
.clk_tbl = waipio_clk_table,
.clk_tbl_size = ARRAY_SIZE(waipio_clk_table),
.clk_rst_tbl = waipio_clk_reset_table,
@@ -1714,6 +1721,12 @@ static const struct msm_vidc_platform_data waipio_data = {
.context_bank_tbl = waipio_context_bank_table,
.context_bank_tbl_size = ARRAY_SIZE(waipio_context_bank_table),
/* populate power domain and opp table */
.pd_tbl = waipio_pd_table,
.pd_tbl_size = ARRAY_SIZE(waipio_pd_table),
.opp_tbl = waipio_opp_table,
.opp_tbl_size = ARRAY_SIZE(waipio_opp_table),
/* platform specific resources */
.freq_tbl = waipio_freq_table,
.freq_tbl_size = ARRAY_SIZE(waipio_freq_table),

1
driver/variant/iris2/src/msm_vidc_iris2.c
Melihat File

@@ -1038,7 +1038,6 @@ int msm_vidc_init_iris2(struct msm_vidc_core *core)
d_vpr_h("%s()\n", __func__);
core->venus_ops = &iris2_ops;
core->session_ops = &msm_session_ops;
core->res_ops = get_resources_ops();
return 0;
}

1
driver/variant/iris3/src/msm_vidc_iris3.c
Melihat File

@@ -1119,7 +1119,6 @@ int msm_vidc_init_iris3(struct msm_vidc_core *core)
d_vpr_h("%s()\n", __func__);
core->venus_ops = &iris3_ops;
core->session_ops = &msm_session_ops;
core->res_ops = get_resources_ops();
return 0;
}

1
driver/variant/iris33/src/msm_vidc_iris33.c
Melihat File

@@ -1245,7 +1245,6 @@ int msm_vidc_init_iris33(struct msm_vidc_core *core)
d_vpr_h("%s()\n", __func__);
core->venus_ops = &iris33_ops;
core->session_ops = &msm_session_ops;
core->res_ops = get_resources_ops();
return 0;
}

16
driver/vidc/inc/resources.h
Melihat File

@@ -67,6 +67,10 @@ struct msm_vidc_core;
venus_hfi_for_each_thing_reverse_continue(__device, __rinfo, \
regulator, __from)
/* Power domain set helpers */
#define venus_hfi_for_each_power_domain(__device, __pdinfo) \
venus_hfi_for_each_thing(__device, __pdinfo, power_domain)
/* Clock set helpers */
#define venus_hfi_for_each_clock(__device, __cinfo) \
venus_hfi_for_each_thing(__device, __cinfo, clock)
@@ -122,6 +126,16 @@ struct regulator_set {
u32 count;
};
struct power_domain_info {
struct device *genpd_dev;
const char *name;
};
struct power_domain_set {
struct power_domain_info *power_domain_tbl;
u32 count;
};
struct clock_residency {
struct list_head list;
u64 rate;
@@ -219,6 +233,7 @@ struct msm_vidc_resource {
u32 irq;
struct bus_set bus_set;
struct regulator_set regulator_set;
struct power_domain_set power_domain_set;
struct clock_set clock_set;
struct reset_set reset_set;
struct subcache_set subcache_set;
@@ -245,6 +260,7 @@ struct msm_vidc_resources_ops {
int (*reset_control_deassert)(struct msm_vidc_core *core,
const char *name);
int (*gdsc_init)(struct msm_vidc_core *core);
int (*gdsc_on)(struct msm_vidc_core *core, const char *name);
int (*gdsc_off)(struct msm_vidc_core *core, const char *name);
int (*gdsc_hw_ctrl)(struct msm_vidc_core *core);

13
driver/vidc/inc/resources_ext.h Normal file
Melihat File

@@ -0,0 +1,13 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2023 Qualcomm Innovation Center, Inc. All rights reserved.
*/
#ifndef _RESOURCES_EXT_H_
#define _RESOURCES_EXT_H_
struct msm_vidc_resources_ops;
const struct msm_vidc_resources_ops *get_res_ops_ext(void);
#endif // _RESOURCES_EXT_H_

607
driver/vidc/src/resources.c
Melihat File

@@ -6,6 +6,9 @@
#include <linux/sort.h>
#include <linux/clk.h>
#include <linux/pm_runtime.h>
#include <linux/pm_domain.h>
#include <linux/pm_opp.h>
#include <linux/reset.h>
#include <linux/interconnect.h>
#include <linux/soc/qcom/llcc-qcom.h>
@@ -32,6 +35,14 @@ enum reset_state {
DEASSERT,
};
/* A comparator to compare loads (needed later on) */
static inline int cmp(const void *a, const void *b)
{
/* want to sort in reverse so flip the comparison */
return ((struct freq_table *)b)->freq -
((struct freq_table *)a)->freq;
}
static void __fatal_error(bool fatal)
{
WARN_ON(fatal);
@@ -89,12 +100,125 @@ static struct mmrm_client *devm_mmrm_get(struct device *dev, struct mmrm_client_
}
#endif
/* A comparator to compare loads (needed later on) */
static inline int cmp(const void *a, const void *b)
static void devm_pd_release(void *res)
{
/* want to sort in reverse so flip the comparison */
return ((struct freq_table *)b)->freq -
((struct freq_table *)a)->freq;
struct device *pd = (struct device *)res;
d_vpr_h("%s(): %s\n", __func__, dev_name(pd));
dev_pm_domain_detach(pd, true);
}
static struct device *devm_pd_get(struct device *dev, const char *name)
{
struct device *pd = NULL;
int rc = 0;
pd = dev_pm_domain_attach_by_name(dev, name);
if (!pd) {
d_vpr_e("%s: pm domain attach failed %s\n", __func__, name);
return NULL;
}
rc = devm_add_action_or_reset(dev, devm_pd_release, (void *)pd);
if (rc) {
d_vpr_e("%s: add action or reset failed %s\n", __func__, name);
return NULL;
}
return pd;
}
static void devm_opp_dl_release(void *res)
{
struct device_link *link = (struct device_link *)res;
d_vpr_h("%s(): %s\n", __func__, dev_name(&link->link_dev));
device_link_del(link);
}
static int devm_opp_dl_get(struct device *dev, struct device *supplier)
{
u32 flag = DL_FLAG_RPM_ACTIVE | DL_FLAG_PM_RUNTIME | DL_FLAG_STATELESS;
struct device_link *link = NULL;
int rc = 0;
link = device_link_add(dev, supplier, flag);
if (!link) {
d_vpr_e("%s: device link add failed\n", __func__);
return -EINVAL;
}
rc = devm_add_action_or_reset(dev, devm_opp_dl_release, (void *)link);
if (rc) {
d_vpr_e("%s: add action or reset failed\n", __func__);
return rc;
}
return rc;
}
static void devm_pm_runtime_put_sync(void *res)
{
struct device *dev = (struct device *)res;
d_vpr_h("%s(): %s\n", __func__, dev_name(dev));
pm_runtime_put_sync(dev);
}
static int devm_pm_runtime_get_sync(struct device *dev)
{
int rc = 0;
rc = pm_runtime_get_sync(dev);
if (rc) {
d_vpr_e("%s: pm domain get sync failed\n", __func__);
return rc;
}
rc = devm_add_action_or_reset(dev, devm_pm_runtime_put_sync, (void *)dev);
if (rc) {
d_vpr_e("%s: add action or reset failed\n", __func__);
return rc;
}
return rc;
}
static int __opp_set_rate(struct msm_vidc_core *core, u64 freq)
{
unsigned long opp_freq = 0;
struct dev_pm_opp *opp;
int rc = 0;
if (!core) {
d_vpr_e("%s: invalid params\n", __func__);
return -EINVAL;
}
opp_freq = freq;
/* find max(ceil) freq from opp table */
opp = dev_pm_opp_find_freq_ceil(&core->pdev->dev, &opp_freq);
if (IS_ERR(opp)) {
opp = dev_pm_opp_find_freq_floor(&core->pdev->dev, &opp_freq);
if (IS_ERR(opp)) {
d_vpr_e("%s: unable to find freq %lld in opp table\n", __func__, freq);
return -EINVAL;
}
}
dev_pm_opp_put(opp);
/* print freq value */
d_vpr_h("%s: set rate %lld (requested %lld)\n",
__func__, opp_freq, freq);
/* scale freq to power up mxc & mmcx */
rc = dev_pm_opp_set_rate(&core->pdev->dev, opp_freq);
if (rc) {
d_vpr_e("%s: failed to set rate\n", __func__);
return rc;
}
return rc;
}
static int __init_register_base(struct msm_vidc_core *core)
@@ -221,68 +345,133 @@ static int __init_bus(struct msm_vidc_core *core)
return rc;
}
static int __init_regulators(struct msm_vidc_core *core)
static int __init_power_domains(struct msm_vidc_core *core)
{
const struct regulator_table *regulator_tbl;
struct regulator_set *regulators;
struct regulator_info *rinfo = NULL;
u32 regulator_count = 0, cnt = 0;
struct power_domain_info *pdinfo = NULL;
const struct pd_table *pd_tbl;
struct power_domain_set *pds;
struct device **opp_vdevs;
const char **opp_tbl;
u32 pd_count = 0, opp_count = 0, cnt = 0;
int rc = 0;
if (!core || !core->resource || !core->platform) {
d_vpr_e("%s: invalid params\n", __func__);
return -EINVAL;
}
regulators = &core->resource->regulator_set;
pds = &core->resource->power_domain_set;
/* skip init if regulators not supported */
if (!is_regulator_supported(core)) {
d_vpr_h("%s: regulators are not available in database\n", __func__);
pd_tbl = core->platform->data.pd_tbl;
pd_count = core->platform->data.pd_tbl_size;
/* skip init if power domain not supported */
if (!pd_count) {
d_vpr_h("%s: power domain entries not available in db\n", __func__);
return 0;
}
regulator_tbl = core->platform->data.regulator_tbl;
regulator_count = core->platform->data.regulator_tbl_size;
if (!regulator_tbl || !regulator_count) {
d_vpr_e("%s: invalid regulator tbl %#x or count %d\n",
__func__, regulator_tbl, regulator_count);
/* sanitize power domain table */
if (!pd_tbl) {
d_vpr_e("%s: invalid power domain tbl\n", __func__);
return -EINVAL;
}
/* allocate regulator_set */
regulators->regulator_tbl = devm_kzalloc(&core->pdev->dev,
sizeof(*regulators->regulator_tbl) * regulator_count, GFP_KERNEL);
if (!regulators->regulator_tbl) {
d_vpr_e("%s: failed to alloc memory for regulator table\n", __func__);
/* allocate power_domain_set */
pds->power_domain_tbl = devm_kzalloc(&core->pdev->dev,
sizeof(*pds->power_domain_tbl) * pd_count, GFP_KERNEL);
if (!pds->power_domain_tbl) {
d_vpr_e("%s: failed to alloc memory for pd table\n", __func__);
return -ENOMEM;
}
regulators->count = regulator_count;
pds->count = pd_count;
/* populate regulator fields */
for (cnt = 0; cnt < regulators->count; cnt++) {
regulators->regulator_tbl[cnt].name = regulator_tbl[cnt].name;
regulators->regulator_tbl[cnt].hw_power_collapse = regulator_tbl[cnt].hw_trigger;
}
/* populate power domain fields */
for (cnt = 0; cnt < pds->count; cnt++)
pds->power_domain_tbl[cnt].name = pd_tbl[cnt].name;
/* print regulator fields */
venus_hfi_for_each_regulator(core, rinfo) {
d_vpr_h("%s: name %s hw_power_collapse %d\n",
__func__, rinfo->name, rinfo->hw_power_collapse);
}
/* print power domain fields */
venus_hfi_for_each_power_domain(core, pdinfo)
d_vpr_h("%s: pd name %s\n", __func__, pdinfo->name);
/* get regulator handle */
venus_hfi_for_each_regulator(core, rinfo) {
rinfo->regulator = devm_regulator_get(&core->pdev->dev, rinfo->name);
if (IS_ERR_OR_NULL(rinfo->regulator)) {
rc = PTR_ERR(rinfo->regulator) ?
PTR_ERR(rinfo->regulator) : -EBADHANDLE;
d_vpr_e("%s: failed to get regulator: %s\n", __func__, rinfo->name);
rinfo->regulator = NULL;
/* get power domain handle */
venus_hfi_for_each_power_domain(core, pdinfo) {
pdinfo->genpd_dev = devm_pd_get(&core->pdev->dev, pdinfo->name);
if (IS_ERR_OR_NULL(pdinfo->genpd_dev)) {
rc = PTR_ERR(pdinfo->genpd_dev) ?
PTR_ERR(pdinfo->genpd_dev) : -EBADHANDLE;
d_vpr_e("%s: failed to get pd: %s\n", __func__, pdinfo->name);
pdinfo->genpd_dev = NULL;
return rc;
}
}
opp_tbl = core->platform->data.opp_tbl;
opp_count = core->platform->data.opp_tbl_size;
/* skip init if opp not supported */
if (opp_count < 2) {
d_vpr_h("%s: opp entries not available\n", __func__);
return 0;
}
/* sanitize opp table */
if (!opp_tbl) {
d_vpr_e("%s: invalid opp table\n", __func__);
return -EINVAL;
}
/* ignore NULL entry at the end of table */
opp_count -= 1;
/* print opp table entries */
for (cnt = 0; cnt < opp_count; cnt++)
d_vpr_h("%s: opp name %s\n", __func__, opp_tbl[cnt]);
/* populate opp power domains(for rails) */
rc = devm_pm_opp_attach_genpd(&core->pdev->dev, opp_tbl, &opp_vdevs);
if (rc)
return rc;
/* create device_links b/w consumer(dev) and multiple suppliers(mx, mmcx) */
for (cnt = 0; cnt < opp_count; cnt++) {
rc = devm_opp_dl_get(&core->pdev->dev, opp_vdevs[cnt]);
if (rc) {
d_vpr_e("%s: failed to create dl: %s\n",
__func__, dev_name(opp_vdevs[cnt]));
return rc;
}
}
/* initialize opp table from device tree */
rc = devm_pm_opp_of_add_table(&core->pdev->dev);
if (rc) {
d_vpr_e("%s: failed to add opp table\n", __func__);
return rc;
}
/**
* 1. power up mx & mmcx supply for RCG(mvs0_clk_src)
* 2. power up gdsc0c for mvs0c branch clk
* 3. power up gdsc0 for mvs0 branch clk
*/
/**
* power up mxc, mmcx rails to enable supply for
* RCG(video_cc_mvs0_clk_src)
*/
/* enable runtime pm */
rc = devm_pm_runtime_enable(&core->pdev->dev);
if (rc) {
d_vpr_e("%s: failed to enable runtime pm\n", __func__);
return rc;
}
/* power up rails(mxc & mmcx) */
rc = devm_pm_runtime_get_sync(&core->pdev->dev);
if (rc) {
d_vpr_e("%s: failed to get sync runtime pm\n", __func__);
return rc;
}
return rc;
}
@@ -765,228 +954,75 @@ static int __register_mmrm(struct msm_vidc_core *core)
}
#endif
static int __acquire_regulator(struct msm_vidc_core *core,
struct regulator_info *rinfo)
static int __enable_power_domains(struct msm_vidc_core *core, const char *name)
{
struct power_domain_info *pdinfo = NULL;
int rc = 0;
if (!core || !rinfo) {
d_vpr_e("%s: invalid params\n", __func__);
return -EINVAL;
}
if (rinfo->hw_power_collapse) {
if (!rinfo->regulator) {
d_vpr_e("%s: invalid regulator\n", __func__);
rc = -EINVAL;
goto exit;
}
if (regulator_get_mode(rinfo->regulator) ==
REGULATOR_MODE_NORMAL) {
/* clear handoff from core sub_state */
msm_vidc_change_core_sub_state(core,
CORE_SUBSTATE_GDSC_HANDOFF, 0, __func__);
d_vpr_h("Skip acquire regulator %s\n", rinfo->name);
goto exit;
}
rc = regulator_set_mode(rinfo->regulator,
REGULATOR_MODE_NORMAL);
/* power up rails(mxc & mmcx) to enable RCG(video_cc_mvs0_clk_src) */
rc = __opp_set_rate(core, ULONG_MAX);
if (rc) {
/*
* This is somewhat fatal, but nothing we can do
* about it. We can't disable the regulator w/o
* getting it back under s/w control
*/
d_vpr_e("Failed to acquire regulator control: %s\n",
rinfo->name);
goto exit;
} else {
/* reset handoff from core sub_state */
msm_vidc_change_core_sub_state(core,
CORE_SUBSTATE_GDSC_HANDOFF, 0, __func__);
d_vpr_h("Acquired regulator control from HW: %s\n",
rinfo->name);
}
if (!regulator_is_enabled(rinfo->regulator)) {
d_vpr_e("%s: Regulator is not enabled %s\n",
__func__, rinfo->name);
__fatal_error(true);
}
}
exit:
d_vpr_e("%s: opp setrate failed\n", __func__);
return rc;
}
static int __acquire_regulators(struct msm_vidc_core *core)
{
int rc = 0;
struct regulator_info *rinfo;
venus_hfi_for_each_regulator(core, rinfo)
__acquire_regulator(core, rinfo);
return rc;
}
static int __hand_off_regulator(struct msm_vidc_core *core,
struct regulator_info *rinfo)
{
int rc = 0;
if (rinfo->hw_power_collapse) {
if (!rinfo->regulator) {
d_vpr_e("%s: invalid regulator\n", __func__);
return -EINVAL;
}
rc = regulator_set_mode(rinfo->regulator,
REGULATOR_MODE_FAST);
if (rc) {
d_vpr_e("Failed to hand off regulator control: %s\n",
rinfo->name);
return rc;
} else {
/* set handoff done in core sub_state */
msm_vidc_change_core_sub_state(core,
0, CORE_SUBSTATE_GDSC_HANDOFF, __func__);
d_vpr_h("Hand off regulator control to HW: %s\n",
rinfo->name);
}
if (!regulator_is_enabled(rinfo->regulator)) {
d_vpr_e("%s: Regulator is not enabled %s\n",
__func__, rinfo->name);
__fatal_error(true);
}
}
return rc;
}
static int __hand_off_regulators(struct msm_vidc_core *core)
{
struct regulator_info *rinfo;
int rc = 0, c = 0;
venus_hfi_for_each_regulator(core, rinfo) {
rc = __hand_off_regulator(core, rinfo);
/*
* If one regulator hand off failed, driver should take
* the control for other regulators back.
*/
if (rc)
goto err_reg_handoff_failed;
c++;
}
return rc;
err_reg_handoff_failed:
venus_hfi_for_each_regulator_reverse_continue(core, rinfo, c)
__acquire_regulator(core, rinfo);
return rc;
}
static int __disable_regulator(struct msm_vidc_core *core, const char *reg_name)
{
int rc = 0;
struct regulator_info *rinfo;
bool found;
if (!core || !reg_name) {
d_vpr_e("%s: invalid params\n", __func__);
return -EINVAL;
}
found = false;
venus_hfi_for_each_regulator(core, rinfo) {
if (!rinfo->regulator) {
d_vpr_e("%s: invalid regulator %s\n",
__func__, rinfo->name);
return -EINVAL;
}
if (strcmp(rinfo->name, reg_name))
/* power up (gdsc0/gdsc0c) to enable (mvs0/mvs0c) branch clock */
venus_hfi_for_each_power_domain(core, pdinfo) {
if (strcmp(pdinfo->name, name))
continue;
found = true;
rc = __acquire_regulator(core, rinfo);
rc = pm_runtime_get_sync(pdinfo->genpd_dev);
if (rc) {
d_vpr_e("%s: failed to acquire %s, rc = %d\n",
__func__, rinfo->name, rc);
/* Bring attention to this issue */
WARN_ON(true);
d_vpr_e("%s: failed to get sync: %s\n", __func__, pdinfo->name);
return rc;
}
d_vpr_h("%s: enabled power doamin %s\n", __func__, pdinfo->name);
}
return rc;
}
static int __disable_power_domains(struct msm_vidc_core *core, const char *name)
{
struct power_domain_info *pdinfo = NULL;
int rc = 0;
/* power down (gdsc0/gdsc0c) to disable (mvs0/mvs0c) branch clock */
venus_hfi_for_each_power_domain(core, pdinfo) {
if (strcmp(pdinfo->name, name))
continue;
rc = pm_runtime_put_sync(pdinfo->genpd_dev);
if (rc) {
d_vpr_e("%s: failed to put sync: %s\n", __func__, pdinfo->name);
return rc;
}
d_vpr_h("%s: disabled power doamin %s\n", __func__, pdinfo->name);
}
/* power down rails(mxc & mmcx) to disable RCG(video_cc_mvs0_clk_src) */
rc = __opp_set_rate(core, 0);
if (rc) {
d_vpr_e("%s: opp setrate failed\n", __func__);
return rc;
}
/* reset handoff done from core sub_state */
msm_vidc_change_core_sub_state(core, CORE_SUBSTATE_GDSC_HANDOFF, 0, __func__);
rc = regulator_disable(rinfo->regulator);
if (rc) {
d_vpr_e("%s: failed to disable %s, rc = %d\n",
__func__, rinfo->name, rc);
return rc;
}
d_vpr_h("%s: disabled regulator %s\n", __func__, rinfo->name);
break;
}
if (!found) {
d_vpr_e("%s: regulator %s not found\n", __func__, reg_name);
return -EINVAL;
}
return rc;
}
static int __enable_regulator(struct msm_vidc_core *core, const char *reg_name)
static int __hand_off_power_domains(struct msm_vidc_core *core)
{
int rc = 0;
struct regulator_info *rinfo;
bool found;
msm_vidc_change_core_sub_state(core, 0, CORE_SUBSTATE_GDSC_HANDOFF, __func__);
if (!core || !reg_name) {
d_vpr_e("%s: invalid params\n", __func__);
return -EINVAL;
return 0;
}
found = false;
venus_hfi_for_each_regulator(core, rinfo) {
if (!rinfo->regulator) {
d_vpr_e("%s: invalid regulator %s\n",
__func__, rinfo->name);
return -EINVAL;
}
if (strcmp(rinfo->name, reg_name))
continue;
found = true;
static int __acquire_power_domains(struct msm_vidc_core *core)
{
msm_vidc_change_core_sub_state(core, CORE_SUBSTATE_GDSC_HANDOFF, 0, __func__);
rc = regulator_enable(rinfo->regulator);
if (rc) {
d_vpr_e("%s: failed to enable %s, rc = %d\n",
__func__, rinfo->name, rc);
return rc;
}
if (!regulator_is_enabled(rinfo->regulator)) {
d_vpr_e("%s: regulator %s not enabled\n",
__func__, rinfo->name);
regulator_disable(rinfo->regulator);
return -EINVAL;
}
d_vpr_h("%s: enabled regulator %s\n", __func__, rinfo->name);
break;
}
if (!found) {
d_vpr_e("%s: regulator %s not found\n", __func__, reg_name);
return -EINVAL;
}
return rc;
return 0;
}
static int __disable_subcaches(struct msm_vidc_core *core)
@@ -1288,68 +1324,6 @@ static int update_residency_stats(
return rc;
}
#ifdef CONFIG_MSM_MMRM
static int __set_clk_rate(struct msm_vidc_core *core, struct clock_info *cl,
u64 rate)
{
int rc = 0;
struct mmrm_client_data client_data;
struct mmrm_client *client;
u64 srate;
/* not registered */
if (!core || !cl || !core->platform) {
d_vpr_e("%s: invalid params\n", __func__);
return -EINVAL;
}
if (is_mmrm_supported(core) && !cl->mmrm_client) {
d_vpr_e("%s: invalid mmrm client\n", __func__);
return -EINVAL;
}
/* update clock residency stats */
update_residency_stats(core, cl, rate);
/*
* This conversion is necessary since we are scaling clock values based on
* the branch clock. However, mmrm driver expects source clock to be registered
* and used for scaling.
* TODO: Remove this scaling if using source clock instead of branch clock.
*/
srate = rate * MSM_VIDC_CLOCK_SOURCE_SCALING_RATIO;
/* bail early if requested clk rate is not changed */
if (rate == cl->prev)
return 0;
d_vpr_p("Scaling clock %s to %llu, prev %llu\n",
cl->name, srate, cl->prev * MSM_VIDC_CLOCK_SOURCE_SCALING_RATIO);
if (is_mmrm_supported(core)) {
/* set clock rate to mmrm driver */
client = cl->mmrm_client;
memset(&client_data, 0, sizeof(client_data));
client_data.num_hw_blocks = 1;
rc = mmrm_client_set_value(client, &client_data, srate);
if (rc) {
d_vpr_e("%s: Failed to set mmrm clock rate %llu %s: %d\n",
__func__, srate, cl->name, rc);
return rc;
}
} else {
/* set clock rate to clock driver */
rc = clk_set_rate(cl->clk, srate);
if (rc) {
d_vpr_e("%s: Failed to set clock rate %llu %s: %d\n",
__func__, srate, cl->name, rc);
return rc;
}
}
cl->prev = rate;
return rc;
}
#else
static int __set_clk_rate(struct msm_vidc_core *core, struct clock_info *cl,
u64 rate)
{
@@ -1391,12 +1365,18 @@ static int __set_clk_rate(struct msm_vidc_core *core, struct clock_info *cl,
return rc;
}
#endif
static int __set_clocks(struct msm_vidc_core *core, u64 freq)
{
int rc = 0;
struct clock_info *cl;
int rc = 0;
/* scale mxc & mmcx rails */
rc = __opp_set_rate(core, freq);
if (rc) {
d_vpr_e("%s: opp setrate failed %lld\n", __func__, freq);
return rc;
}
venus_hfi_for_each_clock(core, cl) {
if (cl->has_scaling) {
@@ -1527,7 +1507,7 @@ static int __init_resources(struct msm_vidc_core *core)
if (rc)
return rc;
rc = __init_regulators(core);
rc = call_res_op(core, gdsc_init, core);
if (rc)
return rc;
@@ -1817,10 +1797,11 @@ static const struct msm_vidc_resources_ops res_ops = {
.reset_control_release = __reset_control_release_name,
.reset_control_assert = __reset_control_assert_name,
.reset_control_deassert = __reset_control_deassert_name,
.gdsc_on = __enable_regulator,
.gdsc_off = __disable_regulator,
.gdsc_hw_ctrl = __hand_off_regulators,
.gdsc_sw_ctrl = __acquire_regulators,
.gdsc_init = __init_power_domains,
.gdsc_on = __enable_power_domains,
.gdsc_off = __disable_power_domains,
.gdsc_hw_ctrl = __hand_off_power_domains,
.gdsc_sw_ctrl = __acquire_power_domains,
.llcc = llcc_enable,
.set_bw = set_bw,
.set_clks = __set_clocks,

516
driver/vidc/src/resources_ext.c Normal file
Melihat File

@@ -0,0 +1,516 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2020-2021, The Linux Foundation. All rights reserved.
* Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. All rights reserved.
*/
#include <linux/clk.h>
#ifdef CONFIG_MSM_MMRM
#include <linux/soc/qcom/msm_mmrm.h>
#endif
#include "resources.h"
#include "msm_vidc_core.h"
#include "msm_vidc_debug.h"
#include "msm_vidc_power.h"
#include "msm_vidc_driver.h"
#include "msm_vidc_platform.h"
static void __fatal_error(bool fatal)
{
WARN_ON(fatal);
}
static int __init_regulators(struct msm_vidc_core *core)
{
const struct regulator_table *regulator_tbl;
struct regulator_set *regulators;
struct regulator_info *rinfo = NULL;
u32 regulator_count = 0, cnt = 0;
int rc = 0;
if (!core || !core->resource || !core->platform) {
d_vpr_e("%s: invalid params\n", __func__);
return -EINVAL;
}
regulators = &core->resource->regulator_set;
regulator_tbl = core->platform->data.regulator_tbl;
regulator_count = core->platform->data.regulator_tbl_size;
/* skip init if regulators not supported */
if (!regulator_count) {
d_vpr_h("%s: regulators are not available in database\n", __func__);
return 0;
}
/* sanitize regulator table */
if (!regulator_tbl) {
d_vpr_e("%s: invalid regulator tbl\n", __func__);
return -EINVAL;
}
/* allocate regulator_set */
regulators->regulator_tbl = devm_kzalloc(&core->pdev->dev,
sizeof(*regulators->regulator_tbl) * regulator_count, GFP_KERNEL);
if (!regulators->regulator_tbl) {
d_vpr_e("%s: failed to alloc memory for regulator table\n", __func__);
return -ENOMEM;
}
regulators->count = regulator_count;
/* populate regulator fields */
for (cnt = 0; cnt < regulators->count; cnt++) {
regulators->regulator_tbl[cnt].name = regulator_tbl[cnt].name;
regulators->regulator_tbl[cnt].hw_power_collapse = regulator_tbl[cnt].hw_trigger;
}
/* print regulator fields */
venus_hfi_for_each_regulator(core, rinfo) {
d_vpr_h("%s: name %s hw_power_collapse %d\n",
__func__, rinfo->name, rinfo->hw_power_collapse);
}
/* get regulator handle */
venus_hfi_for_each_regulator(core, rinfo) {
rinfo->regulator = devm_regulator_get(&core->pdev->dev, rinfo->name);
if (IS_ERR_OR_NULL(rinfo->regulator)) {
rc = PTR_ERR(rinfo->regulator) ?
PTR_ERR(rinfo->regulator) : -EBADHANDLE;
d_vpr_e("%s: failed to get regulator: %s\n", __func__, rinfo->name);
rinfo->regulator = NULL;
return rc;
}
}
return rc;
}
static int __acquire_regulator(struct msm_vidc_core *core,
struct regulator_info *rinfo)
{
int rc = 0;
if (!core || !rinfo) {
d_vpr_e("%s: invalid params\n", __func__);
return -EINVAL;
}
if (rinfo->hw_power_collapse) {
if (!rinfo->regulator) {
d_vpr_e("%s: invalid regulator\n", __func__);
rc = -EINVAL;
goto exit;
}
if (regulator_get_mode(rinfo->regulator) ==
REGULATOR_MODE_NORMAL) {
/* clear handoff from core sub_state */
msm_vidc_change_core_sub_state(core,
CORE_SUBSTATE_GDSC_HANDOFF, 0, __func__);
d_vpr_h("Skip acquire regulator %s\n", rinfo->name);
goto exit;
}
rc = regulator_set_mode(rinfo->regulator,
REGULATOR_MODE_NORMAL);
if (rc) {
/*
* This is somewhat fatal, but nothing we can do
* about it. We can't disable the regulator w/o
* getting it back under s/w control
*/
d_vpr_e("Failed to acquire regulator control: %s\n",
rinfo->name);
goto exit;
} else {
/* reset handoff from core sub_state */
msm_vidc_change_core_sub_state(core,
CORE_SUBSTATE_GDSC_HANDOFF, 0, __func__);
d_vpr_h("Acquired regulator control from HW: %s\n",
rinfo->name);
}
if (!regulator_is_enabled(rinfo->regulator)) {
d_vpr_e("%s: Regulator is not enabled %s\n",
__func__, rinfo->name);
__fatal_error(true);
}
}
exit:
return rc;
}
static int __hand_off_regulator(struct msm_vidc_core *core,
struct regulator_info *rinfo)
{
int rc = 0;
if (rinfo->hw_power_collapse) {
if (!rinfo->regulator) {
d_vpr_e("%s: invalid regulator\n", __func__);
return -EINVAL;
}
rc = regulator_set_mode(rinfo->regulator,
REGULATOR_MODE_FAST);
if (rc) {
d_vpr_e("Failed to hand off regulator control: %s\n",
rinfo->name);
return rc;
} else {
/* set handoff done in core sub_state */
msm_vidc_change_core_sub_state(core,
0, CORE_SUBSTATE_GDSC_HANDOFF, __func__);
d_vpr_h("Hand off regulator control to HW: %s\n",
rinfo->name);
}
if (!regulator_is_enabled(rinfo->regulator)) {
d_vpr_e("%s: Regulator is not enabled %s\n",
__func__, rinfo->name);
__fatal_error(true);
}
}
return rc;
}
static int __enable_regulator(struct msm_vidc_core *core, const char *reg_name)
{
int rc = 0;
struct regulator_info *rinfo;
bool found;
if (!core || !reg_name) {
d_vpr_e("%s: invalid params\n", __func__);
return -EINVAL;
}
found = false;
venus_hfi_for_each_regulator(core, rinfo) {
if (!rinfo->regulator) {
d_vpr_e("%s: invalid regulator %s\n",
__func__, rinfo->name);
return -EINVAL;
}
if (strcmp(rinfo->name, reg_name))
continue;
found = true;
rc = regulator_enable(rinfo->regulator);
if (rc) {
d_vpr_e("%s: failed to enable %s, rc = %d\n",
__func__, rinfo->name, rc);
return rc;
}
if (!regulator_is_enabled(rinfo->regulator)) {
d_vpr_e("%s: regulator %s not enabled\n",
__func__, rinfo->name);
regulator_disable(rinfo->regulator);
return -EINVAL;
}
d_vpr_h("%s: enabled regulator %s\n", __func__, rinfo->name);
break;
}
if (!found) {
d_vpr_e("%s: regulator %s not found\n", __func__, reg_name);
return -EINVAL;
}
return rc;
}
static int __disable_regulator(struct msm_vidc_core *core, const char *reg_name)
{
int rc = 0;
struct regulator_info *rinfo;
bool found;
if (!core || !reg_name) {
d_vpr_e("%s: invalid params\n", __func__);
return -EINVAL;
}
found = false;
venus_hfi_for_each_regulator(core, rinfo) {
if (!rinfo->regulator) {
d_vpr_e("%s: invalid regulator %s\n",
__func__, rinfo->name);
return -EINVAL;
}
if (strcmp(rinfo->name, reg_name))
continue;
found = true;
rc = __acquire_regulator(core, rinfo);
if (rc) {
d_vpr_e("%s: failed to acquire %s, rc = %d\n",
__func__, rinfo->name, rc);
/* Bring attention to this issue */
WARN_ON(true);
return rc;
}
/* reset handoff done from core sub_state */
msm_vidc_change_core_sub_state(core, CORE_SUBSTATE_GDSC_HANDOFF, 0, __func__);
rc = regulator_disable(rinfo->regulator);
if (rc) {
d_vpr_e("%s: failed to disable %s, rc = %d\n",
__func__, rinfo->name, rc);
return rc;
}
d_vpr_h("%s: disabled regulator %s\n", __func__, rinfo->name);
break;
}
if (!found) {
d_vpr_e("%s: regulator %s not found\n", __func__, reg_name);
return -EINVAL;
}
return rc;
}
static int __hand_off_regulators(struct msm_vidc_core *core)
{
struct regulator_info *rinfo;
int rc = 0, c = 0;
venus_hfi_for_each_regulator(core, rinfo) {
rc = __hand_off_regulator(core, rinfo);
/*
* If one regulator hand off failed, driver should take
* the control for other regulators back.
*/
if (rc)
goto err_reg_handoff_failed;
c++;
}
return rc;
err_reg_handoff_failed:
venus_hfi_for_each_regulator_reverse_continue(core, rinfo, c)
__acquire_regulator(core, rinfo);
return rc;
}
static int __acquire_regulators(struct msm_vidc_core *core)
{
int rc = 0;
struct regulator_info *rinfo;
venus_hfi_for_each_regulator(core, rinfo)
__acquire_regulator(core, rinfo);
return rc;
}
static struct clock_residency *get_residency_stats(struct clock_info *cl, u64 rate)
{
struct clock_residency *residency = NULL;
bool found = false;
if (!cl) {
d_vpr_e("%s: invalid params\n", __func__);
return NULL;
}
list_for_each_entry(residency, &cl->residency_list, list) {
if (residency->rate == rate) {
found = true;
break;
}
}
return found ? residency : NULL;
}
static int update_residency_stats(
struct msm_vidc_core *core, struct clock_info *cl, u64 rate)
{
struct clock_residency *cur_residency = NULL, *prev_residency = NULL;
u64 cur_time_us = 0;
int rc = 0;
if (!core || !cl) {
d_vpr_e("%s: invalid params\n", __func__);
return -EINVAL;
}
/* skip update if scaling not supported */
if (!cl->has_scaling)
return 0;
/* skip update if rate not changed */
if (rate == cl->prev)
return 0;
/* get current time in ns */
cur_time_us = ktime_get_ns() / 1000;
/* update previous rate residency end or total time */
prev_residency = get_residency_stats(cl, cl->prev);
if (prev_residency) {
if (prev_residency->start_time_us)
prev_residency->total_time_us = cur_time_us - prev_residency->start_time_us;
/* reset start time us */
prev_residency->start_time_us = 0;
}
/* clk disable case - no need to update new entry */
if (rate == 0)
return 0;
/* check if rate entry is present */
cur_residency = get_residency_stats(cl, rate);
if (!cur_residency) {
d_vpr_e("%s: entry not found. rate %llu\n", __func__, rate);
return -EINVAL;
}
/* update residency start time for current rate/freq */
cur_residency->start_time_us = cur_time_us;
return rc;
}
#ifdef CONFIG_MSM_MMRM
static int __set_clk_rate(struct msm_vidc_core *core, struct clock_info *cl,
u64 rate)
{
int rc = 0;
struct mmrm_client_data client_data;
struct mmrm_client *client;
u64 srate;
/* not registered */
if (!core || !cl || !core->platform) {
d_vpr_e("%s: invalid params\n", __func__);
return -EINVAL;
}
if (is_mmrm_supported(core) && !cl->mmrm_client) {
d_vpr_e("%s: invalid mmrm client\n", __func__);
return -EINVAL;
}
/* update clock residency stats */
update_residency_stats(core, cl, rate);
/*
* This conversion is necessary since we are scaling clock values based on
* the branch clock. However, mmrm driver expects source clock to be registered
* and used for scaling.
* TODO: Remove this scaling if using source clock instead of branch clock.
*/
srate = rate * MSM_VIDC_CLOCK_SOURCE_SCALING_RATIO;
/* bail early if requested clk rate is not changed */
if (rate == cl->prev)
return 0;
d_vpr_p("Scaling clock %s to %llu, prev %llu\n",
cl->name, srate, cl->prev * MSM_VIDC_CLOCK_SOURCE_SCALING_RATIO);
if (is_mmrm_supported(core)) {
/* set clock rate to mmrm driver */
client = cl->mmrm_client;
memset(&client_data, 0, sizeof(client_data));
client_data.num_hw_blocks = 1;
rc = mmrm_client_set_value(client, &client_data, srate);
if (rc) {
d_vpr_e("%s: Failed to set mmrm clock rate %llu %s: %d\n",
__func__, srate, cl->name, rc);
return rc;
}
} else {
/* set clock rate to clock driver */
rc = clk_set_rate(cl->clk, srate);
if (rc) {
d_vpr_e("%s: Failed to set clock rate %llu %s: %d\n",
__func__, srate, cl->name, rc);
return rc;
}
}
cl->prev = rate;
return rc;
}
#else
static int __set_clk_rate(struct msm_vidc_core *core, struct clock_info *cl,
u64 rate)
{
u64 srate;
int rc = 0;
/* not registered */
if (!core || !cl || !core->capabilities) {
d_vpr_e("%s: invalid params\n", __func__);
return -EINVAL;
}
/* update clock residency stats */
update_residency_stats(core, cl, rate);
/*
* This conversion is necessary since we are scaling clock values based on
* the branch clock. However, mmrm driver expects source clock to be registered
* and used for scaling.
* TODO: Remove this scaling if using source clock instead of branch clock.
*/
srate = rate * MSM_VIDC_CLOCK_SOURCE_SCALING_RATIO;
/* bail early if requested clk rate is not changed */
if (rate == cl->prev)
return 0;
d_vpr_p("Scaling clock %s to %llu, prev %llu\n",
cl->name, srate, cl->prev * MSM_VIDC_CLOCK_SOURCE_SCALING_RATIO);
rc = clk_set_rate(cl->clk, srate);
if (rc) {
d_vpr_e("%s: Failed to set clock rate %llu %s: %d\n",
__func__, srate, cl->name, rc);
return rc;
}
cl->prev = rate;
return rc;
}
#endif
static int __set_clocks_ext(struct msm_vidc_core *core, u64 freq)
{
int rc = 0;
struct clock_info *cl;
venus_hfi_for_each_clock(core, cl) {
if (cl->has_scaling) {
rc = __set_clk_rate(core, cl, freq);
if (rc)
return rc;
}
}
return 0;
}
const struct msm_vidc_resources_ops *get_res_ops_ext(void)
{
const struct msm_vidc_resources_ops *res_ops = get_resources_ops();
static struct msm_vidc_resources_ops res_ops_ext;
memcpy(&res_ops_ext, res_ops, sizeof(struct msm_vidc_resources_ops));
res_ops_ext.gdsc_init = __init_regulators;
res_ops_ext.gdsc_on = __enable_regulator;
res_ops_ext.gdsc_off = __disable_regulator;
res_ops_ext.gdsc_hw_ctrl = __hand_off_regulators;
res_ops_ext.gdsc_sw_ctrl = __acquire_regulators;
res_ops_ext.set_clks = __set_clocks_ext;
return &res_ops_ext;
}

1
msm_video/Kbuild
Melihat File

@@ -88,6 +88,7 @@ msm_video-objs += $(VIDEO_DRIVER_REL_PATH)/vidc/src/msm_vidc_v4l2.o \
$(VIDEO_DRIVER_REL_PATH)/vidc/src/msm_vidc_power.o \
$(VIDEO_DRIVER_REL_PATH)/vidc/src/msm_vidc_probe.o \
$(VIDEO_DRIVER_REL_PATH)/vidc/src/resources.o \
$(VIDEO_DRIVER_REL_PATH)/vidc/src/resources_ext.o \
$(VIDEO_DRIVER_REL_PATH)/vidc/src/firmware.o \
$(VIDEO_DRIVER_REL_PATH)/vidc/src/msm_vidc_debug.o \
$(VIDEO_DRIVER_REL_PATH)/vidc/src/msm_vidc_memory.o \