samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Forka 0
Codice Problemi Pull Requests Actions Pacchetti Progetti Rilasci Wiki Attività
Files
0eedd436e144efa0869fa4cf8e1ee754e9cf7c29
android_kernel_samsung_sm86…/msm/eva/cvp_hfi.c
Palak Joshi 0eedd436e1 msm: eva: Identify the actual number of silver cores available with target 
As PM QOS request needs to done for silver cores only for EVA and
number of silver cores would be different for different target so,
better to identify the actual number of available silver cores.
Added cpu_possible check to confirm if cpu is available or not.

Change-Id: Ibccc7688200732c3c666041a8fe414b4f2818993
Signed-off-by: Palak Joshi <quic_palakash@quicinc.com>
2023-06-05 03:29:31 -07:00

5476 righe
139 KiB
C
Originale Blame Cronologia

// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2018-2021, The Linux Foundation. All rights reserved.
* Copyright (c) 2023 Qualcomm Innovation Center, Inc. All rights reserved.
*/
#include <asm/memory.h>
#include <linux/coresight-stm.h>
#include <linux/delay.h>
#include <linux/devfreq.h>
#include <linux/hash.h>
#include <linux/io.h>
#include <linux/iommu.h>
#include <linux/iopoll.h>
#include <linux/of.h>
#include <linux/pm_qos.h>
#include <linux/regulator/consumer.h>
#include <linux/slab.h>
#include <linux/workqueue.h>
#include <linux/platform_device.h>
#include <linux/soc/qcom/llcc-qcom.h>
#include <linux/qcom_scm.h>
#include <linux/soc/qcom/smem.h>
#include <linux/dma-mapping.h>
#include <linux/reset.h>
#include <linux/pm_wakeup.h>
#include "hfi_packetization.h"
#include "msm_cvp_debug.h"
#include "cvp_core_hfi.h"
#include "cvp_hfi_helper.h"
#include "cvp_hfi_io.h"
#include "msm_cvp_dsp.h"
#include "msm_cvp_clocks.h"
#include "vm/cvp_vm.h"
#include "cvp_dump.h"
// ysi - added for debug
#include <linux/clk/qcom.h>
#include "msm_cvp_common.h"
#define REG_ADDR_OFFSET_BITMASK 0x000FFFFF
#define QDSS_IOVA_START 0x80001000
#define MIN_PAYLOAD_SIZE 3
struct cvp_tzbsp_memprot {
u32 cp_start;
u32 cp_size;
u32 cp_nonpixel_start;
u32 cp_nonpixel_size;
};
#define TZBSP_CVP_PAS_ID 26
/* Poll interval in uS */
#define POLL_INTERVAL_US 50
enum tzbsp_subsys_state {
TZ_SUBSYS_STATE_SUSPEND = 0,
TZ_SUBSYS_STATE_RESUME = 1,
TZ_SUBSYS_STATE_RESTORE_THRESHOLD = 2,
};
const struct msm_cvp_gov_data CVP_DEFAULT_BUS_VOTE = {
.data = NULL,
.data_count = 0,
};
const int cvp_max_packets = 32;
static void iris_hfi_pm_handler(struct work_struct *work);
static DECLARE_DELAYED_WORK(iris_hfi_pm_work, iris_hfi_pm_handler);
static inline int __resume(struct iris_hfi_device *device);
static inline int __suspend(struct iris_hfi_device *device);
static int __disable_regulator(struct iris_hfi_device *device,
const char *name);
static int __enable_regulator(struct iris_hfi_device *device,
const char *name);
static void __flush_debug_queue(struct iris_hfi_device *device, u8 *packet);
static int __initialize_packetization(struct iris_hfi_device *device);
static struct cvp_hal_session *__get_session(struct iris_hfi_device *device,
u32 session_id);
static bool __is_session_valid(struct iris_hfi_device *device,
struct cvp_hal_session *session, const char *func);
static int __iface_cmdq_write(struct iris_hfi_device *device,
void *pkt);
static int __load_fw(struct iris_hfi_device *device);
static int __power_on_init(struct iris_hfi_device *device);
static void __unload_fw(struct iris_hfi_device *device);
static int __tzbsp_set_cvp_state(enum tzbsp_subsys_state state);
static int __enable_subcaches(struct iris_hfi_device *device);
static int __set_subcaches(struct iris_hfi_device *device);
static int __release_subcaches(struct iris_hfi_device *device);
static int __disable_subcaches(struct iris_hfi_device *device);
static int __power_collapse(struct iris_hfi_device *device, bool force);
static int iris_hfi_noc_error_info(void *dev);
static void interrupt_init_iris2(struct iris_hfi_device *device);
static void setup_dsp_uc_memmap_vpu5(struct iris_hfi_device *device);
static void clock_config_on_enable_vpu5(struct iris_hfi_device *device);
static void power_off_iris2(struct iris_hfi_device *device);
static int __set_ubwc_config(struct iris_hfi_device *device);
static void __noc_error_info_iris2(struct iris_hfi_device *device);
static int __enable_hw_power_collapse(struct iris_hfi_device *device);
static int __disable_hw_power_collapse(struct iris_hfi_device *device);
static int __power_off_controller(struct iris_hfi_device *device);
static int __hwfence_regs_map(struct iris_hfi_device *device);
static int __hwfence_regs_unmap(struct iris_hfi_device *device);
static int __reset_control_assert_name(struct iris_hfi_device *device, const char *name);
static int __reset_control_deassert_name(struct iris_hfi_device *device, const char *name);
static int __reset_control_acquire(struct iris_hfi_device *device, const char *name);
static int __reset_control_release(struct iris_hfi_device *device, const char *name);
static struct iris_hfi_vpu_ops iris2_ops = {
.interrupt_init = interrupt_init_iris2,
.setup_dsp_uc_memmap = setup_dsp_uc_memmap_vpu5,
.clock_config_on_enable = clock_config_on_enable_vpu5,
.power_off = power_off_iris2,
.noc_error_info = __noc_error_info_iris2,
.reset_control_assert_name = __reset_control_assert_name,
.reset_control_deassert_name = __reset_control_deassert_name,
.reset_control_acquire_name = __reset_control_acquire,
.reset_control_release_name = __reset_control_release,
};
/**
* Utility function to enforce some of our assumptions. Spam calls to this
* in hotspots in code to double check some of the assumptions that we hold.
*/
static inline void __strict_check(struct iris_hfi_device *device)
{
msm_cvp_res_handle_fatal_hw_error(device->res,
!mutex_is_locked(&device->lock));
}
static inline void __set_state(struct iris_hfi_device *device,
enum iris_hfi_state state)
{
device->state = state;
}
static inline bool __core_in_valid_state(struct iris_hfi_device *device)
{
return device->state != IRIS_STATE_DEINIT;
}
static inline bool is_sys_cache_present(struct iris_hfi_device *device)
{
return device->res->sys_cache_present;
}
static int cvp_synx_recover(void)
{
#ifdef CVP_SYNX_ENABLED
return synx_recover(SYNX_CLIENT_EVA_CTX0);
#else
return 0;
#endif /* End of CVP_SYNX_ENABLED */
}
#define ROW_SIZE 32
unsigned long long get_aon_time(void)
{
unsigned long long val;
asm volatile("mrs %0, cntvct_el0" : "=r" (val));
return val;
}
int get_hfi_version(void)
{
struct msm_cvp_core *core;
struct iris_hfi_device *hfi;
core = cvp_driver->cvp_core;
hfi = (struct iris_hfi_device *)core->device->hfi_device_data;
return hfi->version;
}
unsigned int get_msg_size(struct cvp_hfi_msg_session_hdr *hdr)
{
struct msm_cvp_core *core;
struct iris_hfi_device *device;
u32 minor_ver;
core = cvp_driver->cvp_core;
if (core)
device = core->device->hfi_device_data;
else
return 0;
if (!device) {
dprintk(CVP_ERR, "%s: NULL device\n", __func__);
return 0;
}
minor_ver = (device->version & HFI_VERSION_MINOR_MASK) >>
HFI_VERSION_MINOR_SHIFT;
if (minor_ver < 2)
return sizeof(struct cvp_hfi_msg_session_hdr);
if (hdr->packet_type == HFI_MSG_SESSION_CVP_FD)
return sizeof(struct cvp_hfi_msg_session_hdr_ext);
else
return sizeof(struct cvp_hfi_msg_session_hdr);
}
unsigned int get_msg_session_id(void *msg)
{
struct cvp_hfi_msg_session_hdr *hdr =
(struct cvp_hfi_msg_session_hdr *)msg;
return hdr->session_id;
}
unsigned int get_msg_errorcode(void *msg)
{
struct cvp_hfi_msg_session_hdr *hdr =
(struct cvp_hfi_msg_session_hdr *)msg;
return hdr->error_type;
}
int get_msg_opconfigs(void *msg, unsigned int *session_id,
unsigned int *error_type, unsigned int *config_id)
{
struct cvp_hfi_msg_session_op_cfg_packet *cfg =
(struct cvp_hfi_msg_session_op_cfg_packet *)msg;
*session_id = cfg->session_id;
*error_type = cfg->error_type;
*config_id = cfg->op_conf_id;
return 0;
}
static void __dump_packet(u8 *packet, enum cvp_msg_prio log_level)
{
u32 c = 0, packet_size = *(u32 *)packet;
/*
* row must contain enough for 0xdeadbaad * 8 to be converted into
* "de ad ba ab " * 8 + '\0'
*/
char row[3 * ROW_SIZE];
for (c = 0; c * ROW_SIZE < packet_size; ++c) {
int bytes_to_read = ((c + 1) * ROW_SIZE > packet_size) ?
packet_size % ROW_SIZE : ROW_SIZE;
hex_dump_to_buffer(packet + c * ROW_SIZE, bytes_to_read,
ROW_SIZE, 4, row, sizeof(row), false);
dprintk(log_level, "%s\n", row);
}
}
static int __dsp_suspend(struct iris_hfi_device *device, bool force)
{
int rc;
if (msm_cvp_dsp_disable)
return 0;
dprintk(CVP_DSP, "%s: suspend dsp\n", __func__);
rc = cvp_dsp_suspend(force);
if (rc) {
if (rc != -EBUSY)
dprintk(CVP_ERR,
"%s: dsp suspend failed with error %d\n",
__func__, rc);
return rc;
}
dprintk(CVP_DSP, "%s: dsp suspended\n", __func__);
return 0;
}
static int __dsp_resume(struct iris_hfi_device *device)
{
int rc;
if (msm_cvp_dsp_disable)
return 0;
dprintk(CVP_DSP, "%s: resume dsp\n", __func__);
rc = cvp_dsp_resume();
if (rc) {
dprintk(CVP_ERR,
"%s: dsp resume failed with error %d\n",
__func__, rc);
return rc;
}
dprintk(CVP_DSP, "%s: dsp resumed\n", __func__);
return rc;
}
static int __dsp_shutdown(struct iris_hfi_device *device)
{
int rc;
if (msm_cvp_dsp_disable)
return 0;
dprintk(CVP_DSP, "%s: shutdown dsp\n", __func__);
rc = cvp_dsp_shutdown();
if (rc) {
dprintk(CVP_ERR,
"%s: dsp shutdown failed with error %d\n",
__func__, rc);
WARN_ON(1);
}
dprintk(CVP_DSP, "%s: dsp shutdown successful\n", __func__);
return rc;
}
static int __acquire_regulator(struct regulator_info *rinfo,
struct iris_hfi_device *device)
{
int rc = 0;
if (rinfo->has_hw_power_collapse) {
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
*/
dprintk(CVP_WARN,
"Failed to acquire regulator control: %s\n",
rinfo->name);
} else {
dprintk(CVP_PWR,
"Acquire regulator control from HW: %s\n",
rinfo->name);
}
}
if (!regulator_is_enabled(rinfo->regulator)) {
dprintk(CVP_WARN, "Regulator is not enabled %s\n",
rinfo->name);
msm_cvp_res_handle_fatal_hw_error(device->res, true);
}
return rc;
}
static int __hand_off_regulator(struct regulator_info *rinfo)
{
int rc = 0;
if (rinfo->has_hw_power_collapse) {
rc = regulator_set_mode(rinfo->regulator,
REGULATOR_MODE_FAST);
if (rc) {
dprintk(CVP_WARN,
"Failed to hand off regulator control: %s\n",
rinfo->name);
} else {
dprintk(CVP_PWR,
"Hand off regulator control to HW: %s\n",
rinfo->name);
}
}
return rc;
}
static int __hand_off_regulators(struct iris_hfi_device *device)
{
struct regulator_info *rinfo;
int rc = 0, c = 0;
iris_hfi_for_each_regulator(device, rinfo) {
rc = __hand_off_regulator(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:
iris_hfi_for_each_regulator_reverse_continue(device, rinfo, c)
__acquire_regulator(rinfo, device);
return rc;
}
static int __take_back_regulators(struct iris_hfi_device *device)
{
struct regulator_info *rinfo;
int rc = 0;
iris_hfi_for_each_regulator(device, rinfo) {
rc = __acquire_regulator(rinfo, device);
/*
* if one regulator hand off failed, driver should take
* the control for other regulators back.
*/
if (rc)
return rc;
}
return rc;
}
static int __write_queue(struct cvp_iface_q_info *qinfo, u8 *packet,
bool *rx_req_is_set)
{
struct cvp_hfi_queue_header *queue;
struct cvp_hfi_cmd_session_hdr *cmd_pkt;
u32 packet_size_in_words, new_write_idx;
u32 empty_space, read_idx, write_idx;
u32 *write_ptr;
if (!qinfo || !packet) {
dprintk(CVP_ERR, "Invalid Params\n");
return -EINVAL;
} else if (!qinfo->q_array.align_virtual_addr) {
dprintk(CVP_WARN, "Queues have already been freed\n");
return -EINVAL;
}
queue = (struct cvp_hfi_queue_header *) qinfo->q_hdr;
if (!queue) {
dprintk(CVP_ERR, "queue not present\n");
return -ENOENT;
}
cmd_pkt = (struct cvp_hfi_cmd_session_hdr *)packet;
if (cmd_pkt->size >= sizeof(struct cvp_hfi_cmd_session_hdr))
dprintk(CVP_CMD, "%s: "
"pkt_type %08x sess_id %08x trans_id %u ktid %llu\n",
__func__, cmd_pkt->packet_type,
cmd_pkt->session_id,
cmd_pkt->client_data.transaction_id,
cmd_pkt->client_data.kdata & (FENCE_BIT - 1));
else
dprintk(CVP_CMD, "%s: "
"pkt_type %08x", __func__, cmd_pkt->packet_type);
if (msm_cvp_debug & CVP_PKT) {
dprintk(CVP_PKT, "%s: %pK\n", __func__, qinfo);
__dump_packet(packet, CVP_PKT);
}
packet_size_in_words = (*(u32 *)packet) >> 2;
if (!packet_size_in_words || packet_size_in_words >
qinfo->q_array.mem_size>>2) {
dprintk(CVP_ERR, "Invalid packet size\n");
return -ENODATA;
}
spin_lock(&qinfo->hfi_lock);
read_idx = queue->qhdr_read_idx;
write_idx = queue->qhdr_write_idx;
empty_space = (write_idx >= read_idx) ?
((qinfo->q_array.mem_size>>2) - (write_idx - read_idx)) :
(read_idx - write_idx);
if (empty_space <= packet_size_in_words) {
queue->qhdr_tx_req = 1;
spin_unlock(&qinfo->hfi_lock);
dprintk(CVP_ERR, "Insufficient size (%d) to write (%d)\n",
empty_space, packet_size_in_words);
return -ENOTEMPTY;
}
queue->qhdr_tx_req = 0;
new_write_idx = write_idx + packet_size_in_words;
write_ptr = (u32 *)((qinfo->q_array.align_virtual_addr) +
(write_idx << 2));
if (write_ptr < (u32 *)qinfo->q_array.align_virtual_addr ||
write_ptr > (u32 *)(qinfo->q_array.align_virtual_addr +
qinfo->q_array.mem_size)) {
spin_unlock(&qinfo->hfi_lock);
dprintk(CVP_ERR, "Invalid write index\n");
return -ENODATA;
}
if (new_write_idx < (qinfo->q_array.mem_size >> 2)) {
memcpy(write_ptr, packet, packet_size_in_words << 2);
} else {
new_write_idx -= qinfo->q_array.mem_size >> 2;
memcpy(write_ptr, packet, (packet_size_in_words -
new_write_idx) << 2);
memcpy((void *)qinfo->q_array.align_virtual_addr,
packet + ((packet_size_in_words - new_write_idx) << 2),
new_write_idx << 2);
}
/*
* Memory barrier to make sure packet is written before updating the
* write index
*/
mb();
queue->qhdr_write_idx = new_write_idx;
if (rx_req_is_set)
*rx_req_is_set = queue->qhdr_rx_req == 1;
/*
* Memory barrier to make sure write index is updated before an
* interrupt is raised.
*/
mb();
spin_unlock(&qinfo->hfi_lock);
return 0;
}
static int __read_queue(struct cvp_iface_q_info *qinfo, u8 *packet,
u32 *pb_tx_req_is_set)
{
struct cvp_hfi_queue_header *queue;
struct cvp_hfi_msg_session_hdr *msg_pkt;
u32 packet_size_in_words, new_read_idx;
u32 *read_ptr;
u32 receive_request = 0;
u32 read_idx, write_idx;
int rc = 0;
if (!qinfo || !packet || !pb_tx_req_is_set) {
dprintk(CVP_ERR, "Invalid Params\n");
return -EINVAL;
} else if (!qinfo->q_array.align_virtual_addr) {
dprintk(CVP_WARN, "Queues have already been freed\n");
return -EINVAL;
}
/*
* Memory barrier to make sure data is valid before
*reading it
*/
mb();
queue = (struct cvp_hfi_queue_header *) qinfo->q_hdr;
if (!queue) {
dprintk(CVP_ERR, "Queue memory is not allocated\n");
return -ENOMEM;
}
/*
* Do not set receive request for debug queue, if set,
* Iris generates interrupt for debug messages even
* when there is no response message available.
* In general debug queue will not become full as it
* is being emptied out for every interrupt from Iris.
* Iris will anyway generates interrupt if it is full.
*/
spin_lock(&qinfo->hfi_lock);
if (queue->qhdr_type & HFI_Q_ID_CTRL_TO_HOST_MSG_Q)
receive_request = 1;
read_idx = queue->qhdr_read_idx;
write_idx = queue->qhdr_write_idx;
if (read_idx == write_idx) {
queue->qhdr_rx_req = receive_request;
/*
* mb() to ensure qhdr is updated in main memory
* so that iris reads the updated header values
*/
mb();
*pb_tx_req_is_set = 0;
if (write_idx != queue->qhdr_write_idx) {
queue->qhdr_rx_req = 0;
} else {
spin_unlock(&qinfo->hfi_lock);
dprintk(CVP_HFI,
"%s queue is empty, rx_req = %u, tx_req = %u, read_idx = %u\n",
receive_request ? "message" : "debug",
queue->qhdr_rx_req, queue->qhdr_tx_req,
queue->qhdr_read_idx);
return -ENODATA;
}
}
read_ptr = (u32 *)((qinfo->q_array.align_virtual_addr) +
(read_idx << 2));
if (read_ptr < (u32 *)qinfo->q_array.align_virtual_addr ||
read_ptr > (u32 *)(qinfo->q_array.align_virtual_addr +
qinfo->q_array.mem_size - sizeof(*read_ptr))) {
spin_unlock(&qinfo->hfi_lock);
dprintk(CVP_ERR, "Invalid read index\n");
return -ENODATA;
}
packet_size_in_words = (*read_ptr) >> 2;
if (!packet_size_in_words) {
spin_unlock(&qinfo->hfi_lock);
dprintk(CVP_ERR, "Zero packet size\n");
return -ENODATA;
}
new_read_idx = read_idx + packet_size_in_words;
if (((packet_size_in_words << 2) <= CVP_IFACEQ_VAR_HUGE_PKT_SIZE)
&& read_idx <= (qinfo->q_array.mem_size >> 2)) {
if (new_read_idx < (qinfo->q_array.mem_size >> 2)) {
memcpy(packet, read_ptr,
packet_size_in_words << 2);
} else {
new_read_idx -= (qinfo->q_array.mem_size >> 2);
memcpy(packet, read_ptr,
(packet_size_in_words - new_read_idx) << 2);
memcpy(packet + ((packet_size_in_words -
new_read_idx) << 2),
(u8 *)qinfo->q_array.align_virtual_addr,
new_read_idx << 2);
}
} else {
dprintk(CVP_WARN,
"BAD packet received, read_idx: %#x, pkt_size: %d\n",
read_idx, packet_size_in_words << 2);
dprintk(CVP_WARN, "Dropping this packet\n");
new_read_idx = write_idx;
rc = -ENODATA;
}
if (new_read_idx != queue->qhdr_write_idx)
queue->qhdr_rx_req = 0;
else
queue->qhdr_rx_req = receive_request;
queue->qhdr_read_idx = new_read_idx;
/*
* mb() to ensure qhdr is updated in main memory
* so that iris reads the updated header values
*/
mb();
*pb_tx_req_is_set = (queue->qhdr_tx_req == 1) ? 1 : 0;
spin_unlock(&qinfo->hfi_lock);
if (!(queue->qhdr_type & HFI_Q_ID_CTRL_TO_HOST_DEBUG_Q)) {
msg_pkt = (struct cvp_hfi_msg_session_hdr *)packet;
dprintk(CVP_CMD, "%s: "
"pkt_type %08x sess_id %08x trans_id %u ktid %llu\n",
__func__, msg_pkt->packet_type,
msg_pkt->session_id,
msg_pkt->client_data.transaction_id,
msg_pkt->client_data.kdata & (FENCE_BIT - 1));
}
if ((msm_cvp_debug & CVP_PKT) &&
!(queue->qhdr_type & HFI_Q_ID_CTRL_TO_HOST_DEBUG_Q)) {
dprintk(CVP_PKT, "%s: %pK\n", __func__, qinfo);
__dump_packet(packet, CVP_PKT);
}
return rc;
}
static int __smem_alloc(struct iris_hfi_device *dev, struct cvp_mem_addr *mem,
u32 size, u32 align, u32 flags)
{
struct msm_cvp_smem *alloc = &mem->mem_data;
int rc = 0;
if (!dev || !mem || !size) {
dprintk(CVP_ERR, "Invalid Params\n");
return -EINVAL;
}
dprintk(CVP_INFO, "start to alloc size: %d, flags: %d\n", size, flags);
alloc->flags = flags;
rc = msm_cvp_smem_alloc(size, align, 1, (void *)dev->res, alloc);
if (rc) {
dprintk(CVP_ERR, "Alloc failed\n");
rc = -ENOMEM;
goto fail_smem_alloc;
}
dprintk(CVP_MEM, "%s: ptr = %pK, size = %d\n", __func__,
alloc->kvaddr, size);
mem->mem_size = alloc->size;
mem->align_virtual_addr = alloc->kvaddr;
mem->align_device_addr = alloc->device_addr;
alloc->pkt_type = 0;
alloc->buf_idx = 0;
return rc;
fail_smem_alloc:
return rc;
}
static void __smem_free(struct iris_hfi_device *dev, struct msm_cvp_smem *mem)
{
if (!dev || !mem) {
dprintk(CVP_ERR, "invalid param %pK %pK\n", dev, mem);
return;
}
msm_cvp_smem_free(mem);
}
static void __write_register(struct iris_hfi_device *device,
u32 reg, u32 value)
{
u32 hwiosymaddr = reg;
u8 *base_addr;
if (!device) {
dprintk(CVP_ERR, "Invalid params: %pK\n", device);
return;
}
__strict_check(device);
if (!device->power_enabled) {
dprintk(CVP_WARN,
"HFI Write register failed : Power is OFF\n");
msm_cvp_res_handle_fatal_hw_error(device->res, true);
return;
}
base_addr = device->cvp_hal_data->register_base;
dprintk(CVP_REG, "Base addr: %pK, written to: %#x, Value: %#x...\n",
base_addr, hwiosymaddr, value);
base_addr += hwiosymaddr;
writel_relaxed(value, base_addr);
/*
* Memory barrier to make sure value is written into the register.
*/
wmb();
}
static int __read_gcc_register(struct iris_hfi_device *device, u32 reg)
{
int rc = 0;
u8 *base_addr;
if (!device) {
dprintk(CVP_ERR, "Invalid params: %pK\n", device);
return -EINVAL;
}
__strict_check(device);
if (!device->power_enabled) {
dprintk(CVP_WARN,
"%s HFI Read register failed : Power is OFF\n",
__func__);
msm_cvp_res_handle_fatal_hw_error(device->res, true);
return -EINVAL;
}
base_addr = device->cvp_hal_data->gcc_reg_base;
rc = readl_relaxed(base_addr + reg);
/*
* Memory barrier to make sure value is read correctly from the
* register.
*/
rmb();
dprintk(CVP_REG,
"GCC Base addr: %pK, read from: %#x, value: %#x...\n",
base_addr, reg, rc);
return rc;
}
static int __read_register(struct iris_hfi_device *device, u32 reg)
{
int rc = 0;
u8 *base_addr;
if (!device) {
dprintk(CVP_ERR, "Invalid params: %pK\n", device);
return -EINVAL;
}
__strict_check(device);
if (!device->power_enabled) {
dprintk(CVP_WARN,
"HFI Read register failed : Power is OFF\n");
msm_cvp_res_handle_fatal_hw_error(device->res, true);
return -EINVAL;
}
base_addr = device->cvp_hal_data->register_base;
rc = readl_relaxed(base_addr + reg);
/*
* Memory barrier to make sure value is read correctly from the
* register.
*/
rmb();
dprintk(CVP_REG, "Base addr: %pK, read from: %#x, value: %#x...\n",
base_addr, reg, rc);
return rc;
}
static int __set_registers(struct iris_hfi_device *device)
{
struct msm_cvp_core *core;
struct msm_cvp_platform_data *pdata;
struct reg_set *reg_set;
int i;
if (!device->res) {
dprintk(CVP_ERR,
"device resources null, cannot set registers\n");
return -EINVAL ;
}
core = cvp_driver->cvp_core;
pdata = core->platform_data;
reg_set = &device->res->reg_set;
for (i = 0; i < reg_set->count; i++) {
__write_register(device, reg_set->reg_tbl[i].reg,
reg_set->reg_tbl[i].value);
dprintk(CVP_REG, "write_reg offset=%x, val=%x\n",
reg_set->reg_tbl[i].reg,
reg_set->reg_tbl[i].value);
}
i = call_iris_op(device, reset_control_acquire_name, device, "cvp_xo_reset");
if (i) {
dprintk(CVP_WARN, "%s Fail acquire xo_reset\n", __func__);
return -EINVAL;
}
__write_register(device, CVP_CPU_CS_AXI4_QOS,
pdata->noc_qos->axi_qos);
__write_register(device, CVP_NOC_RGE_PRIORITYLUT_LOW,
pdata->noc_qos->prioritylut_low);
__write_register(device, CVP_NOC_RGE_PRIORITYLUT_HIGH,
pdata->noc_qos->prioritylut_high);
__write_register(device, CVP_NOC_RGE_URGENCY_LOW,
pdata->noc_qos->urgency_low);
__write_register(device, CVP_NOC_RGE_DANGERLUT_LOW,
pdata->noc_qos->dangerlut_low);
__write_register(device, CVP_NOC_RGE_SAFELUT_LOW,
pdata->noc_qos->safelut_low);
__write_register(device, CVP_NOC_CDM_PRIORITYLUT_LOW,
pdata->noc_qos->prioritylut_low);
__write_register(device, CVP_NOC_CDM_PRIORITYLUT_HIGH,
pdata->noc_qos->prioritylut_high);
__write_register(device, CVP_NOC_CDM_URGENCY_LOW,
pdata->noc_qos->urgency_low);
__write_register(device, CVP_NOC_CDM_DANGERLUT_LOW,
pdata->noc_qos->dangerlut_low);
__write_register(device, CVP_NOC_CDM_SAFELUT_LOW,
pdata->noc_qos->safelut_low);
/* Below registers write moved from FW to SW to enable UBWC */
__write_register(device, CVP_NOC_RGE_NIU_DECCTL_LOW,
0x1);
__write_register(device, CVP_NOC_RGE_NIU_ENCCTL_LOW,
0x1);
__write_register(device, CVP_NOC_GCE_VADL_TOF_NIU_DECCTL_LOW,
0x1);
__write_register(device, CVP_NOC_GCE_VADL_TOF_NIU_ENCCTL_LOW,
0x1);
__write_register(device, CVP_NOC_CORE_ERR_MAINCTL_LOW_OFFS,
0x3);
__write_register(device, CVP_NOC_MAIN_SIDEBANDMANAGER_FAULTINEN0_LOW,
0x1);
call_iris_op(device, reset_control_release_name, device, "cvp_xo_reset");
return 0;
}
/*
* The existence of this function is a hack for 8996 (or certain Iris versions)
* to overcome a hardware bug. Whenever the GDSCs momentarily power collapse
* (after calling __hand_off_regulators()), the values of the threshold
* registers (typically programmed by TZ) are incorrectly reset. As a result
* reprogram these registers at certain agreed upon points.
*/
static void __set_threshold_registers(struct iris_hfi_device *device)
{
u32 version = __read_register(device, CVP_WRAPPER_HW_VERSION);
version &= ~GENMASK(15, 0);
if (version != (0x3 << 28 | 0x43 << 16))
return;
if (__tzbsp_set_cvp_state(TZ_SUBSYS_STATE_RESTORE_THRESHOLD))
dprintk(CVP_ERR, "Failed to restore threshold values\n");
}
static int __unvote_buses(struct iris_hfi_device *device)
{
int rc = 0;
struct bus_info *bus = NULL;
kfree(device->bus_vote.data);
device->bus_vote.data = NULL;
device->bus_vote.data_count = 0;
iris_hfi_for_each_bus(device, bus) {
rc = msm_cvp_set_bw(bus, 0);
if (rc) {
dprintk(CVP_ERR,
"%s: Failed unvoting bus\n", __func__);
goto err_unknown_device;
}
}
err_unknown_device:
return rc;
}
static int __vote_buses(struct iris_hfi_device *device,
struct cvp_bus_vote_data *data, int num_data)
{
int rc = 0;
struct bus_info *bus = NULL;
struct cvp_bus_vote_data *new_data = NULL;
if (!num_data) {
dprintk(CVP_PWR, "No vote data available\n");
goto no_data_count;
} else if (!data) {
dprintk(CVP_ERR, "Invalid voting data\n");
return -EINVAL;
}
new_data = kmemdup(data, num_data * sizeof(*new_data), GFP_KERNEL);
if (!new_data) {
dprintk(CVP_ERR, "Can't alloc memory to cache bus votes\n");
rc = -ENOMEM;
goto err_no_mem;
}
no_data_count:
kfree(device->bus_vote.data);
device->bus_vote.data = new_data;
device->bus_vote.data_count = num_data;
iris_hfi_for_each_bus(device, bus) {
if (bus) {
rc = msm_cvp_set_bw(bus, bus->range[1]);
if (rc)
dprintk(CVP_ERR,
"Failed voting bus %s to ab %u\n",
bus->name, bus->range[1]*1000);
}
}
err_no_mem:
return rc;
}
static int iris_hfi_vote_buses(void *dev, struct cvp_bus_vote_data *d, int n)
{
int rc = 0;
struct iris_hfi_device *device = dev;
if (!device)
return -EINVAL;
mutex_lock(&device->lock);
rc = __vote_buses(device, d, n);
mutex_unlock(&device->lock);
return rc;
}
static int __core_set_resource(struct iris_hfi_device *device,
struct cvp_resource_hdr *resource_hdr, void *resource_value)
{
struct cvp_hfi_cmd_sys_set_resource_packet *pkt;
u8 packet[CVP_IFACEQ_VAR_SMALL_PKT_SIZE];
int rc = 0;
if (!device || !resource_hdr || !resource_value) {
dprintk(CVP_ERR, "set_res: Invalid Params\n");
return -EINVAL;
}
pkt = (struct cvp_hfi_cmd_sys_set_resource_packet *) packet;
rc = call_hfi_pkt_op(device, sys_set_resource,
pkt, resource_hdr, resource_value);
if (rc) {
dprintk(CVP_ERR, "set_res: failed to create packet\n");
goto err_create_pkt;
}
rc = __iface_cmdq_write(device, pkt);
if (rc)
rc = -ENOTEMPTY;
err_create_pkt:
return rc;
}
static int __core_release_resource(struct iris_hfi_device *device,
struct cvp_resource_hdr *resource_hdr)
{
struct cvp_hfi_cmd_sys_release_resource_packet *pkt;
u8 packet[CVP_IFACEQ_VAR_SMALL_PKT_SIZE];
int rc = 0;
if (!device || !resource_hdr) {
dprintk(CVP_ERR, "release_res: Invalid Params\n");
return -EINVAL;
}
pkt = (struct cvp_hfi_cmd_sys_release_resource_packet *) packet;
rc = call_hfi_pkt_op(device, sys_release_resource,
pkt, resource_hdr);
if (rc) {
dprintk(CVP_ERR, "release_res: failed to create packet\n");
goto err_create_pkt;
}
rc = __iface_cmdq_write(device, pkt);
if (rc)
rc = -ENOTEMPTY;
err_create_pkt:
return rc;
}
static int __tzbsp_set_cvp_state(enum tzbsp_subsys_state state)
{
int rc = 0;
rc = qcom_scm_set_remote_state(state, TZBSP_CVP_PAS_ID);
dprintk(CVP_CORE, "Set state %d, resp %d\n", state, rc);
if (rc) {
dprintk(CVP_ERR, "Failed qcom_scm_set_remote_state %d\n", rc);
return rc;
}
return 0;
}
/*
* Based on fal10_veto, X2RPMh, core_pwr_on and PWAitMode value, infer
* value of xtss_sw_reset. xtss_sw_reset is a TZ register bit. Driver
* cannot access it directly.
*
* In __boot_firmware() function, the caller of this function. It checks
* "core_pwr_on" == false, basically core powered off. So this function
* doesn't check core_pwr_on. Assume core_pwr_on = false.
*
* fal10_veto = VPU_CPU_CS_X2RPMh[2] |
* ( ~VPU_CPU_CS_X2RPMh[1] & core_pwr_on ) |
* ( ~VPU_CPU_CS_X2RPMh[0] & ~( xtss_sw_reset | PWaitMode ) ) ;
*/
static inline void check_tensilica_in_reset(struct iris_hfi_device *device)
{
u32 X2RPMh, fal10_veto, wait_mode;
X2RPMh = __read_register(device, CVP_CPU_CS_X2RPMh);
X2RPMh = X2RPMh & 0x7;
/* wait_mode = 1: Tensilica is in WFI mode (PWaitMode = true) */
wait_mode = __read_register(device, CVP_WRAPPER_CPU_STATUS);
wait_mode = wait_mode & 0x1;
fal10_veto = __read_register(device, CVP_CPU_CS_X2RPMh_STATUS);
fal10_veto = fal10_veto & 0x1;
dprintk(CVP_WARN, "tensilica reset check %#x %#x %#x\n",
X2RPMh, wait_mode, fal10_veto);
}
static const char boot_states[0x40][32] = {
"NOT INIT",
"RST_START",
"INIT_MEMCTL",
"INTENABLE_RST",
"LITBASE_RST",
"PREFETCH_EN",
"MPU_INIT",
"CTRL_INIT_READ",
"MEMCTL_L1_FIX",
"RESTORE_EXTRA_NW",
"CORE_RESTORE",
"COLD_BOOT",
"DISABLE_CACHE",
"BEFORE_MPU_C",
"RET_MPU_C",
"IN_MPU_C",
"IN_MPU_DEFAULT",
"IN_MPU_SYNX",
"UCR_SIZE_FAIL",
"UCR_ADDR_FAIL",
"UCR1_SIZE_FAIL",
"UCR1_ADDR_FAIL",
"UCR_OVERLAPPED_UCR1",
"UCR1_OVERLAPPED_UCR",
"UCR_EQ_UCR1",
"MPU_CHECK_DONE",
"BEFORE_INT_LOCK",
"AFTER_INT_LOCK",
"BEFORE_INT_UNLOCK",
"AFTER_INT_UNLOCK",
"CALL_START",
"MAIN_ENTRY",
"VENUS_INIT_ENTRY",
"VSYS_INIT_ENTRY",
"BEFORE_XOS_CLK",
"AFTER_XOS_CLK",
"LOG_MUTEX_INIT",
"CREATE_FRAMEWORK_ENTRY",
"DTG_INIT",
"IDLE_TASK_INIT",
"VENUS_CORE_INIT",
"HW_CORES_INIT",
"RST_THREAD_INIT",
"HOST_THREAD_INIT",
"ALL_THREADS_INIT",
"TASK_MEMPOOL",
"SESSION_MUTEX",
"SIGNALS_INIT",
"RST_SIGNAL_INIT",
"INTR_EN_HOST",
"INTR_REG_HOST",
"INTR_EN_DSP",
"INTR_REG_DSP",
"X2HSOFTINTEN",
"H2XSOFTINTEN",
"CPU2DSPINTEN",
"DSP2CPUINT_SWRESET",
"THREADS_START",
"RST_THREAD_START",
"HST_THREAD_START",
"HST_THREAD_ENTRY"
};
static inline int __boot_firmware(struct iris_hfi_device *device)
{
int rc = 0, loop = 10;
u32 ctrl_init_val = 0, ctrl_status = 0, count = 0, max_tries = 500;
u32 reg_gdsc;
/*
* Hand off control of regulators to h/w _after_ enabling clocks.
* Note that the GDSC will turn off when switching from normal
* (s/w triggered) to fast (HW triggered) unless the h/w vote is
* present. Since Iris isn't up yet, the GDSC will be off briefly.
*/
if (__enable_hw_power_collapse(device))
dprintk(CVP_ERR, "Failed to enabled inter-frame PC\n");
if (!msm_cvp_fw_low_power_mode)
goto skip_core_power_check;
while (loop) {
reg_gdsc = __read_register(device, CVP_CC_MVS1_GDSCR);
if (reg_gdsc & 0x80000000) {
usleep_range(100, 200);
loop--;
} else {
break;
}
}
if (!loop)
dprintk(CVP_ERR, "fail to power off CORE during resume\n");
skip_core_power_check:
ctrl_init_val = BIT(0);
/* RUMI: CVP_CTRL_INIT in MPTest has bit 0 and 3 set */
__write_register(device, CVP_CTRL_INIT, ctrl_init_val);
while (!(ctrl_status & CVP_CTRL_INIT_STATUS__M) && count < max_tries) {
ctrl_status = __read_register(device, CVP_CTRL_STATUS);
if ((ctrl_status & CVP_CTRL_ERROR_STATUS__M) == 0x4) {
dprintk(CVP_ERR, "invalid setting for UC_REGION\n");
rc = -ENODATA;
break;
}
/* Reduce to 500, 1000 on silicon */
usleep_range(500, 1000);
count++;
}
if (!(ctrl_status & CVP_CTRL_INIT_STATUS__M)) {
ctrl_init_val = __read_register(device, CVP_CTRL_INIT);
dprintk(CVP_ERR,
"Failed to boot FW status: %x %x %s\n",
ctrl_status, ctrl_init_val,
boot_states[(ctrl_status >> 9) & 0x3f]);
check_tensilica_in_reset(device);
rc = -ENODEV;
}
/* Enable interrupt before sending commands to tensilica */
__write_register(device, CVP_CPU_CS_H2XSOFTINTEN, 0x1);
__write_register(device, CVP_CPU_CS_X2RPMh, 0x0);
return rc;
}
static int iris_hfi_resume(void *dev)
{
int rc = 0;
struct iris_hfi_device *device = (struct iris_hfi_device *) dev;
if (!device) {
dprintk(CVP_ERR, "%s invalid device\n", __func__);
return -EINVAL;
}
dprintk(CVP_CORE, "Resuming Iris\n");
mutex_lock(&device->lock);
rc = __resume(device);
mutex_unlock(&device->lock);
return rc;
}
static int iris_hfi_suspend(void *dev)
{
int rc = 0;
struct iris_hfi_device *device = (struct iris_hfi_device *) dev;
if (!device) {
dprintk(CVP_ERR, "%s invalid device\n", __func__);
return -EINVAL;
} else if (!device->res->sw_power_collapsible) {
return -ENOTSUPP;
}
dprintk(CVP_CORE, "Suspending Iris\n");
mutex_lock(&device->lock);
rc = __power_collapse(device, true);
if (rc) {
dprintk(CVP_WARN, "%s: Iris is busy\n", __func__);
rc = -EBUSY;
}
mutex_unlock(&device->lock);
/* Cancel pending delayed works if any */
if (!rc)
cancel_delayed_work(&iris_hfi_pm_work);
return rc;
}
static void cvp_dump_csr(struct iris_hfi_device *dev)
{
u32 reg;
if (!dev)
return;
if (!dev->power_enabled || dev->reg_dumped)
return;
reg = __read_register(dev, CVP_WRAPPER_CPU_STATUS);
dprintk(CVP_ERR, "CVP_WRAPPER_CPU_STATUS: %x\n", reg);
reg = __read_register(dev, CVP_CPU_CS_SCIACMDARG0);
dprintk(CVP_ERR, "CVP_CPU_CS_SCIACMDARG0: %x\n", reg);
reg = __read_register(dev, CVP_WRAPPER_INTR_STATUS);
dprintk(CVP_ERR, "CVP_WRAPPER_INTR_STATUS: %x\n", reg);
reg = __read_register(dev, CVP_CPU_CS_H2ASOFTINT);
dprintk(CVP_ERR, "CVP_CPU_CS_H2ASOFTINT: %x\n", reg);
reg = __read_register(dev, CVP_CPU_CS_A2HSOFTINT);
dprintk(CVP_ERR, "CVP_CPU_CS_A2HSOFTINT: %x\n", reg);
reg = __read_register(dev, CVP_CC_MVS1C_GDSCR);
dprintk(CVP_ERR, "CVP_CC_MVS1C_GDSCR: %x\n", reg);
reg = __read_register(dev, CVP_CC_MVS1C_CBCR);
dprintk(CVP_ERR, "CVP_CC_MVS1C_CBCR: %x\n", reg);
reg = __read_register(dev, CVP_WRAPPER_CPU_CLOCK_CONFIG);
dprintk(CVP_ERR, "CVP_WRAPPER_CPU_CLOCK_CONFIG: %x\n", reg);
reg = __read_register(dev, CVP_WRAPPER_CORE_CLOCK_CONFIG);
dprintk(CVP_ERR, "CVP_WRAPPER_CORE_CLOCK_CONFIG: %x\n", reg);
dev->reg_dumped = true;
}
static int iris_hfi_flush_debug_queue(void *dev)
{
int rc = 0;
struct iris_hfi_device *device = (struct iris_hfi_device *) dev;
if (!device) {
dprintk(CVP_ERR, "%s invalid device\n", __func__);
return -EINVAL;
}
mutex_lock(&device->lock);
if (!device->power_enabled) {
dprintk(CVP_WARN, "%s: iris power off\n", __func__);
rc = -EINVAL;
goto exit;
}
cvp_dump_csr(device);
__flush_debug_queue(device, NULL);
exit:
mutex_unlock(&device->lock);
return rc;
}
static int iris_hfi_scale_clocks(void *dev, u32 freq)
{
int rc = 0;
struct iris_hfi_device *device = dev;
if (!device) {
dprintk(CVP_ERR, "Invalid args: %pK\n", device);
return -EINVAL;
}
mutex_lock(&device->lock);
if (__resume(device)) {
dprintk(CVP_ERR, "Resume from power collapse failed\n");
rc = -ENODEV;
goto exit;
}
rc = msm_cvp_set_clocks_impl(device, freq);
exit:
mutex_unlock(&device->lock);
return rc;
}
/* Writes into cmdq without raising an interrupt */
static int __iface_cmdq_write_relaxed(struct iris_hfi_device *device,
void *pkt, bool *requires_interrupt)
{
struct cvp_iface_q_info *q_info;
struct cvp_hal_cmd_pkt_hdr *cmd_packet;
int result = -E2BIG;
if (!device || !pkt) {
dprintk(CVP_ERR, "Invalid Params\n");
return -EINVAL;
}
__strict_check(device);
if (!__core_in_valid_state(device)) {
dprintk(CVP_ERR, "%s - fw not in init state\n", __func__);
result = -EINVAL;
goto err_q_null;
}
cmd_packet = (struct cvp_hal_cmd_pkt_hdr *)pkt;
device->last_packet_type = cmd_packet->packet_type;
q_info = &device->iface_queues[CVP_IFACEQ_CMDQ_IDX];
if (!q_info) {
dprintk(CVP_ERR, "cannot write to shared Q's\n");
goto err_q_null;
}
if (!q_info->q_array.align_virtual_addr) {
dprintk(CVP_ERR, "cannot write to shared CMD Q's\n");
result = -ENODATA;
goto err_q_null;
}
if (__resume(device)) {
dprintk(CVP_ERR, "%s: Power on failed\n", __func__);
goto err_q_write;
}
if (!__write_queue(q_info, (u8 *)pkt, requires_interrupt)) {
if (device->res->sw_power_collapsible) {
cancel_delayed_work(&iris_hfi_pm_work);
if (!queue_delayed_work(device->iris_pm_workq,
&iris_hfi_pm_work,
msecs_to_jiffies(
device->res->msm_cvp_pwr_collapse_delay))) {
dprintk(CVP_PWR,
"PM work already scheduled\n");
}
}
result = 0;
} else {
dprintk(CVP_ERR, "__iface_cmdq_write: queue full\n");
}
err_q_write:
err_q_null:
return result;
}
static int __iface_cmdq_write(struct iris_hfi_device *device, void *pkt)
{
bool needs_interrupt = false;
int rc = __iface_cmdq_write_relaxed(device, pkt, &needs_interrupt);
if (!rc && needs_interrupt) {
/* Consumer of cmdq prefers that we raise an interrupt */
rc = 0;
__write_register(device, CVP_CPU_CS_H2ASOFTINT, 1);
}
return rc;
}
static int __iface_msgq_read(struct iris_hfi_device *device, void *pkt)
{
u32 tx_req_is_set = 0;
int rc = 0;
struct cvp_iface_q_info *q_info;
if (!pkt) {
dprintk(CVP_ERR, "Invalid Params\n");
return -EINVAL;
}
__strict_check(device);
if (!__core_in_valid_state(device)) {
dprintk(CVP_WARN, "%s - fw not in init state\n", __func__);
rc = -EINVAL;
goto read_error_null;
}
q_info = &device->iface_queues[CVP_IFACEQ_MSGQ_IDX];
if (q_info->q_array.align_virtual_addr == NULL) {
dprintk(CVP_ERR, "cannot read from shared MSG Q's\n");
rc = -ENODATA;
goto read_error_null;
}
if (!__read_queue(q_info, (u8 *)pkt, &tx_req_is_set)) {
if (tx_req_is_set)
__write_register(device, CVP_CPU_CS_H2ASOFTINT, 1);
rc = 0;
} else
rc = -ENODATA;
read_error_null:
return rc;
}
static int __iface_dbgq_read(struct iris_hfi_device *device, void *pkt)
{
u32 tx_req_is_set = 0;
int rc = 0;
struct cvp_iface_q_info *q_info;
if (!pkt) {
dprintk(CVP_ERR, "Invalid Params\n");
return -EINVAL;
}
__strict_check(device);
q_info = &device->iface_queues[CVP_IFACEQ_DBGQ_IDX];
if (q_info->q_array.align_virtual_addr == NULL) {
dprintk(CVP_ERR, "cannot read from shared DBG Q's\n");
rc = -ENODATA;
goto dbg_error_null;
}
if (!__read_queue(q_info, (u8 *)pkt, &tx_req_is_set)) {
if (tx_req_is_set)
__write_register(device, CVP_CPU_CS_H2ASOFTINT, 1);
rc = 0;
} else
rc = -ENODATA;
dbg_error_null:
return rc;
}
static void __set_queue_hdr_defaults(struct cvp_hfi_queue_header *q_hdr)
{
q_hdr->qhdr_status = 0x1;
q_hdr->qhdr_type = CVP_IFACEQ_DFLT_QHDR;
q_hdr->qhdr_q_size = CVP_IFACEQ_QUEUE_SIZE / 4;
q_hdr->qhdr_pkt_size = 0;
q_hdr->qhdr_rx_wm = 0x1;
q_hdr->qhdr_tx_wm = 0x1;
q_hdr->qhdr_rx_req = 0x1;
q_hdr->qhdr_tx_req = 0x0;
q_hdr->qhdr_rx_irq_status = 0x0;
q_hdr->qhdr_tx_irq_status = 0x0;
q_hdr->qhdr_read_idx = 0x0;
q_hdr->qhdr_write_idx = 0x0;
}
/*
*Unused, keep for reference
*/
/*
static void __interface_dsp_queues_release(struct iris_hfi_device *device)
{
int i;
struct msm_cvp_smem *mem_data = &device->dsp_iface_q_table.mem_data;
struct context_bank_info *cb = mem_data->mapping_info.cb_info;
if (!device->dsp_iface_q_table.align_virtual_addr) {
dprintk(CVP_ERR, "%s: already released\n", __func__);
return;
}
dma_unmap_single_attrs(cb->dev, mem_data->device_addr,
mem_data->size, DMA_BIDIRECTIONAL, 0);
dma_free_coherent(device->res->mem_cdsp.dev, mem_data->size,
mem_data->kvaddr, mem_data->dma_handle);
for (i = 0; i < CVP_IFACEQ_NUMQ; i++) {
device->dsp_iface_queues[i].q_hdr = NULL;
device->dsp_iface_queues[i].q_array.align_virtual_addr = NULL;
device->dsp_iface_queues[i].q_array.align_device_addr = 0;
}
device->dsp_iface_q_table.align_virtual_addr = NULL;
device->dsp_iface_q_table.align_device_addr = 0;
}
*/
static int __interface_dsp_queues_init(struct iris_hfi_device *dev)
{
int rc = 0;
u32 i;
struct cvp_iface_q_info *iface_q;
int offset = 0;
phys_addr_t fw_bias = 0;
size_t q_size;
struct msm_cvp_smem *mem_data;
void *kvaddr;
dma_addr_t dma_handle;
dma_addr_t iova;
struct context_bank_info *cb;
q_size = ALIGN(QUEUE_SIZE, SZ_1M);
mem_data = &dev->dsp_iface_q_table.mem_data;
if (mem_data->kvaddr) {
memset((void *)mem_data->kvaddr, 0, q_size);
cvp_dsp_init_hfi_queue_hdr(dev);
return 0;
}
/* Allocate dsp queues from CDSP device memory */
kvaddr = dma_alloc_coherent(dev->res->mem_cdsp.dev, q_size,
&dma_handle, GFP_KERNEL);
if (IS_ERR_OR_NULL(kvaddr)) {
dprintk(CVP_ERR, "%s: failed dma allocation\n", __func__);
goto fail_dma_alloc;
}
cb = msm_cvp_smem_get_context_bank(dev->res, 0);
if (!cb) {
dprintk(CVP_ERR,
"%s: failed to get context bank\n", __func__);
goto fail_dma_map;
}
iova = dma_map_single_attrs(cb->dev, phys_to_virt(dma_handle),
q_size, DMA_BIDIRECTIONAL, 0);
if (dma_mapping_error(cb->dev, iova)) {
dprintk(CVP_ERR, "%s: failed dma mapping\n", __func__);
goto fail_dma_map;
}
dprintk(CVP_DSP,
"%s: kvaddr %pK dma_handle %#llx iova %#llx size %zd\n",
__func__, kvaddr, dma_handle, iova, q_size);
memset(mem_data, 0, sizeof(struct msm_cvp_smem));
mem_data->kvaddr = kvaddr;
mem_data->device_addr = iova;
mem_data->dma_handle = dma_handle;
mem_data->size = q_size;
mem_data->mapping_info.cb_info = cb;
if (!is_iommu_present(dev->res))
fw_bias = dev->cvp_hal_data->firmware_base;
dev->dsp_iface_q_table.align_virtual_addr = kvaddr;
dev->dsp_iface_q_table.align_device_addr = iova - fw_bias;
dev->dsp_iface_q_table.mem_size = CVP_IFACEQ_TABLE_SIZE;
offset = dev->dsp_iface_q_table.mem_size;
for (i = 0; i < CVP_IFACEQ_NUMQ; i++) {
iface_q = &dev->dsp_iface_queues[i];
iface_q->q_array.align_device_addr = iova + offset - fw_bias;
iface_q->q_array.align_virtual_addr = kvaddr + offset;
iface_q->q_array.mem_size = CVP_IFACEQ_QUEUE_SIZE;
offset += iface_q->q_array.mem_size;
spin_lock_init(&iface_q->hfi_lock);
}
cvp_dsp_init_hfi_queue_hdr(dev);
return rc;
fail_dma_map:
dma_free_coherent(dev->res->mem_cdsp.dev, q_size, kvaddr, dma_handle);
fail_dma_alloc:
return -ENOMEM;
}
static void __interface_queues_release(struct iris_hfi_device *device)
{
#ifdef CONFIG_EVA_TVM
int i;
struct cvp_hfi_mem_map_table *qdss;
struct cvp_hfi_mem_map *mem_map;
int num_entries = device->res->qdss_addr_set.count;
unsigned long mem_map_table_base_addr;
struct context_bank_info *cb;
if (device->qdss.align_virtual_addr) {
qdss = (struct cvp_hfi_mem_map_table *)
device->qdss.align_virtual_addr;
qdss->mem_map_num_entries = num_entries;
mem_map_table_base_addr =
device->qdss.align_device_addr +
sizeof(struct cvp_hfi_mem_map_table);
qdss->mem_map_table_base_addr =
(u32)mem_map_table_base_addr;
if ((unsigned long)qdss->mem_map_table_base_addr !=
mem_map_table_base_addr) {
dprintk(CVP_ERR,
"Invalid mem_map_table_base_addr %#lx",
mem_map_table_base_addr);
}
mem_map = (struct cvp_hfi_mem_map *)(qdss + 1);
cb = msm_cvp_smem_get_context_bank(device->res, 0);
for (i = 0; cb && i < num_entries; i++) {
iommu_unmap(cb->domain,
mem_map[i].virtual_addr,
mem_map[i].size);
}
__smem_free(device, &device->qdss.mem_data);
}
__smem_free(device, &device->iface_q_table.mem_data);
__smem_free(device, &device->sfr.mem_data);
for (i = 0; i < CVP_IFACEQ_NUMQ; i++) {
device->iface_queues[i].q_hdr = NULL;
device->iface_queues[i].q_array.align_virtual_addr = NULL;
device->iface_queues[i].q_array.align_device_addr = 0;
}
device->iface_q_table.align_virtual_addr = NULL;
device->iface_q_table.align_device_addr = 0;
device->qdss.align_virtual_addr = NULL;
device->qdss.align_device_addr = 0;
device->sfr.align_virtual_addr = NULL;
device->sfr.align_device_addr = 0;
device->mem_addr.align_virtual_addr = NULL;
device->mem_addr.align_device_addr = 0;
#endif
}
static int __get_qdss_iommu_virtual_addr(struct iris_hfi_device *dev,
struct cvp_hfi_mem_map *mem_map,
struct iommu_domain *domain)
{
int i;
int rc = 0;
dma_addr_t iova = QDSS_IOVA_START;
int num_entries = dev->res->qdss_addr_set.count;
struct addr_range *qdss_addr_tbl = dev->res->qdss_addr_set.addr_tbl;
if (!num_entries)
return -ENODATA;
for (i = 0; i < num_entries; i++) {
if (domain) {
rc = iommu_map(domain, iova,
qdss_addr_tbl[i].start,
qdss_addr_tbl[i].size,
IOMMU_READ | IOMMU_WRITE);
if (rc) {
dprintk(CVP_ERR,
"IOMMU QDSS mapping failed for addr %#x\n",
qdss_addr_tbl[i].start);
rc = -ENOMEM;
break;
}
} else {
iova = qdss_addr_tbl[i].start;
}
mem_map[i].virtual_addr = (u32)iova;
mem_map[i].physical_addr = qdss_addr_tbl[i].start;
mem_map[i].size = qdss_addr_tbl[i].size;
mem_map[i].attr = 0x0;
iova += mem_map[i].size;
}
if (i < num_entries) {
dprintk(CVP_ERR,
"QDSS mapping failed, Freeing other entries %d\n", i);
for (--i; domain && i >= 0; i--) {
iommu_unmap(domain,
mem_map[i].virtual_addr,
mem_map[i].size);
}
}
return rc;
}
static void __setup_ucregion_memory_map(struct iris_hfi_device *device)
{
__write_register(device, CVP_UC_REGION_ADDR,
(u32)device->iface_q_table.align_device_addr);
__write_register(device, CVP_UC_REGION_SIZE, SHARED_QSIZE);
__write_register(device, CVP_QTBL_ADDR,
(u32)device->iface_q_table.align_device_addr);
__write_register(device, CVP_QTBL_INFO, 0x01);
if (device->sfr.align_device_addr)
__write_register(device, CVP_SFR_ADDR,
(u32)device->sfr.align_device_addr);
if (device->qdss.align_device_addr)
__write_register(device, CVP_MMAP_ADDR,
(u32)device->qdss.align_device_addr);
call_iris_op(device, setup_dsp_uc_memmap, device);
}
static void __hfi_queue_init(struct iris_hfi_device *dev)
{
int i, offset = 0;
struct cvp_hfi_queue_table_header *q_tbl_hdr;
struct cvp_iface_q_info *iface_q;
struct cvp_hfi_queue_header *q_hdr;
if (!dev)
return;
offset += dev->iface_q_table.mem_size;
for (i = 0; i < CVP_IFACEQ_NUMQ; i++) {
iface_q = &dev->iface_queues[i];
iface_q->q_array.align_device_addr =
dev->iface_q_table.align_device_addr + offset;
iface_q->q_array.align_virtual_addr =
dev->iface_q_table.align_virtual_addr + offset;
iface_q->q_array.mem_size = CVP_IFACEQ_QUEUE_SIZE;
offset += iface_q->q_array.mem_size;
iface_q->q_hdr = CVP_IFACEQ_GET_QHDR_START_ADDR(
dev->iface_q_table.align_virtual_addr, i);
__set_queue_hdr_defaults(iface_q->q_hdr);
spin_lock_init(&iface_q->hfi_lock);
}
q_tbl_hdr = (struct cvp_hfi_queue_table_header *)
dev->iface_q_table.align_virtual_addr;
q_tbl_hdr->qtbl_version = 0;
q_tbl_hdr->device_addr = (void *)dev;
strlcpy(q_tbl_hdr->name, "msm_cvp", sizeof(q_tbl_hdr->name));
q_tbl_hdr->qtbl_size = CVP_IFACEQ_TABLE_SIZE;
q_tbl_hdr->qtbl_qhdr0_offset =
sizeof(struct cvp_hfi_queue_table_header);
q_tbl_hdr->qtbl_qhdr_size = sizeof(struct cvp_hfi_queue_header);
q_tbl_hdr->qtbl_num_q = CVP_IFACEQ_NUMQ;
q_tbl_hdr->qtbl_num_active_q = CVP_IFACEQ_NUMQ;
iface_q = &dev->iface_queues[CVP_IFACEQ_CMDQ_IDX];
q_hdr = iface_q->q_hdr;
q_hdr->qhdr_start_addr = iface_q->q_array.align_device_addr;
q_hdr->qhdr_type |= HFI_Q_ID_HOST_TO_CTRL_CMD_Q;
iface_q = &dev->iface_queues[CVP_IFACEQ_MSGQ_IDX];
q_hdr = iface_q->q_hdr;
q_hdr->qhdr_start_addr = iface_q->q_array.align_device_addr;
q_hdr->qhdr_type |= HFI_Q_ID_CTRL_TO_HOST_MSG_Q;
iface_q = &dev->iface_queues[CVP_IFACEQ_DBGQ_IDX];
q_hdr = iface_q->q_hdr;
q_hdr->qhdr_start_addr = iface_q->q_array.align_device_addr;
q_hdr->qhdr_type |= HFI_Q_ID_CTRL_TO_HOST_DEBUG_Q;
/*
* Set receive request to zero on debug queue as there is no
* need of interrupt from cvp hardware for debug messages
*/
q_hdr->qhdr_rx_req = 0;
}
static void __sfr_init(struct iris_hfi_device *dev)
{
struct cvp_hfi_sfr_struct *vsfr;
if (!dev)
return;
vsfr = (struct cvp_hfi_sfr_struct *) dev->sfr.align_virtual_addr;
if (vsfr)
vsfr->bufSize = ALIGNED_SFR_SIZE;
}
static int __interface_queues_init(struct iris_hfi_device *dev)
{
int rc = 0;
struct cvp_hfi_mem_map_table *qdss;
struct cvp_hfi_mem_map *mem_map;
struct cvp_mem_addr *mem_addr;
int num_entries = dev->res->qdss_addr_set.count;
phys_addr_t fw_bias = 0;
size_t q_size;
unsigned long mem_map_table_base_addr;
struct context_bank_info *cb;
q_size = SHARED_QSIZE - ALIGNED_SFR_SIZE - ALIGNED_QDSS_SIZE;
mem_addr = &dev->mem_addr;
if (!is_iommu_present(dev->res))
fw_bias = dev->cvp_hal_data->firmware_base;
if (dev->iface_q_table.align_virtual_addr) {
memset((void *)dev->iface_q_table.align_virtual_addr,
0, q_size);
goto hfi_queue_init;
}
rc = __smem_alloc(dev, mem_addr, q_size, 1, SMEM_UNCACHED);
if (rc) {
dprintk(CVP_ERR, "iface_q_table_alloc_fail\n");
goto fail_alloc_queue;
}
dev->iface_q_table.align_virtual_addr = mem_addr->align_virtual_addr;
dev->iface_q_table.align_device_addr = mem_addr->align_device_addr -
fw_bias;
dev->iface_q_table.mem_size = CVP_IFACEQ_TABLE_SIZE;
dev->iface_q_table.mem_data = mem_addr->mem_data;
hfi_queue_init:
__hfi_queue_init(dev);
if (dev->sfr.align_virtual_addr) {
memset((void *)dev->sfr.align_virtual_addr,
0, ALIGNED_SFR_SIZE);
goto sfr_init;
}
rc = __smem_alloc(dev, mem_addr, ALIGNED_SFR_SIZE, 1, SMEM_UNCACHED);
if (rc) {
dprintk(CVP_WARN, "sfr_alloc_fail: SFR not will work\n");
dev->sfr.align_device_addr = 0;
} else {
dev->sfr.align_device_addr = mem_addr->align_device_addr -
fw_bias;
dev->sfr.align_virtual_addr = mem_addr->align_virtual_addr;
dev->sfr.mem_size = ALIGNED_SFR_SIZE;
dev->sfr.mem_data = mem_addr->mem_data;
}
sfr_init:
__sfr_init(dev);
if (dev->qdss.align_virtual_addr)
goto dsp_hfi_queue_init;
if ((msm_cvp_fw_debug_mode & HFI_DEBUG_MODE_QDSS) && num_entries) {
rc = __smem_alloc(dev, mem_addr, ALIGNED_QDSS_SIZE, 1,
SMEM_UNCACHED);
if (rc) {
dprintk(CVP_WARN,
"qdss_alloc_fail: QDSS messages logging will not work\n");
dev->qdss.align_device_addr = 0;
} else {
dev->qdss.align_device_addr =
mem_addr->align_device_addr - fw_bias;
dev->qdss.align_virtual_addr =
mem_addr->align_virtual_addr;
dev->qdss.mem_size = ALIGNED_QDSS_SIZE;
dev->qdss.mem_data = mem_addr->mem_data;
}
}
if (dev->qdss.align_virtual_addr) {
qdss =
(struct cvp_hfi_mem_map_table *)dev->qdss.align_virtual_addr;
qdss->mem_map_num_entries = num_entries;
mem_map_table_base_addr = dev->qdss.align_device_addr +
sizeof(struct cvp_hfi_mem_map_table);
qdss->mem_map_table_base_addr = mem_map_table_base_addr;
mem_map = (struct cvp_hfi_mem_map *)(qdss + 1);
cb = msm_cvp_smem_get_context_bank(dev->res, 0);
if (!cb) {
dprintk(CVP_ERR,
"%s: failed to get context bank\n", __func__);
return -EINVAL;
}
rc = __get_qdss_iommu_virtual_addr(dev, mem_map, cb->domain);
if (rc) {
dprintk(CVP_ERR,
"IOMMU mapping failed, Freeing qdss memdata\n");
__smem_free(dev, &dev->qdss.mem_data);
dev->qdss.align_virtual_addr = NULL;
dev->qdss.align_device_addr = 0;
}
}
dsp_hfi_queue_init:
rc = __interface_dsp_queues_init(dev);
if (rc) {
dprintk(CVP_ERR, "dsp_queues_init failed\n");
goto fail_alloc_queue;
}
__setup_ucregion_memory_map(dev);
return 0;
fail_alloc_queue:
return -ENOMEM;
}
static int __sys_set_debug(struct iris_hfi_device *device, u32 debug)
{
u8 packet[CVP_IFACEQ_VAR_SMALL_PKT_SIZE];
int rc = 0;
struct cvp_hfi_cmd_sys_set_property_packet *pkt =
(struct cvp_hfi_cmd_sys_set_property_packet *) &packet;
rc = call_hfi_pkt_op(device, sys_debug_config, pkt, debug);
if (rc) {
dprintk(CVP_WARN,
"Debug mode setting to FW failed\n");
return -ENOTEMPTY;
}
if (__iface_cmdq_write(device, pkt))
return -ENOTEMPTY;
return 0;
}
static int __sys_set_idle_indicator(struct iris_hfi_device *device,
bool enable)
{
u8 packet[CVP_IFACEQ_VAR_SMALL_PKT_SIZE];
int rc = 0;
struct cvp_hfi_cmd_sys_set_property_packet *pkt =
(struct cvp_hfi_cmd_sys_set_property_packet *) &packet;
rc = call_hfi_pkt_op(device, sys_set_idle_indicator, pkt, enable);
if (__iface_cmdq_write(device, pkt))
return -ENOTEMPTY;
return 0;
}
static int __sys_set_coverage(struct iris_hfi_device *device, u32 mode)
{
u8 packet[CVP_IFACEQ_VAR_SMALL_PKT_SIZE];
int rc = 0;
struct cvp_hfi_cmd_sys_set_property_packet *pkt =
(struct cvp_hfi_cmd_sys_set_property_packet *) &packet;
rc = call_hfi_pkt_op(device, sys_coverage_config,
pkt, mode);
if (rc) {
dprintk(CVP_WARN,
"Coverage mode setting to FW failed\n");
return -ENOTEMPTY;
}
if (__iface_cmdq_write(device, pkt)) {
dprintk(CVP_WARN, "Failed to send coverage pkt to f/w\n");
return -ENOTEMPTY;
}
return 0;
}
static int __sys_set_power_control(struct iris_hfi_device *device,
bool enable)
{
struct regulator_info *rinfo;
bool supported = false;
u8 packet[CVP_IFACEQ_VAR_SMALL_PKT_SIZE];
struct cvp_hfi_cmd_sys_set_property_packet *pkt =
(struct cvp_hfi_cmd_sys_set_property_packet *) &packet;
iris_hfi_for_each_regulator(device, rinfo) {
if (rinfo->has_hw_power_collapse) {
supported = true;
break;
}
}
if (!supported)
return 0;
call_hfi_pkt_op(device, sys_power_control, pkt, enable);
if (__iface_cmdq_write(device, pkt))
return -ENOTEMPTY;
return 0;
}
static void cvp_pm_qos_update(struct iris_hfi_device *device, bool vote_on)
{
u32 latency, off_vote_cnt;
int i, err = 0;
spin_lock(&device->res->pm_qos.lock);
off_vote_cnt = device->res->pm_qos.off_vote_cnt;
spin_unlock(&device->res->pm_qos.lock);
if (vote_on && off_vote_cnt)
return;
latency = vote_on ? device->res->pm_qos.latency_us :
PM_QOS_RESUME_LATENCY_DEFAULT_VALUE;
if (device->res->pm_qos.latency_us && device->res->pm_qos.pm_qos_hdls)
for (i = 0; i < device->res->pm_qos.silver_count; i++) {
if (!cpu_possible(device->res->pm_qos.silver_cores[i]))
continue;
err = dev_pm_qos_update_request(
&device->res->pm_qos.pm_qos_hdls[i],
latency);
if (err < 0) {
if (vote_on) {
dprintk(CVP_WARN,
"pm qos on failed %d\n", err);
} else {
dprintk(CVP_WARN,
"pm qos off failed %d\n", err);
}
}
}
}
static int iris_pm_qos_update(void *device)
{
struct iris_hfi_device *dev;
if (!device) {
dprintk(CVP_ERR, "%s Invalid device\n", __func__);
return -ENODEV;
}
dev = device;
mutex_lock(&dev->lock);
cvp_pm_qos_update(dev, true);
mutex_unlock(&dev->lock);
return 0;
}
static int __hwfence_regs_map(struct iris_hfi_device *device)
{
int rc = 0;
struct context_bank_info *cb;
cb = msm_cvp_smem_get_context_bank(device->res, 0);
if (!cb) {
dprintk(CVP_ERR, "%s: fail to get cb\n", __func__);
return -EINVAL;
}
if (device->res->reg_mappings.ipclite_phyaddr != 0) {
rc = iommu_map(cb->domain,
device->res->reg_mappings.ipclite_iova,
device->res->reg_mappings.ipclite_phyaddr,
device->res->reg_mappings.ipclite_size,
IOMMU_READ | IOMMU_WRITE);
if (rc) {
dprintk(CVP_ERR, "map ipclite fail %d %#x %#x %#x\n",
rc, device->res->reg_mappings.ipclite_iova,
device->res->reg_mappings.ipclite_phyaddr,
device->res->reg_mappings.ipclite_size);
return rc;
}
}
if (device->res->reg_mappings.hwmutex_phyaddr != 0) {
rc = iommu_map(cb->domain,
device->res->reg_mappings.hwmutex_iova,
device->res->reg_mappings.hwmutex_phyaddr,
device->res->reg_mappings.hwmutex_size,
IOMMU_MMIO | IOMMU_READ | IOMMU_WRITE);
if (rc) {
dprintk(CVP_ERR, "map hwmutex fail %d %#x %#x %#x\n",
rc, device->res->reg_mappings.hwmutex_iova,
device->res->reg_mappings.hwmutex_phyaddr,
device->res->reg_mappings.hwmutex_size);
return rc;
}
}
if (device->res->reg_mappings.aon_phyaddr != 0) {
rc = iommu_map(cb->domain,
device->res->reg_mappings.aon_iova,
device->res->reg_mappings.aon_phyaddr,
device->res->reg_mappings.aon_size,
IOMMU_MMIO | IOMMU_READ | IOMMU_WRITE);
if (rc) {
dprintk(CVP_ERR, "map aon fail %d %#x %#x %#x\n",
rc, device->res->reg_mappings.aon_iova,
device->res->reg_mappings.aon_phyaddr,
device->res->reg_mappings.aon_size);
return rc;
}
}
if (device->res->reg_mappings.timer_phyaddr != 0) {
rc = iommu_map(cb->domain,
device->res->reg_mappings.timer_iova,
device->res->reg_mappings.timer_phyaddr,
device->res->reg_mappings.timer_size,
IOMMU_MMIO | IOMMU_READ | IOMMU_WRITE);
if (rc) {
dprintk(CVP_ERR, "map timer fail %d %#x %#x %#x\n",
rc, device->res->reg_mappings.timer_iova,
device->res->reg_mappings.timer_phyaddr,
device->res->reg_mappings.timer_size);
return rc;
}
}
return rc;
}
static int __hwfence_regs_unmap(struct iris_hfi_device *device)
{
int rc = 0;
struct context_bank_info *cb;
cb = msm_cvp_smem_get_context_bank(device->res, 0);
if (!cb) {
dprintk(CVP_ERR, "%s: fail to get cb\n", __func__);
return -EINVAL;
}
if (device->res->reg_mappings.ipclite_iova != 0) {
iommu_unmap(cb->domain,
device->res->reg_mappings.ipclite_iova,
device->res->reg_mappings.ipclite_size);
}
if (device->res->reg_mappings.hwmutex_iova != 0) {
iommu_unmap(cb->domain,
device->res->reg_mappings.hwmutex_iova,
device->res->reg_mappings.hwmutex_size);
}
if (device->res->reg_mappings.aon_iova != 0) {
iommu_unmap(cb->domain,
device->res->reg_mappings.aon_iova,
device->res->reg_mappings.aon_size);
}
if (device->res->reg_mappings.timer_iova != 0) {
iommu_unmap(cb->domain,
device->res->reg_mappings.timer_iova,
device->res->reg_mappings.timer_size);
}
return rc;
}
static int iris_hfi_core_init(void *device)
{
int rc = 0;
u32 ipcc_iova;
struct cvp_hfi_cmd_sys_init_packet pkt;
struct cvp_hfi_cmd_sys_get_property_packet version_pkt;
struct iris_hfi_device *dev;
if (!device) {
dprintk(CVP_ERR, "Invalid device\n");
return -ENODEV;
}
dev = device;
dprintk(CVP_CORE, "Core initializing\n");
pm_stay_awake(dev->res->pdev->dev.parent);
mutex_lock(&dev->lock);
dev->bus_vote.data =
kzalloc(sizeof(struct cvp_bus_vote_data), GFP_KERNEL);
if (!dev->bus_vote.data) {
dprintk(CVP_ERR, "Bus vote data memory is not allocated\n");
rc = -ENOMEM;
goto err_no_mem;
}
dev->bus_vote.data_count = 1;
dev->bus_vote.data->power_mode = CVP_POWER_TURBO;
__hwfence_regs_map(dev);
rc = __power_on_init(dev);
if (rc) {
dprintk(CVP_ERR, "Failed to power on init EVA\n");
goto err_load_fw;
}
rc = cvp_synx_recover();
if (rc) {
dprintk(CVP_ERR, "Failed to recover synx\n");
goto err_core_init;
}
/* mmrm registration */
if (msm_cvp_mmrm_enabled) {
rc = msm_cvp_mmrm_register(device);
if (rc) {
dprintk(CVP_ERR, "Failed to register mmrm client\n");
goto err_core_init;
}
}
__set_state(dev, IRIS_STATE_INIT);
dev->reg_dumped = false;
dprintk(CVP_CORE, "Dev_Virt: %pa, Reg_Virt: %pK\n",
&dev->cvp_hal_data->firmware_base,
dev->cvp_hal_data->register_base);
rc = __interface_queues_init(dev);
if (rc) {
dprintk(CVP_ERR, "failed to init queues\n");
rc = -ENOMEM;
goto err_core_init;
}
cvp_register_va_md_region();
// Add node for dev struct
add_va_node_to_list(CVP_QUEUE_DUMP, dev,
sizeof(struct iris_hfi_device),
"iris_hfi_device-dev", false);
add_queue_header_to_va_md_list((void*)dev);
add_hfi_queue_to_va_md_list((void*)dev);
rc = msm_cvp_map_ipcc_regs(&ipcc_iova);
if (!rc) {
dprintk(CVP_CORE, "IPCC iova 0x%x\n", ipcc_iova);
__write_register(dev, CVP_MMAP_ADDR, ipcc_iova);
}
rc = __load_fw(dev);
if (rc) {
dprintk(CVP_ERR, "Failed to load Iris FW\n");
goto err_core_init;
}
rc = __boot_firmware(dev);
if (rc) {
dprintk(CVP_ERR, "Failed to start core\n");
rc = -ENODEV;
goto err_core_init;
}
dev->version = __read_register(dev, CVP_VERSION_INFO);
rc = call_hfi_pkt_op(dev, sys_init, &pkt, 0);
if (rc) {
dprintk(CVP_ERR, "Failed to create sys init pkt\n");
goto err_core_init;
}
if (__iface_cmdq_write(dev, &pkt)) {
rc = -ENOTEMPTY;
goto err_core_init;
}
rc = call_hfi_pkt_op(dev, sys_image_version, &version_pkt);
if (rc || __iface_cmdq_write(dev, &version_pkt))
dprintk(CVP_WARN, "Failed to send image version pkt to f/w\n");
__sys_set_debug(device, msm_cvp_fw_debug);
__enable_subcaches(device);
__set_subcaches(device);
__set_ubwc_config(device);
__sys_set_idle_indicator(device, true);
if (dev->res->pm_qos.latency_us) {
int err = 0;
u32 i, cpu;
dev->res->pm_qos.pm_qos_hdls = kcalloc(
dev->res->pm_qos.silver_count,
sizeof(struct dev_pm_qos_request),
GFP_KERNEL);
if (!dev->res->pm_qos.pm_qos_hdls) {
dprintk(CVP_WARN, "Failed allocate pm_qos_hdls\n");
goto pm_qos_bail;
}
for (i = 0; i < dev->res->pm_qos.silver_count; i++) {
cpu = dev->res->pm_qos.silver_cores[i];
if (!cpu_possible(cpu))
continue;
err = dev_pm_qos_add_request(
get_cpu_device(cpu),
&dev->res->pm_qos.pm_qos_hdls[i],
DEV_PM_QOS_RESUME_LATENCY,
dev->res->pm_qos.latency_us);
if (err < 0)
dprintk(CVP_WARN,
"%s pm_qos_add_req %d failed\n",
__func__, i);
}
}
pm_qos_bail:
mutex_unlock(&dev->lock);
cvp_dsp_send_hfi_queue();
pm_relax(dev->res->pdev->dev.parent);
dprintk(CVP_CORE, "Core inited successfully\n");
return 0;
err_core_init:
__set_state(dev, IRIS_STATE_DEINIT);
__unload_fw(dev);
if (dev->mmrm_cvp)
{
msm_cvp_mmrm_deregister(dev);
}
err_load_fw:
__hwfence_regs_unmap(dev);
err_no_mem:
dprintk(CVP_ERR, "Core init failed\n");
mutex_unlock(&dev->lock);
pm_relax(dev->res->pdev->dev.parent);
return rc;
}
static int iris_hfi_core_release(void *dev)
{
int rc = 0, i;
struct iris_hfi_device *device = dev;
struct cvp_hal_session *session, *next;
struct dev_pm_qos_request *qos_hdl;
u32 ipcc_iova;
if (!device) {
dprintk(CVP_ERR, "invalid device\n");
return -ENODEV;
}
mutex_lock(&device->lock);
dprintk(CVP_WARN, "Core releasing\n");
if (device->res->pm_qos.latency_us &&
device->res->pm_qos.pm_qos_hdls) {
for (i = 0; i < device->res->pm_qos.silver_count; i++) {
if (!cpu_possible(device->res->pm_qos.silver_cores[i]))
continue;
qos_hdl = &device->res->pm_qos.pm_qos_hdls[i];
if ((qos_hdl != NULL) && dev_pm_qos_request_active(qos_hdl))
dev_pm_qos_remove_request(qos_hdl);
}
kfree(device->res->pm_qos.pm_qos_hdls);
device->res->pm_qos.pm_qos_hdls = NULL;
}
__resume(device);
__set_state(device, IRIS_STATE_DEINIT);
rc = __tzbsp_set_cvp_state(TZ_SUBSYS_STATE_SUSPEND);
if (rc)
dprintk(CVP_WARN, "Failed to suspend cvp FW%d\n", rc);
__dsp_shutdown(device);
__disable_subcaches(device);
ipcc_iova = __read_register(device, CVP_MMAP_ADDR);
msm_cvp_unmap_ipcc_regs(ipcc_iova);
__unload_fw(device);
__hwfence_regs_unmap(device);
if (msm_cvp_mmrm_enabled) {
rc = msm_cvp_mmrm_deregister(device);
if (rc) {
dprintk(CVP_ERR,
"%s: Failed msm_cvp_mmrm_deregister:%d\n",
__func__, rc);
}
}
/* unlink all sessions from device */
list_for_each_entry_safe(session, next, &device->sess_head, list) {
list_del(&session->list);
session->device = NULL;
}
dprintk(CVP_CORE, "Core released successfully\n");
mutex_unlock(&device->lock);
return rc;
}
static void __core_clear_interrupt(struct iris_hfi_device *device)
{
u32 intr_status = 0, mask = 0;
if (!device) {
dprintk(CVP_ERR, "%s: NULL device\n", __func__);
return;
}
intr_status = __read_register(device, CVP_WRAPPER_INTR_STATUS);
mask = (CVP_WRAPPER_INTR_MASK_A2HCPU_BMSK | CVP_FATAL_INTR_BMSK);
if (intr_status & mask) {
device->intr_status |= intr_status;
device->reg_count++;
dprintk(CVP_CORE,
"INTERRUPT for device: %pK: times: %d status: %d\n",
device, device->reg_count, intr_status);
} else {
device->spur_count++;
}
__write_register(device, CVP_CPU_CS_A2HSOFTINTCLR, 1);
}
static int iris_hfi_core_trigger_ssr(void *device,
enum hal_ssr_trigger_type type)
{
struct cvp_hfi_cmd_sys_test_ssr_packet pkt;
int rc = 0;
struct iris_hfi_device *dev;
cvp_free_va_md_list();
if (!device) {
dprintk(CVP_ERR, "invalid device\n");
return -ENODEV;
}
dev = device;
if (mutex_trylock(&dev->lock)) {
rc = call_hfi_pkt_op(dev, ssr_cmd, type, &pkt);
if (rc) {
dprintk(CVP_ERR, "%s: failed to create packet\n",
__func__);
goto err_create_pkt;
}
if (__iface_cmdq_write(dev, &pkt))
rc = -ENOTEMPTY;
} else {
return -EAGAIN;
}
err_create_pkt:
mutex_unlock(&dev->lock);
return rc;
}
static void __set_default_sys_properties(struct iris_hfi_device *device)
{
if (__sys_set_debug(device, msm_cvp_fw_debug))
dprintk(CVP_WARN, "Setting fw_debug msg ON failed\n");
if (__sys_set_power_control(device, msm_cvp_fw_low_power_mode))
dprintk(CVP_WARN, "Setting h/w power collapse ON failed\n");
}
static void __session_clean(struct cvp_hal_session *session)
{
struct cvp_hal_session *temp, *next;
struct iris_hfi_device *device;
if (!session || !session->device) {
dprintk(CVP_WARN, "%s: invalid params\n", __func__);
return;
}
device = session->device;
dprintk(CVP_SESS, "deleted the session: %pK\n", session);
/*
* session might have been removed from the device list in
* core_release, so check and remove if it is in the list
*/
list_for_each_entry_safe(temp, next, &device->sess_head, list) {
if (session == temp) {
list_del(&session->list);
break;
}
}
/* Poison the session handle with zeros */
*session = (struct cvp_hal_session){ {0} };
kfree(session);
}
static int iris_hfi_session_clean(void *session)
{
struct cvp_hal_session *sess_close;
struct iris_hfi_device *device;
if (!session) {
dprintk(CVP_ERR, "Invalid Params %s\n", __func__);
return -EINVAL;
}
sess_close = session;
device = sess_close->device;
if (!device) {
dprintk(CVP_ERR, "Invalid device handle %s\n", __func__);
return -EINVAL;
}
mutex_lock(&device->lock);
__session_clean(sess_close);
mutex_unlock(&device->lock);
return 0;
}
static int iris_debug_hook(void *device)
{
struct iris_hfi_device *dev = device;
u32 val;
if (!device) {
dprintk(CVP_ERR, "%s Invalid device\n", __func__);
return -ENODEV;
}
__write_register(dev, CVP_WRAPPER_CORE_CLOCK_CONFIG, 0x11);
__write_register(dev, CVP_WRAPPER_TZ_CPU_CLOCK_CONFIG, 0x1);
dprintk(CVP_ERR, "Halt Tensilica and core and axi\n");
return 0;
/******* FDU & MPU *****/
#define CVP0_CVP_SS_FDU_SECURE_ENABLE 0x90
#define CVP0_CVP_SS_MPU_SECURE_ENABLE 0x94
#define CVP0_CVP_SS_ARP_THREAD_0_SECURE_ENABLE 0xA0
#define CVP0_CVP_SS_ARP_THREAD_1_SECURE_ENABLE 0xA4
#define CVP0_CVP_SS_ARP_THREAD_2_SECURE_ENABLE 0xA8
#define CVP0_CVP_SS_ARP_THREAD_3_SECURE_ENABLE 0xAC
val = __read_register(dev, CVP0_CVP_SS_FDU_SECURE_ENABLE);
dprintk(CVP_ERR, "FDU_SECURE_ENABLE %#x\n", val);
val = __read_register(dev, CVP0_CVP_SS_MPU_SECURE_ENABLE);
dprintk(CVP_ERR, "MPU_SECURE_ENABLE %#x\n", val);
val = __read_register(dev, CVP0_CVP_SS_ARP_THREAD_0_SECURE_ENABLE);
dprintk(CVP_ERR, "ARP_THREAD_0_SECURE_ENABLE %#x\n", val);
val = __read_register(dev, CVP0_CVP_SS_ARP_THREAD_1_SECURE_ENABLE);
dprintk(CVP_ERR, "ARP_THREAD_1_SECURE_ENABLE %#x\n", val);
val = __read_register(dev, CVP0_CVP_SS_ARP_THREAD_2_SECURE_ENABLE);
dprintk(CVP_ERR, "ARP_THREAD_2_SECURE_ENABLE %#x\n", val);
val = __read_register(dev, CVP0_CVP_SS_ARP_THREAD_3_SECURE_ENABLE);
dprintk(CVP_ERR, "ARP_THREAD_3_SECURE_ENABLE %#x\n", val);
if (true)
return 0;
/***** GCE *******
* Bit 0 of below register is CDM secure enable for GCE
* CDM buffer will be in CB4 if set
*/
#define CVP_GCE_GCE_SS_CP_CTL 0x51100
/* STATUS bit0 && CFG bit 4 of below register set,
* expect pixel buffers in CB3,
* otherwise in CB0
* CFG bit 9:8 b01 -> LMC input in CB3
* CFG bit 9:8 b10 -> LMC input in CB4
*/
#define CVP_GCE0_CP_STATUS 0x51080
#define CVP_GCE0_BIU_RD_INPUT_IF_SECURITY_CFG 0x52020
val = __read_register(dev, CVP_GCE_GCE_SS_CP_CTL);
dprintk(CVP_ERR, "CVP_GCE_GCE_SS_CP_CTL %#x\n", val);
val = __read_register(dev, CVP_GCE0_CP_STATUS);
dprintk(CVP_ERR, "CVP_GCE0_CP_STATUS %#x\n", val);
val = __read_register(dev, CVP_GCE0_BIU_RD_INPUT_IF_SECURITY_CFG);
dprintk(CVP_ERR, "CVP_GCE0_BIU_RD_INPUT_IF_SECURITY_CFG %#x\n", val);
/***** RGE *****
* Bit 0 of below regiser is CDM secure enable for RGE
* CDM buffer to be in CB4 i fset
*/
#define CVP_RGE0_TOPRGE_CP_CTL 0x31010
/* CFG bit 4 && IN bit 0:
* if both are set, expect CB3 or CB4 depending on IN 6:4 field
* either is clear, expect CB0
*/
#define CVP_RGE0_BUS_RD_INPUT_IF_SECURITY_CFG 0x32020
#define CVP_RGE0_TOPSPARE_IN 0x311F4
val = __read_register(dev, CVP_RGE0_TOPRGE_CP_CTL);
dprintk(CVP_ERR, "CVP_RGE0_TOPRGE_CP_CTL %#x\n", val);
val = __read_register(dev, CVP_RGE0_BUS_RD_INPUT_IF_SECURITY_CFG);
dprintk(CVP_ERR, "CVP_RGE0_BUS_RD_INPUT_IF_SECURITY_CFG %#x\n", val);
val = __read_register(dev, CVP_RGE0_TOPSPARE_IN);
dprintk(CVP_ERR, "CVP_RGE0_TOPSPARE_IN %#x\n", val);
/****** VADL ******
* Bit 0 of below register is CDM secure enable for VADL
* CDM buffer will bei in CB4 if set
*/
#define CVP_VADL0_VADL_SS_CP_CTL 0x21010
/* Below registers are used the same way as RGE */
#define CVP_VADL0_BUS_RD_INPUT_IF_SECURITY_CFG 0x22020
#define CVP_VADL0_SPARE_IN 0x211F4
val = __read_register(dev, CVP_VADL0_VADL_SS_CP_CTL);
dprintk(CVP_ERR, "CVP_VADL0_VADL_SS_CP_CTL %#x\n", val);
val = __read_register(dev, CVP_VADL0_BUS_RD_INPUT_IF_SECURITY_CFG);
dprintk(CVP_ERR, "CVP_VADL0_BUS_RD_INPUT_IF_SECURITY_CFG %#x\n", val);
val = __read_register(dev, CVP_VADL0_SPARE_IN);
dprintk(CVP_ERR, "CVP_VADL0_SPARE_IN %#x\n", val);
/****** ITOF *****
* Below registers are used the same way as RGE
*/
#define CVP_ITOF0_TOF_SS_CP_CTL 0x41010
#define CVP_ITOF0_BUS_RD_INPUT_IF_SECURITY_CFG 0x42020
#define CVP_ITOF0_TOF_SS_SPARE_IN 0x411F4
val = __read_register(dev, CVP_ITOF0_TOF_SS_CP_CTL);
dprintk(CVP_ERR, "CVP_ITOF0_TOF_SS_CP_CTL %#x\n", val);
val = __read_register(dev, CVP_ITOF0_BUS_RD_INPUT_IF_SECURITY_CFG);
dprintk(CVP_ERR, "CVP_ITOF0_BUS_RD_INPUT_IF_SECURITY_CFG %#x\n", val);
val = __read_register(dev, CVP_ITOF0_TOF_SS_SPARE_IN);
dprintk(CVP_ERR, "CVP_ITOF0_TOF_SS_SPARE_IN %#x\n", val);
return 0;
}
static int iris_hfi_session_init(void *device, void *session_id,
void **new_session)
{
struct cvp_hfi_cmd_sys_session_init_packet pkt;
struct iris_hfi_device *dev;
struct cvp_hal_session *s;
if (!device || !new_session) {
dprintk(CVP_ERR, "%s - invalid input\n", __func__);
return -EINVAL;
}
dev = device;
mutex_lock(&dev->lock);
s = kzalloc(sizeof(*s), GFP_KERNEL);
if (!s) {
dprintk(CVP_ERR, "new session fail: Out of memory\n");
goto err_session_init_fail;
}
s->session_id = session_id;
s->device = dev;
dprintk(CVP_SESS,
"%s: inst %pK, session %pK\n", __func__, session_id, s);
list_add_tail(&s->list, &dev->sess_head);
__set_default_sys_properties(device);
if (call_hfi_pkt_op(dev, session_init, &pkt, s)) {
dprintk(CVP_ERR, "session_init: failed to create packet\n");
goto err_session_init_fail;
}
*new_session = s;
if (__iface_cmdq_write(dev, &pkt))
goto err_session_init_fail;
mutex_unlock(&dev->lock);
return 0;
err_session_init_fail:
if (s)
__session_clean(s);
*new_session = NULL;
mutex_unlock(&dev->lock);
return -EINVAL;
}
static int __send_session_cmd(struct cvp_hal_session *session, int pkt_type)
{
struct cvp_hal_session_cmd_pkt pkt;
int rc = 0;
struct iris_hfi_device *device = session->device;
if (!__is_session_valid(device, session, __func__))
return -ECONNRESET;
rc = call_hfi_pkt_op(device, session_cmd,
&pkt, pkt_type, session);
if (rc == -EPERM)
return 0;
if (rc) {
dprintk(CVP_ERR, "send session cmd: create pkt failed\n");
goto err_create_pkt;
}
if (__iface_cmdq_write(session->device, &pkt))
rc = -ENOTEMPTY;
err_create_pkt:
return rc;
}
static int iris_hfi_session_end(void *session)
{
struct cvp_hal_session *sess;
struct iris_hfi_device *device;
int rc = 0;
if (!session) {
dprintk(CVP_ERR, "Invalid Params %s\n", __func__);
return -EINVAL;
}
sess = session;
device = sess->device;
if (!device) {
dprintk(CVP_ERR, "Invalid session %s\n", __func__);
return -EINVAL;
}
mutex_lock(&device->lock);
if (msm_cvp_fw_coverage) {
if (__sys_set_coverage(sess->device, msm_cvp_fw_coverage))
dprintk(CVP_WARN, "Fw_coverage msg ON failed\n");
}
rc = __send_session_cmd(session, HFI_CMD_SYS_SESSION_END);
mutex_unlock(&device->lock);
return rc;
}
static int iris_hfi_session_abort(void *sess)
{
struct cvp_hal_session *session = sess;
struct iris_hfi_device *device;
int rc = 0;
if (!session || !session->device) {
dprintk(CVP_ERR, "Invalid Params %s\n", __func__);
return -EINVAL;
}
device = session->device;
mutex_lock(&device->lock);
rc = __send_session_cmd(session, HFI_CMD_SYS_SESSION_ABORT);
mutex_unlock(&device->lock);
return rc;
}
static int iris_hfi_session_set_buffers(void *sess, u32 iova, u32 size)
{
struct cvp_hfi_cmd_session_set_buffers_packet pkt;
int rc = 0;
struct cvp_hal_session *session = sess;
struct iris_hfi_device *device;
if (!session || !session->device || !iova || !size) {
dprintk(CVP_ERR, "Invalid Params\n");
return -EINVAL;
}
device = session->device;
mutex_lock(&device->lock);
if (!__is_session_valid(device, session, __func__)) {
rc = -ECONNRESET;
goto err_create_pkt;
}
rc = call_hfi_pkt_op(device, session_set_buffers,
&pkt, session, iova, size);
if (rc) {
dprintk(CVP_ERR, "set buffers: failed to create packet\n");
goto err_create_pkt;
}
if (__iface_cmdq_write(session->device, &pkt))
rc = -ENOTEMPTY;
err_create_pkt:
mutex_unlock(&device->lock);
return rc;
}
static int iris_hfi_session_release_buffers(void *sess)
{
struct cvp_session_release_buffers_packet pkt;
int rc = 0;
struct cvp_hal_session *session = sess;
struct iris_hfi_device *device;
if (!session || !session->device) {
dprintk(CVP_ERR, "Invalid Params\n");
return -EINVAL;
}
device = session->device;
mutex_lock(&device->lock);
if (!__is_session_valid(device, session, __func__)) {
rc = -ECONNRESET;
goto err_create_pkt;
}
rc = call_hfi_pkt_op(device, session_release_buffers, &pkt, session);
if (rc) {
dprintk(CVP_ERR, "release buffers: failed to create packet\n");
goto err_create_pkt;
}
if (__iface_cmdq_write(session->device, &pkt))
rc = -ENOTEMPTY;
err_create_pkt:
mutex_unlock(&device->lock);
return rc;
}
static int iris_hfi_session_send(void *sess,
struct eva_kmd_hfi_packet *in_pkt)
{
int rc = 0;
struct eva_kmd_hfi_packet pkt;
struct cvp_hal_session *session = sess;
struct iris_hfi_device *device;
if (!session || !session->device) {
dprintk(CVP_ERR, "invalid session");
return -ENODEV;
}
device = session->device;
mutex_lock(&device->lock);
if (!__is_session_valid(device, session, __func__)) {
rc = -ECONNRESET;
goto err_send_pkt;
}
rc = call_hfi_pkt_op(device, session_send,
&pkt, session, in_pkt);
if (rc) {
dprintk(CVP_ERR,
"failed to create pkt\n");
goto err_send_pkt;
}
if (__iface_cmdq_write(session->device, &pkt))
rc = -ENOTEMPTY;
err_send_pkt:
mutex_unlock(&device->lock);
return rc;
return rc;
}
static int iris_hfi_session_flush(void *sess)
{
struct cvp_hal_session *session = sess;
struct iris_hfi_device *device;
int rc = 0;
if (!session || !session->device) {
dprintk(CVP_ERR, "Invalid Params %s\n", __func__);
return -EINVAL;
}
device = session->device;
mutex_lock(&device->lock);
rc = __send_session_cmd(session, HFI_CMD_SESSION_CVP_FLUSH);
mutex_unlock(&device->lock);
return rc;
}
static int iris_hfi_session_start(void *sess)
{
struct cvp_hal_session *session = sess;
struct iris_hfi_device *device;
int rc = 0;
if (!session || !session->device) {
dprintk(CVP_ERR, "Invalid Params %s\n", __func__);
return -EINVAL;
}
device = session->device;
mutex_lock(&device->lock);
rc = __send_session_cmd(session, HFI_CMD_SESSION_EVA_START);
mutex_unlock(&device->lock);
return rc;
}
static int iris_hfi_session_stop(void *sess)
{
struct cvp_hal_session *session = sess;
struct iris_hfi_device *device;
int rc = 0;
if (!session || !session->device) {
dprintk(CVP_ERR, "Invalid Params %s\n", __func__);
return -EINVAL;
}
device = session->device;
mutex_lock(&device->lock);
rc = __send_session_cmd(session, HFI_CMD_SESSION_EVA_STOP);
mutex_unlock(&device->lock);
return rc;
}
static void __process_fatal_error(
struct iris_hfi_device *device)
{
struct msm_cvp_cb_cmd_done cmd_done = {0};
device->callback(HAL_SYS_ERROR, &cmd_done);
}
static int __prepare_pc(struct iris_hfi_device *device)
{
int rc = 0;
struct cvp_hfi_cmd_sys_pc_prep_packet pkt;
rc = call_hfi_pkt_op(device, sys_pc_prep, &pkt);
if (rc) {
dprintk(CVP_ERR, "Failed to create sys pc prep pkt\n");
goto err_pc_prep;
}
if (__iface_cmdq_write(device, &pkt))
rc = -ENOTEMPTY;
if (rc)
dprintk(CVP_ERR, "Failed to prepare iris for power off");
err_pc_prep:
return rc;
}
static void iris_hfi_pm_handler(struct work_struct *work)
{
int rc = 0;
struct msm_cvp_core *core;
struct iris_hfi_device *device;
core = cvp_driver->cvp_core;
if (core)
device = core->device->hfi_device_data;
else
return;
if (!device) {
dprintk(CVP_ERR, "%s: NULL device\n", __func__);
return;
}
dprintk(CVP_PWR,
"Entering %s\n", __func__);
/*
* It is ok to check this variable outside the lock since
* it is being updated in this context only
*/
if (device->skip_pc_count >= CVP_MAX_PC_SKIP_COUNT) {
dprintk(CVP_WARN, "Failed to PC for %d times\n",
device->skip_pc_count);
device->skip_pc_count = 0;
__process_fatal_error(device);
return;
}
mutex_lock(&device->lock);
if (gfa_cv.state == DSP_SUSPEND)
rc = __power_collapse(device, true);
else
rc = __power_collapse(device, false);
mutex_unlock(&device->lock);
switch (rc) {
case 0:
device->skip_pc_count = 0;
/* Cancel pending delayed works if any */
cancel_delayed_work(&iris_hfi_pm_work);
dprintk(CVP_PWR, "%s: power collapse successful!\n",
__func__);
break;
case -EBUSY:
device->skip_pc_count = 0;
dprintk(CVP_PWR, "%s: retry PC as cvp is busy\n", __func__);
queue_delayed_work(device->iris_pm_workq,
&iris_hfi_pm_work, msecs_to_jiffies(
device->res->msm_cvp_pwr_collapse_delay));
break;
case -EAGAIN:
device->skip_pc_count++;
dprintk(CVP_WARN, "%s: retry power collapse (count %d)\n",
__func__, device->skip_pc_count);
queue_delayed_work(device->iris_pm_workq,
&iris_hfi_pm_work, msecs_to_jiffies(
device->res->msm_cvp_pwr_collapse_delay));
break;
default:
dprintk(CVP_ERR, "%s: power collapse failed\n", __func__);
break;
}
}
static int __power_collapse(struct iris_hfi_device *device, bool force)
{
int rc = 0;
u32 wfi_status = 0, idle_status = 0, pc_ready = 0;
int count = 0;
const int max_tries = 150;
if (!device) {
dprintk(CVP_ERR, "%s: invalid params\n", __func__);
return -EINVAL;
}
if (!device->power_enabled) {
dprintk(CVP_PWR, "%s: Power already disabled\n",
__func__);
goto exit;
}
rc = __core_in_valid_state(device);
if (!rc) {
dprintk(CVP_WARN,
"Core is in bad state, Skipping power collapse\n");
return -EINVAL;
}
rc = __dsp_suspend(device, force);
if (rc == -EBUSY)
goto exit;
else if (rc)
goto skip_power_off;
__flush_debug_queue(device, device->raw_packet);
pc_ready = __read_register(device, CVP_CTRL_STATUS) &
CVP_CTRL_STATUS_PC_READY;
if (!pc_ready) {
wfi_status = __read_register(device,
CVP_WRAPPER_CPU_STATUS);
idle_status = __read_register(device,
CVP_CTRL_STATUS);
if (!(wfi_status & BIT(0))) {
dprintk(CVP_WARN,
"Skipping PC as wfi_status (%#x) bit not set\n",
wfi_status);
goto skip_power_off;
}
if (!(idle_status & BIT(30))) {
dprintk(CVP_WARN,
"Skipping PC as idle_status (%#x) bit not set\n",
idle_status);
goto skip_power_off;
}
rc = __prepare_pc(device);
if (rc) {
dprintk(CVP_WARN, "Failed PC %d\n", rc);
goto skip_power_off;
}
while (count < max_tries) {
wfi_status = __read_register(device,
CVP_WRAPPER_CPU_STATUS);
pc_ready = __read_register(device,
CVP_CTRL_STATUS);
if ((wfi_status & BIT(0)) && (pc_ready &
CVP_CTRL_STATUS_PC_READY))
break;
usleep_range(150, 250);
count++;
}
if (count == max_tries) {
dprintk(CVP_ERR,
"Skip PC. Core is not ready (%#x, %#x)\n",
wfi_status, pc_ready);
goto skip_power_off;
}
} else {
wfi_status = __read_register(device, CVP_WRAPPER_CPU_STATUS);
if (!(wfi_status & BIT(0))) {
dprintk(CVP_WARN,
"Skip PC as wfi_status (%#x) bit not set\n",
wfi_status);
goto skip_power_off;
}
}
rc = __suspend(device);
if (rc)
dprintk(CVP_ERR, "Failed __suspend\n");
exit:
return rc;
skip_power_off:
dprintk(CVP_PWR, "Skip PC(%#x, %#x, %#x)\n",
wfi_status, idle_status, pc_ready);
__flush_debug_queue(device, device->raw_packet);
return -EAGAIN;
}
static void __process_sys_error(struct iris_hfi_device *device)
{
struct cvp_hfi_sfr_struct *vsfr = NULL;
vsfr = (struct cvp_hfi_sfr_struct *)device->sfr.align_virtual_addr;
if (vsfr) {
void *p = memchr(vsfr->rg_data, '\0', vsfr->bufSize);
/*
* SFR isn't guaranteed to be NULL terminated
* since SYS_ERROR indicates that Iris is in the
* process of crashing.
*/
if (p == NULL)
vsfr->rg_data[vsfr->bufSize - 1] = '\0';
dprintk(CVP_ERR, "SFR Message from FW: %s\n",
vsfr->rg_data);
}
}
static void __flush_debug_queue(struct iris_hfi_device *device, u8 *packet)
{
bool local_packet = false;
enum cvp_msg_prio log_level = CVP_FW;
if (!device) {
dprintk(CVP_ERR, "%s: Invalid params\n", __func__);
return;
}
if (!packet) {
packet = kzalloc(CVP_IFACEQ_VAR_HUGE_PKT_SIZE, GFP_KERNEL);
if (!packet) {
dprintk(CVP_ERR, "In %s() Fail to allocate mem\n",
__func__);
return;
}
local_packet = true;
/*
* Local packek is used when something FATAL occurred.
* It is good to print these logs by default.
*/
log_level = CVP_ERR;
}
#define SKIP_INVALID_PKT(pkt_size, payload_size, pkt_hdr_size) ({ \
if (pkt_size < pkt_hdr_size || \
payload_size < MIN_PAYLOAD_SIZE || \
payload_size > \
(pkt_size - pkt_hdr_size + sizeof(u8))) { \
dprintk(CVP_ERR, \
"%s: invalid msg size - %d\n", \
__func__, pkt->msg_size); \
continue; \
} \
})
while (!__iface_dbgq_read(device, packet)) {
struct cvp_hfi_packet_header *pkt =
(struct cvp_hfi_packet_header *) packet;
if (pkt->size < sizeof(struct cvp_hfi_packet_header)) {
dprintk(CVP_ERR, "Invalid pkt size - %s\n",
__func__);
continue;
}
if (pkt->packet_type == HFI_MSG_SYS_DEBUG) {
struct cvp_hfi_msg_sys_debug_packet *pkt =
(struct cvp_hfi_msg_sys_debug_packet *) packet;
SKIP_INVALID_PKT(pkt->size,
pkt->msg_size, sizeof(*pkt));
/*
* All fw messages starts with new line character. This
* causes dprintk to print this message in two lines
* in the kernel log. Ignoring the first character
* from the message fixes this to print it in a single
* line.
*/
pkt->rg_msg_data[pkt->msg_size-1] = '\0';
dprintk(log_level, "%s", &pkt->rg_msg_data[1]);
}
}
#undef SKIP_INVALID_PKT
if (local_packet)
kfree(packet);
}
static bool __is_session_valid(struct iris_hfi_device *device,
struct cvp_hal_session *session, const char *func)
{
struct cvp_hal_session *temp = NULL;
if (!device || !session)
goto invalid;
list_for_each_entry(temp, &device->sess_head, list)
if (session == temp)
return true;
invalid:
dprintk(CVP_WARN, "%s: device %pK, invalid session %pK\n",
func, device, session);
return false;
}
static struct cvp_hal_session *__get_session(struct iris_hfi_device *device,
u32 session_id)
{
struct cvp_hal_session *temp = NULL;
list_for_each_entry(temp, &device->sess_head, list) {
if (session_id == hash32_ptr(temp))
return temp;
}
return NULL;
}
#define _INVALID_MSG_ "Unrecognized MSG (%#x) session (%pK), discarding\n"
#define _INVALID_STATE_ "Ignore responses from %d to %d invalid state\n"
#define _DEVFREQ_FAIL_ "Failed to add devfreq device bus %s governor %s: %d\n"
static void process_system_msg(struct msm_cvp_cb_info *info,
struct iris_hfi_device *device,
void *raw_packet)
{
struct cvp_hal_sys_init_done sys_init_done = {0};
switch (info->response_type) {
case HAL_SYS_ERROR:
__process_sys_error(device);
break;
case HAL_SYS_RELEASE_RESOURCE_DONE:
dprintk(CVP_CORE, "Received SYS_RELEASE_RESOURCE\n");
break;
case HAL_SYS_INIT_DONE:
dprintk(CVP_CORE, "Received SYS_INIT_DONE\n");
sys_init_done.capabilities =
device->sys_init_capabilities;
cvp_hfi_process_sys_init_done_prop_read(
(struct cvp_hfi_msg_sys_init_done_packet *)
raw_packet, &sys_init_done);
info->response.cmd.data.sys_init_done = sys_init_done;
break;
default:
break;
}
}
static void **get_session_id(struct msm_cvp_cb_info *info)
{
void **session_id = NULL;
/* For session-related packets, validate session */
switch (info->response_type) {
case HAL_SESSION_INIT_DONE:
case HAL_SESSION_END_DONE:
case HAL_SESSION_ABORT_DONE:
case HAL_SESSION_START_DONE:
case HAL_SESSION_STOP_DONE:
case HAL_SESSION_FLUSH_DONE:
case HAL_SESSION_SET_BUFFER_DONE:
case HAL_SESSION_SUSPEND_DONE:
case HAL_SESSION_RESUME_DONE:
case HAL_SESSION_SET_PROP_DONE:
case HAL_SESSION_GET_PROP_DONE:
case HAL_SESSION_RELEASE_BUFFER_DONE:
case HAL_SESSION_REGISTER_BUFFER_DONE:
case HAL_SESSION_UNREGISTER_BUFFER_DONE:
case HAL_SESSION_PROPERTY_INFO:
case HAL_SESSION_EVENT_CHANGE:
case HAL_SESSION_DUMP_NOTIFY:
case HAL_SESSION_ERROR:
session_id = &info->response.cmd.session_id;
break;
case HAL_RESPONSE_UNUSED:
default:
session_id = NULL;
break;
}
return session_id;
}
static void print_msg_hdr(void *hdr)
{
struct cvp_hfi_msg_session_hdr *new_hdr =
(struct cvp_hfi_msg_session_hdr *)hdr;
dprintk(CVP_HFI, "HFI MSG received: %x %x %x %x %x %x %x %#llx\n",
new_hdr->size, new_hdr->packet_type,
new_hdr->session_id,
new_hdr->client_data.transaction_id,
new_hdr->client_data.data1,
new_hdr->client_data.data2,
new_hdr->error_type,
new_hdr->client_data.kdata);
}
static int __response_handler(struct iris_hfi_device *device)
{
struct msm_cvp_cb_info *packets;
int packet_count = 0;
u8 *raw_packet = NULL;
bool requeue_pm_work = true;
if (!device || device->state != IRIS_STATE_INIT)
return 0;
packets = device->response_pkt;
raw_packet = device->raw_packet;
if (!raw_packet || !packets) {
dprintk(CVP_ERR,
"%s: Invalid args : Res pkt = %pK, Raw pkt = %pK\n",
__func__, packets, raw_packet);
return 0;
}
if (device->intr_status & CVP_FATAL_INTR_BMSK) {
struct cvp_hfi_sfr_struct *vsfr = (struct cvp_hfi_sfr_struct *)
device->sfr.align_virtual_addr;
struct msm_cvp_cb_info info = {
.response_type = HAL_SYS_WATCHDOG_TIMEOUT,
.response.cmd = {
.device_id = 0,
}
};
if (vsfr)
dprintk(CVP_ERR, "SFR Message from FW: %s\n",
vsfr->rg_data);
if (device->intr_status & CVP_WRAPPER_INTR_MASK_CPU_NOC_BMSK)
dprintk(CVP_ERR, "Received Xtensa NOC error\n");
if (device->intr_status & CVP_WRAPPER_INTR_MASK_CORE_NOC_BMSK)
dprintk(CVP_ERR, "Received CVP core NOC error\n");
if (device->intr_status & CVP_WRAPPER_INTR_MASK_A2HWD_BMSK)
dprintk(CVP_ERR, "Received CVP watchdog timeout\n");
packets[packet_count++] = info;
goto exit;
}
/* Bleed the msg queue dry of packets */
while (!__iface_msgq_read(device, raw_packet)) {
void **session_id = NULL;
struct msm_cvp_cb_info *info = &packets[packet_count++];
struct cvp_hfi_msg_session_hdr *hdr =
(struct cvp_hfi_msg_session_hdr *)raw_packet;
int rc = 0;
print_msg_hdr(hdr);
rc = cvp_hfi_process_msg_packet(0, raw_packet, info);
if (rc) {
dprintk(CVP_WARN,
"Corrupt/unknown packet found, discarding\n");
--packet_count;
continue;
} else if (info->response_type == HAL_NO_RESP) {
--packet_count;
continue;
}
/* Process the packet types that we're interested in */
process_system_msg(info, device, raw_packet);
session_id = get_session_id(info);
/*
* hfi_process_msg_packet provides a session_id that's a hashed
* value of struct cvp_hal_session, we need to coerce the hashed
* value back to pointer that we can use. Ideally, hfi_process\
* _msg_packet should take care of this, but it doesn't have
* required information for it
*/
if (session_id) {
struct cvp_hal_session *session = NULL;
if (upper_32_bits((uintptr_t)*session_id) != 0) {
dprintk(CVP_ERR,
"Upper 32-bits != 0 for sess_id=%pK\n",
*session_id);
}
session = __get_session(device,
(u32)(uintptr_t)*session_id);
if (!session) {
dprintk(CVP_ERR, _INVALID_MSG_,
info->response_type,
*session_id);
--packet_count;
continue;
}
*session_id = session->session_id;
}
if (packet_count >= cvp_max_packets) {
dprintk(CVP_WARN,
"Too many packets in message queue!\n");
break;
}
/* do not read packets after sys error packet */
if (info->response_type == HAL_SYS_ERROR)
break;
}
if (requeue_pm_work && device->res->sw_power_collapsible) {
cancel_delayed_work(&iris_hfi_pm_work);
if (!queue_delayed_work(device->iris_pm_workq,
&iris_hfi_pm_work,
msecs_to_jiffies(
device->res->msm_cvp_pwr_collapse_delay))) {
dprintk(CVP_ERR, "PM work already scheduled\n");
}
}
exit:
__flush_debug_queue(device, raw_packet);
return packet_count;
}
irqreturn_t iris_hfi_core_work_handler(int irq, void *data)
{
struct msm_cvp_core *core;
struct iris_hfi_device *device;
int num_responses = 0, i = 0;
u32 intr_status;
static bool warning_on = true;
core = cvp_driver->cvp_core;
if (core)
device = core->device->hfi_device_data;
else
return IRQ_HANDLED;
mutex_lock(&device->lock);
if (!__core_in_valid_state(device)) {
if (warning_on) {
dprintk(CVP_WARN, "%s Core not in init state\n",
__func__);
warning_on = false;
}
goto err_no_work;
}
warning_on = true;
if (!device->callback) {
dprintk(CVP_ERR, "No interrupt callback function: %pK\n",
device);
goto err_no_work;
}
if (__resume(device)) {
dprintk(CVP_ERR, "%s: Power enable failed\n", __func__);
goto err_no_work;
}
__core_clear_interrupt(device);
num_responses = __response_handler(device);
dprintk(CVP_HFI, "%s:: cvp_driver_debug num_responses = %d ",
__func__, num_responses);
err_no_work:
/* Keep the interrupt status before releasing device lock */
intr_status = device->intr_status;
mutex_unlock(&device->lock);
/*
* Issue the callbacks outside of the locked contex to preserve
* re-entrancy.
*/
for (i = 0; !IS_ERR_OR_NULL(device->response_pkt) &&
i < num_responses; ++i) {
struct msm_cvp_cb_info *r = &device->response_pkt[i];
void *rsp = (void *)&r->response;
if (!__core_in_valid_state(device)) {
dprintk(CVP_ERR,
_INVALID_STATE_, (i + 1), num_responses);
break;
}
dprintk(CVP_HFI, "Processing response %d of %d, type %d\n",
(i + 1), num_responses, r->response_type);
/* callback = void cvp_handle_cmd_response() */
device->callback(r->response_type, rsp);
}
/* We need re-enable the irq which was disabled in ISR handler */
if (!(intr_status & CVP_WRAPPER_INTR_STATUS_A2HWD_BMSK))
enable_irq(device->cvp_hal_data->irq);
return IRQ_HANDLED;
}
irqreturn_t cvp_hfi_isr(int irq, void *dev)
{
disable_irq_nosync(irq);
return IRQ_WAKE_THREAD;
}
static void iris_hfi_wd_work_handler(struct work_struct *work)
{
struct msm_cvp_core *core;
struct iris_hfi_device *device;
struct msm_cvp_cb_cmd_done response = {0};
enum hal_command_response cmd = HAL_SYS_WATCHDOG_TIMEOUT;
core = cvp_driver->cvp_core;
if (core)
device = core->device->hfi_device_data;
else
return;
if (msm_cvp_hw_wd_recovery) {
dprintk(CVP_ERR, "Cleaning up as HW WD recovery is enable %d\n",
msm_cvp_hw_wd_recovery);
response.device_id = 0;
handle_sys_error(cmd, (void *) &response);
enable_irq(device->cvp_hal_data->irq_wd);
}
else {
dprintk(CVP_ERR, "Crashing the device as HW WD recovery is disable %d\n",
msm_cvp_hw_wd_recovery);
BUG_ON(1);
}
}
static DECLARE_WORK(iris_hfi_wd_work, iris_hfi_wd_work_handler);
irqreturn_t iris_hfi_isr_wd(int irq, void *dev)
{
struct iris_hfi_device *device = dev;
dprintk(CVP_ERR, "Got HW WDOG IRQ at %llu! \n", get_aon_time());
disable_irq_nosync(irq);
queue_work(device->cvp_workq, &iris_hfi_wd_work);
return IRQ_HANDLED;
}
static int __init_reset_clk(struct msm_cvp_platform_resources *res,
int reset_index)
{
int rc = 0;
struct reset_control *rst;
struct reset_info *rst_info;
struct reset_set *rst_set = &res->reset_set;
if (!rst_set->reset_tbl)
return 0;
rst_info = &rst_set->reset_tbl[reset_index];
rst = rst_info->rst;
dprintk(CVP_PWR, "reset_clk: name %s rst %pK required_stage=%d\n",
rst_set->reset_tbl[reset_index].name, rst, rst_info->required_stage);
if (rst)
goto skip_reset_init;
if (rst_info->required_stage == CVP_ON_USE) {
rst = reset_control_get_exclusive_released(&res->pdev->dev,
rst_set->reset_tbl[reset_index].name);
if (IS_ERR(rst)) {
rc = PTR_ERR(rst);
dprintk(CVP_ERR, "reset get exclusive fail %d\n", rc);
return rc;
}
dprintk(CVP_PWR, "reset_clk: name %s get exclusive rst %llx\n",
rst_set->reset_tbl[reset_index].name, rst);
} else if (rst_info->required_stage == CVP_ON_INIT) {
rst = devm_reset_control_get(&res->pdev->dev,
rst_set->reset_tbl[reset_index].name);
if (IS_ERR(rst)) {
rc = PTR_ERR(rst);
dprintk(CVP_ERR, "reset get fail %d\n", rc);
return rc;
}
dprintk(CVP_PWR, "reset_clk: name %s get rst %llx\n",
rst_set->reset_tbl[reset_index].name, rst);
} else {
dprintk(CVP_ERR, "Invalid reset stage\n");
return -EINVAL;
}
rst_set->reset_tbl[reset_index].rst = rst;
rst_info->state = RESET_INIT;
return 0;
skip_reset_init:
return rc;
}
static int __reset_control_assert_name(struct iris_hfi_device *device,
const char *name)
{
struct reset_info *rcinfo = NULL;
int rc = 0;
bool found = false;
iris_hfi_for_each_reset_clock(device, rcinfo) {
if (strcmp(rcinfo->name, name))
continue;
found = true;
rc = reset_control_assert(rcinfo->rst);
if (rc)
dprintk(CVP_ERR,
"%s: failed to assert reset control (%s), rc = %d\n",
__func__, rcinfo->name, rc);
else
dprintk(CVP_PWR, "%s: assert reset control (%s)\n",
__func__, rcinfo->name);
break;
}
if (!found) {
dprintk(CVP_PWR, "%s: reset control (%s) not found\n",
__func__, name);
rc = -EINVAL;
}
return rc;
}
static int __reset_control_deassert_name(struct iris_hfi_device *device,
const char *name)
{
struct reset_info *rcinfo = NULL;
int rc = 0;
bool found = false;
iris_hfi_for_each_reset_clock(device, rcinfo) {
if (strcmp(rcinfo->name, name))
continue;
found = true;
rc = reset_control_deassert(rcinfo->rst);
if (rc)
dprintk(CVP_ERR,
"%s: deassert reset control for (%s) failed, rc %d\n",
__func__, rcinfo->name, rc);
else
dprintk(CVP_PWR, "%s: deassert reset control (%s)\n",
__func__, rcinfo->name);
break;
}
if (!found) {
dprintk(CVP_PWR, "%s: reset control (%s) not found\n",
__func__, name);
rc = -EINVAL;
}
return rc;
}
static int __reset_control_acquire(struct iris_hfi_device *device,
const char *name)
{
struct reset_info *rcinfo = NULL;
int rc = 0;
bool found = false;
int max_retries = 10;
iris_hfi_for_each_reset_clock(device, rcinfo) {
if (strcmp(rcinfo->name, name))
continue;
found = true;
if (rcinfo->state == RESET_ACQUIRED)
return rc;
acquire_again:
rc = reset_control_acquire(rcinfo->rst);
if (rc) {
if (rc == -EBUSY) {
usleep_range(500, 1000);
max_retries--;
if (max_retries) {
goto acquire_again;
} else {
dprintk(CVP_ERR,
"%s acquire %s -EBUSY\n",
__func__, rcinfo->name);
rc = -EINVAL;
}
} else {
dprintk(CVP_ERR,
"%s: acquire failed (%s) rc %d\n",
__func__, rcinfo->name, rc);
rc = -EINVAL;
}
} else {
dprintk(CVP_PWR, "%s: reset acquire succeed (%s)\n",
__func__, rcinfo->name);
rcinfo->state = RESET_ACQUIRED;
}
break;
}
if (!found) {
dprintk(CVP_PWR, "%s: reset control (%s) not found\n",
__func__, name);
rc = -EINVAL;
}
return rc;
}
static int __reset_control_release(struct iris_hfi_device *device,
const char *name)
{
struct reset_info *rcinfo = NULL;
int rc = 0;
bool found = false;
iris_hfi_for_each_reset_clock(device, rcinfo) {
if (strcmp(rcinfo->name, name))
continue;
found = true;
if (rcinfo->state != RESET_ACQUIRED) {
dprintk(CVP_WARN, "Double releasing reset clk?\n");
return -EINVAL;
}
reset_control_release(rcinfo->rst);
dprintk(CVP_PWR, "%s: reset release succeed (%s)\n",
__func__, rcinfo->name);
rcinfo->state = RESET_RELEASED;
break;
}
if (!found) {
dprintk(CVP_PWR, "%s: reset control (%s) not found\n",
__func__, name);
rc = -EINVAL;
}
return rc;
}
static void __deinit_bus(struct iris_hfi_device *device)
{
struct bus_info *bus = NULL;
if (!device)
return;
kfree(device->bus_vote.data);
device->bus_vote = CVP_DEFAULT_BUS_VOTE;
iris_hfi_for_each_bus_reverse(device, bus) {
dev_set_drvdata(bus->dev, NULL);
icc_put(bus->client);
bus->client = NULL;
}
}
static int __init_bus(struct iris_hfi_device *device)
{
struct bus_info *bus = NULL;
int rc = 0;
if (!device)
return -EINVAL;
iris_hfi_for_each_bus(device, bus) {
/*
* This is stupid, but there's no other easy way to ahold
* of struct bus_info in iris_hfi_devfreq_*()
*/
WARN(dev_get_drvdata(bus->dev), "%s's drvdata already set\n",
dev_name(bus->dev));
dev_set_drvdata(bus->dev, device);
bus->client = icc_get(&device->res->pdev->dev,
bus->master, bus->slave);
if (IS_ERR_OR_NULL(bus->client)) {
rc = PTR_ERR(bus->client) ?: -EBADHANDLE;
dprintk(CVP_ERR, "Failed to register bus %s: %d\n",
bus->name, rc);
bus->client = NULL;
goto err_add_dev;
}
}
return 0;
err_add_dev:
__deinit_bus(device);
return rc;
}
static void __deinit_regulators(struct iris_hfi_device *device)
{
struct regulator_info *rinfo = NULL;
iris_hfi_for_each_regulator_reverse(device, rinfo) {
if (rinfo->regulator) {
regulator_put(rinfo->regulator);
rinfo->regulator = NULL;
}
}
}
static int __init_regulators(struct iris_hfi_device *device)
{
int rc = 0;
struct regulator_info *rinfo = NULL;
iris_hfi_for_each_regulator(device, rinfo) {
rinfo->regulator = regulator_get(&device->res->pdev->dev,
rinfo->name);
if (IS_ERR_OR_NULL(rinfo->regulator)) {
rc = PTR_ERR(rinfo->regulator) ?: -EBADHANDLE;
dprintk(CVP_ERR, "Failed to get regulator: %s\n",
rinfo->name);
rinfo->regulator = NULL;
goto err_reg_get;
}
}
return 0;
err_reg_get:
__deinit_regulators(device);
return rc;
}
static void __deinit_subcaches(struct iris_hfi_device *device)
{
struct subcache_info *sinfo = NULL;
if (!device) {
dprintk(CVP_ERR, "deinit_subcaches: invalid device %pK\n",
device);
goto exit;
}
if (!is_sys_cache_present(device))
goto exit;
iris_hfi_for_each_subcache_reverse(device, sinfo) {
if (sinfo->subcache) {
dprintk(CVP_CORE, "deinit_subcaches: %s\n",
sinfo->name);
llcc_slice_putd(sinfo->subcache);
sinfo->subcache = NULL;
}
}
exit:
return;
}
static int __init_subcaches(struct iris_hfi_device *device)
{
int rc = 0;
struct subcache_info *sinfo = NULL;
if (!device) {
dprintk(CVP_ERR, "init_subcaches: invalid device %pK\n",
device);
return -EINVAL;
}
if (!is_sys_cache_present(device))
return 0;
iris_hfi_for_each_subcache(device, sinfo) {
if (!strcmp("cvp", sinfo->name)) {
sinfo->subcache = llcc_slice_getd(LLCC_CVP);
} else if (!strcmp("cvpfw", sinfo->name)) {
sinfo->subcache = llcc_slice_getd(LLCC_CVPFW);
} else {
dprintk(CVP_ERR, "Invalid subcache name %s\n",
sinfo->name);
}
if (IS_ERR_OR_NULL(sinfo->subcache)) {
rc = PTR_ERR(sinfo->subcache) ?
PTR_ERR(sinfo->subcache) : -EBADHANDLE;
dprintk(CVP_ERR,
"init_subcaches: invalid subcache: %s rc %d\n",
sinfo->name, rc);
sinfo->subcache = NULL;
goto err_subcache_get;
}
dprintk(CVP_CORE, "init_subcaches: %s\n",
sinfo->name);
}
return 0;
err_subcache_get:
__deinit_subcaches(device);
return rc;
}
static int __init_resources(struct iris_hfi_device *device,
struct msm_cvp_platform_resources *res)
{
int i, rc = 0;
rc = __init_regulators(device);
if (rc) {
dprintk(CVP_ERR, "Failed to get all regulators\n");
return -ENODEV;
}
rc = msm_cvp_init_clocks(device);
if (rc) {
dprintk(CVP_ERR, "Failed to init clocks\n");
rc = -ENODEV;
goto err_init_clocks;
}
for (i = 0; i < device->res->reset_set.count; i++) {
rc = __init_reset_clk(res, i);
if (rc) {
dprintk(CVP_ERR, "Failed to init reset clocks\n");
rc = -ENODEV;
goto err_init_reset_clk;
}
}
rc = __init_bus(device);
if (rc) {
dprintk(CVP_ERR, "Failed to init bus: %d\n", rc);
goto err_init_bus;
}
rc = __init_subcaches(device);
if (rc)
dprintk(CVP_WARN, "Failed to init subcaches: %d\n", rc);
device->sys_init_capabilities =
kzalloc(sizeof(struct msm_cvp_capability)
* CVP_MAX_SESSIONS, GFP_KERNEL);
return rc;
err_init_reset_clk:
err_init_bus:
msm_cvp_deinit_clocks(device);
err_init_clocks:
__deinit_regulators(device);
return rc;
}
static void __deinit_resources(struct iris_hfi_device *device)
{
__deinit_subcaches(device);
__deinit_bus(device);
msm_cvp_deinit_clocks(device);
__deinit_regulators(device);
kfree(device->sys_init_capabilities);
device->sys_init_capabilities = NULL;
}
static int __disable_regulator_impl(struct regulator_info *rinfo,
struct iris_hfi_device *device)
{
int rc = 0;
dprintk(CVP_PWR, "Disabling regulator %s\n", rinfo->name);
/*
* This call is needed. Driver needs to acquire the control back
* from HW in order to disable the regualtor. Else the behavior
* is unknown.
*/
rc = __acquire_regulator(rinfo, device);
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
*/
dprintk(CVP_WARN,
"Failed to acquire control on %s\n",
rinfo->name);
goto disable_regulator_failed;
}
rc = regulator_disable(rinfo->regulator);
if (rc) {
dprintk(CVP_WARN,
"Failed to disable %s: %d\n",
rinfo->name, rc);
goto disable_regulator_failed;
}
return 0;
disable_regulator_failed:
/* Bring attention to this issue */
msm_cvp_res_handle_fatal_hw_error(device->res, true);
return rc;
}
static int __disable_hw_power_collapse(struct iris_hfi_device *device)
{
int rc = 0;
if (!msm_cvp_fw_low_power_mode) {
dprintk(CVP_PWR, "Not enabling hardware power collapse\n");
return 0;
}
rc = __take_back_regulators(device);
if (rc)
dprintk(CVP_WARN,
"%s : Failed to disable HW power collapse %d\n",
__func__, rc);
return rc;
}
static int __enable_hw_power_collapse(struct iris_hfi_device *device)
{
int rc = 0;
if (!msm_cvp_fw_low_power_mode) {
dprintk(CVP_PWR, "Not enabling hardware power collapse\n");
return 0;
}
rc = __hand_off_regulators(device);
if (rc)
dprintk(CVP_WARN,
"%s : Failed to enable HW power collapse %d\n",
__func__, rc);
return rc;
}
static int __enable_regulator(struct iris_hfi_device *device,
const char *name)
{
int rc = 0;
struct regulator_info *rinfo;
iris_hfi_for_each_regulator(device, rinfo) {
if (strcmp(rinfo->name, name))
continue;
rc = regulator_enable(rinfo->regulator);
if (rc) {
dprintk(CVP_ERR, "Failed to enable %s: %d\n",
rinfo->name, rc);
return rc;
}
if (!regulator_is_enabled(rinfo->regulator)) {
dprintk(CVP_ERR,"%s: regulator %s not enabled\n",
__func__, rinfo->name);
regulator_disable(rinfo->regulator);
return -EINVAL;
}
dprintk(CVP_PWR, "Enabled regulator %s\n", rinfo->name);
return 0;
}
dprintk(CVP_ERR, "regulator %s not found\n", name);
return -EINVAL;
}
static int __disable_regulator(struct iris_hfi_device *device,
const char *name)
{
struct regulator_info *rinfo;
iris_hfi_for_each_regulator_reverse(device, rinfo) {
if (strcmp(rinfo->name, name))
continue;
__disable_regulator_impl(rinfo, device);
dprintk(CVP_PWR, "%s Disabled regulator %s\n", __func__, name);
return 0;
}
dprintk(CVP_ERR, "%s regulator %s not found\n", __func__, name);
return -EINVAL;
}
static int __enable_subcaches(struct iris_hfi_device *device)
{
int rc = 0;
u32 c = 0;
struct subcache_info *sinfo;
if (msm_cvp_syscache_disable || !is_sys_cache_present(device))
return 0;
/* Activate subcaches */
iris_hfi_for_each_subcache(device, sinfo) {
rc = llcc_slice_activate(sinfo->subcache);
if (rc) {
dprintk(CVP_WARN, "Failed to activate %s: %d\n",
sinfo->name, rc);
msm_cvp_res_handle_fatal_hw_error(device->res, true);
goto err_activate_fail;
}
sinfo->isactive = true;
dprintk(CVP_CORE, "Activated subcache %s\n", sinfo->name);
c++;
}
dprintk(CVP_CORE, "Activated %d Subcaches to CVP\n", c);
return 0;
err_activate_fail:
__release_subcaches(device);
__disable_subcaches(device);
return 0;
}
static int __set_subcaches(struct iris_hfi_device *device)
{
int rc = 0;
u32 c = 0;
struct subcache_info *sinfo;
u32 resource[CVP_MAX_SUBCACHE_SIZE];
struct cvp_hfi_resource_syscache_info_type *sc_res_info;
struct cvp_hfi_resource_subcache_type *sc_res;
struct cvp_resource_hdr rhdr;
if (device->res->sys_cache_res_set || msm_cvp_syscache_disable) {
dprintk(CVP_CORE, "Subcaches already set or disabled\n");
return 0;
}
memset((void *)resource, 0x0, (sizeof(u32) * CVP_MAX_SUBCACHE_SIZE));
sc_res_info = (struct cvp_hfi_resource_syscache_info_type *)resource;
sc_res = &(sc_res_info->rg_subcache_entries[0]);
iris_hfi_for_each_subcache(device, sinfo) {
if (sinfo->isactive) {
sc_res[c].size = sinfo->subcache->slice_size;
sc_res[c].sc_id = sinfo->subcache->slice_id;
c++;
}
}
/* Set resource to CVP for activated subcaches */
if (c) {
dprintk(CVP_CORE, "Setting %d Subcaches\n", c);
rhdr.resource_handle = sc_res_info; /* cookie */
rhdr.resource_id = CVP_RESOURCE_SYSCACHE;
sc_res_info->num_entries = c;
rc = __core_set_resource(device, &rhdr, (void *)sc_res_info);
if (rc) {
dprintk(CVP_WARN, "Failed to set subcaches %d\n", rc);
goto err_fail_set_subacaches;
}
iris_hfi_for_each_subcache(device, sinfo) {
if (sinfo->isactive)
sinfo->isset = true;
}
dprintk(CVP_CORE, "Set Subcaches done to CVP\n");
device->res->sys_cache_res_set = true;
}
return 0;
err_fail_set_subacaches:
__disable_subcaches(device);
return 0;
}
static int __release_subcaches(struct iris_hfi_device *device)
{
struct subcache_info *sinfo;
int rc = 0;
u32 c = 0;
u32 resource[CVP_MAX_SUBCACHE_SIZE];
struct cvp_hfi_resource_syscache_info_type *sc_res_info;
struct cvp_hfi_resource_subcache_type *sc_res;
struct cvp_resource_hdr rhdr;
if (msm_cvp_syscache_disable || !is_sys_cache_present(device))
return 0;
memset((void *)resource, 0x0, (sizeof(u32) * CVP_MAX_SUBCACHE_SIZE));
sc_res_info = (struct cvp_hfi_resource_syscache_info_type *)resource;
sc_res = &(sc_res_info->rg_subcache_entries[0]);
/* Release resource command to Iris */
iris_hfi_for_each_subcache_reverse(device, sinfo) {
if (sinfo->isset) {
/* Update the entry */
sc_res[c].size = sinfo->subcache->slice_size;
sc_res[c].sc_id = sinfo->subcache->slice_id;
c++;
sinfo->isset = false;
}
}
if (c > 0) {
dprintk(CVP_CORE, "Releasing %d subcaches\n", c);
rhdr.resource_handle = sc_res_info; /* cookie */
rhdr.resource_id = CVP_RESOURCE_SYSCACHE;
rc = __core_release_resource(device, &rhdr);
if (rc)
dprintk(CVP_WARN,
"Failed to release %d subcaches\n", c);
}
device->res->sys_cache_res_set = false;
return 0;
}
static int __disable_subcaches(struct iris_hfi_device *device)
{
struct subcache_info *sinfo;
int rc = 0;
if (msm_cvp_syscache_disable || !is_sys_cache_present(device))
return 0;
/* De-activate subcaches */
iris_hfi_for_each_subcache_reverse(device, sinfo) {
if (sinfo->isactive) {
dprintk(CVP_CORE, "De-activate subcache %s\n",
sinfo->name);
rc = llcc_slice_deactivate(sinfo->subcache);
if (rc) {
dprintk(CVP_WARN,
"Failed to de-activate %s: %d\n",
sinfo->name, rc);
}
sinfo->isactive = false;
}
}
return 0;
}
static void interrupt_init_iris2(struct iris_hfi_device *device)
{
u32 mask_val = 0;
/* All interrupts should be disabled initially 0x1F6 : Reset value */
mask_val = __read_register(device, CVP_WRAPPER_INTR_MASK);
/* Write 0 to unmask CPU and WD interrupts */
mask_val &= ~(CVP_FATAL_INTR_BMSK | CVP_WRAPPER_INTR_MASK_A2HCPU_BMSK);
__write_register(device, CVP_WRAPPER_INTR_MASK, mask_val);
dprintk(CVP_REG, "Init irq: reg: %x, mask value %x\n",
CVP_WRAPPER_INTR_MASK, mask_val);
mask_val = 0;
mask_val = __read_register(device, CVP_SS_IRQ_MASK);
mask_val &= ~(CVP_SS_INTR_BMASK);
__write_register(device, CVP_SS_IRQ_MASK, mask_val);
dprintk(CVP_REG, "Init irq_wd: reg: %x, mask value %x\n",
CVP_SS_IRQ_MASK, mask_val);
}
static void setup_dsp_uc_memmap_vpu5(struct iris_hfi_device *device)
{
/* initialize DSP QTBL & UCREGION with CPU queues */
__write_register(device, HFI_DSP_QTBL_ADDR,
(u32)device->dsp_iface_q_table.align_device_addr);
__write_register(device, HFI_DSP_UC_REGION_ADDR,
(u32)device->dsp_iface_q_table.align_device_addr);
__write_register(device, HFI_DSP_UC_REGION_SIZE,
device->dsp_iface_q_table.mem_data.size);
}
static void clock_config_on_enable_vpu5(struct iris_hfi_device *device)
{
__write_register(device, CVP_WRAPPER_CPU_CLOCK_CONFIG, 0);
}
static int __set_ubwc_config(struct iris_hfi_device *device)
{
u8 packet[CVP_IFACEQ_VAR_SMALL_PKT_SIZE];
int rc = 0;
struct cvp_hfi_cmd_sys_set_property_packet *pkt =
(struct cvp_hfi_cmd_sys_set_property_packet *) &packet;
if (!device->res->ubwc_config)
return 0;
rc = call_hfi_pkt_op(device, sys_ubwc_config, pkt,
device->res->ubwc_config);
if (rc) {
dprintk(CVP_WARN,
"ubwc config setting to FW failed\n");
rc = -ENOTEMPTY;
goto fail_to_set_ubwc_config;
}
if (__iface_cmdq_write(device, pkt)) {
rc = -ENOTEMPTY;
goto fail_to_set_ubwc_config;
}
fail_to_set_ubwc_config:
return rc;
}
static int __power_on_controller(struct iris_hfi_device *device)
{
int rc = 0;
rc = __enable_regulator(device, "cvp");
if (rc) {
dprintk(CVP_ERR, "Failed to enable ctrler: %d\n", rc);
return rc;
}
rc = msm_cvp_prepare_enable_clk(device, "sleep_clk");
if (rc) {
dprintk(CVP_ERR, "Failed to enable sleep clk: %d\n", rc);
goto fail_reset_clks;
}
rc = call_iris_op(device, reset_control_assert_name, device, "cvp_axi_reset");
if (rc)
dprintk(CVP_ERR, "%s: assert cvp_axi_reset failed\n", __func__);
rc = call_iris_op(device, reset_control_assert_name, device, "cvp_core_reset");
if (rc)
dprintk(CVP_ERR, "%s: assert cvp_core_reset failed\n", __func__);
/* wait for deassert */
usleep_range(1000, 1050);
rc = call_iris_op(device, reset_control_deassert_name, device, "cvp_axi_reset");
if (rc)
dprintk(CVP_ERR, "%s: de-assert cvp_axi_reset failed\n", __func__);
rc = call_iris_op(device, reset_control_deassert_name, device, "cvp_core_reset");
if (rc)
dprintk(CVP_ERR, "%s: de-assert cvp_core_reset failed\n", __func__);
rc = msm_cvp_prepare_enable_clk(device, "gcc_video_axi1");
if (rc) {
dprintk(CVP_ERR, "Failed to enable axi1 clk: %d\n", rc);
goto fail_reset_clks;
}
rc = msm_cvp_prepare_enable_clk(device, "cvp_clk");
if (rc) {
dprintk(CVP_ERR, "Failed to enable cvp_clk: %d\n", rc);
goto fail_enable_clk;
}
dprintk(CVP_PWR, "EVA controller powered on\n");
return 0;
fail_enable_clk:
msm_cvp_disable_unprepare_clk(device, "gcc_video_axi1");
fail_reset_clks:
__disable_regulator(device, "cvp");
return rc;
}
static int __power_on_core(struct iris_hfi_device *device)
{
int rc = 0;
rc = __enable_regulator(device, "cvp-core");
if (rc) {
dprintk(CVP_ERR, "Failed to enable core: %d\n", rc);
return rc;
}
rc = msm_cvp_prepare_enable_clk(device, "video_cc_mvs1_clk_src");
if (rc) {
dprintk(CVP_ERR, "Failed to enable video_cc_mvs1_clk_src:%d\n",
rc);
__disable_regulator(device, "cvp-core");
return rc;
}
rc = msm_cvp_prepare_enable_clk(device, "core_clk");
if (rc) {
dprintk(CVP_ERR, "Failed to enable core_clk: %d\n", rc);
__disable_regulator(device, "cvp-core");
return rc;
}
/*#ifdef CONFIG_EVA_PINEAPPLE
__write_register(device, CVP_AON_WRAPPER_CVP_NOC_ARCG_CONTROL, 0);
__write_register(device, CVP_NOC_RCGCONTROLLER_HYSTERESIS_LOW, 0x2f);
__write_register(device, CVP_NOC_RCG_VNOC_NOC_CLK_FORCECLOCKON_LOW, 1);
__write_register(device, CVP_NOC_RCGCONTROLLER_MAINCTL_LOW, 1);
usleep_range(50, 100);
__write_register(device, CVP_NOC_RCG_VNOC_NOC_CLK_FORCECLOCKON_LOW, 0);
#endif*/
dprintk(CVP_PWR, "EVA core powered on\n");
return 0;
}
static int __iris_power_on(struct iris_hfi_device *device)
{
int rc = 0;
if (device->power_enabled)
return 0;
/* Vote for all hardware resources */
rc = __vote_buses(device, device->bus_vote.data,
device->bus_vote.data_count);
if (rc) {
dprintk(CVP_ERR, "Failed to vote buses, err: %d\n", rc);
goto fail_vote_buses;
}
rc = __power_on_controller(device);
if (rc)
goto fail_enable_controller;
rc = __power_on_core(device);
if (rc)
goto fail_enable_core;
rc = msm_cvp_scale_clocks(device);
if (rc) {
dprintk(CVP_WARN,
"Failed to scale clocks, perf may regress\n");
rc = 0;
} else {
dprintk(CVP_PWR, "Done with scaling\n");
}
/*Do not access registers before this point!*/
device->power_enabled = true;
/*
* Re-program all of the registers that get reset as a result of
* regulator_disable() and _enable()
* calling below function requires CORE powered on
*/
rc = __set_registers(device);
if (rc)
goto fail_enable_core;
dprintk(CVP_CORE, "Done with register set\n");
call_iris_op(device, interrupt_init, device);
dprintk(CVP_CORE, "Done with interrupt enabling\n");
device->intr_status = 0;
enable_irq(device->cvp_hal_data->irq);
__write_register(device,
CVP_WRAPPER_DEBUG_BRIDGE_LPI_CONTROL, 0x7);
pr_info_ratelimited(CVP_DBG_TAG "cvp (eva) powered on\n", "pwr");
return 0;
fail_enable_core:
__power_off_controller(device);
fail_enable_controller:
__unvote_buses(device);
fail_vote_buses:
device->power_enabled = false;
return rc;
}
static inline int __suspend(struct iris_hfi_device *device)
{
int rc = 0;
if (!device) {
dprintk(CVP_ERR, "Invalid params: %pK\n", device);
return -EINVAL;
} else if (!device->power_enabled) {
dprintk(CVP_PWR, "Power already disabled\n");
return 0;
}
dprintk(CVP_PWR, "Entering suspend\n");
rc = __tzbsp_set_cvp_state(TZ_SUBSYS_STATE_SUSPEND);
if (rc) {
dprintk(CVP_WARN, "Failed to suspend cvp core %d\n", rc);
goto err_tzbsp_suspend;
}
__disable_subcaches(device);
call_iris_op(device, power_off, device);
if (device->res->pm_qos.latency_us && device->res->pm_qos.pm_qos_hdls)
cvp_pm_qos_update(device, false);
return rc;
err_tzbsp_suspend:
return rc;
}
static void __print_sidebandmanager_regs(struct iris_hfi_device *device)
{
u32 sbm_ln0_low, axi_cbcr;
u32 main_sbm_ln0_low = 0xdeadbeef, main_sbm_ln0_high = 0xdeadbeef;
u32 main_sbm_ln1_high = 0xdeadbeef, cpu_cs_x2rpmh;
int rc;
sbm_ln0_low =
__read_register(device, CVP_NOC_SBM_SENSELN0_LOW);
cpu_cs_x2rpmh = __read_register(device, CVP_CPU_CS_X2RPMh);
__write_register(device, CVP_CPU_CS_X2RPMh,
(cpu_cs_x2rpmh | CVP_CPU_CS_X2RPMh_SWOVERRIDE_BMSK));
usleep_range(500, 1000);
cpu_cs_x2rpmh = __read_register(device, CVP_CPU_CS_X2RPMh);
if (!(cpu_cs_x2rpmh & CVP_CPU_CS_X2RPMh_SWOVERRIDE_BMSK)) {
dprintk(CVP_WARN,
"failed set CVP_CPU_CS_X2RPMH mask %x\n",
cpu_cs_x2rpmh);
goto exit;
}
axi_cbcr = __read_gcc_register(device, CVP_GCC_VIDEO_AXI1_CBCR);
if (axi_cbcr & 0x80000000) {
dprintk(CVP_WARN, "failed to turn on AXI clock %x\n",
axi_cbcr);
goto exit;
}
rc = call_iris_op(device, reset_control_acquire_name, device, "cvp_xo_reset");
if (rc) {
dprintk(CVP_WARN, "%s Fail acquire xo_reset\n", __func__);
goto exit;
}
main_sbm_ln0_low = __read_register(device,
CVP_NOC_MAIN_SIDEBANDMANAGER_SENSELN0_LOW);
main_sbm_ln0_high = __read_register(device,
CVP_NOC_MAIN_SIDEBANDMANAGER_SENSELN0_HIGH);
main_sbm_ln1_high = __read_register(device,
CVP_NOC_MAIN_SIDEBANDMANAGER_SENSELN1_HIGH);
call_iris_op(device, reset_control_release_name, device, "cvp_xo_reset");
exit:
cpu_cs_x2rpmh = cpu_cs_x2rpmh & (~CVP_CPU_CS_X2RPMh_SWOVERRIDE_BMSK);
__write_register(device, CVP_CPU_CS_X2RPMh, cpu_cs_x2rpmh);
dprintk(CVP_WARN, "Sidebandmanager regs %x %x %x %x %x\n",
sbm_ln0_low, main_sbm_ln0_low,
main_sbm_ln0_high, main_sbm_ln1_high,
cpu_cs_x2rpmh);
}
static int __power_off_controller(struct iris_hfi_device *device)
{
u32 lpi_status, reg_status = 0, count = 0, max_count = 1000;
u32 sbm_ln0_low;
int rc;
u32 spare_val, spare_status;
/* HPG 6.2.2 Step 1 */
__write_register(device, CVP_CPU_CS_X2RPMh, 0x3);
/* HPG 6.2.2 Step 2, noc to low power */
/* New addition to put CPU/Tensilica to low power */
reg_status = 0;
count = 0;
__write_register(device, CVP_WRAPPER_CPU_NOC_LPI_CONTROL, 0x1);
while (!reg_status && count < max_count) {
lpi_status =
__read_register(device,
CVP_WRAPPER_CPU_NOC_LPI_STATUS);
reg_status = lpi_status & BIT(0);
/* Wait for CPU noc lpi status to be set */
usleep_range(50, 100);
count++;
}
sbm_ln0_low = __read_register(device, CVP_NOC_SBM_SENSELN0_LOW);
dprintk(CVP_PWR,
"CPU Noc: lpi_status %x noc_status %x (count %d) 0x%x\n",
lpi_status, reg_status, count, sbm_ln0_low);
if (count == max_count) {
u32 pc_ready, wfi_status;
wfi_status = __read_register(device, CVP_WRAPPER_CPU_STATUS);
pc_ready = __read_register(device, CVP_CTRL_STATUS);
dprintk(CVP_WARN,
"CPU NOC not in qaccept status %x %x %x %x\n",
reg_status, lpi_status, wfi_status, pc_ready);
__print_sidebandmanager_regs(device);
}
/* HPG 6.2.2 Step 3, debug bridge to low power BYPASSED */
/* HPG 6.2.2 Step 4, debug bridge to lpi release */
__write_register(device,
CVP_WRAPPER_DEBUG_BRIDGE_LPI_CONTROL, 0x0);
lpi_status = 0x1;
count = 0;
while (lpi_status && count < max_count) {
lpi_status = __read_register(device,
CVP_WRAPPER_DEBUG_BRIDGE_LPI_STATUS);
usleep_range(50, 100);
count++;
}
dprintk(CVP_PWR,
"DBLP Release: lpi_status %d(count %d)\n",
lpi_status, count);
if (count == max_count) {
dprintk(CVP_WARN,
"DBLP Release: lpi_status %x\n", lpi_status);
}
/* PDXFIFO reset: addition for Kailua / Lanai */
__write_register(device, CVP_WRAPPER_AXI_CLOCK_CONFIG, 0x3);
__write_register(device, CVP_WRAPPER_QNS4PDXFIFO_RESET, 0x1);
__write_register(device, CVP_WRAPPER_QNS4PDXFIFO_RESET, 0x0);
__write_register(device, CVP_WRAPPER_AXI_CLOCK_CONFIG, 0x0);
/* HPG 6.2.2 Step 5 */
msm_cvp_disable_unprepare_clk(device, "cvp_clk");
rc = call_iris_op(device, reset_control_assert_name, device, "cvp_axi_reset");
if (rc)
dprintk(CVP_ERR, "%s: assert cvp_axi_reset failed\n", __func__);
rc = call_iris_op(device, reset_control_assert_name, device, "cvp_core_reset");
if (rc)
dprintk(CVP_ERR, "%s: assert cvp_core_reset failed\n", __func__);
/* wait for deassert */
usleep_range(1000, 1050);
rc = call_iris_op(device, reset_control_deassert_name, device, "cvp_axi_reset");
if (rc)
dprintk(CVP_ERR, "%s: de-assert cvp_axi_reset failed\n", __func__);
rc = call_iris_op(device, reset_control_deassert_name, device, "cvp_core_reset");
if (rc)
dprintk(CVP_ERR, "%s: de-assert cvp_core_reset failed\n", __func__);
/* disable EVA NoC clock */
__write_register(device, CVP_AON_WRAPPER_CVP_NOC_CORE_CLK_CONTROL, 0x1);
/* enable EVA NoC reset */
__write_register(device, CVP_AON_WRAPPER_CVP_NOC_CORE_SW_RESET, 0x1);
rc = call_iris_op(device, reset_control_acquire_name, device, "cvp_xo_reset");
if (rc) {
dprintk(CVP_ERR, "FATAL ERROR, HPG step 17 to 20 will be bypassed\n");
goto skip_xo_reset;
}
spare_status = 0x1;
while (spare_status != 0x0) {
spare_val = __read_register(device, CVP_AON_WRAPPER_SPARE);
spare_status = spare_val & 0x2;
usleep_range(50, 100);
}
__write_register(device, CVP_AON_WRAPPER_SPARE, 0x1);
rc = call_iris_op(device, reset_control_assert_name, device, "cvp_xo_reset");
if (rc)
dprintk(CVP_ERR, "%s: assert cvp_xo_reset failed\n", __func__);
/* de-assert EVA_NoC reset */
__write_register(device, CVP_AON_WRAPPER_CVP_NOC_CORE_SW_RESET, 0x0);
/* de-assert EVA video_cc XO reset and enable video_cc XO clock after 80us */
usleep_range(80, 100);
rc = call_iris_op(device, reset_control_deassert_name, device, "cvp_xo_reset");
if (rc)
dprintk(CVP_ERR, "%s: de-assert cvp_xo_reset failed\n", __func__);
/* clear XO mask bit - this step was missing in previous sequence */
__write_register(device, CVP_AON_WRAPPER_SPARE, 0x0);
call_iris_op(device, reset_control_release_name, device, "cvp_xo_reset");
skip_xo_reset:
/* enable EVA NoC clock */
__write_register(device, CVP_AON_WRAPPER_CVP_NOC_CORE_CLK_CONTROL, 0x0);
/* De-assert EVA_CTL Force Sleep Retention */
usleep_range(400, 500);
/* HPG 6.2.2 Step 6 */
__disable_regulator(device, "cvp");
/* HPG 6.2.2 Step 7 */
rc = msm_cvp_disable_unprepare_clk(device, "gcc_video_axi1");
if (rc) {
dprintk(CVP_ERR, "Failed to enable axi1 clk: %d\n", rc);
}
rc = msm_cvp_disable_unprepare_clk(device, "sleep_clk");
if (rc) {
dprintk(CVP_ERR, "Failed to disable sleep clk: %d\n", rc);
}
return 0;
}
static int __power_off_core(struct iris_hfi_device *device)
{
u32 reg_status = 0, lpi_status, config, value = 0, count = 0;
u32 warn_flag = 0, max_count = 10;
value = __read_register(device, CVP_CC_MVS1_GDSCR);
if (!(value & 0x80000000)) {
/*
* Core has been powered off by f/w.
* Check NOC reset registers to ensure
* NO outstanding NoC transactions
*/
value = __read_register(device, CVP_NOC_RESET_ACK);
if (value) {
dprintk(CVP_WARN,
"Core off with NOC RESET ACK non-zero %x\n",
value);
__print_sidebandmanager_regs(device);
}
__disable_regulator(device, "cvp-core");
msm_cvp_disable_unprepare_clk(device, "core_clk");
msm_cvp_disable_unprepare_clk(device, "video_cc_mvs1_clk_src");
return 0;
} else if (!(value & 0x2)) {
/*
* HW_CONTROL PC disabled, then core is powered on for
* CVP NoC access
*/
__disable_regulator(device, "cvp-core");
msm_cvp_disable_unprepare_clk(device, "core_clk");
msm_cvp_disable_unprepare_clk(device, "video_cc_mvs1_clk_src");
return 0;
}
dprintk(CVP_PWR, "Driver controls Core power off now\n");
/*
* check to make sure core clock branch enabled else
* we cannot read core idle register
*/
config = __read_register(device, CVP_WRAPPER_CORE_CLOCK_CONFIG);
if (config) {
dprintk(CVP_PWR,
"core clock config not enabled, enable it to access core\n");
__write_register(device, CVP_WRAPPER_CORE_CLOCK_CONFIG, 0);
}
/*
* add MNoC idle check before collapsing MVS1 per HPG update
* poll for NoC DMA idle -> HPG 6.2.1
*
*/
do {
value = __read_register(device, CVP_SS_IDLE_STATUS);
if (value & 0x400000)
break;
else
usleep_range(1000, 2000);
count++;
} while (count < max_count);
if (count == max_count) {
dprintk(CVP_WARN, "Core fail to go idle %x\n", value);
warn_flag = 1;
}
count = 0;
max_count = 1000;
__write_register(device, CVP_AON_WRAPPER_CVP_NOC_LPI_CONTROL, 0x1);
while (!reg_status && count < max_count) {
lpi_status =
__read_register(device,
CVP_AON_WRAPPER_CVP_NOC_LPI_STATUS);
reg_status = lpi_status & BIT(0);
/* Wait for Core noc lpi status to be set */
usleep_range(50, 100);
count++;
}
dprintk(CVP_PWR,
"Core Noc: lpi_status %x noc_status %x (count %d)\n",
lpi_status, reg_status, count);
if (count == max_count) {
u32 pc_ready, wfi_status;
wfi_status = __read_register(device, CVP_WRAPPER_CPU_STATUS);
pc_ready = __read_register(device, CVP_CTRL_STATUS);
dprintk(CVP_WARN,
"Core NOC not in qaccept status %x %x %x %x\n",
reg_status, lpi_status, wfi_status, pc_ready);
__print_sidebandmanager_regs(device);
}
__write_register(device, CVP_AON_WRAPPER_CVP_NOC_LPI_CONTROL, 0x0);
if (warn_flag)
__print_sidebandmanager_regs(device);
/* Reset both sides of 2 ahb2ahb_bridges (TZ and non-TZ) */
__write_register(device, CVP_AHB_BRIDGE_SYNC_RESET, 0x3);
__write_register(device, CVP_AHB_BRIDGE_SYNC_RESET, 0x2);
__write_register(device, CVP_AHB_BRIDGE_SYNC_RESET, 0x0);
__write_register(device, CVP_WRAPPER_CORE_CLOCK_CONFIG, config);
__disable_hw_power_collapse(device);
usleep_range(100, 200);
__disable_regulator(device, "cvp-core");
msm_cvp_disable_unprepare_clk(device, "core_clk");
msm_cvp_disable_unprepare_clk(device, "video_cc_mvs1_clk_src");
return 0;
}
static void power_off_iris2(struct iris_hfi_device *device)
{
if (!device->power_enabled || !device->res->sw_power_collapsible)
return;
if (!(device->intr_status & CVP_WRAPPER_INTR_STATUS_A2HWD_BMSK))
disable_irq_nosync(device->cvp_hal_data->irq);
device->intr_status = 0;
__power_off_core(device);
__power_off_controller(device);
if (__unvote_buses(device))
dprintk(CVP_WARN, "Failed to unvote for buses\n");
/*Do not access registers after this point!*/
device->power_enabled = false;
pr_info(CVP_DBG_TAG "cvp (eva) power collapsed\n", "pwr");
}
static inline int __resume(struct iris_hfi_device *device)
{
int rc = 0;
u32 reg_gdsc, reg_cbcr;
struct msm_cvp_core *core;
if (!device) {
dprintk(CVP_ERR, "Invalid params: %pK\n", device);
return -EINVAL;
} else if (device->power_enabled) {
goto exit;
} else if (!__core_in_valid_state(device)) {
dprintk(CVP_PWR, "iris_hfi_device in deinit state.");
return -EINVAL;
}
core = cvp_driver->cvp_core;
dprintk(CVP_PWR, "Resuming from power collapse\n");
rc = __iris_power_on(device);
if (rc) {
dprintk(CVP_ERR, "Failed to power on cvp\n");
goto err_iris_power_on;
}
reg_gdsc = __read_register(device, CVP_CC_MVS1C_GDSCR);
reg_cbcr = __read_register(device, CVP_CC_MVS1C_CBCR);
if (!(reg_gdsc & 0x80000000) || (reg_cbcr & 0x80000000))
dprintk(CVP_ERR, "CVP power on failed gdsc %x cbcr %x\n",
reg_gdsc, reg_cbcr);
__setup_ucregion_memory_map(device);
/* RUMI: set CVP_CTRL_INIT register to disable synx in FW */
/* Reboot the firmware */
rc = __tzbsp_set_cvp_state(TZ_SUBSYS_STATE_RESUME);
if (rc) {
dprintk(CVP_ERR, "Failed to resume cvp core %d\n", rc);
goto err_set_cvp_state;
}
/* Wait for boot completion */
rc = __boot_firmware(device);
if (rc) {
dprintk(CVP_ERR, "Failed to reset cvp core\n");
goto err_reset_core;
}
/*
* Work around for H/W bug, need to reprogram these registers once
* firmware is out reset
*/
__set_threshold_registers(device);
if (device->res->pm_qos.latency_us && device->res->pm_qos.pm_qos_hdls)
cvp_pm_qos_update(device, true);
__sys_set_debug(device, msm_cvp_fw_debug);
__enable_subcaches(device);
__set_subcaches(device);
__dsp_resume(device);
dprintk(CVP_PWR, "Resumed from power collapse\n");
exit:
/* Don't reset skip_pc_count for SYS_PC_PREP cmd */
if (device->last_packet_type != HFI_CMD_SYS_PC_PREP)
device->skip_pc_count = 0;
return rc;
err_reset_core:
__tzbsp_set_cvp_state(TZ_SUBSYS_STATE_SUSPEND);
err_set_cvp_state:
call_iris_op(device, power_off, device);
err_iris_power_on:
dprintk(CVP_ERR, "Failed to resume from power collapse\n");
return rc;
}
static int __power_on_init(struct iris_hfi_device *device)
{
int rc = 0;
/* Initialize resources */
rc = __init_resources(device, device->res);
if (rc) {
dprintk(CVP_ERR, "Failed to init resources: %d\n", rc);
return rc;
}
rc = __initialize_packetization(device);
if (rc) {
dprintk(CVP_ERR, "Failed to initialize packetization\n");
goto fail_iris_init;
}
rc = __iris_power_on(device);
if (rc) {
dprintk(CVP_ERR, "Failed to power on iris in in load_fw\n");
goto fail_iris_init;
}
return rc;
fail_iris_init:
__deinit_resources(device);
return rc;
}
static int __load_fw(struct iris_hfi_device *device)
{
int rc = 0;
if ((!device->res->use_non_secure_pil && !device->res->firmware_base)
|| device->res->use_non_secure_pil) {
rc = load_cvp_fw_impl(device);
if (rc)
goto fail_load_fw;
}
return rc;
fail_load_fw:
call_iris_op(device, power_off, device);
return rc;
}
static void __unload_fw(struct iris_hfi_device *device)
{
if (!device->resources.fw.cookie)
return;
cancel_delayed_work(&iris_hfi_pm_work);
if (device->state != IRIS_STATE_DEINIT)
flush_workqueue(device->iris_pm_workq);
unload_cvp_fw_impl(device);
__interface_queues_release(device);
call_iris_op(device, power_off, device);
__deinit_resources(device);
dprintk(CVP_WARN, "Firmware unloaded\n");
}
static int iris_hfi_get_fw_info(void *dev, struct cvp_hal_fw_info *fw_info)
{
int i = 0;
struct iris_hfi_device *device = dev;
if (!device || !fw_info) {
dprintk(CVP_ERR,
"%s Invalid parameter: device = %pK fw_info = %pK\n",
__func__, device, fw_info);
return -EINVAL;
}
mutex_lock(&device->lock);
while (cvp_driver->fw_version[i++] != 'V' && i < CVP_VERSION_LENGTH)
;
if (i == CVP_VERSION_LENGTH - 1) {
dprintk(CVP_WARN, "Iris version string is not proper\n");
fw_info->version[0] = '\0';
goto fail_version_string;
}
memcpy(&fw_info->version[0], &cvp_driver->fw_version[0],
CVP_VERSION_LENGTH);
fw_info->version[CVP_VERSION_LENGTH - 1] = '\0';
fail_version_string:
dprintk(CVP_CORE, "F/W version retrieved : %s\n", fw_info->version);
fw_info->base_addr = device->cvp_hal_data->firmware_base;
fw_info->register_base = device->res->register_base;
fw_info->register_size = device->cvp_hal_data->register_size;
fw_info->irq = device->cvp_hal_data->irq;
mutex_unlock(&device->lock);
return 0;
}
static int iris_hfi_get_core_capabilities(void *dev)
{
dprintk(CVP_CORE, "%s not supported yet!\n", __func__);
return 0;
}
static const char * const mid_names[16] = {
"CVP_FW",
"ARP_DATA",
"CVP_MPU_PIXEL",
"CVP_MPU_NON_PIXEL",
"CVP_FDU_PIXEL",
"CVP_FDU_NON_PIXEL",
"CVP_GCE_PIXEL",
"CVP_GCE_NON_PIXEL",
"CVP_TOF_PIXEL",
"CVP_TOF_NON_PIXEL",
"CVP_VADL_PIXEL",
"CVP_VADL_NON_PIXEL",
"CVP_RGE_NON_PIXEL",
"CVP_CDM",
"Invalid",
"Invalid"
};
static void __print_reg_details(u32 val)
{
u32 mid, sid;
mid = (val >> 5) & 0xF;
sid = (val >> 2) & 0x7;
dprintk(CVP_ERR, "CVP_NOC_CORE_ERL_MAIN_ERRLOG3_LOW: %#x\n", val);
dprintk(CVP_ERR, "Sub-client:%s, SID: %d\n", mid_names[mid], sid);
}
static void __err_log(bool logging, u32 *data, const char *name, u32 val)
{
if (logging)
*data = val;
dprintk(CVP_ERR, "%s: %#x\n", name, val);
}
static void __noc_error_info_iris2(struct iris_hfi_device *device)
{
struct msm_cvp_core *core;
struct cvp_noc_log *noc_log;
u32 val = 0, regi, regii, regiii, i;
bool log_required = false;
int rc;
core = cvp_driver->cvp_core;
if (!core->ssr_count && core->resources.max_ssr_allowed > 1)
log_required = true;
noc_log = &core->log.noc_log;
if (noc_log->used) {
dprintk(CVP_WARN, "Data already in NoC log, skip logging\n");
return;
}
noc_log->used = 1;
__disable_hw_power_collapse(device);
val = __read_register(device, CVP_CC_MVS1_GDSCR);
regi = __read_register(device, CVP_AON_WRAPPER_CVP_NOC_CORE_CLK_CONTROL);
regii = __read_register(device, CVP_CC_MVS1_CBCR);
regiii = __read_register(device, CVP_WRAPPER_CORE_CLOCK_CONFIG);
dprintk(CVP_ERR, "noc reg check: %#x %#x %#x %#x\n",
val, regi, regii, regiii);
val = __read_register(device, CVP_NOC_ERR_SWID_LOW_OFFS);
__err_log(log_required, &noc_log->err_ctrl_swid_low,
"CVP_NOC_ERL_MAIN_SWID_LOW", val);
val = __read_register(device, CVP_NOC_ERR_SWID_HIGH_OFFS);
__err_log(log_required, &noc_log->err_ctrl_swid_high,
"CVP_NOC_ERL_MAIN_SWID_HIGH", val);
val = __read_register(device, CVP_NOC_ERR_MAINCTL_LOW_OFFS);
__err_log(log_required, &noc_log->err_ctrl_mainctl_low,
"CVP_NOC_ERL_MAIN_MAINCTL_LOW", val);
val = __read_register(device, CVP_NOC_ERR_ERRVLD_LOW_OFFS);
__err_log(log_required, &noc_log->err_ctrl_errvld_low,
"CVP_NOC_ERL_MAIN_ERRVLD_LOW", val);
val = __read_register(device, CVP_NOC_ERR_ERRCLR_LOW_OFFS);
__err_log(log_required, &noc_log->err_ctrl_errclr_low,
"CVP_NOC_ERL_MAIN_ERRCLR_LOW", val);
val = __read_register(device, CVP_NOC_ERR_ERRLOG0_LOW_OFFS);
__err_log(log_required, &noc_log->err_ctrl_errlog0_low,
"CVP_NOC_ERL_MAIN_ERRLOG0_LOW", val);
val = __read_register(device, CVP_NOC_ERR_ERRLOG0_HIGH_OFFS);
__err_log(log_required, &noc_log->err_ctrl_errlog0_high,
"CVP_NOC_ERL_MAIN_ERRLOG0_HIGH", val);
val = __read_register(device, CVP_NOC_ERR_ERRLOG1_LOW_OFFS);
__err_log(log_required, &noc_log->err_ctrl_errlog1_low,
"CVP_NOC_ERL_MAIN_ERRLOG1_LOW", val);
val = __read_register(device, CVP_NOC_ERR_ERRLOG1_HIGH_OFFS);
__err_log(log_required, &noc_log->err_ctrl_errlog1_high,
"CVP_NOC_ERL_MAIN_ERRLOG1_HIGH", val);
val = __read_register(device, CVP_NOC_ERR_ERRLOG2_LOW_OFFS);
__err_log(log_required, &noc_log->err_ctrl_errlog2_low,
"CVP_NOC_ERL_MAIN_ERRLOG2_LOW", val);
val = __read_register(device, CVP_NOC_ERR_ERRLOG2_HIGH_OFFS);
__err_log(log_required, &noc_log->err_ctrl_errlog2_high,
"CVP_NOC_ERL_MAIN_ERRLOG2_HIGH", val);
val = __read_register(device, CVP_NOC_ERR_ERRLOG3_LOW_OFFS);
__err_log(log_required, &noc_log->err_ctrl_errlog3_low,
"CVP_NOC_ERL_MAIN_ERRLOG3_LOW", val);
val = __read_register(device, CVP_NOC_ERR_ERRLOG3_HIGH_OFFS);
__err_log(log_required, &noc_log->err_ctrl_errlog3_high,
"CVP_NOC_ERL_MAIN_ERRLOG3_HIGH", val);
rc = call_iris_op(device, reset_control_acquire_name, device, "cvp_xo_reset");
if (rc) {
dprintk(CVP_WARN, "%s Fail acquire xo_reset\n", __func__);
return;
}
val = __read_register(device, CVP_NOC_CORE_ERR_SWID_LOW_OFFS);
__err_log(log_required, &noc_log->err_core_swid_low,
"CVP_NOC__CORE_ERL_MAIN_SWID_LOW", val);
val = __read_register(device, CVP_NOC_CORE_ERR_SWID_HIGH_OFFS);
__err_log(log_required, &noc_log->err_core_swid_high,
"CVP_NOC_CORE_ERL_MAIN_SWID_HIGH", val);
val = __read_register(device, CVP_NOC_CORE_ERR_MAINCTL_LOW_OFFS);
__err_log(log_required, &noc_log->err_core_mainctl_low,
"CVP_NOC_CORE_ERL_MAIN_MAINCTL_LOW", val);
val = __read_register(device, CVP_NOC_CORE_ERR_ERRVLD_LOW_OFFS);
__err_log(log_required, &noc_log->err_core_errvld_low,
"CVP_NOC_CORE_ERL_MAIN_ERRVLD_LOW", val);
val = __read_register(device, CVP_NOC_CORE_ERR_ERRCLR_LOW_OFFS);
__err_log(log_required, &noc_log->err_core_errclr_low,
"CVP_NOC_CORE_ERL_MAIN_ERRCLR_LOW", val);
val = __read_register(device, CVP_NOC_CORE_ERR_ERRLOG0_LOW_OFFS);
__err_log(log_required, &noc_log->err_core_errlog0_low,
"CVP_NOC_CORE_ERL_MAIN_ERRLOG0_LOW", val);
val = __read_register(device, CVP_NOC_CORE_ERR_ERRLOG0_HIGH_OFFS);
__err_log(log_required, &noc_log->err_core_errlog0_high,
"CVP_NOC_CORE_ERL_MAIN_ERRLOG0_HIGH", val);
val = __read_register(device, CVP_NOC_CORE_ERR_ERRLOG1_LOW_OFFS);
__err_log(log_required, &noc_log->err_core_errlog1_low,
"CVP_NOC_CORE_ERL_MAIN_ERRLOG1_LOW", val);
val = __read_register(device, CVP_NOC_CORE_ERR_ERRLOG1_HIGH_OFFS);
__err_log(log_required, &noc_log->err_core_errlog1_high,
"CVP_NOC_CORE_ERL_MAIN_ERRLOG1_HIGH", val);
val = __read_register(device, CVP_NOC_CORE_ERR_ERRLOG2_LOW_OFFS);
__err_log(log_required, &noc_log->err_core_errlog2_low,
"CVP_NOC_CORE_ERL_MAIN_ERRLOG2_LOW", val);
val = __read_register(device, CVP_NOC_CORE_ERR_ERRLOG2_HIGH_OFFS);
__err_log(log_required, &noc_log->err_core_errlog2_high,
"CVP_NOC_CORE_ERL_MAIN_ERRLOG2_HIGH", val);
val = __read_register(device, CVP_NOC_CORE_ERR_ERRLOG3_LOW_OFFS);
__err_log(log_required, &noc_log->err_core_errlog3_low,
"CORE ERRLOG3_LOW, below details", val);
__print_reg_details(val);
val = __read_register(device, CVP_NOC_CORE_ERR_ERRLOG3_HIGH_OFFS);
__err_log(log_required, &noc_log->err_core_errlog3_high,
"CVP_NOC_CORE_ERL_MAIN_ERRLOG3_HIGH", val);
__write_register(device, CVP_NOC_CORE_ERR_ERRCLR_LOW_OFFS, 0x1);
call_iris_op(device, reset_control_release_name, device, "cvp_xo_reset");
#define CVP_SS_CLK_HALT 0x8
#define CVP_SS_CLK_EN 0xC
#define CVP_SS_ARP_TEST_BUS_CONTROL 0x700
#define CVP_SS_ARP_TEST_BUS_REGISTER 0x704
#define CVP_DMA_TEST_BUS_CONTROL 0x66A0
#define CVP_DMA_TEST_BUS_REGISTER 0x66A4
#define CVP_VPU_WRAPPER_CORE_CONFIG 0xB0088
__write_register(device, CVP_SS_CLK_HALT, 0);
__write_register(device, CVP_SS_CLK_EN, 0x3f);
__write_register(device, CVP_VPU_WRAPPER_CORE_CONFIG, 0);
for (i = 0; i < 15; i++) {
regi = 0xC0000000 + i;
__write_register(device, CVP_SS_ARP_TEST_BUS_CONTROL, regi);
val = __read_register(device, CVP_SS_ARP_TEST_BUS_REGISTER);
noc_log->arp_test_bus[i] = val;
}
for (i = 0; i < 512; i++) {
regi = 0x40000000 + i;
__write_register(device, CVP_DMA_TEST_BUS_CONTROL, regi);
val = __read_register(device, CVP_DMA_TEST_BUS_REGISTER);
noc_log->dma_test_bus[i] = val;
}
}
static int iris_hfi_noc_error_info(void *dev)
{
struct iris_hfi_device *device;
if (!dev) {
dprintk(CVP_ERR, "%s: null device\n", __func__);
return -EINVAL;
}
device = dev;
mutex_lock(&device->lock);
dprintk(CVP_ERR, "%s: non error information\n", __func__);
call_iris_op(device, noc_error_info, device);
mutex_unlock(&device->lock);
return 0;
}
static int __initialize_packetization(struct iris_hfi_device *device)
{
int rc = 0;
if (!device || !device->res) {
dprintk(CVP_ERR, "%s - invalid param\n", __func__);
return -EINVAL;
}
device->packetization_type = HFI_PACKETIZATION_4XX;
device->pkt_ops = cvp_hfi_get_pkt_ops_handle(
device->packetization_type);
if (!device->pkt_ops) {
rc = -EINVAL;
dprintk(CVP_ERR, "Failed to get pkt_ops handle\n");
}
return rc;
}
void __init_cvp_ops(struct iris_hfi_device *device)
{
device->vpu_ops = &iris2_ops;
}
static struct iris_hfi_device *__add_device(struct msm_cvp_platform_resources *res,
hfi_cmd_response_callback callback)
{
struct iris_hfi_device *hdevice = NULL;
int rc = 0;
if (!res || !callback) {
dprintk(CVP_ERR, "Invalid Parameters\n");
return NULL;
}
hdevice = kzalloc(sizeof(*hdevice), GFP_KERNEL);
if (!hdevice) {
dprintk(CVP_ERR, "failed to allocate new device\n");
goto exit;
}
hdevice->response_pkt = kmalloc_array(cvp_max_packets,
sizeof(*hdevice->response_pkt), GFP_KERNEL);
if (!hdevice->response_pkt) {
dprintk(CVP_ERR, "failed to allocate response_pkt\n");
goto err_cleanup;
}
hdevice->raw_packet =
kzalloc(CVP_IFACEQ_VAR_HUGE_PKT_SIZE, GFP_KERNEL);
if (!hdevice->raw_packet) {
dprintk(CVP_ERR, "failed to allocate raw packet\n");
goto err_cleanup;
}
rc = vm_manager.vm_ops->vm_init_reg_and_irq(hdevice, res);
if (rc)
goto err_cleanup;
hdevice->res = res;
hdevice->callback = callback;
__init_cvp_ops(hdevice);
hdevice->cvp_workq = create_singlethread_workqueue(
"msm_cvp_workerq_iris");
if (!hdevice->cvp_workq) {
dprintk(CVP_ERR, ": create cvp workq failed\n");
goto err_cleanup;
}
hdevice->iris_pm_workq = create_singlethread_workqueue(
"pm_workerq_iris");
if (!hdevice->iris_pm_workq) {
dprintk(CVP_ERR, ": create pm workq failed\n");
goto err_cleanup;
}
mutex_init(&hdevice->lock);
INIT_LIST_HEAD(&hdevice->sess_head);
return hdevice;
err_cleanup:
if (hdevice->iris_pm_workq)
destroy_workqueue(hdevice->iris_pm_workq);
if (hdevice->cvp_workq)
destroy_workqueue(hdevice->cvp_workq);
kfree(hdevice->response_pkt);
kfree(hdevice->raw_packet);
kfree(hdevice);
exit:
return NULL;
}
static struct iris_hfi_device *__get_device(struct msm_cvp_platform_resources *res,
hfi_cmd_response_callback callback)
{
if (!res || !callback) {
dprintk(CVP_ERR, "Invalid params: %pK %pK\n", res, callback);
return NULL;
}
return __add_device(res, callback);
}
void cvp_iris_hfi_delete_device(void *device)
{
struct msm_cvp_core *core;
struct iris_hfi_device *dev = NULL;
if (!device)
return;
core = cvp_driver->cvp_core;
if (core)
dev = core->device->hfi_device_data;
if (!dev)
return;
mutex_destroy(&dev->lock);
destroy_workqueue(dev->cvp_workq);
destroy_workqueue(dev->iris_pm_workq);
free_irq(dev->cvp_hal_data->irq, dev);
iounmap(dev->cvp_hal_data->register_base);
iounmap(dev->cvp_hal_data->gcc_reg_base);
kfree(dev->cvp_hal_data);
kfree(dev->response_pkt);
kfree(dev->raw_packet);
kfree(dev);
}
static int iris_hfi_validate_session(void *sess, const char *func)
{
struct cvp_hal_session *session = sess;
int rc = 0;
struct iris_hfi_device *device;
if (!session || !session->device) {
dprintk(CVP_ERR, " %s Invalid Params %pK\n", __func__, session);
return -EINVAL;
}
device = session->device;
mutex_lock(&device->lock);
if (!__is_session_valid(device, session, func))
rc = -ECONNRESET;
mutex_unlock(&device->lock);
return rc;
}
static void iris_init_hfi_callbacks(struct cvp_hfi_device *hdev)
{
hdev->core_init = iris_hfi_core_init;
hdev->core_release = iris_hfi_core_release;
hdev->core_trigger_ssr = iris_hfi_core_trigger_ssr;
hdev->session_init = iris_hfi_session_init;
hdev->session_end = iris_hfi_session_end;
hdev->session_start = iris_hfi_session_start;
hdev->session_stop = iris_hfi_session_stop;
hdev->session_abort = iris_hfi_session_abort;
hdev->session_clean = iris_hfi_session_clean;
hdev->session_set_buffers = iris_hfi_session_set_buffers;
hdev->session_release_buffers = iris_hfi_session_release_buffers;
hdev->session_send = iris_hfi_session_send;
hdev->session_flush = iris_hfi_session_flush;
hdev->scale_clocks = iris_hfi_scale_clocks;
hdev->vote_bus = iris_hfi_vote_buses;
hdev->get_fw_info = iris_hfi_get_fw_info;
hdev->get_core_capabilities = iris_hfi_get_core_capabilities;
hdev->suspend = iris_hfi_suspend;
hdev->resume = iris_hfi_resume;
hdev->flush_debug_queue = iris_hfi_flush_debug_queue;
hdev->noc_error_info = iris_hfi_noc_error_info;
hdev->validate_session = iris_hfi_validate_session;
hdev->pm_qos_update = iris_pm_qos_update;
hdev->debug_hook = iris_debug_hook;
}
int cvp_iris_hfi_initialize(struct cvp_hfi_device *hdev,
struct msm_cvp_platform_resources *res,
hfi_cmd_response_callback callback)
{
int rc = 0;
if (!hdev || !res || !callback) {
dprintk(CVP_ERR, "Invalid params: %pK %pK %pK\n",
hdev, res, callback);
rc = -EINVAL;
goto err_iris_hfi_init;
}
hdev->hfi_device_data = __get_device(res, callback);
if (IS_ERR_OR_NULL(hdev->hfi_device_data)) {
rc = PTR_ERR(hdev->hfi_device_data) ?: -EINVAL;
goto err_iris_hfi_init;
}
iris_init_hfi_callbacks(hdev);
err_iris_hfi_init:
return rc;
}
Fai riferimento in un nuovo problema Visualizza Git Blame Copia Permalink