shinys000114/linux
1
0
Fork 0
mirror of https://github.com/hardkernel/linux.git synced 2026-06-06 10:58:48 +09:00
Code Issues Packages Projects Releases Wiki Activity

video: rockchip: rga3: log adds process info(tgid/pid)

Browse Source 
Signed-off-by: Yu Qiaowei <cerf.yu@rock-chips.com>
Change-Id: I2a2a6c6c23e78687c476515c71765c518d140620
This commit is contained in:
Yu Qiaowei
2024-08-19 10:33:43 +08:00
committed by Tao Huang
parent b0cac0a410
commit c81e0d308d
13 changed files with 598 additions and 602 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
drivers/video/rockchip/rga3/include/rga_common.h
View File

@@ -12,6 +12,22 @@
#include "rga_drv.h"
#include "rga_hw_config.h"
#ifdef pr_fmt
#undef pr_fmt
#endif
#define pr_fmt(fmt) "%s: " fmt, "rga"
#define rga_log(fmt, args...) \
pr_info("%-6d %-6d: " fmt, get_current()->tgid, get_current()->pid, ##args)
#define rga_err(fmt, args...) \
pr_err("%-6d %-6d: " fmt, get_current()->tgid, get_current()->pid, ##args)
#define rga_dev_log(dev, fmt, args...) \
dev_info(dev, "%-6d %-6d: " fmt, current->tgid, current->pid, ##args)
#define rga_dev_err(dev, fmt, args...) \
dev_err(dev, "%-6d %-6d: " fmt, current->tgid, current->pid, ##args)
#define RGA_GET_PAGE_COUNT(size) (((size) >> PAGE_SHIFT) + (((size) & (~PAGE_MASK)) ? 1 : 0))
bool rga_is_rgb_format(uint32_t format);
@@ -46,5 +62,6 @@ int rga_image_size_cal(int w, int h, int format,
int *yrgb_size, int *uv_size, int *v_size);
void rga_dump_memory_parm(struct rga_memory_parm *parm);
void rga_dump_external_buffer(struct rga_external_buffer *buffer);
void rga_dump_req(struct rga_req *req);
#endif

1
drivers/video/rockchip/rga3/include/rga_debugger.h
View File

@@ -132,7 +132,6 @@ static inline int rga_procfs_init(void)
#endif /* #ifdef CONFIG_ROCKCHIP_RGA_DEBUGGER */
void rga_cmd_print_debug_info(struct rga_req *req);
void rga_request_task_debug_info(struct seq_file *m, struct rga_req *req);
#ifdef CONFIG_NO_GKI
void rga_dump_job_image(struct rga_job *dump_job);

127
drivers/video/rockchip/rga3/rga2_reg_info.c
View File

@@ -5,8 +5,6 @@
* Author: Huang Lee <Putin.li@rock-chips.com>
*/
#define pr_fmt(fmt) "rga2_reg: " fmt
#include "rga2_reg_info.h"
#include "rga_dma_buf.h"
#include "rga_iommu.h"
@@ -350,7 +348,7 @@ static void RGA2_set_reg_src_info(u8 *base, struct rga2_req *msg)
vsp_scale_mode = 0x0;
} else {
/* force select bi-linear */
pr_err("Horizontal scaling will be forcibly switched to bilinear.\n");
rga_err("Horizontal scaling will be forcibly switched to bilinear.\n");
vsp_scale_mode = 0x1;
}
break;
@@ -1355,15 +1353,15 @@ static void RGA2_set_reg_dst_info(u8 *base, struct rga2_req *msg)
if (ydither_en) {
if (x_mirr && y_mirr) {
pr_err("ydither mode do not support rotate x_mirr=%d,y_mirr=%d\n",
rga_err("ydither mode do not support rotate x_mirr=%d,y_mirr=%d\n",
x_mirr, y_mirr);
}
if (msg->dst.act_w != msg->src.act_w)
pr_err("ydither mode do not support x dir scale\n");
rga_err("ydither mode do not support x dir scale\n");
if (msg->dst.act_h != msg->src.act_h)
pr_err("ydither mode do not support y dir scale\n");
rga_err("ydither mode do not support y dir scale\n");
}
if (dst_fmt_y4_lut_en) {
@@ -1918,20 +1916,20 @@ static int RGA_set_reg_gauss(u8 *base, struct rga2_req *msg)
bRGA_GAUSS_COE = (u32 *)(base + RGA2_GAUSS_COE_OFFSET);
if (msg->gauss_config.size != 3) {
pr_err("Gaussian blur only support 3x3\n");
rga_err("Gaussian blur only support 3x3\n");
return -EINVAL;
}
coe = kmalloc(sizeof(uint32_t) * msg->gauss_config.size, GFP_KERNEL);
if (coe == NULL) {
pr_err("Gaussian blur alloc coe buffer error!\n");
rga_err("Gaussian blur alloc coe buffer error!\n");
return -ENOMEM;
}
if (unlikely(copy_from_user(coe,
u64_to_user_ptr(msg->gauss_config.coe_ptr),
sizeof(uint32_t) * msg->gauss_config.size))) {
pr_err("Gaussian blur coe copy_from_user failed\n");
rga_err("Gaussian blur coe copy_from_user failed\n");
kfree(coe);
return -EFAULT;
@@ -2319,7 +2317,7 @@ static int rga2_gen_reg_info(struct rga_scheduler_t *scheduler, u8 *base, struct
RGA2_set_reg_update_patten_buff(base, msg);
break;
default:
pr_err("ERROR msg render mode %d\n", msg->render_mode);
rga_err("ERROR msg render mode %d\n", msg->render_mode);
return -EINVAL;
}
@@ -2623,9 +2621,9 @@ static void rga2_soft_reset(struct rga_scheduler_t *scheduler)
}
if (i == RGA_RESET_TIMEOUT)
pr_err("RAG2 core[%d] soft reset timeout.\n", scheduler->core);
rga_err("RAG2 core[%d] soft reset timeout.\n", scheduler->core);
else
pr_info("RGA2 core[%d] soft reset complete.\n", scheduler->core);
rga_log("RGA2 core[%d] soft reset complete.\n", scheduler->core);
}
@@ -2634,41 +2632,41 @@ static int rga2_check_param(const struct rga_hw_data *data, const struct rga2_re
if (!((req->render_mode == COLOR_FILL_MODE))) {
if (unlikely(rga_hw_out_of_range(&data->input_range,
req->src.act_w, req->src.act_h))) {
pr_err("invalid src resolution act_w = %d, act_h = %d\n",
rga_err("invalid src resolution act_w = %d, act_h = %d\n",
req->src.act_w, req->src.act_h);
return -EINVAL;
}
if (unlikely(req->src.vir_w * rga_get_pixel_stride_from_format(req->src.format) >
data->max_byte_stride * 8)) {
pr_err("invalid src stride, stride = %d, max_byte_stride = %d\n",
rga_err("invalid src stride, stride = %d, max_byte_stride = %d\n",
req->src.vir_w, data->max_byte_stride);
return -EINVAL;
}
if (unlikely(req->src.vir_w < req->src.act_w)) {
pr_err("invalid src_vir_w act_w = %d, vir_w = %d\n",
rga_err("invalid src_vir_w act_w = %d, vir_w = %d\n",
req->src.act_w, req->src.vir_w);
return -EINVAL;
}
}
if (unlikely(rga_hw_out_of_range(&data->output_range, req->dst.act_w, req->dst.act_h))) {
pr_err("invalid dst resolution act_w = %d, act_h = %d\n",
rga_err("invalid dst resolution act_w = %d, act_h = %d\n",
req->dst.act_w, req->dst.act_h);
return -EINVAL;
}
if (unlikely(req->dst.vir_w * rga_get_pixel_stride_from_format(req->dst.format) >
data->max_byte_stride * 8)) {
pr_err("invalid dst stride, stride = %d, max_byte_stride = %d\n",
rga_err("invalid dst stride, stride = %d, max_byte_stride = %d\n",
req->dst.vir_w, data->max_byte_stride);
return -EINVAL;
}
if (unlikely(req->dst.vir_w < req->dst.act_w)) {
if (req->rotate_mode != 1) {
pr_err("invalid dst_vir_w act_h = %d, vir_h = %d\n",
rga_err("invalid dst_vir_w act_h = %d, vir_h = %d\n",
req->dst.act_w, req->dst.vir_w);
return -EINVAL;
}
@@ -2683,77 +2681,77 @@ static int rga2_align_check(struct rga2_req *req)
if ((req->src.vir_w % 16) || (req->src.x_offset % 2) ||
(req->src.act_w % 2) || (req->src.y_offset % 2) ||
(req->src.act_h % 2) || (req->src.vir_h % 2))
pr_info("err src wstride, 10bit yuv\n");
rga_log("err src wstride, 10bit yuv\n");
if (rga_is_yuv10bit_format(req->dst.format))
if ((req->dst.vir_w % 16) || (req->dst.x_offset % 2) ||
(req->dst.act_w % 2) || (req->dst.y_offset % 2) ||
(req->dst.act_h % 2) || (req->dst.vir_h % 2))
pr_info("err dst wstride, 10bit yuv\n");
rga_log("err dst wstride, 10bit yuv\n");
if (rga_is_yuv8bit_format(req->src.format))
if ((req->src.vir_w % 4) || (req->src.x_offset % 2) ||
(req->src.act_w % 2) || (req->src.y_offset % 2) ||
(req->src.act_h % 2) || (req->src.vir_h % 2))
pr_info("err src wstride, 8bit yuv\n");
rga_log("err src wstride, 8bit yuv\n");
if (rga_is_yuv8bit_format(req->dst.format))
if ((req->dst.vir_w % 4) || (req->dst.x_offset % 2) ||
(req->dst.act_w % 2) || (req->dst.y_offset % 2) ||
(req->dst.act_h % 2) || (req->dst.vir_h % 2))
pr_info("err dst wstride, 8bit yuv\n");
rga_log("err dst wstride, 8bit yuv\n");
return 0;
}
static void print_debug_info(struct rga2_req *req)
{
pr_info("render_mode:%s,bitblit_mode=%d,rotate_mode:%s\n",
rga_log("render_mode:%s,bitblit_mode=%d,rotate_mode:%s\n",
rga_get_render_mode_str(req->render_mode), req->bitblt_mode,
rga_get_rotate_mode_str(req->rotate_mode));
pr_info("src: y=%lx uv=%lx v=%lx aw=%d ah=%d vw=%d vh=%d\n",
rga_log("src: y=%lx uv=%lx v=%lx aw=%d ah=%d vw=%d vh=%d\n",
(unsigned long)req->src.yrgb_addr,
(unsigned long)req->src.uv_addr,
(unsigned long)req->src.v_addr,
req->src.act_w, req->src.act_h,
req->src.vir_w, req->src.vir_h);
pr_info("src: xoff=%d yoff=%d format=%s\n",
rga_log("src: xoff=%d yoff=%d format=%s\n",
req->src.x_offset, req->src.y_offset,
rga_get_format_name(req->src.format));
if (req->src1.yrgb_addr != 0 || req->src1.uv_addr != 0
|| req->src1.v_addr != 0) {
pr_info("src1: y=%lx uv=%lx v=%lx aw=%d ah=%d vw=%d vh=%d\n",
rga_log("src1: y=%lx uv=%lx v=%lx aw=%d ah=%d vw=%d vh=%d\n",
(unsigned long)req->src1.yrgb_addr,
(unsigned long)req->src1.uv_addr,
(unsigned long)req->src1.v_addr,
req->src1.act_w, req->src1.act_h,
req->src1.vir_w, req->src1.vir_h);
pr_info("src1: xoff=%d yoff=%d format=%s\n",
rga_log("src1: xoff=%d yoff=%d format=%s\n",
req->src1.x_offset, req->src1.y_offset,
rga_get_format_name(req->src1.format));
}
pr_info("dst: y=%lx uv=%lx v=%lx aw=%d ah=%d vw=%d vh=%d\n",
rga_log("dst: y=%lx uv=%lx v=%lx aw=%d ah=%d vw=%d vh=%d\n",
(unsigned long)req->dst.yrgb_addr,
(unsigned long)req->dst.uv_addr,
(unsigned long)req->dst.v_addr,
req->dst.act_w, req->dst.act_h,
req->dst.vir_w, req->dst.vir_h);
pr_info("dst: xoff=%d yoff=%d format=%s\n",
rga_log("dst: xoff=%d yoff=%d format=%s\n",
req->dst.x_offset, req->dst.y_offset,
rga_get_format_name(req->dst.format));
pr_info("mmu: src=%.2x src1=%.2x dst=%.2x els=%.2x\n",
rga_log("mmu: src=%.2x src1=%.2x dst=%.2x els=%.2x\n",
req->mmu_info.src0_mmu_flag, req->mmu_info.src1_mmu_flag,
req->mmu_info.dst_mmu_flag, req->mmu_info.els_mmu_flag);
pr_info("alpha: flag %x mode=%s\n",
rga_log("alpha: flag %x mode=%s\n",
req->alpha_rop_flag, rga_get_blend_mode_str(req->alpha_config.mode));
pr_info("alpha: pre_multi=[%d,%d] pixl=[%d,%d] glb=[%d,%d]\n",
rga_log("alpha: pre_multi=[%d,%d] pixl=[%d,%d] glb=[%d,%d]\n",
req->alpha_config.fg_pre_multiplied, req->alpha_config.bg_pre_multiplied,
req->alpha_config.fg_pixel_alpha_en, req->alpha_config.bg_pixel_alpha_en,
req->alpha_config.fg_global_alpha_en, req->alpha_config.bg_global_alpha_en);
pr_info("alpha: fg_global_alpha=%x bg_global_alpha=%x\n",
rga_log("alpha: fg_global_alpha=%x bg_global_alpha=%x\n",
req->alpha_config.fg_global_alpha_value, req->alpha_config.bg_global_alpha_value);
pr_info("yuv2rgb mode is %x\n", req->yuv2rgb_mode);
rga_log("yuv2rgb mode is %x\n", req->yuv2rgb_mode);
}
static int rga2_init_reg(struct rga_job *job)
@@ -2765,7 +2763,7 @@ static int rga2_init_reg(struct rga_job *job)
scheduler = job->scheduler;
if (unlikely(scheduler == NULL)) {
pr_err("failed to get scheduler, %s(%d)\n", __func__, __LINE__);
rga_err("failed to get scheduler, %s(%d)\n", __func__, __LINE__);
return -EINVAL;
}
@@ -2796,7 +2794,7 @@ static int rga2_init_reg(struct rga_job *job)
/* check value if legal */
ret = rga2_check_param(scheduler->data, &req);
if (ret == -EINVAL) {
pr_err("req argument is inval\n");
rga_err("req argument is inval\n");
return ret;
}
@@ -2810,17 +2808,17 @@ static int rga2_init_reg(struct rga_job *job)
if ((req.mmu_info.src0_mmu_flag & 1) || (req.mmu_info.src1_mmu_flag & 1) ||
(req.mmu_info.dst_mmu_flag & 1) || (req.mmu_info.els_mmu_flag & 1)) {
if (scheduler->data->mmu != RGA_MMU) {
pr_err("core[%d] has no MMU, please use physically contiguous memory.\n",
scheduler->core);
pr_err("mmu_flag[src, src1, dst, els] = [0x%x, 0x%x, 0x%x, 0x%x]\n",
req.mmu_info.src0_mmu_flag, req.mmu_info.src1_mmu_flag,
req.mmu_info.dst_mmu_flag, req.mmu_info.els_mmu_flag);
rga_err("core[%d] has no MMU, please use physically contiguous memory.\n",
scheduler->core);
rga_err("mmu_flag[src, src1, dst, els] = [0x%x, 0x%x, 0x%x, 0x%x]\n",
req.mmu_info.src0_mmu_flag, req.mmu_info.src1_mmu_flag,
req.mmu_info.dst_mmu_flag, req.mmu_info.els_mmu_flag);
return -EINVAL;
}
ret = rga_set_mmu_base(job, &req);
if (ret < 0) {
pr_err("%s, [%d] set mmu info error\n", __func__,
rga_err("%s, [%d] set mmu info error\n", __func__,
__LINE__);
return -EFAULT;
}
@@ -2832,12 +2830,12 @@ static int rga2_init_reg(struct rga_job *job)
ret = rga2_gen_reg_info(scheduler, (uint8_t *)job->cmd_buf->vaddr, &req);
if (ret < 0) {
pr_err("gen reg info error\n");
rga_err("gen reg info error\n");
return -EINVAL;
}
if (DEBUGGER_EN(TIME))
pr_info("request[%d], generate register cost time %lld us\n",
rga_log("request[%d], generate register cost time %lld us\n",
job->request_id, ktime_us_delta(ktime_get(), timestamp));
return ret;
@@ -2856,9 +2854,9 @@ static void rga2_dump_read_back_sys_reg(struct rga_scheduler_t *scheduler)
spin_unlock_irqrestore(&scheduler->irq_lock, flags);
pr_info("SYS_READ_BACK_REG\n");
rga_log("SYS_READ_BACK_REG\n");
for (i = 0; i < 6; i++)
pr_info("0x%04x : %.8x %.8x %.8x %.8x\n",
rga_log("0x%04x : %.8x %.8x %.8x %.8x\n",
RGA2_SYS_REG_BASE + i * 0x10,
sys_reg[0 + i * 4], sys_reg[1 + i * 4],
sys_reg[2 + i * 4], sys_reg[3 + i * 4]);
@@ -2877,9 +2875,9 @@ static void rga2_dump_read_back_csc_reg(struct rga_scheduler_t *scheduler)
spin_unlock_irqrestore(&scheduler->irq_lock, flags);
pr_info("CSC_READ_BACK_REG\n");
rga_log("CSC_READ_BACK_REG\n");
for (i = 0; i < 3; i++)
pr_info("0x%04x : %.8x %.8x %.8x %.8x\n",
rga_log("0x%04x : %.8x %.8x %.8x %.8x\n",
RGA2_CSC_REG_BASE + i * 0x10,
csc_reg[0 + i * 4], csc_reg[1 + i * 4],
csc_reg[2 + i * 4], csc_reg[3 + i * 4]);
@@ -2898,9 +2896,9 @@ static void rga2_dump_read_back_cmd_reg(struct rga_scheduler_t *scheduler)
spin_unlock_irqrestore(&scheduler->irq_lock, flags);
pr_info("CMD_READ_BACK_REG\n");
rga_log("CMD_READ_BACK_REG\n");
for (i = 0; i < 8; i++)
pr_info("0x%04x : %.8x %.8x %.8x %.8x\n",
rga_log("0x%04x : %.8x %.8x %.8x %.8x\n",
RGA2_CMD_REG_BASE + i * 0x10,
cmd_reg[0 + i * 4], cmd_reg[1 + i * 4],
cmd_reg[2 + i * 4], cmd_reg[3 + i * 4]);
@@ -2993,9 +2991,10 @@ static int rga2_set_reg(struct rga_job *job, struct rga_scheduler_t *scheduler)
rga2_dump_read_back_sys_reg(scheduler);
rga2_dump_read_back_csc_reg(scheduler);
pr_info("CMD_REG\n");
rga_log("CMD_REG\n");
for (i = 0; i < 8; i++)
pr_info("i = %x : %.8x %.8x %.8x %.8x\n", i,
rga_log("0x%04x : %.8x %.8x %.8x %.8x\n",
RGA2_CMD_REG_BASE + i * 0x10,
cmd[0 + i * 4], cmd[1 + i * 4],
cmd[2 + i * 4], cmd[3 + i * 4]);
}
@@ -3052,7 +3051,7 @@ static int rga2_set_reg(struct rga_job *job, struct rga_scheduler_t *scheduler)
spin_unlock_irqrestore(&scheduler->irq_lock, flags);
if (DEBUGGER_EN(TIME))
pr_info("request[%d], set register cost time %lld us\n",
rga_log("request[%d], set register cost time %lld us\n",
job->request_id, ktime_us_delta(ktime_get(), now));
job->hw_running_time = now;
@@ -3071,7 +3070,7 @@ static int rga2_get_version(struct rga_scheduler_t *scheduler)
u32 reg_version;
if (!scheduler) {
pr_err("scheduler is null\n");
rga_err("scheduler is null\n");
return -EINVAL;
}
@@ -3133,7 +3132,7 @@ static int rga2_irq(struct rga_scheduler_t *scheduler)
scheduler->ops->read_status(job, scheduler);
if (DEBUGGER_EN(INT_FLAG))
pr_info("irq handler, INTR[0x%x], HW_STATUS[0x%x], CMD_STATUS[0x%x], WORK_CYCLE[0x%x(%d)]\n",
rga_log("irq handler, INTR[0x%x], HW_STATUS[0x%x], CMD_STATUS[0x%x], WORK_CYCLE[0x%x(%d)]\n",
job->intr_status, job->hw_status, job->cmd_status,
job->work_cycle, job->work_cycle);
@@ -3143,9 +3142,9 @@ static int rga2_irq(struct rga_scheduler_t *scheduler)
} else if (job->intr_status & m_RGA2_INT_ERROR_FLAG_MASK) {
set_bit(RGA_JOB_STATE_INTR_ERR, &job->state);
pr_err("irq handler err! INTR[0x%x], HW_STATUS[0x%x], CMD_STATUS[0x%x], WORK_CYCLE[0x%x(%d)]\n",
job->intr_status, job->hw_status, job->cmd_status,
job->work_cycle, job->work_cycle);
rga_err("irq handler err! INTR[0x%x], HW_STATUS[0x%x], CMD_STATUS[0x%x], WORK_CYCLE[0x%x(%d)]\n",
job->intr_status, job->hw_status, job->cmd_status,
job->work_cycle, job->work_cycle);
scheduler->ops->soft_reset(scheduler);
}
@@ -3163,27 +3162,27 @@ static int rga2_irq(struct rga_scheduler_t *scheduler)
static int rga2_isr_thread(struct rga_job *job, struct rga_scheduler_t *scheduler)
{
if (DEBUGGER_EN(INT_FLAG))
pr_info("isr thread, INTR[0x%x], HW_STATUS[0x%x], CMD_STATUS[0x%x]\n",
rga_log("isr thread, INTR[0x%x], HW_STATUS[0x%x], CMD_STATUS[0x%x]\n",
rga_read(RGA2_INT, scheduler),
rga_read(RGA2_STATUS2, scheduler),
rga_read(RGA2_STATUS1, scheduler));
if (test_bit(RGA_JOB_STATE_INTR_ERR, &job->state)) {
if (job->hw_status & m_RGA2_STATUS2_RPP_ERROR)
pr_err("RGA current status: rpp error!\n");
rga_err("RGA current status: rpp error!\n");
if (job->hw_status & m_RGA2_STATUS2_BUS_ERROR)
pr_err("RGA current status: bus error!\n");
rga_err("RGA current status: bus error!\n");
if (job->intr_status & m_RGA2_INT_ERROR_INT_FLAG) {
pr_err("RGA bus error intr, please check your configuration and buffer.\n");
rga_err("RGA bus error intr, please check your configuration and buffer.\n");
job->ret = -EFAULT;
} else if (job->intr_status & m_RGA2_INT_MMU_INT_FLAG) {
pr_err("mmu failed, please check size of the buffer or whether the buffer has been freed.\n");
rga_err("mmu failed, please check size of the buffer or whether the buffer has been freed.\n");
job->ret = -EACCES;
}
if (job->ret == 0) {
pr_err("rga intr error[0x%x]!\n", job->intr_status);
rga_err("rga intr error[0x%x]!\n", job->intr_status);
job->ret = -EFAULT;
}
}

186
drivers/video/rockchip/rga3/rga3_reg_info.c
View File

@@ -5,8 +5,6 @@
* Author: Huang Lee <Putin.li@rock-chips.com>
*/
#define pr_fmt(fmt) "rga3_reg: " fmt
#include "rga3_reg_info.h"
#include "rga_dma_buf.h"
#include "rga_iommu.h"
@@ -1338,7 +1336,7 @@ static int rga3_gen_reg_info(u8 *base, struct rga3_req *msg)
RGA3_set_reg_wr_info(base, msg);
break;
default:
pr_err("error msg render mode %d\n", msg->render_mode);
rga_err("error msg render mode %d\n", msg->render_mode);
break;
}
@@ -1743,11 +1741,11 @@ static void rga3_soft_reset(struct rga_scheduler_t *scheduler)
}
if (i == RGA_RESET_TIMEOUT)
pr_err("RGA3 core[%d] soft reset timeout. SYS_CTRL[0x%x], RO_SRST[0x%x]\n",
scheduler->core, rga_read(RGA3_SYS_CTRL, scheduler),
rga_read(RGA3_RO_SRST, scheduler));
rga_err("RGA3 core[%d] soft reset timeout. SYS_CTRL[0x%x], RO_SRST[0x%x]\n",
scheduler->core, rga_read(RGA3_SYS_CTRL, scheduler),
rga_read(RGA3_RO_SRST, scheduler));
else
pr_info("RGA3 core[%d] soft reset complete.\n", scheduler->core);
rga_log("RGA3 core[%d] soft reset complete.\n", scheduler->core);
}
static int rga3_scale_check(const struct rga3_req *req)
@@ -1801,24 +1799,24 @@ static int rga3_scale_check(const struct rga3_req *req)
}
if (((win0_saw >> 3) > win0_daw) || ((win0_sah >> 3) > win0_dah)) {
pr_info("win0 unsupported to scaling less than 1/8 times. src[%d, %d], dst[%d, %d]\n",
rga_log("win0 unsupported to scaling less than 1/8 times. src[%d, %d], dst[%d, %d]\n",
win0_saw, win0_sah, win0_daw, win0_dah);
return -EINVAL;
}
if (((win0_daw >> 3) > win0_saw) || ((win0_dah >> 3) > win0_sah)) {
pr_info("win0 unsupported to scaling more than 8 times. src[%d, %d], dst[%d, %d]\n",
rga_log("win0 unsupported to scaling more than 8 times. src[%d, %d], dst[%d, %d]\n",
win0_saw, win0_sah, win0_daw, win0_dah);
return -EINVAL;
}
if (req->win1.yrgb_addr != 0) {
if (((win1_saw >> 3) > win1_daw) || ((win1_sah >> 3) > win1_dah)) {
pr_info("win1 unsupported to scaling less than 1/8 times. src[%d, %d], dst[%d, %d]\n",
rga_log("win1 unsupported to scaling less than 1/8 times. src[%d, %d], dst[%d, %d]\n",
win1_saw, win1_sah, win1_daw, win1_dah);
return -EINVAL;
}
if (((win1_daw >> 3) > win1_saw) || ((win1_dah >> 3) > win1_sah)) {
pr_info("win1 unsupported to scaling more than 8 times. src[%d, %d], dst[%d, %d]\n",
rga_log("win1 unsupported to scaling more than 8 times. src[%d, %d], dst[%d, %d]\n",
win1_saw, win1_sah, win1_daw, win1_dah);
return -EINVAL;
}
@@ -1836,32 +1834,32 @@ static int rga3_check_param(const struct rga_hw_data *data, const struct rga3_re
rga_hw_out_of_range(&(data->input_range),
req->win0.src_act_w + req->win0.x_offset,
req->win0.src_act_h + req->win0.y_offset))) {
pr_err("invalid win0, src[w,h] = [%d, %d], dst[w,h] = [%d, %d], off[x,y] = [%d,%d]\n",
req->win0.src_act_w, req->win0.src_act_h,
req->win0.dst_act_w, req->win0.dst_act_h,
req->win0.x_offset, req->win0.y_offset);
rga_err("invalid win0, src[w,h] = [%d, %d], dst[w,h] = [%d, %d], off[x,y] = [%d,%d]\n",
req->win0.src_act_w, req->win0.src_act_h,
req->win0.dst_act_w, req->win0.dst_act_h,
req->win0.x_offset, req->win0.y_offset);
return -EINVAL;
}
if (unlikely(req->win0.vir_w * rga_get_pixel_stride_from_format(req->win0.format) >
data->max_byte_stride * 8)) {
pr_err("invalid win0 stride, stride = %d, pixel_stride = %d, max_byte_stride = %d\n",
req->win0.vir_w, rga_get_pixel_stride_from_format(req->win0.format),
data->max_byte_stride);
rga_err("invalid win0 stride, stride = %d, pixel_stride = %d, max_byte_stride = %d\n",
req->win0.vir_w, rga_get_pixel_stride_from_format(req->win0.format),
data->max_byte_stride);
return -EINVAL;
}
if (unlikely(rga_hw_out_of_range(&(data->output_range),
req->wr.dst_act_w, req->wr.dst_act_h))) {
pr_err("invalid wr, [w,h] = [%d, %d]\n", req->wr.dst_act_w, req->wr.dst_act_h);
rga_err("invalid wr, [w,h] = [%d, %d]\n", req->wr.dst_act_w, req->wr.dst_act_h);
return -EINVAL;
}
if (unlikely(req->wr.vir_w * rga_get_pixel_stride_from_format(req->wr.format) >
data->max_byte_stride * 8)) {
pr_err("invalid wr stride, stride = %d, pixel_stride = %d, max_byte_stride = %d\n",
req->wr.vir_w, rga_get_pixel_stride_from_format(req->wr.format),
data->max_byte_stride);
rga_err("invalid wr stride, stride = %d, pixel_stride = %d, max_byte_stride = %d\n",
req->wr.vir_w, rga_get_pixel_stride_from_format(req->wr.format),
data->max_byte_stride);
return -EINVAL;
}
@@ -1873,18 +1871,18 @@ static int rga3_check_param(const struct rga_hw_data *data, const struct rga3_re
rga_hw_out_of_range(&(data->input_range),
req->win1.src_act_w + req->win1.x_offset,
req->win1.src_act_h + req->win1.y_offset))) {
pr_err("invalid win1, src[w,h] = [%d, %d], dst[w,h] = [%d, %d], off[x,y] = [%d,%d]\n",
req->win1.src_act_w, req->win1.src_act_h,
req->win1.dst_act_w, req->win1.dst_act_h,
req->win1.x_offset, req->win1.y_offset);
rga_err("invalid win1, src[w,h] = [%d, %d], dst[w,h] = [%d, %d], off[x,y] = [%d,%d]\n",
req->win1.src_act_w, req->win1.src_act_h,
req->win1.dst_act_w, req->win1.dst_act_h,
req->win1.x_offset, req->win1.y_offset);
return -EINVAL;
}
if (unlikely(req->win1.vir_w * rga_get_pixel_stride_from_format(req->win1.format) >
data->max_byte_stride * 8)) {
pr_err("invalid win1 stride, stride = %d, pixel_stride = %d, max_byte_stride = %d\n",
req->win1.vir_w, rga_get_pixel_stride_from_format(req->win1.format),
data->max_byte_stride);
rga_err("invalid win1 stride, stride = %d, pixel_stride = %d, max_byte_stride = %d\n",
req->win1.vir_w, rga_get_pixel_stride_from_format(req->win1.format),
data->max_byte_stride);
return -EINVAL;
}
@@ -1893,9 +1891,9 @@ static int rga3_check_param(const struct rga_hw_data *data, const struct rga3_re
/* check win0 dst size > win1 dst size */
if (unlikely((req->win1.dst_act_w > req->win0.dst_act_w) ||
(req->win1.dst_act_h > req->win0.dst_act_h))) {
pr_err("invalid output param win0[w,h] = [%d, %d], win1[w,h] = [%d, %d]\n",
req->win0.dst_act_w, req->win0.dst_act_h,
req->win1.dst_act_w, req->win1.dst_act_h);
rga_err("invalid output param win0[w,h] = [%d, %d], win1[w,h] = [%d, %d]\n",
req->win0.dst_act_w, req->win0.dst_act_h,
req->win1.dst_act_w, req->win1.dst_act_h);
return -EINVAL;
}
}
@@ -1909,59 +1907,59 @@ static int rga3_check_param(const struct rga_hw_data *data, const struct rga3_re
static void print_debug_info(struct rga3_req *req)
{
pr_info("render_mode:%s, bitblit_mode=%d, rotate_mode:%x\n",
rga_log("render_mode:%s, bitblit_mode=%d, rotate_mode:%x\n",
rga_get_render_mode_str(req->render_mode), req->bitblt_mode,
req->rotate_mode);
pr_info("win0: y = %lx uv = %lx v = %lx src_w = %d src_h = %d\n",
req->win0.yrgb_addr, req->win0.uv_addr, req->win0.v_addr,
req->win0.src_act_w, req->win0.src_act_h);
pr_info("win0: vw = %d vh = %d xoff = %d yoff = %d format = %s\n",
req->win0.vir_w, req->win0.vir_h,
req->win0.x_offset, req->win0.y_offset,
rga_get_format_name(req->win0.format));
pr_info("win0: dst_w = %d, dst_h = %d, rd_mode = %d\n",
req->win0.dst_act_w, req->win0.dst_act_h, req->win0.rd_mode);
pr_info("win0: rot_mode = %d, en = %d, compact = %d, endian = %d\n",
req->win0.rotate_mode, req->win0.enable,
req->win0.is_10b_compact, req->win0.is_10b_endian);
rga_log("win0: y = %lx uv = %lx v = %lx src_w = %d src_h = %d\n",
req->win0.yrgb_addr, req->win0.uv_addr, req->win0.v_addr,
req->win0.src_act_w, req->win0.src_act_h);
rga_log("win0: vw = %d vh = %d xoff = %d yoff = %d format = %s\n",
req->win0.vir_w, req->win0.vir_h,
req->win0.x_offset, req->win0.y_offset,
rga_get_format_name(req->win0.format));
rga_log("win0: dst_w = %d, dst_h = %d, rd_mode = %d\n",
req->win0.dst_act_w, req->win0.dst_act_h, req->win0.rd_mode);
rga_log("win0: rot_mode = %d, en = %d, compact = %d, endian = %d\n",
req->win0.rotate_mode, req->win0.enable,
req->win0.is_10b_compact, req->win0.is_10b_endian);
if (req->win1.yrgb_addr != 0 || req->win1.uv_addr != 0
|| req->win1.v_addr != 0) {
pr_info("win1: y = %lx uv = %lx v = %lx src_w = %d src_h = %d\n",
req->win1.yrgb_addr, req->win1.uv_addr,
req->win1.v_addr, req->win1.src_act_w,
req->win1.src_act_h);
pr_info("win1: vw = %d vh = %d xoff = %d yoff = %d format = %s\n",
req->win1.vir_w, req->win1.vir_h,
req->win1.x_offset, req->win1.y_offset,
rga_get_format_name(req->win1.format));
pr_info("win1: dst_w = %d, dst_h = %d, rd_mode = %d\n",
req->win1.dst_act_w, req->win1.dst_act_h,
req->win1.rd_mode);
pr_info("win1: rot_mode = %d, en = %d, compact = %d, endian = %d\n",
req->win1.rotate_mode, req->win1.enable,
req->win1.is_10b_compact, req->win1.is_10b_endian);
rga_log("win1: y = %lx uv = %lx v = %lx src_w = %d src_h = %d\n",
req->win1.yrgb_addr, req->win1.uv_addr,
req->win1.v_addr, req->win1.src_act_w,
req->win1.src_act_h);
rga_log("win1: vw = %d vh = %d xoff = %d yoff = %d format = %s\n",
req->win1.vir_w, req->win1.vir_h,
req->win1.x_offset, req->win1.y_offset,
rga_get_format_name(req->win1.format));
rga_log("win1: dst_w = %d, dst_h = %d, rd_mode = %d\n",
req->win1.dst_act_w, req->win1.dst_act_h,
req->win1.rd_mode);
rga_log("win1: rot_mode = %d, en = %d, compact = %d, endian = %d\n",
req->win1.rotate_mode, req->win1.enable,
req->win1.is_10b_compact, req->win1.is_10b_endian);
}
pr_info("wr: y = %lx uv = %lx v = %lx vw = %d vh = %d\n",
req->wr.yrgb_addr, req->wr.uv_addr, req->wr.v_addr,
req->wr.vir_w, req->wr.vir_h);
pr_info("wr: ovlp_xoff = %d ovlp_yoff = %d format = %s rdmode = %d\n",
req->wr.x_offset, req->wr.y_offset,
rga_get_format_name(req->wr.format), req->wr.rd_mode);
rga_log("wr: y = %lx uv = %lx v = %lx vw = %d vh = %d\n",
req->wr.yrgb_addr, req->wr.uv_addr, req->wr.v_addr,
req->wr.vir_w, req->wr.vir_h);
rga_log("wr: ovlp_xoff = %d ovlp_yoff = %d format = %s rdmode = %d\n",
req->wr.x_offset, req->wr.y_offset,
rga_get_format_name(req->wr.format), req->wr.rd_mode);
pr_info("mmu: win0 = %.2x win1 = %.2x wr = %.2x\n",
rga_log("mmu: win0 = %.2x win1 = %.2x wr = %.2x\n",
req->mmu_info.src0_mmu_flag, req->mmu_info.src1_mmu_flag,
req->mmu_info.dst_mmu_flag);
pr_info("alpha: flag %x mode=%s\n",
rga_log("alpha: flag %x mode=%s\n",
req->alpha_rop_flag, rga_get_blend_mode_str(req->alpha_config.mode));
pr_info("alpha: pre_multi=[%d,%d] pixl=[%d,%d] glb=[%d,%d]\n",
rga_log("alpha: pre_multi=[%d,%d] pixl=[%d,%d] glb=[%d,%d]\n",
req->alpha_config.fg_pre_multiplied, req->alpha_config.bg_pre_multiplied,
req->alpha_config.fg_pixel_alpha_en, req->alpha_config.bg_pixel_alpha_en,
req->alpha_config.fg_global_alpha_en, req->alpha_config.bg_global_alpha_en);
pr_info("alpha: fg_global_alpha=%x bg_global_alpha=%x\n",
rga_log("alpha: fg_global_alpha=%x bg_global_alpha=%x\n",
req->alpha_config.fg_global_alpha_value, req->alpha_config.bg_global_alpha_value);
pr_info("yuv2rgb mode is %x\n", req->yuv2rgb_mode);
rga_log("yuv2rgb mode is %x\n", req->yuv2rgb_mode);
}
static int rga3_align_check(struct rga3_req *req)
@@ -1970,22 +1968,22 @@ static int rga3_align_check(struct rga3_req *req)
if ((req->win0.vir_w % 64) || (req->win0.x_offset % 4) ||
(req->win0.src_act_w % 4) || (req->win0.y_offset % 4) ||
(req->win0.src_act_h % 4) || (req->win0.vir_h % 2))
pr_info("yuv10bit err win0 wstride is not align\n");
rga_log("yuv10bit err win0 wstride is not align\n");
if (rga_is_yuv10bit_format(req->win1.format))
if ((req->win1.vir_w % 64) || (req->win1.x_offset % 4) ||
(req->win1.src_act_w % 4) || (req->win1.y_offset % 4) ||
(req->win1.src_act_h % 4) || (req->win1.vir_h % 2))
pr_info("yuv10bit err win1 wstride is not align\n");
rga_log("yuv10bit err win1 wstride is not align\n");
if (rga_is_yuv8bit_format(req->win0.format))
if ((req->win0.vir_w % 16) || (req->win0.x_offset % 2) ||
(req->win0.src_act_w % 2) || (req->win0.y_offset % 2) ||
(req->win0.src_act_h % 2) || (req->win0.vir_h % 2))
pr_info("yuv8bit err win0 wstride is not align\n");
rga_log("yuv8bit err win0 wstride is not align\n");
if (rga_is_yuv8bit_format(req->win1.format))
if ((req->win1.vir_w % 16) || (req->win1.x_offset % 2) ||
(req->win1.src_act_w % 2) || (req->win1.y_offset % 2) ||
(req->win1.src_act_h % 2) || (req->win1.vir_h % 2))
pr_info("yuv8bit err win1 wstride is not align\n");
rga_log("yuv8bit err win1 wstride is not align\n");
return 0;
}
@@ -1998,7 +1996,7 @@ static int rga3_init_reg(struct rga_job *job)
scheduler = job->scheduler;
if (unlikely(scheduler == NULL)) {
pr_err("failed to get scheduler, %s(%d)\n", __func__, __LINE__);
rga_err("failed to get scheduler, %s(%d)\n", __func__, __LINE__);
return -EINVAL;
}
@@ -2009,7 +2007,7 @@ static int rga3_init_reg(struct rga_job *job)
/* check value if legal */
ret = rga3_check_param(scheduler->data, &req);
if (ret == -EINVAL) {
pr_err("req argument is inval\n");
rga_err("req argument is inval\n");
return ret;
}
@@ -2020,12 +2018,12 @@ static int rga3_init_reg(struct rga_job *job)
print_debug_info(&req);
if (rga3_gen_reg_info((uint8_t *) job->cmd_buf->vaddr, &req) == -1) {
pr_err("RKA: gen reg info error\n");
rga_err("RKA: gen reg info error\n");
return -EINVAL;
}
if (DEBUGGER_EN(TIME))
pr_info("request[%d], generate register cost time %lld us\n",
rga_log("request[%d], generate register cost time %lld us\n",
job->request_id, ktime_us_delta(ktime_get(), timestamp));
return ret;
@@ -2044,9 +2042,9 @@ static void rga3_dump_read_back_reg(struct rga_scheduler_t *scheduler)
spin_unlock_irqrestore(&scheduler->irq_lock, flags);
pr_info("CMD_READ_BACK_REG\n");
rga_log("CMD_READ_BACK_REG\n");
for (i = 0; i < 12; i++)
pr_info("i = %x : %.8x %.8x %.8x %.8x\n", i,
rga_log("i = %x : %.8x %.8x %.8x %.8x\n", i,
cmd_reg[0 + i * 4], cmd_reg[1 + i * 4],
cmd_reg[2 + i * 4], cmd_reg[3 + i * 4]);
}
@@ -2071,9 +2069,9 @@ static int rga3_set_reg(struct rga_job *job, struct rga_scheduler_t *scheduler)
master_mode_en = false;
if (DEBUGGER_EN(REG)) {
pr_info("CMD_REG\n");
rga_log("CMD_REG\n");
for (i = 0; i < 12; i++)
pr_info("i = %x : %.8x %.8x %.8x %.8x\n", i,
rga_log("i = %x : %.8x %.8x %.8x %.8x\n", i,
cmd[0 + i * 4], cmd[1 + i * 4],
cmd[2 + i * 4], cmd[3 + i * 4]);
}
@@ -2100,18 +2098,18 @@ static int rga3_set_reg(struct rga_job *job, struct rga_scheduler_t *scheduler)
}
if (DEBUGGER_EN(REG)) {
pr_info("sys_ctrl = 0x%x, int_en = 0x%x, int_raw = 0x%x\n",
rga_log("sys_ctrl = 0x%x, int_en = 0x%x, int_raw = 0x%x\n",
rga_read(RGA3_SYS_CTRL, scheduler),
rga_read(RGA3_INT_EN, scheduler),
rga_read(RGA3_INT_RAW, scheduler));
pr_info("hw_status = 0x%x, cmd_status = 0x%x\n",
rga_log("hw_status = 0x%x, cmd_status = 0x%x\n",
rga_read(RGA3_STATUS0, scheduler),
rga_read(RGA3_CMD_STATE, scheduler));
}
if (DEBUGGER_EN(TIME))
pr_info("request[%d], set register cost time %lld us\n",
rga_log("request[%d], set register cost time %lld us\n",
job->request_id, ktime_us_delta(now, job->timestamp));
job->hw_running_time = now;
@@ -2130,7 +2128,7 @@ static int rga3_get_version(struct rga_scheduler_t *scheduler)
u32 reg_version;
if (!scheduler) {
pr_err("scheduler is null\n");
rga_err("scheduler is null\n");
return -EINVAL;
}
@@ -2165,7 +2163,7 @@ static int rga3_irq(struct rga_scheduler_t *scheduler)
job->cmd_status = rga_read(RGA3_CMD_STATE, scheduler);
if (DEBUGGER_EN(INT_FLAG))
pr_info("irq handler, INTR[0x%x], HW_STATUS[0x%x], CMD_STATUS[0x%x]\n",
rga_log("irq handler, INTR[0x%x], HW_STATUS[0x%x], CMD_STATUS[0x%x]\n",
job->intr_status, job->hw_status, job->cmd_status);
if (job->intr_status & (m_RGA3_INT_FRM_DONE | m_RGA3_INT_CMD_LINE_FINISH)) {
@@ -2173,7 +2171,7 @@ static int rga3_irq(struct rga_scheduler_t *scheduler)
} else if (job->intr_status & m_RGA3_INT_ERROR_MASK) {
set_bit(RGA_JOB_STATE_INTR_ERR, &job->state);
pr_err("irq handler err! INTR[0x%x], HW_STATUS[0x%x], CMD_STATUS[0x%x]\n",
rga_err("irq handler err! INTR[0x%x], HW_STATUS[0x%x], CMD_STATUS[0x%x]\n",
job->intr_status, job->hw_status, job->cmd_status);
scheduler->ops->soft_reset(scheduler);
}
@@ -2188,28 +2186,28 @@ static int rga3_irq(struct rga_scheduler_t *scheduler)
static int rga3_isr_thread(struct rga_job *job, struct rga_scheduler_t *scheduler)
{
if (DEBUGGER_EN(INT_FLAG))
pr_info("isr thread, INTR[0x%x], HW_STATUS[0x%x], CMD_STATUS[0x%x]\n",
rga_log("isr thread, INTR[0x%x], HW_STATUS[0x%x], CMD_STATUS[0x%x]\n",
rga_read(RGA3_INT_RAW, scheduler),
rga_read(RGA3_STATUS0, scheduler),
rga_read(RGA3_CMD_STATE, scheduler));
if (test_bit(RGA_JOB_STATE_INTR_ERR, &job->state)) {
if (job->intr_status & m_RGA3_INT_RAG_MI_RD_BUS_ERR) {
pr_err("DMA read bus error, please check size of the input_buffer or whether the buffer has been freed.\n");
rga_err("DMA read bus error, please check size of the input_buffer or whether the buffer has been freed.\n");
job->ret = -EFAULT;
} else if (job->intr_status & m_RGA3_INT_WIN0_FBCD_DEC_ERR) {
pr_err("win0 FBC decoder error, please check the fbc image of the source.\n");
rga_err("win0 FBC decoder error, please check the fbc image of the source.\n");
job->ret = -EFAULT;
} else if (job->intr_status & m_RGA3_INT_WIN1_FBCD_DEC_ERR) {
pr_err("win1 FBC decoder error, please check the fbc image of the source.\n");
rga_err("win1 FBC decoder error, please check the fbc image of the source.\n");
job->ret = -EFAULT;
} else if (job->intr_status & m_RGA3_INT_RGA_MI_WR_BUS_ERR) {
pr_err("wr buss error, please check size of the output_buffer or whether the buffer has been freed.\n");
rga_err("wr buss error, please check size of the output_buffer or whether the buffer has been freed.\n");
job->ret = -EFAULT;
}
if (job->ret == 0) {
pr_err("rga intr error[0x%x]!\n", job->intr_status);
rga_err("rga intr error[0x%x]!\n", job->intr_status);
job->ret = -EFAULT;
}
}

60
drivers/video/rockchip/rga3/rga_common.c
View File

@@ -5,8 +5,6 @@
* Author: Cerf Yu <cerf.yu@rock-chips.com>
*/
#define pr_fmt(fmt) "rga_common: " fmt
#include "rga.h"
#include "rga_common.h"
@@ -436,7 +434,7 @@ int rga_get_format_bits(uint32_t format)
bits = 1;
break;
default:
pr_err("unknown format [0x%x]\n", format);
rga_err("unknown format [0x%x]\n", format);
return -1;
}
@@ -511,7 +509,7 @@ int rga_get_pixel_stride_from_format(uint32_t format)
pixel_stride = 4;
break;
default:
pr_err("unknown format [0x%x]\n", format);
rga_err("unknown format [0x%x]\n", format);
return -1;
}
@@ -798,7 +796,7 @@ int rga_image_size_cal(int w, int h, int format,
yrgb = (w * h) >> 1;
break;
default:
pr_err("Unsuport format [0x%x]\n", format);
rga_err("Unsuport format [0x%x]\n", format);
return -EFAULT;
}
@@ -814,14 +812,62 @@ int rga_image_size_cal(int w, int h, int format,
void rga_dump_memory_parm(struct rga_memory_parm *parm)
{
pr_info("memory param: w = %d, h = %d, f = %s(0x%x), size = %d\n",
rga_log("memory param: w = %d, h = %d, f = %s(0x%x), size = %d\n",
parm->width, parm->height, rga_get_format_name(parm->format),
parm->format, parm->size);
}
void rga_dump_external_buffer(struct rga_external_buffer *buffer)
{
pr_info("external: memory = 0x%lx, type = %s\n",
rga_log("external: memory = 0x%lx, type = %s\n",
(unsigned long)buffer->memory, rga_get_memory_type_str(buffer->type));
rga_dump_memory_parm(&buffer->memory_parm);
}
void rga_dump_req(struct rga_req *req)
{
rga_log("render_mode = %d, bitblit_mode=%d, rotate_mode = %d\n",
req->render_mode, req->bsfilter_flag,
req->rotate_mode);
rga_log("src: y = %lx uv = %lx v = %lx aw = %d ah = %d vw = %d vh = %d\n",
(unsigned long)req->src.yrgb_addr,
(unsigned long)req->src.uv_addr,
(unsigned long)req->src.v_addr,
req->src.act_w, req->src.act_h,
req->src.vir_w, req->src.vir_h);
rga_log("src: xoff = %d, yoff = %d, format = 0x%x, rd_mode = %d\n",
req->src.x_offset, req->src.y_offset,
req->src.format, req->src.rd_mode);
if (req->pat.yrgb_addr != 0 || req->pat.uv_addr != 0
|| req->pat.v_addr != 0) {
rga_log("pat: y=%lx uv=%lx v=%lx aw=%d ah=%d vw=%d vh=%d\n",
(unsigned long)req->pat.yrgb_addr,
(unsigned long)req->pat.uv_addr,
(unsigned long)req->pat.v_addr,
req->pat.act_w, req->pat.act_h,
req->pat.vir_w, req->pat.vir_h);
rga_log("pat: xoff = %d yoff = %d, format = 0x%x, rd_mode = %d\n",
req->pat.x_offset, req->pat.y_offset,
req->pat.format, req->pat.rd_mode);
}
rga_log("dst: y=%lx uv=%lx v=%lx aw=%d ah=%d vw=%d vh=%d\n",
(unsigned long)req->dst.yrgb_addr,
(unsigned long)req->dst.uv_addr,
(unsigned long)req->dst.v_addr,
req->dst.act_w, req->dst.act_h,
req->dst.vir_w, req->dst.vir_h);
rga_log("dst: xoff = %d, yoff = %d, format = 0x%x, rd_mode = %d\n",
req->dst.x_offset, req->dst.y_offset,
req->dst.format, req->dst.rd_mode);
rga_log("mmu: mmu_flag=%x en=%x\n",
req->mmu_info.mmu_flag, req->mmu_info.mmu_en);
rga_log("alpha: rop_mode = %x\n", req->alpha_rop_mode);
rga_log("yuv2rgb mode is %x\n", req->yuv2rgb_mode);
rga_log("imterplotion: horiz = 0x%x, verti = 0x%x\n", req->interp.horiz, req->interp.verti);
rga_log("set core = %d, priority = %d, in_fence_fd = %d\n",
req->core, req->priority, req->in_fence_fd);
}

50
drivers/video/rockchip/rga3/rga_debugger.c
View File

@@ -7,8 +7,6 @@
* Huang Lee <Putin.li@rock-chips.com>
*/
#define pr_fmt(fmt) "rga_debugger: " fmt
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/syscalls.h>
@@ -865,54 +863,6 @@ void rga_request_task_debug_info(struct seq_file *m, struct rga_req *req)
req->core, req->priority, req->in_fence_fd);
}
void rga_cmd_print_debug_info(struct rga_req *req)
{
pr_info("render_mode = %d, bitblit_mode=%d, rotate_mode = %d\n",
req->render_mode, req->bsfilter_flag,
req->rotate_mode);
pr_info("src: y = %lx uv = %lx v = %lx aw = %d ah = %d vw = %d vh = %d\n",
(unsigned long)req->src.yrgb_addr,
(unsigned long)req->src.uv_addr,
(unsigned long)req->src.v_addr,
req->src.act_w, req->src.act_h,
req->src.vir_w, req->src.vir_h);
pr_info("src: xoff = %d, yoff = %d, format = 0x%x, rd_mode = %d\n",
req->src.x_offset, req->src.y_offset,
req->src.format, req->src.rd_mode);
if (req->pat.yrgb_addr != 0 || req->pat.uv_addr != 0
|| req->pat.v_addr != 0) {
pr_info("pat: y=%lx uv=%lx v=%lx aw=%d ah=%d vw=%d vh=%d\n",
(unsigned long)req->pat.yrgb_addr,
(unsigned long)req->pat.uv_addr,
(unsigned long)req->pat.v_addr,
req->pat.act_w, req->pat.act_h,
req->pat.vir_w, req->pat.vir_h);
pr_info("pat: xoff = %d yoff = %d, format = 0x%x, rd_mode = %d\n",
req->pat.x_offset, req->pat.y_offset,
req->pat.format, req->pat.rd_mode);
}
pr_info("dst: y=%lx uv=%lx v=%lx aw=%d ah=%d vw=%d vh=%d\n",
(unsigned long)req->dst.yrgb_addr,
(unsigned long)req->dst.uv_addr,
(unsigned long)req->dst.v_addr,
req->dst.act_w, req->dst.act_h,
req->dst.vir_w, req->dst.vir_h);
pr_info("dst: xoff = %d, yoff = %d, format = 0x%x, rd_mode = %d\n",
req->dst.x_offset, req->dst.y_offset,
req->dst.format, req->dst.rd_mode);
pr_info("mmu: mmu_flag=%x en=%x\n",
req->mmu_info.mmu_flag, req->mmu_info.mmu_en);
pr_info("alpha: rop_mode = %x\n", req->alpha_rop_mode);
pr_info("yuv2rgb mode is %x\n", req->yuv2rgb_mode);
pr_info("imterplotion: horiz = 0x%x, verti = 0x%x\n", req->interp.horiz, req->interp.verti);
pr_info("set core = %d, priority = %d, in_fence_fd = %d\n",
req->core, req->priority, req->in_fence_fd);
}
#ifdef CONFIG_NO_GKI
static int rga_dump_image_to_file(struct rga_internal_buffer *dump_buffer,
const char *channel_name,

44
drivers/video/rockchip/rga3/rga_dma_buf.c
View File

@@ -5,8 +5,6 @@
* Author: Huang Lee <Putin.li@rock-chips.com>
*/
#define pr_fmt(fmt) "rga_dma_buf: " fmt
#include "rga_dma_buf.h"
#include "rga.h"
#include "rga_common.h"
@@ -281,7 +279,7 @@ int rga_iommu_map_sgt(struct sg_table *sgt, size_t size,
unsigned long align_size;
if (sgt == NULL) {
pr_err("can not map iommu, because sgt is null!\n");
rga_err("can not map iommu, because sgt is null!\n");
return -EINVAL;
}
@@ -291,18 +289,18 @@ int rga_iommu_map_sgt(struct sg_table *sgt, size_t size,
align_size = iova_align(iovad, size);
if (DEBUGGER_EN(MSG))
pr_info("iova_align size = %ld", align_size);
rga_log("iova_align size = %ld", align_size);
iova = rga_iommu_dma_alloc_iova(domain, align_size, rga_dev->coherent_dma_mask, rga_dev);
if (!iova) {
pr_err("rga_iommu_dma_alloc_iova failed");
rga_err("rga_iommu_dma_alloc_iova failed");
return -ENOMEM;
}
map_size = iommu_map_sg(domain, iova, sgt->sgl, sgt->orig_nents,
rga_dma_info_to_prot(DMA_BIDIRECTIONAL));
if (map_size < align_size) {
pr_err("iommu can not map sgt to iova");
rga_err("iommu can not map sgt to iova");
rga_iommu_dma_free_iova(domain, iova, align_size);
return -EINVAL;
}
@@ -326,7 +324,7 @@ int rga_iommu_map(phys_addr_t paddr, size_t size,
unsigned long align_size;
if (paddr == 0) {
pr_err("can not map iommu, because phys_addr is 0!\n");
rga_err("can not map iommu, because phys_addr is 0!\n");
return -EINVAL;
}
@@ -336,18 +334,18 @@ int rga_iommu_map(phys_addr_t paddr, size_t size,
align_size = iova_align(iovad, size);
if (DEBUGGER_EN(MSG))
pr_info("iova_align size = %ld", align_size);
rga_log("iova_align size = %ld", align_size);
iova = rga_iommu_dma_alloc_iova(domain, align_size, rga_dev->coherent_dma_mask, rga_dev);
if (!iova) {
pr_err("rga_iommu_dma_alloc_iova failed");
rga_err("rga_iommu_dma_alloc_iova failed");
return -ENOMEM;
}
ret = iommu_map(domain, iova, paddr, align_size,
rga_dma_info_to_prot(DMA_BIDIRECTIONAL));
if (ret) {
pr_err("iommu can not map phys_addr to iova");
rga_err("iommu can not map phys_addr to iova");
rga_iommu_dma_free_iova(domain, iova, align_size);
return ret;
}
@@ -371,20 +369,20 @@ int rga_virtual_memory_check(void *vaddr, u32 w, u32 h, u32 format, int fd)
one_line = kzalloc(w * 4, GFP_KERNEL);
if (!one_line) {
pr_err("kzalloc fail %s[%d]\n", __func__, __LINE__);
rga_err("kzalloc fail %s[%d]\n", __func__, __LINE__);
return 0;
}
temp_data = w * (h - 1) * bits >> 3;
if (fd > 0) {
pr_info("vaddr is%p, bits is %d, fd check\n", vaddr, bits);
rga_log("vaddr is%p, bits is %d, fd check\n", vaddr, bits);
memcpy(one_line, (char *)vaddr + temp_data, w * bits >> 3);
pr_info("fd check ok\n");
rga_log("fd check ok\n");
} else {
pr_info("vir addr memory check.\n");
rga_log("vir addr memory check.\n");
memcpy((void *)((char *)vaddr + temp_data), one_line,
w * bits >> 3);
pr_info("vir addr check ok.\n");
rga_log("vir addr check ok.\n");
}
kfree(one_line);
@@ -413,7 +411,7 @@ int rga_dma_memory_check(struct rga_dma_buffer *rga_dma_buffer, struct rga_img_i
ret = rga_virtual_memory_check(vaddr, img->vir_w,
img->vir_h, img->format, img->yrgb_addr);
} else {
pr_err("can't vmap the dma buffer!\n");
rga_err("can't vmap the dma buffer!\n");
return -EINVAL;
}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 1, 0)
@@ -437,21 +435,21 @@ int rga_dma_map_buf(struct dma_buf *dma_buf, struct rga_dma_buffer *rga_dma_buff
if (dma_buf != NULL) {
get_dma_buf(dma_buf);
} else {
pr_err("dma_buf is invalid[%p]\n", dma_buf);
rga_err("dma_buf is invalid[%p]\n", dma_buf);
return -EINVAL;
}
attach = dma_buf_attach(dma_buf, rga_dev);
if (IS_ERR(attach)) {
ret = PTR_ERR(attach);
pr_err("Failed to attach dma_buf, ret[%d]\n", ret);
rga_err("Failed to attach dma_buf, ret[%d]\n", ret);
goto err_get_attach;
}
sgt = dma_buf_map_attachment(attach, dir);
if (IS_ERR(sgt)) {
ret = PTR_ERR(sgt);
pr_err("Failed to map attachment, ret[%d]\n", ret);
rga_err("Failed to map attachment, ret[%d]\n", ret);
goto err_get_sgt;
}
@@ -488,21 +486,21 @@ int rga_dma_map_fd(int fd, struct rga_dma_buffer *rga_dma_buffer,
dma_buf = dma_buf_get(fd);
if (IS_ERR(dma_buf)) {
ret = PTR_ERR(dma_buf);
pr_err("Fail to get dma_buf from fd[%d], ret[%d]\n", fd, ret);
rga_err("Fail to get dma_buf from fd[%d], ret[%d]\n", fd, ret);
return ret;
}
attach = dma_buf_attach(dma_buf, rga_dev);
if (IS_ERR(attach)) {
ret = PTR_ERR(attach);
pr_err("Failed to attach dma_buf, ret[%d]\n", ret);
rga_err("Failed to attach dma_buf, ret[%d]\n", ret);
goto err_get_attach;
}
sgt = dma_buf_map_attachment(attach, dir);
if (IS_ERR(sgt)) {
ret = PTR_ERR(sgt);
pr_err("Failed to map attachment, ret[%d]\n", ret);
rga_err("Failed to map attachment, ret[%d]\n", ret);
goto err_get_sgt;
}
@@ -549,7 +547,7 @@ void rga_dma_sync_flush_range(void *pstart, void *pend, struct rga_scheduler_t *
int rga_dma_free(struct rga_dma_buffer *buffer)
{
if (buffer == NULL) {
pr_err("rga_dma_buffer is NULL.\n");
rga_err("rga_dma_buffer is NULL.\n");
return -EINVAL;
}

114
drivers/video/rockchip/rga3/rga_drv.c
View File

@@ -5,8 +5,6 @@
* Author: Huang Lee <Putin.li@rock-chips.com>
*/
#define pr_fmt(fmt) "rga: " fmt
#include "rga2_reg_info.h"
#include "rga3_reg_info.h"
#include "rga_dma_buf.h"
@@ -44,7 +42,7 @@ static int rga_mpi_set_channel_buffer(struct dma_buf *dma_buf,
buffer.handle = rga_mm_import_buffer(&buffer, session);
if (buffer.handle == 0) {
pr_err("can not import dma_buf %p\n", dma_buf);
rga_err("can not import dma_buf %p\n", dma_buf);
return -EFAULT;
}
channel_info->yrgb_addr = buffer.handle;
@@ -115,14 +113,14 @@ int rga_mpi_commit(struct rga_mpi_job_t *mpi_job)
mutex_lock(&request_manager->lock);
request = rga_request_lookup(request_manager, mpi_job->ctx_id);
if (IS_ERR_OR_NULL(request)) {
pr_err("can not find request from id[%d]", mpi_job->ctx_id);
rga_err("can not find request from id[%d]", mpi_job->ctx_id);
mutex_unlock(&request_manager->lock);
return -EINVAL;
}
if (request->task_count > 1) {
/* TODO */
pr_err("Currently request does not support multiple tasks!");
rga_err("Currently request does not support multiple tasks!");
mutex_unlock(&request_manager->lock);
return -EINVAL;
}
@@ -168,7 +166,7 @@ int rga_mpi_commit(struct rga_mpi_job_t *mpi_job)
&mpi_cmd.src,
request->session);
if (ret < 0) {
pr_err("src channel set buffer handle failed!\n");
rga_err("src channel set buffer handle failed!\n");
goto err_put_request;
}
}
@@ -178,7 +176,7 @@ int rga_mpi_commit(struct rga_mpi_job_t *mpi_job)
&mpi_cmd.pat,
request->session);
if (ret < 0) {
pr_err("src1 channel set buffer handle failed!\n");
rga_err("src1 channel set buffer handle failed!\n");
goto err_put_request;
}
}
@@ -188,7 +186,7 @@ int rga_mpi_commit(struct rga_mpi_job_t *mpi_job)
&mpi_cmd.dst,
request->session);
if (ret < 0) {
pr_err("dst channel set buffer handle failed!\n");
rga_err("dst channel set buffer handle failed!\n");
goto err_put_request;
}
}
@@ -198,16 +196,16 @@ int rga_mpi_commit(struct rga_mpi_job_t *mpi_job)
mpi_cmd.mmu_info.mmu_flag = 0;
if (DEBUGGER_EN(MSG))
rga_cmd_print_debug_info(&mpi_cmd);
rga_dump_req(&mpi_cmd);
ret = rga_request_mpi_submit(&mpi_cmd, request);
if (ret < 0) {
if (ret == -ERESTARTSYS) {
if (DEBUGGER_EN(MSG))
pr_err("%s, commit mpi job failed, by a software interrupt.\n",
rga_err("%s, commit mpi job failed, by a software interrupt.\n",
__func__);
} else {
pr_err("%s, commit mpi job failed\n", __func__);
rga_err("%s, commit mpi job failed\n", __func__);
}
goto err_put_request;
@@ -256,7 +254,7 @@ int rga_kernel_commit(struct rga_req *cmd)
request_id = rga_request_alloc(0, session);
if (request_id < 0) {
pr_err("request alloc error!\n");
rga_err("request alloc error!\n");
ret = request_id;
return ret;
}
@@ -269,25 +267,25 @@ int rga_kernel_commit(struct rga_req *cmd)
ret = rga_request_check(&kernel_request);
if (ret < 0) {
pr_err("user request check error!\n");
rga_err("user request check error!\n");
goto err_free_request_by_id;
}
request = rga_request_kernel_config(&kernel_request);
if (IS_ERR(request)) {
pr_err("request[%d] config failed!\n", kernel_request.id);
rga_err("request[%d] config failed!\n", kernel_request.id);
ret = -EFAULT;
goto err_free_request_by_id;
}
if (DEBUGGER_EN(MSG)) {
pr_info("kernel blit mode: request id = %d", kernel_request.id);
rga_cmd_print_debug_info(cmd);
rga_log("kernel blit mode: request id = %d", kernel_request.id);
rga_dump_req(cmd);
}
ret = rga_request_submit(request);
if (ret < 0) {
pr_err("request[%d] submit failed!\n", kernel_request.id);
rga_err("request[%d] submit failed!\n", kernel_request.id);
goto err_put_request;
}
@@ -305,7 +303,7 @@ err_free_request_by_id:
request = rga_request_lookup(request_manager, request_id);
if (IS_ERR_OR_NULL(request)) {
pr_err("can not find request from id[%d]", request_id);
rga_err("can not find request from id[%d]", request_id);
mutex_unlock(&request_manager->lock);
return -EINVAL;
}
@@ -434,7 +432,7 @@ static void rga_power_enable_all(void)
scheduler = rga_drvdata->scheduler[i];
ret = rga_power_enable(scheduler);
if (ret < 0)
pr_err("power enable failed");
rga_err("power enable failed");
}
}
@@ -539,13 +537,13 @@ static struct rga_session *rga_session_init(void)
session_manager = rga_drvdata->session_manager;
if (session_manager == NULL) {
pr_err("rga_session_manager is null!\n");
rga_err("rga_session_manager is null!\n");
return ERR_PTR(-EFAULT);
}
session = kzalloc(sizeof(*session), GFP_KERNEL);
if (!session) {
pr_err("rga_session alloc failed\n");
rga_err("rga_session alloc failed\n");
return ERR_PTR(-ENOMEM);
}
@@ -557,7 +555,7 @@ static struct rga_session *rga_session_init(void)
if (new_id < 0) {
mutex_unlock(&session_manager->lock);
pr_err("rga_session alloc id failed!\n");
rga_err("rga_session alloc id failed!\n");
kfree(session);
return ERR_PTR(new_id);
}
@@ -598,32 +596,32 @@ static long rga_ioctl_import_buffer(unsigned long arg, struct rga_session *sessi
if (unlikely(copy_from_user(&buffer_pool,
(struct rga_buffer_pool *)arg,
sizeof(buffer_pool)))) {
pr_err("rga_buffer_pool copy_from_user failed!\n");
rga_err("rga_buffer_pool copy_from_user failed!\n");
return -EFAULT;
}
if (buffer_pool.size > RGA_BUFFER_POOL_SIZE_MAX) {
pr_err("Cannot import more than %d buffers at a time!\n",
rga_err("Cannot import more than %d buffers at a time!\n",
RGA_BUFFER_POOL_SIZE_MAX);
return -EFBIG;
}
if (buffer_pool.buffers_ptr == 0) {
pr_err("Import buffers is NULL!\n");
rga_err("Import buffers is NULL!\n");
return -EFAULT;
}
external_buffer = kmalloc(sizeof(struct rga_external_buffer) * buffer_pool.size,
GFP_KERNEL);
if (external_buffer == NULL) {
pr_err("external buffer list alloc error!\n");
rga_err("external buffer list alloc error!\n");
return -ENOMEM;
}
if (unlikely(copy_from_user(external_buffer,
u64_to_user_ptr(buffer_pool.buffers_ptr),
sizeof(struct rga_external_buffer) * buffer_pool.size))) {
pr_err("rga_buffer_pool external_buffer list copy_from_user failed\n");
rga_err("rga_buffer_pool external_buffer list copy_from_user failed\n");
ret = -EFAULT;
goto err_free_external_buffer;
@@ -631,13 +629,13 @@ static long rga_ioctl_import_buffer(unsigned long arg, struct rga_session *sessi
for (i = 0; i < buffer_pool.size; i++) {
if (DEBUGGER_EN(MSG)) {
pr_info("import buffer info:\n");
rga_log("import buffer info:\n");
rga_dump_external_buffer(&external_buffer[i]);
}
ret = rga_mm_import_buffer(&external_buffer[i], session);
if (ret <= 0) {
pr_err("buffer[%d] mm import buffer failed! memory = 0x%lx, type = %s(0x%x)\n",
rga_err("buffer[%d] mm import buffer failed! memory = 0x%lx, type = %s(0x%x)\n",
i, (unsigned long)external_buffer[i].memory,
rga_get_memory_type_str(external_buffer[i].type),
external_buffer[i].type);
@@ -651,7 +649,7 @@ static long rga_ioctl_import_buffer(unsigned long arg, struct rga_session *sessi
if (unlikely(copy_to_user(u64_to_user_ptr(buffer_pool.buffers_ptr),
external_buffer,
sizeof(struct rga_external_buffer) * buffer_pool.size))) {
pr_err("rga_buffer_pool external_buffer list copy_to_user failed\n");
rga_err("rga_buffer_pool external_buffer list copy_to_user failed\n");
ret = -EFAULT;
goto err_free_external_buffer;
@@ -672,32 +670,32 @@ static long rga_ioctl_release_buffer(unsigned long arg)
if (unlikely(copy_from_user(&buffer_pool,
(struct rga_buffer_pool *)arg,
sizeof(buffer_pool)))) {
pr_err("rga_buffer_pool copy_from_user failed!\n");
rga_err("rga_buffer_pool copy_from_user failed!\n");
return -EFAULT;
}
if (buffer_pool.size > RGA_BUFFER_POOL_SIZE_MAX) {
pr_err("Cannot release more than %d buffers at a time!\n",
rga_err("Cannot release more than %d buffers at a time!\n",
RGA_BUFFER_POOL_SIZE_MAX);
return -EFBIG;
}
if (buffer_pool.buffers_ptr == 0) {
pr_err("Release buffers is NULL!\n");
rga_err("Release buffers is NULL!\n");
return -EFAULT;
}
external_buffer = kmalloc(sizeof(struct rga_external_buffer) * buffer_pool.size,
GFP_KERNEL);
if (external_buffer == NULL) {
pr_err("external buffer list alloc error!\n");
rga_err("external buffer list alloc error!\n");
return -ENOMEM;
}
if (unlikely(copy_from_user(external_buffer,
u64_to_user_ptr(buffer_pool.buffers_ptr),
sizeof(struct rga_external_buffer) * buffer_pool.size))) {
pr_err("rga_buffer_pool external_buffer list copy_from_user failed\n");
rga_err("rga_buffer_pool external_buffer list copy_from_user failed\n");
ret = -EFAULT;
goto err_free_external_buffer;
@@ -705,11 +703,11 @@ static long rga_ioctl_release_buffer(unsigned long arg)
for (i = 0; i < buffer_pool.size; i++) {
if (DEBUGGER_EN(MSG))
pr_info("release buffer handle[%d]\n", external_buffer[i].handle);
rga_log("release buffer handle[%d]\n", external_buffer[i].handle);
ret = rga_mm_release_buffer(external_buffer[i].handle);
if (ret < 0) {
pr_err("buffer[%d] mm release buffer failed! handle = %d\n",
rga_err("buffer[%d] mm release buffer failed! handle = %d\n",
i, external_buffer[i].handle);
goto err_free_external_buffer;
@@ -727,14 +725,14 @@ static long rga_ioctl_request_create(unsigned long arg, struct rga_session *sess
uint32_t flags;
if (copy_from_user(&flags, (void *)arg, sizeof(uint32_t))) {
pr_err("%s failed to copy from usrer!\n", __func__);
rga_err("%s failed to copy from user!\n", __func__);
return -EFAULT;
}
id = rga_request_alloc(flags, session);
if (copy_to_user((void *)arg, &id, sizeof(uint32_t))) {
pr_err("%s failed to copy to usrer!\n", __func__);
rga_err("%s failed to copy to user!\n", __func__);
return -EFAULT;
}
@@ -753,29 +751,29 @@ static long rga_ioctl_request_submit(unsigned long arg, bool run_enbale)
if (unlikely(copy_from_user(&user_request,
(struct rga_user_request *)arg,
sizeof(user_request)))) {
pr_err("%s copy_from_user failed!\n", __func__);
rga_err("%s copy_from_user failed!\n", __func__);
return -EFAULT;
}
ret = rga_request_check(&user_request);
if (ret < 0) {
pr_err("user request check error!\n");
rga_err("user request check error!\n");
return ret;
}
if (DEBUGGER_EN(MSG))
pr_info("config request id = %d", user_request.id);
rga_log("config request id = %d", user_request.id);
request = rga_request_config(&user_request);
if (IS_ERR_OR_NULL(request)) {
pr_err("request[%d] config failed!\n", user_request.id);
rga_err("request[%d] config failed!\n", user_request.id);
return -EFAULT;
}
if (run_enbale) {
ret = rga_request_submit(request);
if (ret < 0) {
pr_err("request[%d] submit failed!\n", user_request.id);
rga_err("request[%d] submit failed!\n", user_request.id);
return -EFAULT;
}
@@ -783,7 +781,7 @@ static long rga_ioctl_request_submit(unsigned long arg, bool run_enbale)
user_request.release_fence_fd = request->release_fence_fd;
if (copy_to_user((struct rga_req *)arg,
&user_request, sizeof(user_request))) {
pr_err("copy_to_user failed\n");
rga_err("copy_to_user failed\n");
return -EFAULT;
}
}
@@ -804,23 +802,23 @@ static long rga_ioctl_request_cancel(unsigned long arg)
request_manager = rga_drvdata->pend_request_manager;
if (request_manager == NULL) {
pr_err("rga_pending_request_manager is null!\n");
rga_err("rga_pending_request_manager is null!\n");
return -EFAULT;
}
if (unlikely(copy_from_user(&id, (uint32_t *)arg, sizeof(uint32_t)))) {
pr_err("request id copy_from_user failed!\n");
rga_err("request id copy_from_user failed!\n");
return -EFAULT;
}
if (DEBUGGER_EN(MSG))
pr_info("config cancel request id = %d", id);
rga_log("config cancel request id = %d", id);
mutex_lock(&request_manager->lock);
request = rga_request_lookup(request_manager, id);
if (IS_ERR_OR_NULL(request)) {
pr_err("can not find request from id[%d]", id);
rga_err("can not find request from id[%d]", id);
mutex_unlock(&request_manager->lock);
return -EINVAL;
}
@@ -843,7 +841,7 @@ static long rga_ioctl_blit(unsigned long arg, uint32_t cmd, struct rga_session *
request_id = rga_request_alloc(0, session);
if (request_id < 0) {
pr_err("request alloc error!\n");
rga_err("request alloc error!\n");
ret = request_id;
return ret;
}
@@ -856,13 +854,13 @@ static long rga_ioctl_blit(unsigned long arg, uint32_t cmd, struct rga_session *
ret = rga_request_check(&user_request);
if (ret < 0) {
pr_err("user request check error!\n");
rga_err("user request check error!\n");
goto err_free_request_by_id;
}
request = rga_request_config(&user_request);
if (IS_ERR(request)) {
pr_err("request[%d] config failed!\n", user_request.id);
rga_err("request[%d] config failed!\n", user_request.id);
ret = -EFAULT;
goto err_free_request_by_id;
}
@@ -873,14 +871,14 @@ static long rga_ioctl_blit(unsigned long arg, uint32_t cmd, struct rga_session *
ret = rga_request_submit(request);
if (ret < 0) {
pr_err("request[%d] submit failed!\n", user_request.id);
rga_err("request[%d] submit failed!\n", user_request.id);
goto err_put_request;
}
if (request->sync_mode == RGA_BLIT_ASYNC) {
rga_req->out_fence_fd = request->release_fence_fd;
if (copy_to_user((struct rga_req *)arg, rga_req, sizeof(struct rga_req))) {
pr_err("copy_to_user failed\n");
rga_err("copy_to_user failed\n");
ret = -EFAULT;
goto err_put_request;
}
@@ -898,7 +896,7 @@ err_free_request_by_id:
request = rga_request_lookup(request_manager, request_id);
if (IS_ERR_OR_NULL(request)) {
pr_err("can not find request from id[%d]", request_id);
rga_err("can not find request from id[%d]", request_id);
mutex_unlock(&request_manager->lock);
return -EINVAL;
}
@@ -922,7 +920,7 @@ static long rga_ioctl(struct file *file, uint32_t cmd, unsigned long arg)
struct rga_session *session = file->private_data;
if (!rga) {
pr_err("rga_drvdata is null, rga is not init\n");
rga_err("rga_drvdata is null, rga is not init\n");
return -ENODEV;
}
@@ -1050,7 +1048,7 @@ static long rga_ioctl(struct file *file, uint32_t cmd, unsigned long arg)
case RGA_IMPORT_DMA:
case RGA_RELEASE_DMA:
default:
pr_err("unknown ioctl cmd!\n");
rga_err("unknown ioctl cmd!\n");
ret = -EINVAL;
break;
}
@@ -1140,7 +1138,7 @@ static irqreturn_t rga_isr_thread(int irq, void *data)
job = rga_job_done(scheduler);
if (job == NULL) {
pr_err("isr thread invalid job!\n");
rga_err("isr thread invalid job!\n");
return IRQ_HANDLED;
}

13
drivers/video/rockchip/rga3/rga_fence.c
View File

@@ -5,14 +5,13 @@
* Author: Huang Lee <Putin.li@rock-chips.com>
*/
#define pr_fmt(fmt) "rga_fence: " fmt
#include <linux/dma-fence.h>
#include <linux/sync_file.h>
#include <linux/slab.h>
#include "rga_drv.h"
#include "rga_fence.h"
#include "rga_common.h"
static const char *rga_fence_get_name(struct dma_fence *fence)
{
@@ -57,7 +56,7 @@ struct dma_fence *rga_dma_fence_alloc(void)
struct dma_fence *fence = NULL;
if (fence_ctx == NULL) {
pr_err("fence_context is NULL!\n");
rga_err("fence_context is NULL!\n");
return ERR_PTR(-EINVAL);
}
@@ -100,7 +99,7 @@ struct dma_fence *rga_get_dma_fence_from_fd(int fence_fd)
fence = sync_file_get_fence(fence_fd);
if (!fence)
pr_err("can not get fence from fd\n");
rga_err("can not get fence from fd\n");
return fence;
}
@@ -123,7 +122,7 @@ int rga_dma_fence_add_callback(struct dma_fence *fence, dma_fence_func_t func, v
waiter = kmalloc(sizeof(*waiter), GFP_KERNEL);
if (!waiter) {
pr_err("%s: Failed to allocate waiter\n", __func__);
rga_err("%s: Failed to allocate waiter\n", __func__);
return -ENOMEM;
}
@@ -131,10 +130,10 @@ int rga_dma_fence_add_callback(struct dma_fence *fence, dma_fence_func_t func, v
ret = dma_fence_add_callback(fence, &waiter->waiter, func);
if (ret == -ENOENT) {
pr_err("'input fence' has been already signaled.");
rga_err("'input fence' has been already signaled.");
goto err_free_waiter;
} else if (ret == -EINVAL) {
pr_err("%s: failed to add callback to dma_fence, err: %d\n", __func__, ret);
rga_err("%s: failed to add callback to dma_fence, err: %d\n", __func__, ret);
goto err_free_waiter;
}

26
drivers/video/rockchip/rga3/rga_iommu.c
View File

@@ -5,8 +5,6 @@
* Author: Huang Lee <Putin.li@rock-chips.com>
*/
#define pr_fmt(fmt) "rga_iommu: " fmt
#include "rga_iommu.h"
#include "rga_dma_buf.h"
#include "rga_mm.h"
@@ -37,11 +35,11 @@ int rga_user_memory_check(struct page **pages, u32 w, u32 h, u32 format, int fla
}
if (flag == 1) {
pr_info("src user memory check\n");
pr_info("tai data is %d\n", *tai_vaddr);
rga_log("src user memory check\n");
rga_log("tai data is %d\n", *tai_vaddr);
} else {
pr_info("dst user memory check\n");
pr_info("tai data is %d\n", *tai_vaddr);
rga_log("dst user memory check\n");
rga_log("tai data is %d\n", *tai_vaddr);
}
if (taidata_num == 0)
@@ -100,14 +98,14 @@ static int rga_mmu_buf_get_try(struct rga_mmu_base *t, uint32_t size)
if ((t->back - t->front) > t->size) {
if (t->front + size > t->back - t->size) {
pr_info("front %d, back %d dsize %d size %d",
rga_log("front %d, back %d dsize %d size %d",
t->front, t->back, t->size, size);
ret = -ENOMEM;
goto out;
}
} else {
if ((t->front + size) > t->back) {
pr_info("front %d, back %d dsize %d size %d",
rga_log("front %d, back %d dsize %d size %d",
t->front, t->back, t->size, size);
ret = -ENOMEM;
goto out;
@@ -115,7 +113,7 @@ static int rga_mmu_buf_get_try(struct rga_mmu_base *t, uint32_t size)
if (t->front + size > t->size) {
if (size > (t->back - t->size)) {
pr_info("front %d, back %d dsize %d size %d",
rga_log("front %d, back %d dsize %d size %d",
t->front, t->back, t->size, size);
ret = -ENOMEM;
goto out;
@@ -138,7 +136,7 @@ unsigned int *rga_mmu_buf_get(struct rga_mmu_base *mmu_base, uint32_t size)
ret = rga_mmu_buf_get_try(mmu_base, size);
if (ret < 0) {
pr_err("Get MMU mem failed\n");
rga_err("Get MMU mem failed\n");
return NULL;
}
@@ -242,7 +240,7 @@ static int rga_iommu_intr_fault_handler(struct iommu_domain *iommu, struct devic
if (job == NULL)
return 0;
pr_err("IOMMU intr fault, IOVA[0x%lx], STATUS[0x%x]\n", iova, status);
rga_err("IOMMU intr fault, IOVA[0x%lx], STATUS[0x%x]\n", iova, status);
if (scheduler->ops->irq)
scheduler->ops->irq(scheduler);
@@ -253,13 +251,13 @@ static int rga_iommu_intr_fault_handler(struct iommu_domain *iommu, struct devic
}
if (status & RGA_IOMMU_IRQ_PAGE_FAULT) {
pr_err("RGA IOMMU: page fault! Please check the memory size.\n");
rga_err("RGA IOMMU: page fault! Please check the memory size.\n");
job->ret = -EACCES;
} else if (status & RGA_IOMMU_IRQ_BUS_ERROR) {
pr_err("RGA IOMMU: bus error! Please check if the memory is invalid or has been freed.\n");
rga_err("RGA IOMMU: bus error! Please check if the memory is invalid or has been freed.\n");
job->ret = -EACCES;
} else {
pr_err("RGA IOMMU: Wrong IOMMU interrupt signal!\n");
rga_err("RGA IOMMU: Wrong IOMMU interrupt signal!\n");
}
return 0;

142
drivers/video/rockchip/rga3/rga_job.c
View File

@@ -5,8 +5,6 @@
* Author: Huang Lee <Putin.li@rock-chips.com>
*/
#define pr_fmt(fmt) "rga_job: " fmt
#include "rga_job.h"
#include "rga_fence.h"
#include "rga_dma_buf.h"
@@ -45,8 +43,8 @@ static void rga_job_get(struct rga_job *job)
static int rga_job_cleanup(struct rga_job *job)
{
if (DEBUGGER_EN(TIME))
pr_info("request[%d], job cleanup total cost time %lld us\n",
job->request_id,
rga_log("request[%d] tgid[%d], job cleanup total cost time %lld us\n",
job->request_id, job->session->tgid,
ktime_us_delta(ktime_get(), job->timestamp));
rga_job_put(job);
@@ -64,7 +62,7 @@ static int rga_job_judgment_support_core(struct rga_job *job)
req = &job->rga_command_base;
mm = rga_drvdata->mm;
if (mm == NULL) {
pr_err("rga mm is null!\n");
rga_err("rga mm is null!\n");
return -EFAULT;
}
@@ -156,7 +154,7 @@ static struct rga_job *rga_job_alloc(struct rga_req *rga_command_base)
static void rga_job_dump_info(struct rga_job *job)
{
pr_info("job: reqeust_id = %d, priority = %d, core = %d\n",
rga_log("job: reqeust_id = %d, priority = %d, core = %d\n",
job->request_id, job->priority, job->core);
}
@@ -166,8 +164,8 @@ void rga_job_scheduler_dump_info(struct rga_scheduler_t *scheduler)
lockdep_assert_held(&scheduler->irq_lock);
pr_info("===============================================================\n");
pr_info("%s core = %d job_count = %d status = %d\n",
rga_log("===============================================================\n");
rga_log("%s core = %d job_count = %d status = %d\n",
dev_driver_string(scheduler->dev),
scheduler->core, scheduler->job_count, scheduler->status);
@@ -178,7 +176,7 @@ void rga_job_scheduler_dump_info(struct rga_scheduler_t *scheduler)
rga_job_dump_info(job_pos);
}
pr_info("===============================================================\n");
rga_log("===============================================================\n");
}
static int rga_job_run(struct rga_job *job, struct rga_scheduler_t *scheduler)
@@ -188,13 +186,13 @@ static int rga_job_run(struct rga_job *job, struct rga_scheduler_t *scheduler)
/* enable power */
ret = rga_power_enable(scheduler);
if (ret < 0) {
pr_err("power enable failed");
rga_err("power enable failed");
return ret;
}
ret = scheduler->ops->set_reg(job, scheduler);
if (ret < 0) {
pr_err("set reg failed");
rga_err("set reg failed");
rga_power_disable(scheduler);
return ret;
}
@@ -238,7 +236,7 @@ next_job:
ret = rga_job_run(job, scheduler);
/* If some error before hw run */
if (ret < 0) {
pr_err("some error on rga_job_run before hw start, %s(%d)\n", __func__, __LINE__);
rga_err("some error on rga_job_run before hw start, %s(%d)\n", __func__, __LINE__);
spin_lock_irqsave(&scheduler->irq_lock, flags);
scheduler->running_job = NULL;
@@ -265,7 +263,7 @@ struct rga_job *rga_job_done(struct rga_scheduler_t *scheduler)
job = scheduler->running_job;
if (job == NULL) {
pr_err("core[0x%x] running job has been cleanup.\n", scheduler->core);
rga_err("core[0x%x] running job has been cleanup.\n", scheduler->core);
spin_unlock_irqrestore(&scheduler->irq_lock, flags);
return NULL;
@@ -285,7 +283,7 @@ struct rga_job *rga_job_done(struct rga_scheduler_t *scheduler)
rga_dump_job_image(job);
if (DEBUGGER_EN(TIME))
pr_info("request[%d], hardware[%s] cost time %lld us, work cycle %d\n",
rga_log("request[%d], hardware[%s] cost time %lld us, work cycle %d\n",
job->request_id,
rga_get_core_name(scheduler->core),
ktime_us_delta(now, job->hw_running_time),
@@ -302,7 +300,7 @@ static int rga_job_timeout_query_state(struct rga_job *job, int orig_ret)
if (scheduler->ops->read_status) {
scheduler->ops->read_status(job, scheduler);
pr_err("request[%d] core[%d]: INTR[0x%x], HW_STATUS[0x%x], CMD_STATUS[0x%x], WORK_CYCLE[0x%x(%d)]\n",
rga_err("request[%d] core[%d]: INTR[0x%x], HW_STATUS[0x%x], CMD_STATUS[0x%x], WORK_CYCLE[0x%x(%d)]\n",
job->request_id, scheduler->core,
job->intr_status, job->hw_status, job->cmd_status,
job->work_cycle, job->work_cycle);
@@ -313,12 +311,12 @@ static int rga_job_timeout_query_state(struct rga_job *job, int orig_ret)
return orig_ret;
} else if (!test_bit(RGA_JOB_STATE_DONE, &job->state) &&
test_bit(RGA_JOB_STATE_FINISH, &job->state)) {
pr_err("request[%d] job hardware has finished, but the software has timeout!\n",
rga_err("request[%d] job hardware has finished, but the software has timeout!\n",
job->request_id);
return -EBUSY;
} else if (!test_bit(RGA_JOB_STATE_DONE, &job->state) &&
!test_bit(RGA_JOB_STATE_FINISH, &job->state)) {
pr_err("request[%d] job hardware has timeout.\n", job->request_id);
rga_err("request[%d] job hardware has timeout.\n", job->request_id);
return -EBUSY;
}
@@ -408,7 +406,7 @@ static struct rga_scheduler_t *rga_job_schedule(struct rga_job *job)
if (rga_drvdata->num_of_scheduler > 1) {
job->core = rga_job_assign(job);
if (job->core <= 0) {
pr_err("job assign failed");
rga_err("job assign failed");
job->ret = -EINVAL;
return NULL;
}
@@ -419,7 +417,7 @@ static struct rga_scheduler_t *rga_job_schedule(struct rga_job *job)
scheduler = job->scheduler;
if (scheduler == NULL) {
pr_err("failed to get scheduler, %s(%d)\n", __func__, __LINE__);
rga_err("failed to get scheduler, %s(%d)\n", __func__, __LINE__);
job->ret = -EFAULT;
return NULL;
}
@@ -435,7 +433,7 @@ struct rga_job *rga_job_commit(struct rga_req *rga_command_base, struct rga_requ
job = rga_job_alloc(rga_command_base);
if (!job) {
pr_err("failed to alloc rga job!\n");
rga_err("failed to alloc rga job!\n");
return ERR_PTR(-ENOMEM);
}
@@ -446,33 +444,33 @@ struct rga_job *rga_job_commit(struct rga_req *rga_command_base, struct rga_requ
scheduler = rga_job_schedule(job);
if (scheduler == NULL) {
pr_err("failed to get scheduler, %s(%d)\n", __func__, __LINE__);
rga_err("failed to get scheduler, %s(%d)\n", __func__, __LINE__);
goto err_free_job;
}
job->cmd_buf = rga_dma_alloc_coherent(scheduler, RGA_CMD_REG_SIZE);
if (job->cmd_buf == NULL) {
pr_err("failed to alloc command buffer.\n");
rga_err("failed to alloc command buffer.\n");
goto err_free_job;
}
/* Memory mapping needs to keep pd enabled. */
if (rga_power_enable(scheduler) < 0) {
pr_err("power enable failed");
rga_err("power enable failed");
job->ret = -EFAULT;
goto err_free_cmd_buf;
}
ret = rga_mm_map_job_info(job);
if (ret < 0) {
pr_err("%s: failed to map job info\n", __func__);
rga_err("%s: failed to map job info\n", __func__);
job->ret = ret;
goto err_power_disable;
}
ret = scheduler->ops->init_reg(job);
if (ret < 0) {
pr_err("%s: init reg failed", __func__);
rga_err("%s: init reg failed", __func__);
job->ret = ret;
goto err_unmap_job_info;
}
@@ -578,11 +576,11 @@ static int rga_request_add_acquire_fence_callback(int acquire_fence_fd,
struct rga_pending_request_manager *request_manager = rga_drvdata->pend_request_manager;
if (DEBUGGER_EN(MSG))
pr_info("acquire_fence_fd = %d", acquire_fence_fd);
rga_log("acquire_fence_fd = %d", acquire_fence_fd);
acquire_fence = rga_get_dma_fence_from_fd(acquire_fence_fd);
if (IS_ERR_OR_NULL(acquire_fence)) {
pr_err("%s: failed to get acquire dma_fence from[%d]\n",
rga_err("%s: failed to get acquire dma_fence from[%d]\n",
__func__, acquire_fence_fd);
return -EINVAL;
}
@@ -596,7 +594,7 @@ static int rga_request_add_acquire_fence_callback(int acquire_fence_fd,
ksys_close(acquire_fence_fd);
#endif
#else
pr_err("Please update the driver to v1.2.28 to prevent acquire_fence_fd leaks.");
rga_err("Please update the driver to v1.2.28 to prevent acquire_fence_fd leaks.");
return -EFAULT;
#endif
}
@@ -604,7 +602,7 @@ static int rga_request_add_acquire_fence_callback(int acquire_fence_fd,
ret = rga_dma_fence_get_status(acquire_fence);
if (ret < 0) {
pr_err("%s: Current acquire fence unexpectedly has error status before signal\n",
rga_err("%s: Current acquire fence unexpectedly has error status before signal\n",
__func__);
return ret;
} else if (ret > 0) {
@@ -623,7 +621,7 @@ static int rga_request_add_acquire_fence_callback(int acquire_fence_fd,
ret = rga_dma_fence_add_callback(acquire_fence, cb_func, (void *)request);
if (ret < 0) {
if (ret != -ENOENT)
pr_err("%s: failed to add fence callback\n", __func__);
rga_err("%s: failed to add fence callback\n", __func__);
mutex_lock(&request_manager->lock);
rga_request_put(request);
@@ -637,22 +635,22 @@ static int rga_request_add_acquire_fence_callback(int acquire_fence_fd,
int rga_request_check(struct rga_user_request *req)
{
if (req->id <= 0) {
pr_err("user request id[%d] is invalid", req->id);
rga_err("user request id[%d] is invalid", req->id);
return -EINVAL;
}
if (req->task_num <= 0) {
pr_err("invalied user request!\n");
rga_err("invalid user request!\n");
return -EINVAL;
}
if (req->task_ptr == 0) {
pr_err("task_ptr is NULL!\n");
rga_err("task_ptr is NULL!\n");
return -EINVAL;
}
if (req->task_num > RGA_TASK_NUM_MAX) {
pr_err("Only supports running %d tasks, now %d\n",
rga_err("Only supports running %d tasks, now %d\n",
RGA_TASK_NUM_MAX, req->task_num);
return -EFBIG;
}
@@ -750,8 +748,8 @@ static int rga_request_scheduler_job_abort(struct rga_request *request)
}
job->session->last_active = ktime_get();
pr_err("reset core[%d] by request[%d] abort",
scheduler->core, request->id);
rga_err("reset core[%d] by request[%d] abort",
scheduler->core, request->id);
running_abort_count++;
}
}
@@ -778,9 +776,9 @@ static int rga_request_scheduler_job_abort(struct rga_request *request)
all_task_count == request->task_count)
return 1;
pr_err("request[%d] abort! finished %d failed %d running_abort %d todo_abort %d\n",
request->id, request->finished_task_count, request->failed_task_count,
running_abort_count, todo_abort_count);
rga_err("request[%d] abort! finished %d failed %d running_abort %d todo_abort %d\n",
request->id, request->finished_task_count, request->failed_task_count,
running_abort_count, todo_abort_count);
return 0;
}
@@ -826,7 +824,7 @@ void rga_request_session_destroy_abort(struct rga_session *session)
request_manager = rga_drvdata->pend_request_manager;
if (request_manager == NULL) {
pr_err("rga_pending_request_manager is null!\n");
rga_err("rga_pending_request_manager is null!\n");
return;
}
@@ -834,8 +832,8 @@ void rga_request_session_destroy_abort(struct rga_session *session)
idr_for_each_entry(&request_manager->request_idr, request, request_id) {
if (session == request->session) {
pr_err("[tgid:%d pid:%d] destroy request[%d] when the user exits",
session->tgid, current->pid, request->id);
rga_err("[tgid:%d pid:%d] destroy request[%d] when the user exits",
session->tgid, current->pid, request->id);
rga_request_put(request);
}
}
@@ -910,13 +908,13 @@ int rga_request_commit(struct rga_request *request)
struct rga_req *req = &(request->task_list[i]);
if (DEBUGGER_EN(MSG)) {
pr_info("commit request[%d] task[%d]:\n", request->id, i);
rga_cmd_print_debug_info(req);
rga_log("commit request[%d] task[%d]:\n", request->id, i);
rga_dump_req(req);
}
job = rga_job_commit(req, request);
if (IS_ERR(job)) {
pr_err("request[%d] task[%d] job_commit failed.\n", request->id, i);
rga_err("request[%d] task[%d] job_commit failed.\n", request->id, i);
rga_request_release_abort(request, PTR_ERR(job));
return PTR_ERR(job);
@@ -942,7 +940,7 @@ static void rga_request_acquire_fence_work(struct work_struct *work)
ret = rga_request_commit(request);
if (ret < 0) {
pr_err("acquire_fence callback: rga request[%d] commit failed!\n", request->id);
rga_err("acquire_fence callback: rga request[%d] commit failed!\n", request->id);
spin_lock_irqsave(&request->lock, flags);
@@ -984,7 +982,7 @@ int rga_request_release_signal(struct rga_scheduler_t *scheduler, struct rga_job
request_manager = rga_drvdata->pend_request_manager;
if (request_manager == NULL) {
pr_err("rga_pending_request_manager is null!\n");
rga_err("rga_pending_request_manager is null!\n");
return -EFAULT;
}
@@ -992,7 +990,7 @@ int rga_request_release_signal(struct rga_scheduler_t *scheduler, struct rga_job
request = rga_request_lookup(request_manager, job->request_id);
if (IS_ERR_OR_NULL(request)) {
pr_err("can not find internal request from id[%d]", job->request_id);
rga_err("can not find internal request from id[%d]", job->request_id);
mutex_unlock(&request_manager->lock);
return -EINVAL;
}
@@ -1031,7 +1029,7 @@ int rga_request_release_signal(struct rga_scheduler_t *scheduler, struct rga_job
is_finished = true;
if (DEBUGGER_EN(MSG))
pr_info("request[%d] finished %d failed %d\n",
rga_log("request[%d] finished %d failed %d\n",
request->id, finished_count, failed_count);
/* current submit request put */
@@ -1050,7 +1048,7 @@ int rga_request_release_signal(struct rga_scheduler_t *scheduler, struct rga_job
mutex_unlock(&request_manager->lock);
if (DEBUGGER_EN(TIME))
pr_info("request[%d], job done total cost time %lld us\n",
rga_log("request[%d], job done total cost time %lld us\n",
job->request_id,
ktime_us_delta(ktime_get(), job->timestamp));
@@ -1069,7 +1067,7 @@ struct rga_request *rga_request_config(struct rga_user_request *user_request)
request_manager = rga_drvdata->pend_request_manager;
if (request_manager == NULL) {
pr_err("rga_pending_request_manager is null!\n");
rga_err("rga_pending_request_manager is null!\n");
return ERR_PTR(-EFAULT);
}
@@ -1077,7 +1075,7 @@ struct rga_request *rga_request_config(struct rga_user_request *user_request)
request = rga_request_lookup(request_manager, user_request->id);
if (IS_ERR_OR_NULL(request)) {
pr_err("can not find request from id[%d]", user_request->id);
rga_err("can not find request from id[%d]", user_request->id);
mutex_unlock(&request_manager->lock);
return ERR_PTR(-EINVAL);
}
@@ -1087,14 +1085,14 @@ struct rga_request *rga_request_config(struct rga_user_request *user_request)
task_list = kmalloc_array(user_request->task_num, sizeof(struct rga_req), GFP_KERNEL);
if (task_list == NULL) {
pr_err("task_req list alloc error!\n");
rga_err("task_req list alloc error!\n");
ret = -ENOMEM;
goto err_put_request;
}
if (unlikely(copy_from_user(task_list, u64_to_user_ptr(user_request->task_ptr),
sizeof(struct rga_req) * user_request->task_num))) {
pr_err("rga_user_request task list copy_from_user failed\n");
rga_err("rga_user_request task list copy_from_user failed\n");
ret = -EFAULT;
goto err_free_task_list;
}
@@ -1133,7 +1131,7 @@ struct rga_request *rga_request_kernel_config(struct rga_user_request *user_requ
request_manager = rga_drvdata->pend_request_manager;
if (request_manager == NULL) {
pr_err("rga_pending_request_manager is null!\n");
rga_err("rga_pending_request_manager is null!\n");
return ERR_PTR(-EFAULT);
}
@@ -1141,7 +1139,7 @@ struct rga_request *rga_request_kernel_config(struct rga_user_request *user_requ
request = rga_request_lookup(request_manager, user_request->id);
if (IS_ERR_OR_NULL(request)) {
pr_err("can not find request from id[%d]", user_request->id);
rga_err("can not find request from id[%d]", user_request->id);
mutex_unlock(&request_manager->lock);
return ERR_PTR(-EINVAL);
}
@@ -1151,7 +1149,7 @@ struct rga_request *rga_request_kernel_config(struct rga_user_request *user_requ
task_list = kmalloc_array(user_request->task_num, sizeof(struct rga_req), GFP_KERNEL);
if (task_list == NULL) {
pr_err("task_req list alloc error!\n");
rga_err("task_req list alloc error!\n");
ret = -ENOMEM;
goto err_put_request;
}
@@ -1194,7 +1192,7 @@ int rga_request_submit(struct rga_request *request)
if (request->is_running) {
spin_unlock_irqrestore(&request->lock, flags);
pr_err("can not re-config when request is running\n");
rga_err("can not re-config when request is running\n");
ret = -EFAULT;
goto err_put_current_mm;
}
@@ -1202,7 +1200,7 @@ int rga_request_submit(struct rga_request *request)
if (request->task_list == NULL) {
spin_unlock_irqrestore(&request->lock, flags);
pr_err("can not find task list from id[%d]\n", request->id);
rga_err("can not find task list from id[%d]\n", request->id);
ret = -EINVAL;
goto err_put_current_mm;
}
@@ -1221,7 +1219,7 @@ int rga_request_submit(struct rga_request *request)
if (request->sync_mode == RGA_BLIT_ASYNC) {
release_fence = rga_dma_fence_alloc();
if (IS_ERR(release_fence)) {
pr_err("Can not alloc release fence!\n");
rga_err("Can not alloc release fence!\n");
ret = IS_ERR(release_fence);
goto err_reset_request;
}
@@ -1239,7 +1237,7 @@ int rga_request_submit(struct rga_request *request)
/* acquire fence has been signaled */
goto request_commit;
} else {
pr_err("Failed to add callback with acquire fence fd[%d]!\n",
rga_err("Failed to add callback with acquire fence fd[%d]!\n",
request->acquire_fence_fd);
goto err_put_release_fence;
}
@@ -1249,7 +1247,7 @@ int rga_request_submit(struct rga_request *request)
request_commit:
ret = rga_request_commit(request);
if (ret < 0) {
pr_err("rga request[%d] commit failed!\n", request->id);
rga_err("rga request[%d] commit failed!\n", request->id);
goto err_put_release_fence;
}
@@ -1257,7 +1255,7 @@ export_release_fence_fd:
if (request->release_fence != NULL) {
ret = rga_dma_fence_get_fd(request->release_fence);
if (ret < 0) {
pr_err("Failed to alloc release fence fd!\n");
rga_err("Failed to alloc release fence fd!\n");
rga_request_release_abort(request, ret);
return ret;
}
@@ -1297,20 +1295,20 @@ int rga_request_mpi_submit(struct rga_req *req, struct rga_request *request)
request_manager = rga_drvdata->pend_request_manager;
if (request->sync_mode == RGA_BLIT_ASYNC) {
pr_err("mpi unsupported async mode!\n");
rga_err("mpi unsupported async mode!\n");
return -EINVAL;
}
spin_lock_irqsave(&request->lock, flags);
if (request->is_running) {
pr_err("can not re-config when request is running");
rga_err("can not re-config when request is running");
spin_unlock_irqrestore(&request->lock, flags);
return -EFAULT;
}
if (request->task_list == NULL) {
pr_err("can not find task list from id[%d]", request->id);
rga_err("can not find task list from id[%d]", request->id);
spin_unlock_irqrestore(&request->lock, flags);
return -EINVAL;
}
@@ -1334,7 +1332,7 @@ int rga_request_mpi_submit(struct rga_req *req, struct rga_request *request)
job = rga_job_commit(req, request);
if (IS_ERR_OR_NULL(job)) {
pr_err("failed to commit job!\n");
rga_err("failed to commit job!\n");
return job ? PTR_ERR(job) : -EFAULT;
}
@@ -1353,14 +1351,14 @@ int rga_request_free(struct rga_request *request)
request_manager = rga_drvdata->pend_request_manager;
if (request_manager == NULL) {
pr_err("rga_pending_request_manager is null!\n");
rga_err("rga_pending_request_manager is null!\n");
return -EFAULT;
}
WARN_ON(!mutex_is_locked(&request_manager->lock));
if (IS_ERR_OR_NULL(request)) {
pr_err("request already freed");
rga_err("request already freed");
return -EFAULT;
}
@@ -1432,13 +1430,13 @@ int rga_request_alloc(uint32_t flags, struct rga_session *session)
request_manager = rga_drvdata->pend_request_manager;
if (request_manager == NULL) {
pr_err("rga_pending_request_manager is null!\n");
rga_err("rga_pending_request_manager is null!\n");
return -EFAULT;
}
request = kzalloc(sizeof(*request), GFP_KERNEL);
if (request == NULL) {
pr_err("can not kzalloc for rga_request\n");
rga_err("can not kzalloc for rga_request\n");
return -ENOMEM;
}
@@ -1460,7 +1458,7 @@ int rga_request_alloc(uint32_t flags, struct rga_session *session)
new_id = idr_alloc_cyclic(&request_manager->request_idr, request, 1, 0, GFP_NOWAIT);
idr_preload_end();
if (new_id < 0) {
pr_err("request alloc id failed!\n");
rga_err("request alloc id failed!\n");
mutex_unlock(&request_manager->lock);
kfree(request);

372
drivers/video/rockchip/rga3/rga_mm.c
View File

File diff suppressed because it is too large Load Diff

48
drivers/video/rockchip/rga3/rga_policy.c
View File

@@ -5,8 +5,6 @@
* Author: Huang Lee <Putin.li@rock-chips.com>
*/
#define pr_fmt(fmt) "rga_policy: " fmt
#include "rga_job.h"
#include "rga_common.h"
#include "rga_hw_config.h"
@@ -166,7 +164,7 @@ static bool rga_check_align(uint32_t byte_stride_align, uint32_t format, uint16_
if (DEBUGGER_EN(MSG)) {
gcd = GET_GCD(pixel_stride, byte_stride_align * 8);
align = GET_LCM(pixel_stride, byte_stride_align * 8, gcd) / pixel_stride;
pr_info("unsupported width stride %d, 0x%x should be %d aligned!",
rga_log("unsupported width stride %d, 0x%x should be %d aligned!",
w_stride, format, align);
}
@@ -186,7 +184,7 @@ static bool rga_check_channel(const struct rga_hw_data *data,
if (!rga_check_resolution(range, img->act_w, img->act_h)) {
if (DEBUGGER_EN(MSG))
pr_info("%s resolution check error, input range[%dx%d ~ %dx%d], [w,h] = [%d, %d]\n",
rga_log("%s resolution check error, input range[%dx%d ~ %dx%d], [w,h] = [%d, %d]\n",
name,
data->input_range.min.width, data->input_range.min.height,
data->input_range.max.width, data->input_range.max.height,
@@ -200,7 +198,7 @@ static bool rga_check_channel(const struct rga_hw_data *data,
img->act_w + img->x_offset,
img->act_h + img->y_offset)) {
if (DEBUGGER_EN(MSG))
pr_info("%s RGA3 resolution check error, input range[%dx%d ~ %dx%d], [w+x,h+y] = [%d, %d]\n",
rga_log("%s RGA3 resolution check error, input range[%dx%d ~ %dx%d], [w+x,h+y] = [%d, %d]\n",
name,
data->input_range.min.width, data->input_range.min.height,
data->input_range.max.width, data->input_range.max.height,
@@ -211,14 +209,14 @@ static bool rga_check_channel(const struct rga_hw_data *data,
if (!rga_check_format(data, img->rd_mode, img->format, win_num)) {
if (DEBUGGER_EN(MSG))
pr_info("%s format check error, mode = %#x, format = %#x\n",
rga_log("%s format check error, mode = %#x, format = %#x\n",
name, img->rd_mode, img->format);
return false;
}
if (!rga_check_align(data->byte_stride_align, img->format, img->vir_w)) {
if (DEBUGGER_EN(MSG))
pr_info("%s align check error, byte_stride_align[%d], format[%#x], vir_w[%d]\n",
rga_log("%s align check error, byte_stride_align[%d], format[%#x], vir_w[%d]\n",
name, data->byte_stride_align, img->format, img->vir_w);
return false;
}
@@ -259,7 +257,7 @@ static bool rga_check_scale(const struct rga_hw_data *data,
return true;
check_error:
if (DEBUGGER_EN(MSG))
pr_info("scale check error, scale limit[1/%d ~ %d], src[%d, %d], dst[%d, %d]\n",
rga_log("scale check error, scale limit[1/%d ~ %d], src[%d, %d], dst[%d, %d]\n",
(1 << data->max_downscale_factor), (1 << data->max_upscale_factor),
sw, sh, dw, dh);
@@ -287,7 +285,7 @@ int rga_job_assign(struct rga_job *job)
/* assigned by userspace */
if (rga_base->core > RGA_NONE_CORE) {
if (rga_base->core > RGA_CORE_MASK) {
pr_err("invalid setting core by user\n");
rga_err("invalid setting core by user\n");
goto finish;
} else if (rga_base->core & RGA_CORE_MASK)
specified_cores = rga_base->core;
@@ -305,19 +303,19 @@ int rga_job_assign(struct rga_job *job)
continue;
if (DEBUGGER_EN(MSG))
pr_info("start policy on core = %d", scheduler->core);
rga_log("start policy on core = %d", scheduler->core);
if (scheduler->data->mmu == RGA_MMU &&
job->flags & RGA_JOB_UNSUPPORT_RGA_MMU) {
if (DEBUGGER_EN(MSG))
pr_info("RGA2 only support under 4G memory!\n");
rga_log("RGA2 only support under 4G memory!\n");
continue;
}
if (feature > 0) {
if (!(feature & data->feature)) {
if (DEBUGGER_EN(MSG))
pr_info("core = %d, break on feature\n",
rga_log("core = %d, break on feature\n",
scheduler->core);
continue;
}
@@ -328,35 +326,35 @@ int rga_job_assign(struct rga_job *job)
if (src1->yrgb_addr > 0) {
if (!(src0->rd_mode & data->win[0].rd_mode)) {
if (DEBUGGER_EN(MSG))
pr_info("core[%#x], src0 break on rd_mode[%#x]\n",
rga_log("core[%#x], src0 break on rd_mode[%#x]\n",
scheduler->core, src0->rd_mode);
continue;
}
if (!(src1->rd_mode & data->win[1].rd_mode)) {
if (DEBUGGER_EN(MSG))
pr_info("core[%#x], src1 break on rd_mode[%#x]\n",
rga_log("core[%#x], src1 break on rd_mode[%#x]\n",
scheduler->core, src1->rd_mode);
continue;
}
if (!(dst->rd_mode & data->win[2].rd_mode)) {
if (DEBUGGER_EN(MSG))
pr_info("core[%#x], dst break on rd_mode[%#x]\n",
rga_log("core[%#x], dst break on rd_mode[%#x]\n",
scheduler->core, dst->rd_mode);
continue;
}
} else {
if (!(src0->rd_mode & data->win[0].rd_mode)) {
if (DEBUGGER_EN(MSG))
pr_info("core[%#x], src break on rd_mode[%#x]\n",
rga_log("core[%#x], src break on rd_mode[%#x]\n",
scheduler->core, src0->rd_mode);
continue;
}
if (!(dst->rd_mode & data->win[2].rd_mode)) {
if (DEBUGGER_EN(MSG))
pr_info("core[%#x], dst break on rd_mode[%#x]\n",
rga_log("core[%#x], dst break on rd_mode[%#x]\n",
scheduler->core, dst->rd_mode);
continue;
}
@@ -364,14 +362,14 @@ int rga_job_assign(struct rga_job *job)
if (!rga_check_scale(data, rga_base)) {
if (DEBUGGER_EN(MSG))
pr_info("core = %d, break on rga_check_scale",
rga_log("core = %d, break on rga_check_scale",
scheduler->core);
continue;
}
if (!rga_check_channel(data, src0, "src0", true, 0)) {
if (DEBUGGER_EN(MSG))
pr_info("core = %d, break on src0",
rga_log("core = %d, break on src0",
scheduler->core);
continue;
}
@@ -379,7 +377,7 @@ int rga_job_assign(struct rga_job *job)
if (src1->yrgb_addr > 0) {
if (!rga_check_channel(data, src1, "src1", true, 1)) {
if (DEBUGGER_EN(MSG))
pr_info("core = %d, break on src1",
rga_log("core = %d, break on src1",
scheduler->core);
continue;
}
@@ -388,14 +386,14 @@ int rga_job_assign(struct rga_job *job)
if (!rga_check_channel(data, dst, "dst", false, 2)) {
if (DEBUGGER_EN(MSG))
pr_info("core = %d, break on dst",
rga_log("core = %d, break on dst",
scheduler->core);
continue;
}
if (!rga_check_csc(data, rga_base)) {
if (DEBUGGER_EN(MSG))
pr_info("core = %d, break on rga_check_csc",
rga_log("core = %d, break on rga_check_csc",
scheduler->core);
continue;
}
@@ -404,11 +402,11 @@ int rga_job_assign(struct rga_job *job)
}
if (DEBUGGER_EN(MSG))
pr_info("optional_cores = %d\n", optional_cores);
rga_log("optional_cores = %d\n", optional_cores);
if (optional_cores == 0) {
core = -1;
pr_err("invalid function policy\n");
rga_err("invalid function policy\n");
goto finish;
}
@@ -440,7 +438,7 @@ int rga_job_assign(struct rga_job *job)
/* TODO: need consider full load */
finish:
if (DEBUGGER_EN(MSG))
pr_info("assign core: %d\n", core);
rga_log("assign core: %d\n", core);
return core;
}