diff --git a/drivers/video/rockchip/rga3/include/rga_common.h b/drivers/video/rockchip/rga3/include/rga_common.h index 1afdb6ef59f7..a87207d0b5b3 100644 --- a/drivers/video/rockchip/rga3/include/rga_common.h +++ b/drivers/video/rockchip/rga3/include/rga_common.h @@ -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 diff --git a/drivers/video/rockchip/rga3/include/rga_debugger.h b/drivers/video/rockchip/rga3/include/rga_debugger.h index f6d423872b28..cc2966ec554d 100644 --- a/drivers/video/rockchip/rga3/include/rga_debugger.h +++ b/drivers/video/rockchip/rga3/include/rga_debugger.h @@ -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); diff --git a/drivers/video/rockchip/rga3/rga2_reg_info.c b/drivers/video/rockchip/rga3/rga2_reg_info.c index 05138cf4c83e..0b8a75e1da4a 100644 --- a/drivers/video/rockchip/rga3/rga2_reg_info.c +++ b/drivers/video/rockchip/rga3/rga2_reg_info.c @@ -5,8 +5,6 @@ * Author: Huang Lee */ -#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; } } diff --git a/drivers/video/rockchip/rga3/rga3_reg_info.c b/drivers/video/rockchip/rga3/rga3_reg_info.c index 2503f8cc3f73..ab8e15c7799f 100644 --- a/drivers/video/rockchip/rga3/rga3_reg_info.c +++ b/drivers/video/rockchip/rga3/rga3_reg_info.c @@ -5,8 +5,6 @@ * Author: Huang Lee */ -#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; } } diff --git a/drivers/video/rockchip/rga3/rga_common.c b/drivers/video/rockchip/rga3/rga_common.c index 77ad30bd5857..07ec8ddda806 100644 --- a/drivers/video/rockchip/rga3/rga_common.c +++ b/drivers/video/rockchip/rga3/rga_common.c @@ -5,8 +5,6 @@ * Author: Cerf Yu */ -#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); +} diff --git a/drivers/video/rockchip/rga3/rga_debugger.c b/drivers/video/rockchip/rga3/rga_debugger.c index 3b7f11ebbb2f..93c5fcf3ec48 100644 --- a/drivers/video/rockchip/rga3/rga_debugger.c +++ b/drivers/video/rockchip/rga3/rga_debugger.c @@ -7,8 +7,6 @@ * Huang Lee */ -#define pr_fmt(fmt) "rga_debugger: " fmt - #include #include #include @@ -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, diff --git a/drivers/video/rockchip/rga3/rga_dma_buf.c b/drivers/video/rockchip/rga3/rga_dma_buf.c index da421580c9bb..e72470e5c5f5 100644 --- a/drivers/video/rockchip/rga3/rga_dma_buf.c +++ b/drivers/video/rockchip/rga3/rga_dma_buf.c @@ -5,8 +5,6 @@ * Author: Huang Lee */ -#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; } diff --git a/drivers/video/rockchip/rga3/rga_drv.c b/drivers/video/rockchip/rga3/rga_drv.c index 550d2c2401d2..03c21a418243 100644 --- a/drivers/video/rockchip/rga3/rga_drv.c +++ b/drivers/video/rockchip/rga3/rga_drv.c @@ -5,8 +5,6 @@ * Author: Huang Lee */ -#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; } diff --git a/drivers/video/rockchip/rga3/rga_fence.c b/drivers/video/rockchip/rga3/rga_fence.c index 7d831d55d15d..9c663f3be5ca 100644 --- a/drivers/video/rockchip/rga3/rga_fence.c +++ b/drivers/video/rockchip/rga3/rga_fence.c @@ -5,14 +5,13 @@ * Author: Huang Lee */ -#define pr_fmt(fmt) "rga_fence: " fmt - #include #include #include #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; } diff --git a/drivers/video/rockchip/rga3/rga_iommu.c b/drivers/video/rockchip/rga3/rga_iommu.c index 6ef9cbc0d5d2..3ba0d58b2c20 100644 --- a/drivers/video/rockchip/rga3/rga_iommu.c +++ b/drivers/video/rockchip/rga3/rga_iommu.c @@ -5,8 +5,6 @@ * Author: Huang Lee */ -#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; diff --git a/drivers/video/rockchip/rga3/rga_job.c b/drivers/video/rockchip/rga3/rga_job.c index 8115031ec1a8..b08fa46f27c7 100644 --- a/drivers/video/rockchip/rga3/rga_job.c +++ b/drivers/video/rockchip/rga3/rga_job.c @@ -5,8 +5,6 @@ * Author: Huang Lee */ -#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); diff --git a/drivers/video/rockchip/rga3/rga_mm.c b/drivers/video/rockchip/rga3/rga_mm.c index e793a632a13e..019df6636a79 100644 --- a/drivers/video/rockchip/rga3/rga_mm.c +++ b/drivers/video/rockchip/rga3/rga_mm.c @@ -5,8 +5,6 @@ * Author: Cerf Yu */ -#define pr_fmt(fmt) "rga_mm: " fmt - #include "rga.h" #include "rga_job.h" #include "rga_mm.h" @@ -53,14 +51,14 @@ static int rga_get_user_pages_from_vma(struct page **pages, unsigned long Memory for (i = 0; i < pageCount; i++) { vma = find_vma(current_mm, (Memory + i) << PAGE_SHIFT); if (!vma) { - pr_err("page[%d] failed to get vma\n", i); + rga_err("page[%d] failed to get vma\n", i); ret = RGA_OUT_OF_RESOURCES; break; } pgd = pgd_offset(current_mm, (Memory + i) << PAGE_SHIFT); if (pgd_none(*pgd) || unlikely(pgd_bad(*pgd))) { - pr_err("page[%d] failed to get pgd\n", i); + rga_err("page[%d] failed to get pgd\n", i); ret = RGA_OUT_OF_RESOURCES; break; } @@ -71,7 +69,7 @@ static int rga_get_user_pages_from_vma(struct page **pages, unsigned long Memory */ p4d = p4d_offset(pgd, (Memory + i) << PAGE_SHIFT); if (p4d_none(*p4d) || unlikely(p4d_bad(*p4d))) { - pr_err("page[%d] failed to get p4d\n", i); + rga_err("page[%d] failed to get p4d\n", i); ret = RGA_OUT_OF_RESOURCES; break; } @@ -82,20 +80,20 @@ static int rga_get_user_pages_from_vma(struct page **pages, unsigned long Memory #endif if (pud_none(*pud) || unlikely(pud_bad(*pud))) { - pr_err("page[%d] failed to get pud\n", i); + rga_err("page[%d] failed to get pud\n", i); ret = RGA_OUT_OF_RESOURCES; break; } pmd = pmd_offset(pud, (Memory + i) << PAGE_SHIFT); if (pmd_none(*pmd) || unlikely(pmd_bad(*pmd))) { - pr_err("page[%d] failed to get pmd\n", i); + rga_err("page[%d] failed to get pmd\n", i); ret = RGA_OUT_OF_RESOURCES; break; } pte = pte_offset_map_lock(current_mm, pmd, (Memory + i) << PAGE_SHIFT, &ptl); if (pte_none(*pte)) { - pr_err("page[%d] failed to get pte\n", i); + rga_err("page[%d] failed to get pte\n", i); pte_unmap_unlock(pte, ptl); ret = RGA_OUT_OF_RESOURCES; break; @@ -107,8 +105,8 @@ static int rga_get_user_pages_from_vma(struct page **pages, unsigned long Memory } if (ret == RGA_OUT_OF_RESOURCES && i > 0) - pr_err("Only get buffer %d byte from vma, but current image required %d byte", - (int)(i * PAGE_SIZE), (int)(pageCount * PAGE_SIZE)); + rga_err("Only get buffer %d byte from vma, but current image required %d byte", + (int)(i * PAGE_SIZE), (int)(pageCount * PAGE_SIZE)); return ret; } @@ -149,8 +147,8 @@ static int rga_get_user_pages(struct page **pages, unsigned long Memory, ret = rga_get_user_pages_from_vma(pages, Memory, pageCount, current_mm); if (ret < 0 && result > 0) { - pr_err("Only get buffer %d byte from user pages, but current image required %d byte\n", - (int)(result * PAGE_SIZE), (int)(pageCount * PAGE_SIZE)); + rga_err("Only get buffer %d byte from user pages, but current image required %d byte\n", + (int)(result * PAGE_SIZE), (int)(pageCount * PAGE_SIZE)); } } @@ -176,7 +174,7 @@ static struct sg_table *rga_alloc_sgt(struct rga_virt_addr *virt_addr) sgt = kzalloc(sizeof(*sgt), GFP_KERNEL); if (sgt == NULL) { - pr_err("%s alloc sgt error!\n", __func__); + rga_err("%s alloc sgt error!\n", __func__); return ERR_PTR(-ENOMEM); } @@ -189,7 +187,7 @@ static struct sg_table *rga_alloc_sgt(struct rga_virt_addr *virt_addr) virt_addr->size, GFP_KERNEL); if (ret) { - pr_err("sg_alloc_table_from_pages failed"); + rga_err("sg_alloc_table_from_pages failed"); goto out_free_sgt; } @@ -250,8 +248,8 @@ static int rga_alloc_virt_addr(struct rga_virt_addr **virt_addr_p, count = RGA_GET_PAGE_COUNT(img_size + offset); size = count * PAGE_SIZE; if (!size) { - pr_err("failed to calculating buffer size! size = %ld, count = %d, offset = %ld\n", - size, count, (unsigned long)offset); + rga_err("failed to calculating buffer size! size = %ld, count = %d, offset = %ld\n", + size, count, (unsigned long)offset); rga_dump_memory_parm(memory_parm); return -EFAULT; } @@ -259,21 +257,21 @@ static int rga_alloc_virt_addr(struct rga_virt_addr **virt_addr_p, /* alloc pages and page_table */ order = get_order(count * sizeof(struct page *)); if (order >= MAX_ORDER) { - pr_err("Can not alloc pages with order[%d] for viraddr pages, max_order = %d\n", - order, MAX_ORDER); + rga_err("Can not alloc pages with order[%d] for viraddr pages, max_order = %d\n", + order, MAX_ORDER); return -ENOMEM; } pages = (struct page **)__get_free_pages(GFP_KERNEL, order); if (pages == NULL) { - pr_err("%s can not alloc pages for viraddr pages\n", __func__); + rga_err("%s can not alloc pages for viraddr pages\n", __func__); return -ENOMEM; } /* get pages from virtual address. */ ret = rga_get_user_pages(pages, viraddr >> PAGE_SHIFT, count, writeFlag, mm); if (ret < 0) { - pr_err("failed to get pages from virtual adrees: 0x%lx\n", + rga_err("failed to get pages from virtual adrees: 0x%lx\n", (unsigned long)viraddr); ret = -EINVAL; goto out_free_pages; @@ -284,7 +282,7 @@ static int rga_alloc_virt_addr(struct rga_virt_addr **virt_addr_p, *virt_addr_p = kzalloc(sizeof(struct rga_virt_addr), GFP_KERNEL); if (*virt_addr_p == NULL) { - pr_err("%s alloc virt_addr error!\n", __func__); + rga_err("%s alloc virt_addr error!\n", __func__); ret = -ENOMEM; goto out_put_and_free_pages; } @@ -316,7 +314,7 @@ static inline bool rga_mm_check_memory_limit(struct rga_scheduler_t *scheduler, if (scheduler->data->mmu == RGA_MMU && !(mm_flag & RGA_MEM_UNDER_4G)) { - pr_err("%s unsupported memory larger than 4G!\n", + rga_err("%s unsupported memory larger than 4G!\n", rga_get_mmu_type_str(scheduler->data->mmu)); return false; } @@ -383,7 +381,7 @@ static int rga_mm_map_dma_buffer(struct rga_external_buffer *external_buffer, scheduler = job ? job->scheduler : rga_drvdata->scheduler[rga_drvdata->map_scheduler_index]; if (scheduler == NULL) { - pr_err("Invalid scheduler device!\n"); + rga_err("Invalid scheduler device!\n"); return -EINVAL; } @@ -395,7 +393,7 @@ static int rga_mm_map_dma_buffer(struct rga_external_buffer *external_buffer, external_buffer->memory_parm.format, NULL, NULL, NULL); if (ex_buffer_size <= 0) { - pr_err("failed to calculating buffer size!\n"); + rga_err("failed to calculating buffer size!\n"); rga_dump_memory_parm(&external_buffer->memory_parm); return ex_buffer_size == 0 ? -EINVAL : ex_buffer_size; } @@ -408,7 +406,7 @@ static int rga_mm_map_dma_buffer(struct rga_external_buffer *external_buffer, buffer = kzalloc(sizeof(*buffer), GFP_KERNEL); if (buffer == NULL) { - pr_err("%s alloc internal_buffer error!\n", __func__); + rga_err("%s alloc internal_buffer error!\n", __func__); return -ENOMEM; } @@ -428,15 +426,15 @@ static int rga_mm_map_dma_buffer(struct rga_external_buffer *external_buffer, break; } if (ret < 0) { - pr_err("%s core[%d] map dma buffer error!\n", - __func__, scheduler->core); + rga_err("%s core[%d] map dma buffer error!\n", + __func__, scheduler->core); goto free_buffer; } if (buffer->size < ex_buffer_size) { - pr_err("Only get buffer %ld byte from %s = 0x%lx, but current image required %d byte\n", - buffer->size, rga_get_memory_type_str(external_buffer->type), - (unsigned long)external_buffer->memory, ex_buffer_size); + rga_err("Only get buffer %ld byte from %s = 0x%lx, but current image required %d byte\n", + buffer->size, rga_get_memory_type_str(external_buffer->type), + (unsigned long)external_buffer->memory, ex_buffer_size); rga_dump_memory_parm(&external_buffer->memory_parm); ret = -EINVAL; goto unmap_buffer; @@ -457,7 +455,7 @@ static int rga_mm_map_dma_buffer(struct rga_external_buffer *external_buffer, if (rga_mm_check_contiguous_sgt(buffer->sgt)) { phys_addr = sg_phys(buffer->sgt->sgl); if (phys_addr == 0) { - pr_err("%s get physical address error!", __func__); + rga_err("%s get physical address error!", __func__); ret = -EFAULT; goto unmap_buffer; } @@ -466,8 +464,8 @@ static int rga_mm_map_dma_buffer(struct rga_external_buffer *external_buffer, } if (!rga_mm_check_memory_limit(scheduler, mm_flag)) { - pr_err("scheduler core[%d] unsupported mm_flag[0x%x]!\n", - scheduler->core, mm_flag); + rga_err("scheduler core[%d] unsupported mm_flag[0x%x]!\n", + scheduler->core, mm_flag); ret = -EINVAL; goto unmap_buffer; } @@ -539,13 +537,13 @@ static int rga_mm_map_virt_addr(struct rga_external_buffer *external_buffer, scheduler = job ? job->scheduler : rga_drvdata->scheduler[rga_drvdata->map_scheduler_index]; if (scheduler == NULL) { - pr_err("Invalid scheduler device!\n"); + rga_err("Invalid scheduler device!\n"); return -EINVAL; } internal_buffer->current_mm = job ? job->mm : current->mm; if (internal_buffer->current_mm == NULL) { - pr_err("%s, cannot get current mm!\n", __func__); + rga_err("%s, cannot get current mm!\n", __func__); return -EFAULT; } mmgrab(internal_buffer->current_mm); @@ -556,14 +554,14 @@ static int rga_mm_map_virt_addr(struct rga_external_buffer *external_buffer, &internal_buffer->memory_parm, write_flag, internal_buffer->current_mm); if (ret < 0) { - pr_err("Can not alloc rga_virt_addr from 0x%lx\n", + rga_err("Can not alloc rga_virt_addr from 0x%lx\n", (unsigned long)external_buffer->memory); goto put_current_mm; } sgt = rga_alloc_sgt(virt_addr); if (IS_ERR(sgt)) { - pr_err("alloc sgt error!\n"); + rga_err("alloc sgt error!\n"); ret = PTR_ERR(sgt); goto free_virt_addr; } @@ -574,7 +572,7 @@ static int rga_mm_map_virt_addr(struct rga_external_buffer *external_buffer, if (rga_mm_check_contiguous_sgt(sgt)) { phys_addr = sg_phys(sgt->sgl); if (phys_addr == 0) { - pr_err("%s get physical address error!", __func__); + rga_err("%s get physical address error!", __func__); ret = -EFAULT; goto free_sgt; } @@ -590,15 +588,15 @@ static int rga_mm_map_virt_addr(struct rga_external_buffer *external_buffer, mm_flag |= RGA_MEM_FORCE_FLUSH_CACHE; if (!rga_mm_check_memory_limit(scheduler, mm_flag)) { - pr_err("scheduler core[%d] unsupported mm_flag[0x%x]!\n", - scheduler->core, mm_flag); + rga_err("scheduler core[%d] unsupported mm_flag[0x%x]!\n", + scheduler->core, mm_flag); ret = -EINVAL; goto free_sgt; } buffer = kzalloc(sizeof(*buffer), GFP_KERNEL); if (buffer == NULL) { - pr_err("%s alloc internal dma_buffer error!\n", __func__); + rga_err("%s alloc internal dma_buffer error!\n", __func__); ret = -ENOMEM; goto free_sgt; } @@ -607,8 +605,8 @@ static int rga_mm_map_virt_addr(struct rga_external_buffer *external_buffer, case RGA_IOMMU: ret = rga_iommu_map_sgt(sgt, virt_addr->size, buffer, scheduler->dev); if (ret < 0) { - pr_err("%s core[%d] iommu_map virtual address error!\n", - __func__, scheduler->core); + rga_err("%s core[%d] iommu_map virtual address error!\n", + __func__, scheduler->core); goto free_dma_buffer; } @@ -618,7 +616,7 @@ static int rga_mm_map_virt_addr(struct rga_external_buffer *external_buffer, case RGA_MMU: ret = dma_map_sg(scheduler->dev, sgt->sgl, sgt->orig_nents, DMA_BIDIRECTIONAL); if (ret == 0) { - pr_err("%s core[%d] dma_map_sgt error! va = 0x%lx, nents = %d\n", + rga_err("%s core[%d] dma_map_sgt error! va = 0x%lx, nents = %d\n", __func__, scheduler->core, (unsigned long)virt_addr->addr, sgt->orig_nents); ret = -EINVAL; @@ -629,8 +627,8 @@ static int rga_mm_map_virt_addr(struct rga_external_buffer *external_buffer, if (mm_flag & RGA_MEM_PHYSICAL_CONTIGUOUS) break; - pr_err("Current %s[%d] cannot support physically discontinuous virtual address!\n", - rga_get_mmu_type_str(scheduler->data->mmu), scheduler->data->mmu); + rga_err("Current %s[%d] cannot support physically discontinuous virtual address!\n", + rga_get_mmu_type_str(scheduler->data->mmu), scheduler->data->mmu); ret = -EOPNOTSUPP; goto free_dma_buffer; } @@ -691,7 +689,7 @@ static int rga_mm_map_phys_addr(struct rga_external_buffer *external_buffer, scheduler = job ? job->scheduler : rga_drvdata->scheduler[rga_drvdata->map_scheduler_index]; if (scheduler == NULL) { - pr_err("Invalid scheduler device!\n"); + rga_err("Invalid scheduler device!\n"); return -EINVAL; } @@ -703,7 +701,7 @@ static int rga_mm_map_phys_addr(struct rga_external_buffer *external_buffer, internal_buffer->memory_parm.format, NULL, NULL, NULL); if (buffer_size <= 0) { - pr_err("Failed to get phys addr size!\n"); + rga_err("Failed to get phys addr size!\n"); rga_dump_memory_parm(&internal_buffer->memory_parm); return buffer_size == 0 ? -EINVAL : buffer_size; } @@ -714,21 +712,21 @@ static int rga_mm_map_phys_addr(struct rga_external_buffer *external_buffer, mm_flag |= RGA_MEM_UNDER_4G; if (!rga_mm_check_memory_limit(scheduler, mm_flag)) { - pr_err("scheduler core[%d] unsupported mm_flag[0x%x]!\n", - scheduler->core, mm_flag); + rga_err("scheduler core[%d] unsupported mm_flag[0x%x]!\n", + scheduler->core, mm_flag); return -EINVAL; } buffer = kzalloc(sizeof(*buffer), GFP_KERNEL); if (buffer == NULL) { - pr_err("%s alloc internal dma buffer error!\n", __func__); + rga_err("%s alloc internal dma buffer error!\n", __func__); return -ENOMEM; } if (scheduler->data->mmu == RGA_IOMMU) { ret = rga_iommu_map(phys_addr, buffer_size, buffer, scheduler->dev); if (ret < 0) { - pr_err("%s core[%d] map phys_addr error!\n", __func__, scheduler->core); + rga_err("%s core[%d] map phys_addr error!\n", __func__, scheduler->core); goto free_dma_buffer; } } @@ -762,7 +760,7 @@ static int rga_mm_unmap_buffer(struct rga_internal_buffer *internal_buffer) rga_mm_unmap_phys_addr(internal_buffer); break; default: - pr_err("Illegal external buffer!\n"); + rga_err("Illegal external buffer!\n"); return -EFAULT; } @@ -785,7 +783,7 @@ static int rga_mm_map_buffer(struct rga_external_buffer *external_buffer, ret = rga_mm_map_dma_buffer(external_buffer, internal_buffer, job); if (ret < 0) { - pr_err("%s map dma_buf error!\n", __func__); + rga_err("%s map dma_buf error!\n", __func__); return ret; } @@ -798,7 +796,7 @@ static int rga_mm_map_buffer(struct rga_external_buffer *external_buffer, ret = rga_mm_map_virt_addr(external_buffer, internal_buffer, job, write_flag); if (ret < 0) { - pr_err("%s map virtual address error!\n", __func__); + rga_err("%s map virtual address error!\n", __func__); return ret; } @@ -811,14 +809,14 @@ static int rga_mm_map_buffer(struct rga_external_buffer *external_buffer, ret = rga_mm_map_phys_addr(external_buffer, internal_buffer, job); if (ret < 0) { - pr_err("%s map physical address error!\n", __func__); + rga_err("%s map physical address error!\n", __func__); return ret; } internal_buffer->mm_flag |= RGA_MEM_NEED_USE_IOMMU; break; default: - pr_err("Illegal external buffer!\n"); + rga_err("Illegal external buffer!\n"); return -EFAULT; } @@ -938,7 +936,7 @@ rga_mm_lookup_external(struct rga_mm *mm_session, break; default: - pr_err("Illegal external buffer!\n"); + rga_err("Illegal external buffer!\n"); return NULL; } @@ -962,7 +960,7 @@ int rga_mm_lookup_flag(struct rga_mm *mm_session, uint64_t handle) output_buffer = rga_mm_lookup_handle(mm_session, handle); if (output_buffer == NULL) { - pr_err("This handle[%ld] is illegal.\n", (unsigned long)handle); + rga_err("This handle[%ld] is illegal.\n", (unsigned long)handle); return -EINVAL; } @@ -987,7 +985,7 @@ struct sg_table *rga_mm_lookup_sgt(struct rga_internal_buffer *buffer) void rga_mm_dump_buffer(struct rga_internal_buffer *dump_buffer) { - pr_info("handle = %d refcount = %d mm_flag = 0x%x\n", + rga_log("handle = %d refcount = %d mm_flag = 0x%x\n", dump_buffer->handle, kref_read(&dump_buffer->refcount), dump_buffer->mm_flag); @@ -997,10 +995,10 @@ void rga_mm_dump_buffer(struct rga_internal_buffer *dump_buffer) if (rga_mm_is_invalid_dma_buffer(dump_buffer->dma_buffer)) break; - pr_info("dma_buffer:\n"); - pr_info("dma_buf = %p\n", + rga_log("dma_buffer:\n"); + rga_log("dma_buf = %p\n", dump_buffer->dma_buffer->dma_buf); - pr_info("iova = 0x%lx, dma_addr = 0x%lx, offset = 0x%lx, sgt = %p, size = %ld, map_core = 0x%x\n", + rga_log("iova = 0x%lx, dma_addr = 0x%lx, offset = 0x%lx, sgt = %p, size = %ld, map_core = 0x%x\n", (unsigned long)dump_buffer->dma_buffer->iova, (unsigned long)dump_buffer->dma_buffer->dma_addr, (unsigned long)dump_buffer->dma_buffer->offset, @@ -1009,15 +1007,15 @@ void rga_mm_dump_buffer(struct rga_internal_buffer *dump_buffer) dump_buffer->dma_buffer->scheduler->core); if (dump_buffer->mm_flag & RGA_MEM_PHYSICAL_CONTIGUOUS) - pr_info("is contiguous, pa = 0x%lx\n", + rga_log("is contiguous, pa = 0x%lx\n", (unsigned long)dump_buffer->phys_addr); break; case RGA_VIRTUAL_ADDRESS: if (dump_buffer->virt_addr == NULL) break; - pr_info("virtual address:\n"); - pr_info("va = 0x%lx, pages = %p, size = %ld\n", + rga_log("virtual address:\n"); + rga_log("va = 0x%lx, pages = %p, size = %ld\n", (unsigned long)dump_buffer->virt_addr->addr, dump_buffer->virt_addr->pages, dump_buffer->virt_addr->size); @@ -1025,7 +1023,7 @@ void rga_mm_dump_buffer(struct rga_internal_buffer *dump_buffer) if (rga_mm_is_invalid_dma_buffer(dump_buffer->dma_buffer)) break; - pr_info("iova = 0x%lx, dma_addr = 0x%lx, offset = 0x%lx, sgt = %p, size = %ld, map_core = 0x%x\n", + rga_log("iova = 0x%lx, dma_addr = 0x%lx, offset = 0x%lx, sgt = %p, size = %ld, map_core = 0x%x\n", (unsigned long)dump_buffer->dma_buffer->iova, (unsigned long)dump_buffer->dma_buffer->dma_addr, (unsigned long)dump_buffer->dma_buffer->offset, @@ -1034,15 +1032,15 @@ void rga_mm_dump_buffer(struct rga_internal_buffer *dump_buffer) dump_buffer->dma_buffer->scheduler->core); if (dump_buffer->mm_flag & RGA_MEM_PHYSICAL_CONTIGUOUS) - pr_info("is contiguous, pa = 0x%lx\n", + rga_log("is contiguous, pa = 0x%lx\n", (unsigned long)dump_buffer->phys_addr); break; case RGA_PHYSICAL_ADDRESS: - pr_info("physical address:\n"); - pr_info("pa = 0x%lx\n", (unsigned long)dump_buffer->phys_addr); + rga_log("physical address:\n"); + rga_log("pa = 0x%lx\n", (unsigned long)dump_buffer->phys_addr); break; default: - pr_err("Illegal external buffer!\n"); + rga_err("Illegal external buffer!\n"); break; } } @@ -1054,15 +1052,15 @@ void rga_mm_dump_info(struct rga_mm *mm_session) WARN_ON(!mutex_is_locked(&mm_session->lock)); - pr_info("rga mm info:\n"); + rga_log("rga mm info:\n"); - pr_info("buffer count = %d\n", mm_session->buffer_count); - pr_info("===============================================================\n"); + rga_log("buffer count = %d\n", mm_session->buffer_count); + rga_log("===============================================================\n"); idr_for_each_entry(&mm_session->memory_idr, dump_buffer, id) { rga_mm_dump_buffer(dump_buffer); - pr_info("---------------------------------------------------------------\n"); + rga_log("---------------------------------------------------------------\n"); } } @@ -1192,8 +1190,8 @@ static int rga_mm_set_mmu_base(struct rga_job *job, img_size = rga_image_size_cal(img->vir_w, img->vir_h, img->format, &yrgb_size, &uv_size, &v_size); if (img_size <= 0) { - pr_err("Image size cal error! width = %d, height = %d, format = %s\n", - img->vir_w, img->vir_h, rga_get_format_name(img->format)); + rga_err("Image size cal error! width = %d, height = %d, format = %s\n", + img->vir_w, img->vir_h, rga_get_format_name(img->format)); return -EINVAL; } @@ -1212,23 +1210,23 @@ static int rga_mm_set_mmu_base(struct rga_job *job, page_count = yrgb_count + uv_count + v_count; if (page_count <= 0) { - pr_err("page count cal error! yrba = %d, uv = %d, v = %d\n", - yrgb_count, uv_count, v_count); + rga_err("page count cal error! yrba = %d, uv = %d, v = %d\n", + yrgb_count, uv_count, v_count); return -EFAULT; } if (job->flags & RGA_JOB_USE_HANDLE) { order = get_order(page_count * sizeof(uint32_t *)); if (order >= MAX_ORDER) { - pr_err("Can not alloc pages with order[%d] for page_table, max_order = %d\n", - order, MAX_ORDER); + rga_err("Can not alloc pages with order[%d] for page_table, max_order = %d\n", + order, MAX_ORDER); return -ENOMEM; } page_table = (uint32_t *)__get_free_pages(GFP_KERNEL | GFP_DMA32, order); if (page_table == NULL) { - pr_err("%s can not alloc pages for page_table, order = %d\n", - __func__, order); + rga_err("%s can not alloc pages for page_table, order = %d\n", + __func__, order); return -ENOMEM; } } else { @@ -1236,7 +1234,7 @@ static int rga_mm_set_mmu_base(struct rga_job *job, page_table = rga_mmu_buf_get(rga_drvdata->mmu_base, page_count); if (page_table == NULL) { - pr_err("mmu_buf get error!\n"); + rga_err("mmu_buf get error!\n"); mutex_unlock(&rga_drvdata->lock); return -EFAULT; } @@ -1246,7 +1244,7 @@ static int rga_mm_set_mmu_base(struct rga_job *job, sgt = rga_mm_lookup_sgt(job_buf->y_addr); if (sgt == NULL) { - pr_err("rga2 cannot get sgt from internal buffer!\n"); + rga_err("rga2 cannot get sgt from internal buffer!\n"); ret = -EINVAL; goto err_free_page_table; } @@ -1254,7 +1252,7 @@ static int rga_mm_set_mmu_base(struct rga_job *job, sgt = rga_mm_lookup_sgt(job_buf->uv_addr); if (sgt == NULL) { - pr_err("rga2 cannot get sgt from internal buffer!\n"); + rga_err("rga2 cannot get sgt from internal buffer!\n"); ret = -EINVAL; goto err_free_page_table; } @@ -1262,7 +1260,7 @@ static int rga_mm_set_mmu_base(struct rga_job *job, sgt = rga_mm_lookup_sgt(job_buf->v_addr); if (sgt == NULL) { - pr_err("rga2 cannot get sgt from internal buffer!\n"); + rga_err("rga2 cannot get sgt from internal buffer!\n"); ret = -EINVAL; goto err_free_page_table; } @@ -1277,23 +1275,23 @@ static int rga_mm_set_mmu_base(struct rga_job *job, page_count = RGA_GET_PAGE_COUNT(img_size + img_offset); if (page_count < 0) { - pr_err("page count cal error! yrba = %d, uv = %d, v = %d\n", - yrgb_count, uv_count, v_count); + rga_err("page count cal error! yrba = %d, uv = %d, v = %d\n", + yrgb_count, uv_count, v_count); return -EFAULT; } if (job->flags & RGA_JOB_USE_HANDLE) { order = get_order(page_count * sizeof(uint32_t *)); if (order >= MAX_ORDER) { - pr_err("Can not alloc pages with order[%d] for page_table, max_order = %d\n", - order, MAX_ORDER); + rga_err("Can not alloc pages with order[%d] for page_table, max_order = %d\n", + order, MAX_ORDER); return -ENOMEM; } page_table = (uint32_t *)__get_free_pages(GFP_KERNEL | GFP_DMA32, order); if (page_table == NULL) { - pr_err("%s can not alloc pages for page_table, order = %d\n", - __func__, order); + rga_err("%s can not alloc pages for page_table, order = %d\n", + __func__, order); return -ENOMEM; } } else { @@ -1301,7 +1299,7 @@ static int rga_mm_set_mmu_base(struct rga_job *job, page_table = rga_mmu_buf_get(rga_drvdata->mmu_base, page_count); if (page_table == NULL) { - pr_err("mmu_buf get error!\n"); + rga_err("mmu_buf get error!\n"); mutex_unlock(&rga_drvdata->lock); return -EFAULT; } @@ -1311,7 +1309,7 @@ static int rga_mm_set_mmu_base(struct rga_job *job, sgt = rga_mm_lookup_sgt(job_buf->addr); if (sgt == NULL) { - pr_err("rga2 cannot get sgt from internal buffer!\n"); + rga_err("rga2 cannot get sgt from internal buffer!\n"); ret = -EINVAL; goto err_free_page_table; } @@ -1343,8 +1341,8 @@ static int rga_mm_sync_dma_sg_for_device(struct rga_internal_buffer *buffer, scheduler = buffer->dma_buffer->scheduler; if (scheduler == NULL) { - pr_err("%s(%d), failed to get scheduler, core = 0x%x\n", - __func__, __LINE__, job->core); + rga_err("%s(%d), failed to get scheduler, core = 0x%x\n", + __func__, __LINE__, job->core); return -EFAULT; } @@ -1354,8 +1352,8 @@ static int rga_mm_sync_dma_sg_for_device(struct rga_internal_buffer *buffer, } else { sgt = rga_mm_lookup_sgt(buffer); if (sgt == NULL) { - pr_err("%s(%d), failed to get sgt, core = 0x%x\n", - __func__, __LINE__, job->core); + rga_err("%s(%d), failed to get sgt, core = 0x%x\n", + __func__, __LINE__, job->core); return -EINVAL; } @@ -1363,7 +1361,7 @@ static int rga_mm_sync_dma_sg_for_device(struct rga_internal_buffer *buffer, } if (DEBUGGER_EN(TIME)) - pr_info("handle[%d], %s, flush CPU cache for device cost %lld us\n", + rga_log("handle[%d], %s, flush CPU cache for device cost %lld us\n", buffer->handle, rga_get_dma_data_direction_str(dir), ktime_us_delta(ktime_get(), timestamp)); @@ -1380,8 +1378,8 @@ static int rga_mm_sync_dma_sg_for_cpu(struct rga_internal_buffer *buffer, scheduler = buffer->dma_buffer->scheduler; if (scheduler == NULL) { - pr_err("%s(%d), failed to get scheduler, core = 0x%x\n", - __func__, __LINE__, job->core); + rga_err("%s(%d), failed to get scheduler, core = 0x%x\n", + __func__, __LINE__, job->core); return -EFAULT; } @@ -1391,8 +1389,8 @@ static int rga_mm_sync_dma_sg_for_cpu(struct rga_internal_buffer *buffer, } else { sgt = rga_mm_lookup_sgt(buffer); if (sgt == NULL) { - pr_err("%s(%d), failed to get sgt, core = 0x%x\n", - __func__, __LINE__, job->core); + rga_err("%s(%d), failed to get sgt, core = 0x%x\n", + __func__, __LINE__, job->core); return -EINVAL; } @@ -1400,7 +1398,7 @@ static int rga_mm_sync_dma_sg_for_cpu(struct rga_internal_buffer *buffer, } if (DEBUGGER_EN(TIME)) - pr_info("handle[%d], %s, flush CPU cache for CPU cost %lld us\n", + rga_log("handle[%d], %s, flush CPU cache for CPU cost %lld us\n", buffer->handle, rga_get_dma_data_direction_str(dir), ktime_us_delta(ktime_get(), timestamp)); @@ -1417,7 +1415,7 @@ static int rga_mm_get_buffer_info(struct rga_job *job, case RGA_IOMMU: addr = rga_mm_lookup_iova(internal_buffer); if (addr == 0) { - pr_err("core[%d] lookup buffer_type[0x%x] iova error!\n", + rga_err("core[%d] lookup buffer_type[0x%x] iova error!\n", job->core, internal_buffer->type); return -EINVAL; } @@ -1441,7 +1439,7 @@ static int rga_mm_get_buffer_info(struct rga_job *job, addr = internal_buffer->phys_addr; break; default: - pr_err("Illegal external buffer!\n"); + rga_err("Illegal external buffer!\n"); return -EFAULT; } break; @@ -1464,14 +1462,14 @@ static int rga_mm_get_buffer(struct rga_mm *mm, struct rga_internal_buffer *internal_buffer = NULL; if (handle == 0) { - pr_err("No buffer handle can be used!\n"); + rga_err("No buffer handle can be used!\n"); return -EFAULT; } mutex_lock(&mm->lock); *buf = rga_mm_lookup_handle(mm, handle); if (*buf == NULL) { - pr_err("This handle[%ld] is illegal.\n", (unsigned long)handle); + rga_err("This handle[%ld] is illegal.\n", (unsigned long)handle); mutex_unlock(&mm->lock); return -EFAULT; @@ -1481,7 +1479,7 @@ static int rga_mm_get_buffer(struct rga_mm *mm, kref_get(&internal_buffer->refcount); if (DEBUGGER_EN(MM)) { - pr_info("handle[%d] get info:\n", (int)handle); + rga_log("handle[%d] get info:\n", (int)handle); rga_mm_dump_buffer(internal_buffer); } @@ -1489,13 +1487,13 @@ static int rga_mm_get_buffer(struct rga_mm *mm, ret = rga_mm_get_buffer_info(job, internal_buffer, channel_addr); if (ret < 0) { - pr_err("handle[%ld] failed to get internal buffer info!\n", (unsigned long)handle); + rga_err("handle[%ld] failed to get internal buffer info!\n", (unsigned long)handle); return ret; } if (internal_buffer->size < require_size) { ret = -EINVAL; - pr_err("Only get buffer %ld byte from handle[%ld], but current required %d byte\n", + rga_err("Only get buffer %ld byte from handle[%ld], but current required %d byte\n", internal_buffer->size, (unsigned long)handle, require_size); goto put_internal_buffer; @@ -1509,7 +1507,7 @@ static int rga_mm_get_buffer(struct rga_mm *mm, */ ret = rga_mm_sync_dma_sg_for_device(internal_buffer, job, dir); if (ret < 0) { - pr_err("sync sgt for device error!\n"); + rga_err("sync sgt for device error!\n"); goto put_internal_buffer; } } @@ -1532,10 +1530,10 @@ static void rga_mm_put_buffer(struct rga_mm *mm, { if (internal_buffer->mm_flag & RGA_MEM_FORCE_FLUSH_CACHE && dir != DMA_NONE) if (rga_mm_sync_dma_sg_for_cpu(internal_buffer, job, dir)) - pr_err("sync sgt for cpu error!\n"); + rga_err("sync sgt for cpu error!\n"); if (DEBUGGER_EN(MM)) { - pr_info("handle[%d] put info:\n", (int)internal_buffer->handle); + rga_log("handle[%d] put info:\n", (int)internal_buffer->handle); rga_mm_dump_buffer(internal_buffer); } @@ -1573,8 +1571,8 @@ static int rga_mm_get_channel_handle_info(struct rga_mm *mm, img_size = rga_image_size_cal(img->vir_w, img->vir_h, img->format, &yrgb_size, &uv_size, &v_size); if (img_size <= 0) { - pr_err("Image size cal error! width = %d, height = %d, format = %s\n", - img->vir_w, img->vir_h, rga_get_format_name(img->format)); + rga_err("Image size cal error! width = %d, height = %d, format = %s\n", + img->vir_w, img->vir_h, rga_get_format_name(img->format)); return -EINVAL; } @@ -1585,7 +1583,7 @@ static int rga_mm_get_channel_handle_info(struct rga_mm *mm, ret = rga_mm_get_buffer(mm, job, handle, &img->yrgb_addr, &job_buf->y_addr, yrgb_size, dir); if (ret < 0) { - pr_err("handle[%d] Can't get y/rgb address info!\n", handle); + rga_err("handle[%d] Can't get y/rgb address info!\n", handle); return ret; } } @@ -1595,7 +1593,7 @@ static int rga_mm_get_channel_handle_info(struct rga_mm *mm, ret = rga_mm_get_buffer(mm, job, handle, &img->uv_addr, &job_buf->uv_addr, uv_size, dir); if (ret < 0) { - pr_err("handle[%d] Can't get uv address info!\n", handle); + rga_err("handle[%d] Can't get uv address info!\n", handle); return ret; } } @@ -1605,7 +1603,7 @@ static int rga_mm_get_channel_handle_info(struct rga_mm *mm, ret = rga_mm_get_buffer(mm, job, handle, &img->v_addr, &job_buf->v_addr, v_size, dir); if (ret < 0) { - pr_err("handle[%d] Can't get uv address info!\n", handle); + rga_err("handle[%d] Can't get uv address info!\n", handle); return ret; } } @@ -1615,7 +1613,7 @@ static int rga_mm_get_channel_handle_info(struct rga_mm *mm, ret = rga_mm_get_buffer(mm, job, handle, &img->yrgb_addr, &job_buf->addr, img_size, dir); if (ret < 0) { - pr_err("handle[%d] Can't get y/rgb address info!\n", handle); + rga_err("handle[%d] Can't get y/rgb address info!\n", handle); return ret; } } @@ -1627,7 +1625,7 @@ static int rga_mm_get_channel_handle_info(struct rga_mm *mm, rga_mm_is_need_mmu(job, job_buf->addr)) { ret = rga_mm_set_mmu_base(job, img, job_buf); if (ret < 0) { - pr_err("Can't set RGA2 MMU_BASE from handle!\n"); + rga_err("Can't set RGA2 MMU_BASE from handle!\n"); rga_mm_put_channel_handle_info(mm, job, job_buf, dir); return ret; @@ -1651,21 +1649,21 @@ static int rga_mm_get_handle_info(struct rga_job *job) case BITBLT_MODE: case COLOR_PALETTE_MODE: if (unlikely(req->src.yrgb_addr <= 0)) { - pr_err("render_mode[0x%x] src0 channel handle[%ld] must is valid!", - req->render_mode, (unsigned long)req->src.yrgb_addr); + rga_err("render_mode[0x%x] src0 channel handle[%ld] must is valid!", + req->render_mode, (unsigned long)req->src.yrgb_addr); return -EINVAL; } if (unlikely(req->dst.yrgb_addr <= 0)) { - pr_err("render_mode[0x%x] dst channel handle[%ld] must is valid!", - req->render_mode, (unsigned long)req->dst.yrgb_addr); + rga_err("render_mode[0x%x] dst channel handle[%ld] must is valid!", + req->render_mode, (unsigned long)req->dst.yrgb_addr); return -EINVAL; } if (req->bsfilter_flag) { if (unlikely(req->pat.yrgb_addr <= 0)) { - pr_err("render_mode[0x%x] src1/pat channel handle[%ld] must is valid!", - req->render_mode, (unsigned long)req->pat.yrgb_addr); + rga_err("render_mode[0x%x] src1/pat channel handle[%ld] must is valid!", + req->render_mode, (unsigned long)req->pat.yrgb_addr); return -EINVAL; } } @@ -1673,8 +1671,8 @@ static int rga_mm_get_handle_info(struct rga_job *job) break; case COLOR_FILL_MODE: if (unlikely(req->dst.yrgb_addr <= 0)) { - pr_err("render_mode[0x%x] dst channel handle[%ld] must is valid!", - req->render_mode, (unsigned long)req->dst.yrgb_addr); + rga_err("render_mode[0x%x] dst channel handle[%ld] must is valid!", + req->render_mode, (unsigned long)req->dst.yrgb_addr); return -EINVAL; } @@ -1683,14 +1681,14 @@ static int rga_mm_get_handle_info(struct rga_job *job) case UPDATE_PALETTE_TABLE_MODE: case UPDATE_PATTEN_BUF_MODE: if (unlikely(req->pat.yrgb_addr <= 0)) { - pr_err("render_mode[0x%x] lut/pat channel handle[%ld] must is valid!, req->render_mode", - req->render_mode, (unsigned long)req->pat.yrgb_addr); + rga_err("render_mode[0x%x] lut/pat channel handle[%ld] must is valid!, req->render_mode", + req->render_mode, (unsigned long)req->pat.yrgb_addr); return -EINVAL; } break; default: - pr_err("%s, unknown render mode!\n", __func__); + rga_err("%s, unknown render mode!\n", __func__); break; } @@ -1699,7 +1697,7 @@ static int rga_mm_get_handle_info(struct rga_job *job) &job->src_buffer, DMA_TO_DEVICE); if (ret < 0) { - pr_err("Can't get src buffer info from handle!\n"); + rga_err("Can't get src buffer info from handle!\n"); return ret; } } @@ -1709,7 +1707,7 @@ static int rga_mm_get_handle_info(struct rga_job *job) &job->dst_buffer, DMA_TO_DEVICE); if (ret < 0) { - pr_err("Can't get dst buffer info from handle!\n"); + rga_err("Can't get dst buffer info from handle!\n"); return ret; } } @@ -1731,7 +1729,7 @@ static int rga_mm_get_handle_info(struct rga_job *job) DMA_BIDIRECTIONAL); } if (ret < 0) { - pr_err("Can't get pat buffer info from handle!\n"); + rga_err("Can't get pat buffer info from handle!\n"); return ret; } } @@ -1770,15 +1768,15 @@ static int rga_mm_get_channel_external_buffer(int mmu_flag, /* Default unsupported multi-planar format */ external_buffer = kzalloc(sizeof(*external_buffer), GFP_KERNEL); if (external_buffer == NULL) { - pr_err("Cannot alloc job_buffer!\n"); + rga_err("Cannot alloc job_buffer!\n"); return -ENOMEM; } if (img_info->yrgb_addr) { dma_buf = dma_buf_get(img_info->yrgb_addr); if (IS_ERR(dma_buf)) { - pr_err("%s dma_buf_get fail fd[%lu]\n", - __func__, (unsigned long)img_info->yrgb_addr); + rga_err("%s dma_buf_get fail fd[%lu]\n", + __func__, (unsigned long)img_info->yrgb_addr); kfree(external_buffer); return -EINVAL; } @@ -1842,7 +1840,7 @@ static int rga_mm_get_external_buffer(struct rga_job *job) mmu_flag = ((job->rga_command_base.mmu_info.mmu_flag >> 8) & 1); ret = rga_mm_get_channel_external_buffer(mmu_flag, src0, &job->src_buffer); if (ret < 0) { - pr_err("Cannot get src0 channel buffer!\n"); + rga_err("Cannot get src0 channel buffer!\n"); return ret; } } @@ -1851,7 +1849,7 @@ static int rga_mm_get_external_buffer(struct rga_job *job) mmu_flag = ((job->rga_command_base.mmu_info.mmu_flag >> 10) & 1); ret = rga_mm_get_channel_external_buffer(mmu_flag, dst, &job->dst_buffer); if (ret < 0) { - pr_err("Cannot get dst channel buffer!\n"); + rga_err("Cannot get dst channel buffer!\n"); goto error_put_buffer; } } @@ -1860,7 +1858,7 @@ static int rga_mm_get_external_buffer(struct rga_job *job) mmu_flag = ((job->rga_command_base.mmu_info.mmu_flag >> 9) & 1); ret = rga_mm_get_channel_external_buffer(mmu_flag, src1, &job->src1_buffer); if (ret < 0) { - pr_err("Cannot get src1 channel buffer!\n"); + rga_err("Cannot get src1 channel buffer!\n"); goto error_put_buffer; } } @@ -1869,7 +1867,7 @@ static int rga_mm_get_external_buffer(struct rga_job *job) mmu_flag = ((job->rga_command_base.mmu_info.mmu_flag >> 11) & 1); ret = rga_mm_get_channel_external_buffer(mmu_flag, els, &job->els_buffer); if (ret < 0) { - pr_err("Cannot get els channel buffer!\n"); + rga_err("Cannot get els channel buffer!\n"); goto error_put_buffer; } } @@ -1886,10 +1884,10 @@ static void rga_mm_unmap_channel_job_buffer(struct rga_job *job, { if (job_buffer->addr->mm_flag & RGA_MEM_FORCE_FLUSH_CACHE && dir != DMA_NONE) if (rga_mm_sync_dma_sg_for_cpu(job_buffer->addr, job, dir)) - pr_err("sync sgt for cpu error!\n"); + rga_err("sync sgt for cpu error!\n"); if (DEBUGGER_EN(MM)) { - pr_info("unmap buffer:\n"); + rga_log("unmap buffer:\n"); rga_mm_dump_buffer(job_buffer->addr); } @@ -1910,31 +1908,31 @@ static int rga_mm_map_channel_job_buffer(struct rga_job *job, buffer = kzalloc(sizeof(*buffer), GFP_KERNEL); if (buffer == NULL) { - pr_err("%s alloc internal_buffer error!\n", __func__); + rga_err("%s alloc internal_buffer error!\n", __func__); return -ENOMEM; } ret = rga_mm_map_buffer(job_buffer->ex_addr, buffer, job, write_flag); if (ret < 0) { - pr_err("job buffer map failed!\n"); + rga_err("job buffer map failed!\n"); goto error_free_buffer; } if (DEBUGGER_EN(MM)) { - pr_info("map buffer:\n"); + rga_log("map buffer:\n"); rga_mm_dump_buffer(buffer); } ret = rga_mm_get_buffer_info(job, buffer, &img->yrgb_addr); if (ret < 0) { - pr_err("Failed to get internal buffer info!\n"); + rga_err("Failed to get internal buffer info!\n"); goto error_unmap_buffer; } if (buffer->mm_flag & RGA_MEM_FORCE_FLUSH_CACHE) { ret = rga_mm_sync_dma_sg_for_device(buffer, job, dir); if (ret < 0) { - pr_err("sync sgt for device error!\n"); + rga_err("sync sgt for device error!\n"); goto error_unmap_buffer; } } @@ -1947,7 +1945,7 @@ static int rga_mm_map_channel_job_buffer(struct rga_job *job, rga_mm_is_need_mmu(job, job_buffer->addr)) { ret = rga_mm_set_mmu_base(job, img, job_buffer); if (ret < 0) { - pr_err("Can't set RGA2 MMU_BASE!\n"); + rga_err("Can't set RGA2 MMU_BASE!\n"); job_buffer->addr = NULL; goto error_unmap_buffer; } @@ -1985,7 +1983,7 @@ static int rga_mm_map_buffer_info(struct rga_job *job) ret = rga_mm_get_external_buffer(job); if (ret < 0) { - pr_err("failed to get external buffer from job_cmd!\n"); + rga_err("failed to get external buffer from job_cmd!\n"); return ret; } @@ -1996,7 +1994,7 @@ static int rga_mm_map_buffer_info(struct rga_job *job) &job->src_buffer, DMA_TO_DEVICE, false); if (ret < 0) { - pr_err("src channel map job buffer failed!"); + rga_err("src channel map job buffer failed!"); goto error_unmap_buffer; } } @@ -2006,7 +2004,7 @@ static int rga_mm_map_buffer_info(struct rga_job *job) &job->dst_buffer, DMA_TO_DEVICE, true); if (ret < 0) { - pr_err("dst channel map job buffer failed!"); + rga_err("dst channel map job buffer failed!"); goto error_unmap_buffer; } } @@ -2021,7 +2019,7 @@ static int rga_mm_map_buffer_info(struct rga_job *job) &job->src1_buffer, dir, false); if (ret < 0) { - pr_err("src1 channel map job buffer failed!"); + rga_err("src1 channel map job buffer failed!"); goto error_unmap_buffer; } } @@ -2031,7 +2029,7 @@ static int rga_mm_map_buffer_info(struct rga_job *job) &job->els_buffer, DMA_BIDIRECTIONAL, false); if (ret < 0) { - pr_err("els channel map job buffer failed!"); + rga_err("els channel map job buffer failed!"); goto error_unmap_buffer; } } @@ -2055,7 +2053,7 @@ static void rga_mm_free_channel_fake_buffer(struct rga_job *job, return; if (DEBUGGER_EN(MM)) { - pr_info("free fake-buffer dump info:\n"); + rga_log("free fake-buffer dump info:\n"); rga_mm_dump_buffer(buffer); } @@ -2078,7 +2076,7 @@ static int rga_mm_alloc_channel_fake_buffer(struct rga_job *job, buffer = kzalloc(sizeof(*buffer), GFP_KERNEL); if (buffer == NULL) { - pr_err("%s alloc internal_buffer error!\n", __func__); + rga_err("%s alloc internal_buffer error!\n", __func__); return -ENOMEM; } @@ -2087,7 +2085,7 @@ static int rga_mm_alloc_channel_fake_buffer(struct rga_job *job, dma_buf = rga_dma_alloc_coherent(job->scheduler, size); if (dma_buf == NULL) { ret = -ENOMEM; - pr_err("%s failed to alloc dma_buf.\n", __func__); + rga_err("%s failed to alloc dma_buf.\n", __func__); goto error_free_buffer; } @@ -2100,7 +2098,7 @@ static int rga_mm_alloc_channel_fake_buffer(struct rga_job *job, } if (!rga_mm_check_memory_limit(job->scheduler, mm_flag)) { - pr_err("%s scheduler core[%d] unsupported mm_flag[0x%x]!\n", + rga_err("%s scheduler core[%d] unsupported mm_flag[0x%x]!\n", __func__, job->scheduler->core, mm_flag); ret = -EINVAL; goto error_free_dma_buf; @@ -2119,7 +2117,7 @@ static int rga_mm_alloc_channel_fake_buffer(struct rga_job *job, ret = rga_mm_get_buffer_info(job, buffer, &img->yrgb_addr); if (ret < 0) { - pr_err("%s failed to get internal buffer info!\n", __func__); + rga_err("%s failed to get internal buffer info!\n", __func__); goto error_free_dma_buf; } @@ -2131,14 +2129,14 @@ static int rga_mm_alloc_channel_fake_buffer(struct rga_job *job, rga_mm_is_need_mmu(job, job_buffer->addr)) { ret = rga_mm_set_mmu_base(job, img, job_buffer); if (ret < 0) { - pr_err("%s can't set RGA2 MMU_BASE!\n", __func__); + rga_err("%s can't set RGA2 MMU_BASE!\n", __func__); job_buffer->addr = NULL; goto error_free_dma_buf; } } if (DEBUGGER_EN(MM)) { - pr_info("alloc fake-buffer dump info:\n"); + rga_log("alloc fake-buffer dump info:\n"); rga_mm_dump_buffer(buffer); } @@ -2177,7 +2175,7 @@ static int rga_mm_alloc_fake_buffer(struct rga_job *job) ret = rga_mm_alloc_channel_fake_buffer(job, &req->src, &job->src_buffer, DMA_TO_DEVICE); if (ret < 0) { - pr_err("%s src channel map job buffer failed!", __func__); + rga_err("%s src channel map job buffer failed!", __func__); goto error_free_fake_buffer; } } @@ -2186,7 +2184,7 @@ static int rga_mm_alloc_fake_buffer(struct rga_job *job) ret = rga_mm_alloc_channel_fake_buffer(job, &req->dst, &job->dst_buffer, DMA_TO_DEVICE); if (ret < 0) { - pr_err("%s dst channel map job buffer failed!", __func__); + rga_err("%s dst channel map job buffer failed!", __func__); goto error_free_fake_buffer; } } @@ -2201,14 +2199,14 @@ static int rga_mm_alloc_fake_buffer(struct rga_job *job) ret = rga_mm_alloc_channel_fake_buffer(job, &req->pat, &job->src1_buffer, dir); if (ret < 0) { - pr_err("%s src1 channel map job buffer failed!", __func__); + rga_err("%s src1 channel map job buffer failed!", __func__); goto error_free_fake_buffer; } } else if (req->pat.yrgb_addr != 0 || req->pat.uv_addr != 0) { ret = rga_mm_alloc_channel_fake_buffer(job, &req->pat, &job->els_buffer, DMA_TO_DEVICE); if (ret < 0) { - pr_err("%s els channel map job buffer failed!", __func__); + rga_err("%s els channel map job buffer failed!", __func__); goto error_free_fake_buffer; } } @@ -2234,7 +2232,7 @@ int rga_mm_map_job_info(struct rga_job *job) return ret; if (DEBUGGER_EN(TIME)) - pr_info("request[%d], alloc fake buffer cost %lld us\n", + rga_log("request[%d], alloc fake buffer cost %lld us\n", job->request_id, ktime_us_delta(ktime_get(), timestamp)); job->flags &= ~RGA_JOB_USE_HANDLE; @@ -2246,22 +2244,22 @@ int rga_mm_map_job_info(struct rga_job *job) if (job->flags & RGA_JOB_USE_HANDLE) { ret = rga_mm_get_handle_info(job); if (ret < 0) { - pr_err("failed to get buffer from handle\n"); + rga_err("failed to get buffer from handle\n"); return ret; } if (DEBUGGER_EN(TIME)) - pr_info("request[%d], get buffer_handle info cost %lld us\n", + rga_log("request[%d], get buffer_handle info cost %lld us\n", job->request_id, ktime_us_delta(ktime_get(), timestamp)); } else { ret = rga_mm_map_buffer_info(job); if (ret < 0) { - pr_err("failed to map buffer\n"); + rga_err("failed to map buffer\n"); return ret; } if (DEBUGGER_EN(TIME)) - pr_info("request[%d], map buffer cost %lld us\n", + rga_log("request[%d], map buffer cost %lld us\n", job->request_id, ktime_us_delta(ktime_get(), timestamp)); } @@ -2276,7 +2274,7 @@ void rga_mm_unmap_job_info(struct rga_job *job) rga_mm_free_fake_buffer(job); if (DEBUGGER_EN(TIME)) - pr_info("request[%d], free fake buffer cost %lld us\n", + rga_log("request[%d], free fake buffer cost %lld us\n", job->request_id, ktime_us_delta(ktime_get(), timestamp)); return; @@ -2286,13 +2284,13 @@ void rga_mm_unmap_job_info(struct rga_job *job) rga_mm_put_handle_info(job); if (DEBUGGER_EN(TIME)) - pr_info("request[%d], put buffer_handle info cost %lld us\n", + rga_log("request[%d], put buffer_handle info cost %lld us\n", job->request_id, ktime_us_delta(ktime_get(), timestamp)); } else { rga_mm_unmap_buffer_info(job); if (DEBUGGER_EN(TIME)) - pr_info("request[%d], unmap buffer cost %lld us\n", + rga_log("request[%d], unmap buffer cost %lld us\n", job->request_id, ktime_us_delta(ktime_get(), timestamp)); } } @@ -2317,7 +2315,7 @@ int rga_mm_import_buffer(struct rga_external_buffer *external_buffer, mm = rga_drvdata->mm; if (mm == NULL) { - pr_err("rga mm is null!\n"); + rga_err("rga mm is null!\n"); return -EFAULT; } @@ -2331,7 +2329,7 @@ int rga_mm_import_buffer(struct rga_external_buffer *external_buffer, mutex_unlock(&mm->lock); if (DEBUGGER_EN(MM)) { - pr_info("import existing buffer:\n"); + rga_log("import existing buffer:\n"); rga_mm_dump_buffer(internal_buffer); } @@ -2343,7 +2341,7 @@ int rga_mm_import_buffer(struct rga_external_buffer *external_buffer, /* finally, map and cached external_buffer in rga_mm */ internal_buffer = kzalloc(sizeof(struct rga_internal_buffer), GFP_KERNEL); if (internal_buffer == NULL) { - pr_err("%s alloc internal_buffer error!\n", __func__); + rga_err("%s alloc internal_buffer error!\n", __func__); mutex_unlock(&mm->lock); return -ENOMEM; @@ -2365,7 +2363,7 @@ int rga_mm_import_buffer(struct rga_external_buffer *external_buffer, new_id = idr_alloc_cyclic(&mm->memory_idr, internal_buffer, 1, 0, GFP_NOWAIT); idr_preload_end(); if (new_id < 0) { - pr_err("internal_buffer alloc id failed!\n"); + rga_err("internal_buffer alloc id failed!\n"); ret = new_id; mutex_unlock(&mm->lock); @@ -2376,14 +2374,14 @@ int rga_mm_import_buffer(struct rga_external_buffer *external_buffer, mm->buffer_count++; if (DEBUGGER_EN(MM)) { - pr_info("import buffer:\n"); + rga_log("import buffer:\n"); rga_mm_dump_buffer(internal_buffer); } mutex_unlock(&mm->lock); if (DEBUGGER_EN(TIME)) - pr_info("handle[%d], import buffer cost %lld us\n", + rga_log("handle[%d], import buffer cost %lld us\n", internal_buffer->handle, ktime_us_delta(ktime_get(), timestamp)); return internal_buffer->handle; @@ -2402,7 +2400,7 @@ int rga_mm_release_buffer(uint32_t handle) mm = rga_drvdata->mm; if (mm == NULL) { - pr_err("rga mm is null!\n"); + rga_err("rga mm is null!\n"); return -EFAULT; } @@ -2411,21 +2409,21 @@ int rga_mm_release_buffer(uint32_t handle) /* Find the buffer that has been imported */ internal_buffer = rga_mm_lookup_handle(mm, handle); if (IS_ERR_OR_NULL(internal_buffer)) { - pr_err("This is not a buffer that has been imported, handle = %d\n", (int)handle); + rga_err("This is not a buffer that has been imported, handle = %d\n", (int)handle); mutex_unlock(&mm->lock); return -ENOENT; } if (DEBUGGER_EN(MM)) { - pr_info("release buffer:\n"); + rga_log("release buffer:\n"); rga_mm_dump_buffer(internal_buffer); } kref_put(&internal_buffer->refcount, rga_mm_kref_release_buffer); if (DEBUGGER_EN(TIME)) - pr_info("handle[%d], release buffer cost %lld us\n", + rga_log("handle[%d], release buffer cost %lld us\n", handle, ktime_us_delta(ktime_get(), timestamp)); mutex_unlock(&mm->lock); @@ -2441,7 +2439,7 @@ int rga_mm_session_release_buffer(struct rga_session *session) mm = rga_drvdata->mm; if (mm == NULL) { - pr_err("rga mm is null!\n"); + rga_err("rga mm is null!\n"); return -EFAULT; } @@ -2449,7 +2447,7 @@ int rga_mm_session_release_buffer(struct rga_session *session) idr_for_each_entry(&mm->memory_idr, buffer, i) { if (session == buffer->session) { - pr_err("[tgid:%d] Destroy handle[%d] when the user exits\n", + rga_err("[tgid:%d] Destroy handle[%d] when the user exits\n", session->tgid, buffer->handle); rga_mm_force_releaser_buffer(buffer); } diff --git a/drivers/video/rockchip/rga3/rga_policy.c b/drivers/video/rockchip/rga3/rga_policy.c index 6194b0fccba1..168cff7e423a 100644 --- a/drivers/video/rockchip/rga3/rga_policy.c +++ b/drivers/video/rockchip/rga3/rga_policy.c @@ -5,8 +5,6 @@ * Author: Huang Lee */ -#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; }