samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

disp: msm: rotator: migrated the new BUS driver for rotator on lahaina

Browse Source 
Migrate to icb framework API in drm and rotator driver. The change also
removes msm_bus custom API usage from both drivers.

Change-Id: I15de82986204a12e4cc124f51793328c3d403256
Signed-off-by: Yuan Zhao <yzhao@codeaurora.org>
This commit is contained in:
Yuan Zhao
2019-09-09 16:52:20 +08:00
committed by Gerrit - the friendly Code Review server
parent cc564849ae
commit f3553ab628
7 changed files with 204 additions and 269 deletions
Download Patch File Download Diff File Expand all files Collapse all files

106
rotator/sde_rotator_base.c
View File

@@ -14,8 +14,6 @@
#include <linux/slab.h>
#include <linux/io.h>
#include <linux/iopoll.h>
#include <linux/msm-bus.h>
#include <linux/msm-bus-board.h>
#include <linux/regulator/consumer.h>
#define CREATE_TRACE_POINTS
@@ -26,6 +24,13 @@
#include "sde_rotator_dev.h"
#include "sde_rotator_vbif.h"
static const struct sde_rot_bus_data sde_rot_reg_bus_table[] = {
{0, 0},
{0, 76800},
{0, 150000},
{0, 300000},
};
static inline u64 fudge_factor(u64 val, u32 numer, u32 denom)
{
u64 result = (val * (u64)numer);
@@ -51,6 +56,11 @@ static inline bool validate_comp_ratio(struct sde_mult_factor *factor)
return factor->numer && factor->denom;
}
const struct sde_rot_bus_data *sde_get_rot_reg_bus_value(u32 usecase_ndx)
{
return &sde_rot_reg_bus_table[usecase_ndx];
}
u32 sde_apply_comp_ratio_factor(u32 quota,
struct sde_mdp_format_params *fmt,
struct sde_mult_factor *factor)
@@ -471,6 +481,7 @@ int sde_update_reg_bus_vote(struct reg_bus_client *bus_client, u32 usecase_ndx)
int ret = 0;
bool changed = false;
u32 max_usecase_ndx = VOTE_INDEX_DISABLE;
const struct sde_rot_bus_data *reg_bus_value = NULL;
struct reg_bus_client *client, *temp_client;
struct sde_rot_data_type *sde_res = sde_rot_get_mdata();
@@ -487,19 +498,27 @@ int sde_update_reg_bus_vote(struct reg_bus_client *bus_client, u32 usecase_ndx)
max_usecase_ndx = client->usecase_ndx;
}
if (sde_res->reg_bus_usecase_ndx != max_usecase_ndx) {
if (sde_res->reg_bus_usecase_ndx != max_usecase_ndx)
changed = true;
sde_res->reg_bus_usecase_ndx = max_usecase_ndx;
}
SDEROT_DBG(
"%pS: changed=%d current idx=%d request client %s id:%u idx:%d\n",
__builtin_return_address(0), changed, max_usecase_ndx,
bus_client->name, bus_client->id, usecase_ndx);
if (changed)
ret = msm_bus_scale_client_update_request(sde_res->reg_bus_hdl,
max_usecase_ndx);
if (changed) {
reg_bus_value = sde_get_rot_reg_bus_value(max_usecase_ndx);
ret = icc_set_bw(sde_res->reg_bus_hdl, reg_bus_value->ab,
reg_bus_value->ib);
}
if (ret) {
pr_err("rotator: reg_bus_hdl set failed ab=%llu, ib=%llu\n",
reg_bus_value->ab, reg_bus_value->ib);
if (sde_res->reg_bus_usecase_ndx == VOTE_INDEX_DISABLE)
pr_err("rotator: reg_bus_hdl was disabled\n");
} else {
sde_res->reg_bus_usecase_ndx = max_usecase_ndx;
}
mutex_unlock(&sde_res->reg_bus_lock);
return ret;
}
@@ -820,74 +839,33 @@ static void sde_mdp_destroy_dt_misc(struct platform_device *pdev,
mdata->vbif_nrt_qos = NULL;
}
#define MDP_REG_BUS_VECTOR_ENTRY(ab_val, ib_val) \
{ \
.src = MSM_BUS_MASTER_AMPSS_M0, \
.dst = MSM_BUS_SLAVE_DISPLAY_CFG, \
.ab = (ab_val), \
.ib = (ib_val), \
}
#define BUS_VOTE_19_MHZ 153600000
#define BUS_VOTE_40_MHZ 320000000
#define BUS_VOTE_80_MHZ 640000000
#ifdef CONFIG_QCOM_BUS_SCALING
static struct msm_bus_vectors mdp_reg_bus_vectors[] = {
MDP_REG_BUS_VECTOR_ENTRY(0, 0),
MDP_REG_BUS_VECTOR_ENTRY(0, BUS_VOTE_19_MHZ),
MDP_REG_BUS_VECTOR_ENTRY(0, BUS_VOTE_40_MHZ),
MDP_REG_BUS_VECTOR_ENTRY(0, BUS_VOTE_80_MHZ),
};
static struct msm_bus_paths mdp_reg_bus_usecases[ARRAY_SIZE(
mdp_reg_bus_vectors)];
static struct msm_bus_scale_pdata mdp_reg_bus_scale_table = {
.usecase = mdp_reg_bus_usecases,
.num_usecases = ARRAY_SIZE(mdp_reg_bus_usecases),
.name = "sde_reg",
.active_only = true,
};
static int sde_mdp_bus_scale_register(struct sde_rot_data_type *mdata)
{
struct msm_bus_scale_pdata *reg_bus_pdata;
int i;
int rc = 0;
if (!mdata->reg_bus_hdl) {
reg_bus_pdata = &mdp_reg_bus_scale_table;
for (i = 0; i < reg_bus_pdata->num_usecases; i++) {
mdp_reg_bus_usecases[i].num_paths = 1;
mdp_reg_bus_usecases[i].vectors =
&mdp_reg_bus_vectors[i];
}
mdata->reg_bus_hdl =
msm_bus_scale_register_client(reg_bus_pdata);
if (!mdata->reg_bus_hdl) {
/* Continue without reg_bus scaling */
SDEROT_WARN("reg_bus_client register failed\n");
} else
SDEROT_DBG("register reg_bus_hdl=%x\n",
mdata->reg_bus_hdl);
}
mdata->reg_bus_hdl = of_icc_get(&mdata->pdev->dev, "qcom,sde-reg-bus");
if (mdata->reg_bus_hdl == NULL) {
pr_err("rotator: reg bus dt node missing\n");
return 0;
} else if (IS_ERR(mdata->reg_bus_hdl)) {
SDEROT_ERR("reg bus handle parsing failed\n");
mdata->reg_bus_hdl = NULL;
rc = -EINVAL;
} else {
SDEROT_DBG("rotator reg_bus_hdl parsing success\n");
}
#else
static inline int sde_mdp_bus_scale_register(struct sde_rot_data_type *mdata)
{
return 0;
return rc;
}
#endif
static void sde_mdp_bus_scale_unregister(struct sde_rot_data_type *mdata)
{
SDEROT_DBG("unregister reg_bus_hdl=%x\n", mdata->reg_bus_hdl);
SDEROT_DBG("unregister reg_bus_hdl\n");
if (mdata->reg_bus_hdl) {
msm_bus_scale_unregister_client(mdata->reg_bus_hdl);
mdata->reg_bus_hdl = 0;
icc_put(mdata->reg_bus_hdl);
mdata->reg_bus_hdl = NULL;
}
}

20
rotator/sde_rotator_base.h
View File

@@ -13,6 +13,7 @@
#include <linux/regulator/consumer.h>
#include <linux/of_platform.h>
#include <linux/platform_device.h>
#include <linux/interconnect.h>
#include "sde_rotator_hwio.h"
#include "sde_rotator_io_util.h"
@@ -90,9 +91,9 @@ struct sde_mdp_vbif_halt_params {
enum sde_bus_vote_type {
VOTE_INDEX_DISABLE,
VOTE_INDEX_19_MHZ,
VOTE_INDEX_40_MHZ,
VOTE_INDEX_80_MHZ,
VOTE_INDEX_76_MHZ,
VOTE_INDEX_150_MHZ,
VOTE_INDEX_300_MHZ,
VOTE_INDEX_MAX,
};
@@ -192,6 +193,16 @@ struct sde_smmu_client {
u32 sid;
};
/*
* struct sde_rot_bus_data: struct for bus setting
* @ab: average bandwidth in kilobytes per second
* @ib: peak bandwidth in kilobytes per second
*/
struct sde_rot_bus_data {
uint64_t ab; /* Arbitrated bandwidth */
uint64_t ib; /* Instantaneous bandwidth */
};
/*
* struct sde_rot_debug_bus: rotator debugbus header structure
* @wr_addr: write address for debugbus controller
@@ -251,7 +262,7 @@ struct sde_rot_data_type {
u32 rot_block_size;
/* register bus (AHB) */
u32 reg_bus_hdl;
struct icc_path *reg_bus_hdl;
u32 reg_bus_usecase_ndx;
struct list_head reg_bus_clist;
struct mutex reg_bus_lock;
@@ -320,6 +331,7 @@ void vbif_unlock(struct platform_device *parent_pdev);
void sde_mdp_halt_vbif_xin(struct sde_mdp_vbif_halt_params *params);
int sde_mdp_init_vbif(void);
const struct sde_rot_bus_data *sde_get_rot_reg_bus_value(u32 usecase_ndx);
#define SDE_VBIF_WRITE(mdata, offset, value) \
(sde_reg_w(&mdata->vbif_nrt_io, offset, value, 0))

304
rotator/sde_rotator_core.c
View File

@@ -13,8 +13,6 @@
#include <linux/of.h>
#include <linux/clk.h>
#include <linux/debugfs.h>
#include <linux/msm-bus.h>
#include <linux/msm-bus-board.h>
#include <linux/regulator/consumer.h>
#include <linux/dma-direction.h>
#include <soc/qcom/scm.h>
@@ -69,50 +67,20 @@
*/
#define ROT_MAX_HW_BLOCKS 2
#define SDE_REG_BUS_VECTOR_ENTRY(ab_val, ib_val) \
{ \
.src = MSM_BUS_MASTER_AMPSS_M0, \
.dst = MSM_BUS_SLAVE_DISPLAY_CFG, \
.ab = (ab_val), \
.ib = (ib_val), \
}
#define BUS_VOTE_19_MHZ 153600000
/* forward prototype */
static int sde_rotator_update_perf(struct sde_rot_mgr *mgr);
#ifdef CONFIG_QCOM_BUS_SCALING
static struct msm_bus_vectors rot_reg_bus_vectors[] = {
SDE_REG_BUS_VECTOR_ENTRY(0, 0),
SDE_REG_BUS_VECTOR_ENTRY(0, BUS_VOTE_19_MHZ),
};
static struct msm_bus_paths rot_reg_bus_usecases[ARRAY_SIZE(
rot_reg_bus_vectors)];
static struct msm_bus_scale_pdata rot_reg_bus_scale_table = {
.usecase = rot_reg_bus_usecases,
.num_usecases = ARRAY_SIZE(rot_reg_bus_usecases),
.name = "mdss_rot_reg",
.active_only = 1,
};
static int sde_rotator_bus_scale_set_quota(struct sde_rot_bus_data_type *bus,
u64 quota)
{
int new_uc_idx;
int ret;
int ret = 0, i = 0, j = 0;
u64 ab = 0;
if (!bus) {
SDEROT_ERR("null parameter\n");
return -EINVAL;
}
if (!bus->bus_hdl) {
SDEROT_DBG("bus scaling not enabled\n");
if (!bus || !bus->data_paths_cnt) {
SDEROT_DBG("bus scaling not register\n");
return 0;
} else if (bus->bus_hdl < 0) {
SDEROT_ERR("invalid bus handle %d\n", bus->bus_hdl);
return -EINVAL;
}
if (bus->curr_quota_val == quota) {
@@ -120,46 +88,31 @@ static int sde_rotator_bus_scale_set_quota(struct sde_rot_bus_data_type *bus,
return 0;
}
if (!bus->bus_scale_pdata || !bus->bus_scale_pdata->num_usecases) {
SDEROT_ERR("invalid bus scale data\n");
return -EINVAL;
}
SDEROT_EVTLOG(quota);
SDEROT_DBG("quota=%llu\n", quota);
ATRACE_BEGIN("msm_bus_scale_req_rot");
ab = div_u64(quota, bus->data_paths_cnt);
if (!quota) {
new_uc_idx = 0;
} else {
struct msm_bus_vectors *vect = NULL;
struct msm_bus_scale_pdata *bw_table =
bus->bus_scale_pdata;
u64 port_quota = quota;
u32 total_axi_port_cnt;
int i;
new_uc_idx = (bus->curr_bw_uc_idx %
(bw_table->num_usecases - 1)) + 1;
total_axi_port_cnt = bw_table->usecase[new_uc_idx].num_paths;
if (total_axi_port_cnt == 0) {
SDEROT_ERR("Number of bw paths is 0\n");
return -ENODEV;
}
do_div(port_quota, total_axi_port_cnt);
for (i = 0; i < total_axi_port_cnt; i++) {
vect = &bw_table->usecase[new_uc_idx].vectors[i];
vect->ab = port_quota;
vect->ib = 0;
for (i = 0; i < bus->data_paths_cnt; i++) {
if (bus->data_bus_hdl[i]) {
ret = icc_set_bw(bus->data_bus_hdl[i], ab, ab);
if (ret)
goto err;
}
}
bus->curr_bw_uc_idx = new_uc_idx;
ATRACE_END("msm_bus_scale_req_rot");
bus->curr_quota_val = quota;
SDEROT_EVTLOG(new_uc_idx, quota);
SDEROT_DBG("uc_idx=%d quota=%llu\n", new_uc_idx, quota);
ATRACE_BEGIN("msm_bus_scale_req_rot");
ret = msm_bus_scale_client_update_request(bus->bus_hdl,
new_uc_idx);
return 0;
err:
ab = div_u64(bus->curr_quota_val, bus->data_paths_cnt);
for (j = 0; j < i; j++)
icc_set_bw(bus->data_bus_hdl[j], ab, ab);
ATRACE_END("msm_bus_scale_req_rot");
pr_err("failed to set data bus quota %llu\n", quota);
if (!bus->curr_quota_val) {
pr_err("rotator: data bus was set to 0\n");
return ret;
}
@@ -168,43 +121,40 @@ static int sde_rotator_enable_reg_bus(struct sde_rot_mgr *mgr, u64 quota)
{
int ret = 0, changed = 0;
u32 usecase_ndx = 0;
const struct sde_rot_bus_data *reg_bus_value = NULL;
if (!mgr || !mgr->reg_bus.bus_hdl)
if (!mgr || !mgr->reg_bus.data_paths_cnt)
return 0;
if (quota)
usecase_ndx = 1;
usecase_ndx = VOTE_INDEX_76_MHZ;
if (usecase_ndx != mgr->reg_bus.curr_bw_uc_idx) {
mgr->reg_bus.curr_bw_uc_idx = usecase_ndx;
if (usecase_ndx != mgr->reg_bus.curr_bw_uc_idx)
changed++;
}
SDEROT_DBG("%s, changed=%d register bus %s\n", __func__, changed,
quota ? "Enable":"Disable");
if (changed) {
ATRACE_BEGIN("msm_bus_scale_req_rot_reg");
ret = msm_bus_scale_client_update_request(mgr->reg_bus.bus_hdl,
usecase_ndx);
reg_bus_value = sde_get_rot_reg_bus_value(usecase_ndx);
ret = icc_set_bw(mgr->reg_bus.data_bus_hdl[0],
reg_bus_value->ab, reg_bus_value->ib);
ATRACE_END("msm_bus_scale_req_rot_reg");
}
if (ret) {
pr_err("rotator: set reg bus failed ab=%llu, lb=%llu\n",
reg_bus_value->ab, reg_bus_value->ib);
if (mgr->reg_bus.curr_bw_uc_idx == VOTE_INDEX_DISABLE)
pr_err("rotator: reg bus was disabled\n");
} else {
mgr->reg_bus.curr_bw_uc_idx = usecase_ndx;
}
return ret;
}
#else
static inline int sde_rotator_enable_reg_bus(struct sde_rot_mgr *mgr, u64 quota)
{
return 0;
}
static inline int sde_rotator_bus_scale_set_quota(
struct sde_rot_bus_data_type *bus, u64 quota)
{
return 0;
}
#endif
/*
* Clock rate of all open sessions working a particular hw block
* are added together to get the required rate for that hw block.
@@ -375,6 +325,7 @@ int sde_rotator_clk_ctrl(struct sde_rot_mgr *mgr, int enable)
{
int ret = 0;
int changed = 0;
int i = 0, bus_cnt = 0;
if (enable) {
if (mgr->rot_enable_clk_cnt == 0)
@@ -425,9 +376,15 @@ int sde_rotator_clk_ctrl(struct sde_rot_mgr *mgr, int enable)
goto error_rot_sub;
/* Active+Sleep */
msm_bus_scale_client_update_context(
mgr->data_bus.bus_hdl, false,
mgr->data_bus.curr_bw_uc_idx);
if (mgr->data_bus.bus_active_only) {
bus_cnt = mgr->data_bus.data_paths_cnt;
for (i = 0; i < bus_cnt; i++) {
icc_set_tag(
mgr->data_bus.data_bus_hdl[i],
(QCOM_ICC_TAG_ACTIVE_ONLY |
QCOM_ICC_TAG_SLEEP));
}
}
trace_rot_bw_ao_as_context(0);
} else {
sde_rotator_disable_clk(mgr,
@@ -440,9 +397,15 @@ int sde_rotator_clk_ctrl(struct sde_rot_mgr *mgr, int enable)
sde_rotator_disable_clk(mgr, SDE_ROTATOR_CLK_MNOC_AHB);
/* Active Only */
msm_bus_scale_client_update_context(
mgr->data_bus.bus_hdl, true,
mgr->data_bus.curr_bw_uc_idx);
if (mgr->data_bus.bus_active_only) {
bus_cnt = mgr->data_bus.data_paths_cnt;
for (i = 0; i < bus_cnt; i++) {
icc_set_tag(
mgr->data_bus.data_bus_hdl[i],
QCOM_ICC_TAG_ACTIVE_ONLY);
}
}
trace_rot_bw_ao_as_context(1);
}
}
@@ -2766,56 +2729,67 @@ static struct attribute_group sde_rotator_fs_attr_group = {
.attrs = sde_rotator_fs_attrs
};
#ifdef CONFIG_QCOM_BUS_SCALING
static int sde_rotator_parse_dt_bus(struct sde_rot_mgr *mgr,
struct platform_device *dev)
{
int ret = 0, i;
int usecases;
struct device_node *node;
char bus_name[32];
int ret = 0, i = 0;
mgr->data_bus.bus_scale_pdata = msm_bus_cl_get_pdata(dev);
if (IS_ERR_OR_NULL(mgr->data_bus.bus_scale_pdata)) {
ret = PTR_ERR(mgr->data_bus.bus_scale_pdata);
if (ret) {
SDEROT_ERR("msm_bus_cl_get_pdata failed. ret=%d\n",
mgr->reg_bus.data_bus_hdl[0] = of_icc_get(&dev->dev,
"qcom,sde-reg-bus");
if (mgr->reg_bus.data_bus_hdl[0] == NULL) {
mgr->reg_bus.data_paths_cnt = 0;
pr_debug("rotator: reg bus dt node missing\n");
goto data_bus;
} else if (IS_ERR(mgr->reg_bus.data_bus_hdl[0])) {
SDEROT_ERR("sde rotator parse reg bus failed. ret=%d\n",
ret);
mgr->data_bus.bus_scale_pdata = NULL;
}
}
node = of_get_child_by_name(dev->dev.of_node, "qcom,rot-reg-bus");
if (node) {
mgr->reg_bus.bus_scale_pdata
= msm_bus_pdata_from_node(dev, node);
if (IS_ERR_OR_NULL(mgr->reg_bus.bus_scale_pdata)) {
SDEROT_ERR("reg bus pdata parsing failed\n");
ret = PTR_ERR(mgr->reg_bus.bus_scale_pdata);
if (!mgr->reg_bus.bus_scale_pdata)
mgr->reg_bus.data_bus_hdl[0] = NULL;
ret = -EINVAL;
mgr->reg_bus.bus_scale_pdata = NULL;
}
} else {
SDEROT_DBG(
"no DT entries, configuring default reg bus table\n");
mgr->reg_bus.bus_scale_pdata = &rot_reg_bus_scale_table;
usecases = mgr->reg_bus.bus_scale_pdata->num_usecases;
for (i = 0; i < usecases; i++) {
rot_reg_bus_usecases[i].num_paths = 1;
rot_reg_bus_usecases[i].vectors =
&rot_reg_bus_vectors[i];
}
}
return ret;
}
#else
static inline int sde_rotator_parse_dt_bus(struct sde_rot_mgr *mgr,
struct platform_device *dev)
{
mgr->reg_bus.data_paths_cnt = 1;
data_bus:
for (i = 0; i < SDE_ROTATION_BUS_PATH_MAX; i++) {
snprintf(bus_name, 32, "%s%d", "qcom,rot-data-bus", i);
ret = of_property_match_string(pdev->dev.of_node,
"interconnect-names", bus_name);
if (ret < 0) {
if (!mgr->data_bus.data_paths_cnt) {
pr_debug("rotator: bus %s dt node missing\n", bus_name);
return 0;
} else
goto end;
} else
mgr->data_bus.data_bus_hdl[i] = of_icc_get(&pdev->dev, bus_name);
if (IS_ERR_OR_NULL(mgr->data_bus.data_bus_hdl[i])) {
SDEROT_ERR("rotator: get data bus %s failed\n",
bus_name);
break;
}
mgr->data_bus.data_paths_cnt++;
}
if (!mgr->data_bus.data_paths_cnt) {
pr_err("rotator: get none data bus path\n");
return -EINVAL;
}
end:
if (of_find_property(dev->dev.of_node,
"qcom,msm-bus,active-only", NULL)) {
mgr->data_bus.bus_active_only = true;
for (i = 0; i < mgr->data_bus.data_paths_cnt; i++) {
icc_set_tag(mgr->data_bus.data_bus_hdl[i],
QCOM_ICC_TAG_ACTIVE_ONLY);
}
}
return 0;
}
#endif
static int sde_rotator_parse_dt(struct sde_rot_mgr *mgr,
struct platform_device *dev)
@@ -2920,60 +2894,20 @@ error:
return rc;
}
#ifdef CONFIG_QCOM_BUS_SCALING
static void sde_rotator_bus_scale_unregister(struct sde_rot_mgr *mgr)
{
SDEROT_DBG("unregister bus_hdl=%x, reg_bus_hdl=%x\n",
mgr->data_bus.bus_hdl, mgr->reg_bus.bus_hdl);
int i = 0;
if (mgr->data_bus.bus_hdl)
msm_bus_scale_unregister_client(mgr->data_bus.bus_hdl);
if (mgr->reg_bus.bus_hdl)
msm_bus_scale_unregister_client(mgr->reg_bus.bus_hdl);
SDEROT_DBG("unregister sde rotator bus\n");
for (i = 0; i < mgr->data_bus.data_paths_cnt; i++) {
if (mgr->data_bus.data_bus_hdl[i])
icc_put(mgr->data_bus.data_bus_hdl[i]);
}
static int sde_rotator_bus_scale_register(struct sde_rot_mgr *mgr)
{
if (!mgr->data_bus.bus_scale_pdata) {
SDEROT_DBG("Bus scaling is not enabled\n");
return 0;
if (mgr->reg_bus.data_bus_hdl[0])
icc_put(mgr->reg_bus.data_bus_hdl[0]);
}
mgr->data_bus.bus_hdl =
msm_bus_scale_register_client(
mgr->data_bus.bus_scale_pdata);
if (!mgr->data_bus.bus_hdl) {
SDEROT_ERR("bus_client register failed\n");
return -EINVAL;
}
SDEROT_DBG("registered bus_hdl=%x\n", mgr->data_bus.bus_hdl);
if (mgr->reg_bus.bus_scale_pdata) {
mgr->reg_bus.bus_hdl =
msm_bus_scale_register_client(
mgr->reg_bus.bus_scale_pdata);
if (!mgr->reg_bus.bus_hdl) {
SDEROT_ERR("register bus_client register failed\n");
sde_rotator_bus_scale_unregister(mgr);
} else {
SDEROT_DBG("registered register bus_hdl=%x\n",
mgr->reg_bus.bus_hdl);
}
}
return 0;
}
#else
static inline void sde_rotator_bus_scale_unregister(struct sde_rot_mgr *mgr)
{
}
static inline int sde_rotator_bus_scale_register(struct sde_rot_mgr *mgr)
{
return 0;
}
#endif
static inline int sde_rotator_search_dt_clk(struct platform_device *pdev,
struct sde_rot_mgr *mgr, char *clk_name, int clk_idx,
bool mandatory)
@@ -3092,10 +3026,6 @@ static int sde_rotator_res_init(struct platform_device *pdev,
if (ret)
goto error;
ret = sde_rotator_bus_scale_register(mgr);
if (ret)
goto error;
return 0;
error:
sde_rotator_put_dt_vreg_data(&pdev->dev, &mgr->module_power);

36
rotator/sde_rotator_core.h
View File

@@ -60,6 +60,23 @@
/* use client provided clock/bandwidth parameters */
#define SDE_ROTATION_EXT_PERF 0x100000
#define SDE_ROTATION_BUS_PATH_MAX 0x2
/*
* The AMC bucket denotes constraints that are applied to hardware when
* icc_set_bw() completes, whereas the WAKE and SLEEP constraints are applied
* when the execution environment transitions between active and low power mode.
*/
#define QCOM_ICC_BUCKET_AMC 0
#define QCOM_ICC_BUCKET_WAKE 1
#define QCOM_ICC_BUCKET_SLEEP 2
#define QCOM_ICC_NUM_BUCKETS 3
#define QCOM_ICC_TAG_AMC BIT(QCOM_ICC_BUCKET_AMC)
#define QCOM_ICC_TAG_WAKE BIT(QCOM_ICC_BUCKET_WAKE)
#define QCOM_ICC_TAG_SLEEP BIT(QCOM_ICC_BUCKET_SLEEP)
#define QCOM_ICC_TAG_ACTIVE_ONLY (QCOM_ICC_TAG_AMC | QCOM_ICC_TAG_WAKE)
#define QCOM_ICC_TAG_ALWAYS (QCOM_ICC_TAG_AMC | QCOM_ICC_TAG_WAKE |\
QCOM_ICC_TAG_SLEEP)
/**********************************************************************
* configuration structures
@@ -374,18 +391,19 @@ struct sde_rot_file_private {
struct sde_rot_queue_v1 *fenceq;
};
/*
* struct sde_rot_bus_data_type - rotator bus scaling configuration
* @bus_cale_pdata: pointer to bus scaling configuration table
* @bus_hdl: msm bus scaling handle
* @curr_bw_uc_idx; current usecase index into configuration table
* @curr_quota_val: current bandwidth request in byte per second
/**
* struct sde_rot_bus_data_type: power handle struct for data bus
* @data_paths_cnt: number of rt data path ports
* @curr_quota_val: save the current bus value
* @curr_bw_uc_idx: current reg bus value index
* @bus_active_only: AMC support, can set the bus path WAKE/SLEEP
*/
struct sde_rot_bus_data_type {
struct msm_bus_scale_pdata *bus_scale_pdata;
u32 bus_hdl;
u32 curr_bw_uc_idx;
struct icc_path *data_bus_hdl[SDE_ROTATION_BUS_PATH_MAX];
u32 data_paths_cnt;
u64 curr_quota_val;
u32 curr_bw_uc_idx;
bool bus_active_only;
};
/*

1
rotator/sde_rotator_dev.h
View File

@@ -12,7 +12,6 @@
#include <linux/ktime.h>
#include <linux/iommu.h>
#include <linux/dma-buf.h>
#include <linux/msm-bus.h>
#include <linux/platform_device.h>
#include <linux/soc/qcom/llcc-qcom.h>
#include <linux/kthread.h>

2
rotator/sde_rotator_smmu.c
View File

@@ -164,7 +164,7 @@ static int sde_smmu_enable_power(struct sde_smmu_client *sde_smmu,
goto end;
}
sde_update_reg_bus_vote(sde_smmu->reg_bus_clt,
VOTE_INDEX_19_MHZ);
VOTE_INDEX_76_MHZ);
rc = sde_rot_enable_clk(mp->clk_config, mp->num_clk, true);
if (rc) {
SDEROT_ERR("clock enable failed - rc:%d\n", rc);

2
rotator/sde_rotator_util.c
View File

@@ -18,8 +18,6 @@
#include <linux/slab.h>
#include <linux/io.h>
#include <linux/iopoll.h>
#include <linux/msm-bus.h>
#include <linux/msm-bus-board.h>
#include <linux/regulator/consumer.h>
#include <media/msm_media_info.h>
#include <linux/videodev2.h>