SSL iris_power.c   Interaktion und
PortierbarkeitC

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2022-2024 Qualcomm Innovation Center, Inc. All rights reserved.
 */

#include <linux/pm_opp.h>
#include <linux/pm_runtime.h>
#include <media/v4l2-mem2mem.h>

#include "iris_buffer.h"
#include "iris_instance.h"
#include "iris_power.h"
#include "iris_resources.h"
#include "iris_vpu_common.h"

static u32 iris_calc_bw(struct iris_inst *inst, struct icc_vote_data *data)
{
 const struct bw_info *bw_tbl = NULL;
 struct iris_core *core = inst->core;
 u32 num_rows, i, mbs, mbps;
 u32 icc_bw = 0;

 mbs = DIV_ROUND_UP(data->height, 16) * DIV_ROUND_UP(data->width, 16);
 mbps = mbs * data->fps;
 if (mbps == 0)
  goto exit;

 bw_tbl = core->iris_platform_data->bw_tbl_dec;
 num_rows = core->iris_platform_data->bw_tbl_dec_size;

 for (i = 0; i < num_rows; i++) {
  if (i != 0 && mbps > bw_tbl[i].mbs_per_sec)
   break;

  icc_bw = bw_tbl[i].bw_ddr;
 }

exit:
 return icc_bw;
}

static int iris_set_interconnects(struct iris_inst *inst)
{
 struct iris_core *core = inst->core;
 struct iris_inst *instance;
 u64 total_bw_ddr = 0;
 int ret;

 mutex_lock(&core->lock);
 list_for_each_entry(instance, &core->instances, list) {
  if (!instance->max_input_data_size)
   continue;

  total_bw_ddr += instance->power.icc_bw;
 }

 ret = iris_set_icc_bw(core, total_bw_ddr);

 mutex_unlock(&core->lock);

 return ret;
}

static int iris_vote_interconnects(struct iris_inst *inst)
{
 struct icc_vote_data *vote_data = &inst->icc_data;
 struct v4l2_format *inp_f = inst->fmt_src;

 vote_data->width = inp_f->fmt.pix_mp.width;
 vote_data->height = inp_f->fmt.pix_mp.height;
 vote_data->fps = DEFAULT_FPS;

 inst->power.icc_bw = iris_calc_bw(inst, vote_data);

 return iris_set_interconnects(inst);
}

static int iris_set_clocks(struct iris_inst *inst)
{
 struct iris_core *core = inst->core;
 struct iris_inst *instance;
 u64 freq = 0;
 int ret;

 mutex_lock(&core->lock);
 list_for_each_entry(instance, &core->instances, list) {
  if (!instance->max_input_data_size)
   continue;

  freq += instance->power.min_freq;
 }

 core->power.clk_freq = freq;
 ret = dev_pm_opp_set_rate(core->dev, freq);
 mutex_unlock(&core->lock);

 return ret;
}

static int iris_scale_clocks(struct iris_inst *inst)
{
 const struct vpu_ops *vpu_ops = inst->core->iris_platform_data->vpu_ops;
 struct v4l2_m2m_ctx *m2m_ctx = inst->m2m_ctx;
 struct v4l2_m2m_buffer *buffer, *n;
 struct iris_buffer *buf;
 size_t data_size = 0;

 v4l2_m2m_for_each_src_buf_safe(m2m_ctx, buffer, n) {
  buf = to_iris_buffer(&buffer->vb);
  data_size = max(data_size, buf->data_size);
 }

 inst->max_input_data_size = data_size;
 if (!inst->max_input_data_size)
  return 0;

 inst->power.min_freq = vpu_ops->calc_freq(inst, inst->max_input_data_size);

 return iris_set_clocks(inst);
}

int iris_scale_power(struct iris_inst *inst)
{
 struct iris_core *core = inst->core;
 int ret;

 if (pm_runtime_suspended(core->dev)) {
  ret = pm_runtime_resume_and_get(core->dev);
  if (ret < 0)
   return ret;

  pm_runtime_put_autosuspend(core->dev);
 }

 ret = iris_scale_clocks(inst);
 if (ret)
  return ret;

 return iris_vote_interconnects(inst);
}