diff --git a/msm/vidc/hfi_ar50.c b/msm/vidc/hfi_ar50.c index a5428dbfe246..55f3f5ee9247 100644 --- a/msm/vidc/hfi_ar50.c +++ b/msm/vidc/hfi_ar50.c @@ -6,8 +6,8 @@ #include "hfi_common.h" #include "hfi_io_common.h" -void __interrupt_init_ar50(struct venus_hfi_device *device) +void __interrupt_init_ar50(struct venus_hfi_device *device, u32 sid) { __write_register(device, WRAPPER_INTR_MASK, - WRAPPER_INTR_MASK_A2HVCODEC_BMSK); + WRAPPER_INTR_MASK_A2HVCODEC_BMSK, sid); } diff --git a/msm/vidc/hfi_common.c b/msm/vidc/hfi_common.c index 20d31a0f5586..162db79feff3 100644 --- a/msm/vidc/hfi_common.c +++ b/msm/vidc/hfi_common.c @@ -84,37 +84,40 @@ const int max_packets = 1000; static void venus_hfi_pm_handler(struct work_struct *work); static DECLARE_DELAYED_WORK(venus_hfi_pm_work, venus_hfi_pm_handler); -static inline int __resume(struct venus_hfi_device *device); +static inline int __resume(struct venus_hfi_device *device, u32 sid); static inline int __suspend(struct venus_hfi_device *device); -static int __enable_regulators(struct venus_hfi_device *device); -static inline int __prepare_enable_clks(struct venus_hfi_device *device); +static int __enable_regulators(struct venus_hfi_device *device, u32 sid); +static inline int __prepare_enable_clks( + struct venus_hfi_device *device, u32 sid); static void __flush_debug_queue(struct venus_hfi_device *device, u8 *packet); static int __initialize_packetization(struct venus_hfi_device *device); static struct hal_session *__get_session(struct venus_hfi_device *device, - u32 session_id); + u32 sid); static bool __is_session_valid(struct venus_hfi_device *device, struct hal_session *session, const char *func); -static int __set_clocks(struct venus_hfi_device *device, u32 freq); +static int __set_clocks(struct venus_hfi_device *device, u32 freq, u32 sid); static int __iface_cmdq_write(struct venus_hfi_device *device, - void *pkt); + void *pkt, u32 sid); static int __load_fw(struct venus_hfi_device *device); static void __unload_fw(struct venus_hfi_device *device); -static int __tzbsp_set_video_state(enum tzbsp_video_state state); -static int __enable_subcaches(struct venus_hfi_device *device); -static int __set_subcaches(struct venus_hfi_device *device); -static int __release_subcaches(struct venus_hfi_device *device); -static int __disable_subcaches(struct venus_hfi_device *device); +static int __tzbsp_set_video_state(enum tzbsp_video_state state, u32 sid); +static int __enable_subcaches(struct venus_hfi_device *device, u32 sid); +static int __set_subcaches(struct venus_hfi_device *device, u32 sid); +static int __release_subcaches(struct venus_hfi_device *device, u32 sid); +static int __disable_subcaches(struct venus_hfi_device *device, u32 sid); static int __power_collapse(struct venus_hfi_device *device, bool force); static int venus_hfi_noc_error_info(void *dev); static int __set_ubwc_config(struct venus_hfi_device *device); static void __power_off_common(struct venus_hfi_device *device); static int __prepare_pc_common(struct venus_hfi_device *device); -static void __raise_interrupt_common(struct venus_hfi_device *device); +static void __raise_interrupt_common(struct venus_hfi_device *device, u32 sid); static bool __watchdog_common(u32 intr_status); static void __noc_error_info_common(struct venus_hfi_device *device); static void __core_clear_interrupt_common(struct venus_hfi_device *device); -static inline int __boot_firmware_common(struct venus_hfi_device *device); -static void __setup_ucregion_memory_map_common(struct venus_hfi_device *device); +static inline int __boot_firmware_common( + struct venus_hfi_device *device, u32 sid); +static void __setup_ucregion_memory_map_common( + struct venus_hfi_device *device, u32 sid); struct venus_hfi_vpu_ops vpu4_ops = { .interrupt_init = __interrupt_init_ar50, @@ -184,7 +187,7 @@ static inline bool is_sys_cache_present(struct venus_hfi_device *device) return device->res->sys_cache_present; } -static void __dump_packet(u8 *packet, enum vidc_msg_prio log_level) +static void __dump_packet(u8 *packet, u32 sid) { u32 c = 0, packet_size = *(u32 *)packet; const int row_size = 32; @@ -199,7 +202,7 @@ static void __dump_packet(u8 *packet, enum vidc_msg_prio log_level) packet_size % row_size : row_size; hex_dump_to_buffer(packet + c * row_size, bytes_to_read, row_size, 4, row, sizeof(row), false); - dprintk(log_level, "%s\n", row); + s_vpr_t(sid, "%s\n", row); } } @@ -210,21 +213,20 @@ static void __sim_modify_cmd_packet(u8 *packet, struct venus_hfi_device *device) u8 i; phys_addr_t fw_bias = 0; - if (!device || !packet) { - dprintk(VIDC_ERR, "Invalid Param\n"); + sys_init = (struct hfi_cmd_sys_session_init_packet *)packet; + if (!device || !sys_init) { + d_vpr_e("%s: invalid params %pK %pK\n", + __func__, device, sys_init); return; } else if (!device->hal_data->firmware_base || is_iommu_present(device->res)) { return; } - fw_bias = device->hal_data->firmware_base; - sys_init = (struct hfi_cmd_sys_session_init_packet *)packet; - session = __get_session(device, sys_init->session_id); + session = __get_session(device, sys_init->sid); if (!session) { - dprintk(VIDC_ERR, "%s :Invalid session id: %x\n", - __func__, sys_init->session_id); + d_vpr_e("%s: Invalid session id\n", __func__); return; } @@ -312,28 +314,28 @@ static int __dsp_send_hfi_queue(struct venus_hfi_device *device) return 0; if (!device->dsp_iface_q_table.mem_data.dma_handle) { - dprintk(VIDC_ERR, "%s: invalid dsm_handle\n", __func__); + d_vpr_e("%s: invalid dsm_handle\n", __func__); return -EINVAL; } if (device->dsp_flags & DSP_INIT) { - dprintk(VIDC_HIGH, "%s: dsp already inited\n", __func__); + d_vpr_h("%s: dsp already inited\n", __func__); return 0; } - dprintk(VIDC_HIGH, "%s: hfi queue %#llx size %d\n", + d_vpr_h("%s: hfi queue %#llx size %d\n", __func__, device->dsp_iface_q_table.mem_data.dma_handle, device->dsp_iface_q_table.mem_data.size); rc = fastcvpd_video_send_cmd_hfi_queue( (phys_addr_t *)device->dsp_iface_q_table.mem_data.dma_handle, device->dsp_iface_q_table.mem_data.size); if (rc) { - dprintk(VIDC_ERR, "%s: dsp init failed\n", __func__); + d_vpr_e("%s: dsp init failed\n", __func__); return rc; } device->dsp_flags |= DSP_INIT; - dprintk(VIDC_HIGH, "%s: dsp inited\n", __func__); + d_vpr_h("%s: dsp inited\n", __func__); return rc; } @@ -358,24 +360,24 @@ static int __dsp_suspend(struct venus_hfi_device *device, bool force, u32 flags) if (temp->domain == HAL_VIDEO_DOMAIN_CVP) { /* don't suspend if cvp session is not paused */ if (!(temp->flags & SESSION_PAUSE)) { - dprintk(VIDC_HIGH, - "%s: cvp session %x not paused\n", - __func__, hash32_ptr(temp)); + s_vpr_h(temp->sid, + "%s: cvp session not paused\n", + __func__); return -EBUSY; } } } - dprintk(VIDC_HIGH, "%s: suspend dsp\n", __func__); + d_vpr_h("%s: suspend dsp\n", __func__); rc = fastcvpd_video_suspend(flags); if (rc) { - dprintk(VIDC_ERR, "%s: dsp suspend failed with error %d\n", + d_vpr_e("%s: dsp suspend failed with error %d\n", __func__, rc); return -EINVAL; } device->dsp_flags |= DSP_SUSPEND; - dprintk(VIDC_HIGH, "%s: dsp suspended\n", __func__); + d_vpr_h("%s: dsp suspended\n", __func__); return 0; } @@ -387,21 +389,20 @@ static int __dsp_resume(struct venus_hfi_device *device, u32 flags) return 0; if (!(device->dsp_flags & DSP_SUSPEND)) { - dprintk(VIDC_HIGH, "%s: dsp not suspended\n", __func__); + d_vpr_h("%s: dsp not suspended\n", __func__); return 0; } - dprintk(VIDC_HIGH, "%s: resume dsp\n", __func__); + d_vpr_h("%s: resume dsp\n", __func__); rc = fastcvpd_video_resume(flags); if (rc) { - dprintk(VIDC_ERR, - "%s: dsp resume failed with error %d\n", + d_vpr_e("%s: dsp resume failed with error %d\n", __func__, rc); return rc; } device->dsp_flags &= ~DSP_SUSPEND; - dprintk(VIDC_HIGH, "%s: dsp resumed\n", __func__); + d_vpr_h("%s: dsp resumed\n", __func__); return rc; } @@ -413,21 +414,20 @@ static int __dsp_shutdown(struct venus_hfi_device *device, u32 flags) return 0; if (!(device->dsp_flags & DSP_INIT)) { - dprintk(VIDC_HIGH, "%s: dsp not inited\n", __func__); + d_vpr_h("%s: dsp not inited\n", __func__); return 0; } - dprintk(VIDC_HIGH, "%s: shutdown dsp\n", __func__); + d_vpr_h("%s: shutdown dsp\n", __func__); rc = fastcvpd_video_shutdown(flags); if (rc) { - dprintk(VIDC_ERR, - "%s: dsp shutdown failed with error %d\n", + d_vpr_e("%s: dsp shutdown failed with error %d\n", __func__, rc); WARN_ON(1); } device->dsp_flags &= ~DSP_INIT; - dprintk(VIDC_HIGH, "%s: dsp shutdown successful\n", __func__); + d_vpr_h("%s: dsp shutdown successful\n", __func__); return rc; } @@ -444,8 +444,7 @@ static int __session_pause(struct venus_hfi_device *device, return 0; session->flags |= SESSION_PAUSE; - dprintk(VIDC_HIGH, "%s: cvp session %x paused\n", __func__, - hash32_ptr(session)); + s_vpr_h(session->sid, "%s: cvp session paused\n", __func__); return rc; } @@ -463,17 +462,16 @@ static int __session_resume(struct venus_hfi_device *device, return 0; session->flags &= ~SESSION_PAUSE; - dprintk(VIDC_HIGH, "%s: cvp session %x resumed\n", __func__, - hash32_ptr(session)); + s_vpr_h(session->sid, "%s: cvp session resumed\n", __func__); - rc = __resume(device); + rc = __resume(device, session->sid); if (rc) { - dprintk(VIDC_ERR, "%s: resume failed\n", __func__); + s_vpr_e(session->sid, "%s: resume failed\n", __func__); goto exit; } if (device->dsp_flags & DSP_SUSPEND) { - dprintk(VIDC_ERR, "%s: dsp not resumed\n", __func__); + s_vpr_e(session->sid, "%s: dsp not resumed\n", __func__); rc = -EINVAL; goto exit; } @@ -509,7 +507,7 @@ static int venus_hfi_session_resume(void *sess) } static int __acquire_regulator(struct regulator_info *rinfo, - struct venus_hfi_device *device) + struct venus_hfi_device *device, u32 sid) { int rc = 0; @@ -522,20 +520,19 @@ static int __acquire_regulator(struct regulator_info *rinfo, * about it. We can't disable the regulator w/o * getting it back under s/w control */ - dprintk(VIDC_ERR, + s_vpr_e(sid, "Failed to acquire regulator control: %s\n", - rinfo->name); + rinfo->name); } else { - dprintk(VIDC_HIGH, - "Acquire regulator control from HW: %s\n", + s_vpr_h(sid, "Acquire regulator control from HW: %s\n", rinfo->name); } } if (!regulator_is_enabled(rinfo->regulator)) { - dprintk(VIDC_ERR, "Regulator is not enabled %s\n", + s_vpr_e(sid, "Regulator is not enabled %s\n", rinfo->name); msm_vidc_res_handle_fatal_hw_error(device->res, true); } @@ -543,7 +540,7 @@ static int __acquire_regulator(struct regulator_info *rinfo, return rc; } -static int __hand_off_regulator(struct regulator_info *rinfo) +static int __hand_off_regulator(struct regulator_info *rinfo, u32 sid) { int rc = 0; @@ -551,12 +548,11 @@ static int __hand_off_regulator(struct regulator_info *rinfo) rc = regulator_set_mode(rinfo->regulator, REGULATOR_MODE_FAST); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(sid, "Failed to hand off regulator control: %s\n", - rinfo->name); + rinfo->name); } else { - dprintk(VIDC_HIGH, - "Hand off regulator control to HW: %s\n", + s_vpr_h(sid, "Hand off regulator control to HW: %s\n", rinfo->name); } } @@ -564,13 +560,13 @@ static int __hand_off_regulator(struct regulator_info *rinfo) return rc; } -static int __hand_off_regulators(struct venus_hfi_device *device) +static int __hand_off_regulators(struct venus_hfi_device *device, u32 sid) { struct regulator_info *rinfo; int rc = 0, c = 0; venus_hfi_for_each_regulator(device, rinfo) { - rc = __hand_off_regulator(rinfo); + rc = __hand_off_regulator(rinfo, sid); /* * If one regulator hand off failed, driver should take * the control for other regulators back. @@ -583,13 +579,13 @@ static int __hand_off_regulators(struct venus_hfi_device *device) return rc; err_reg_handoff_failed: venus_hfi_for_each_regulator_reverse_continue(device, rinfo, c) - __acquire_regulator(rinfo, device); + __acquire_regulator(rinfo, device, sid); return rc; } static int __write_queue(struct vidc_iface_q_info *qinfo, u8 *packet, - bool *rx_req_is_set) + bool *rx_req_is_set, u32 sid) { struct hfi_queue_header *queue; u32 packet_size_in_words, new_write_idx; @@ -597,28 +593,29 @@ static int __write_queue(struct vidc_iface_q_info *qinfo, u8 *packet, u32 *write_ptr; if (!qinfo || !packet) { - dprintk(VIDC_ERR, "Invalid Params\n"); + s_vpr_e(sid, "%s: invalid params %pK %pK\n", + __func__, qinfo, packet); return -EINVAL; } else if (!qinfo->q_array.align_virtual_addr) { - dprintk(VIDC_ERR, "Queues have already been freed\n"); + s_vpr_e(sid, "Queues have already been freed\n"); return -EINVAL; } queue = (struct hfi_queue_header *) qinfo->q_hdr; if (!queue) { - dprintk(VIDC_ERR, "queue not present\n"); + s_vpr_e(sid, "queue not present\n"); return -ENOENT; } if (msm_vidc_debug & VIDC_PKT) { - dprintk(VIDC_PKT, "%s: %pK\n", __func__, qinfo); - __dump_packet(packet, VIDC_PKT); + s_vpr_t(sid, "%s: %pK\n", __func__, qinfo); + __dump_packet(packet, sid); } packet_size_in_words = (*(u32 *)packet) >> 2; if (!packet_size_in_words || packet_size_in_words > qinfo->q_array.mem_size>>2) { - dprintk(VIDC_ERR, "Invalid packet size\n"); + s_vpr_e(sid, "Invalid packet size\n"); return -ENODATA; } @@ -630,7 +627,7 @@ static int __write_queue(struct vidc_iface_q_info *qinfo, u8 *packet, (read_idx - write_idx); if (empty_space <= packet_size_in_words) { queue->qhdr_tx_req = 1; - dprintk(VIDC_ERR, "Insufficient size (%d) to write (%d)\n", + s_vpr_e(sid, "Insufficient size (%d) to write (%d)\n", empty_space, packet_size_in_words); return -ENOTEMPTY; } @@ -643,7 +640,7 @@ static int __write_queue(struct vidc_iface_q_info *qinfo, u8 *packet, if (write_ptr < (u32 *)qinfo->q_array.align_virtual_addr || write_ptr > (u32 *)(qinfo->q_array.align_virtual_addr + qinfo->q_array.mem_size)) { - dprintk(VIDC_ERR, "Invalid write index"); + s_vpr_e(sid, "Invalid write index"); return -ENODATA; } @@ -682,7 +679,8 @@ static void __hal_sim_modify_msg_packet(u8 *packet, phys_addr_t fw_bias = 0; if (!device || !packet) { - dprintk(VIDC_ERR, "Invalid Param\n"); + d_vpr_e("%s: invalid params %pK %pK\n", + __func__, device, packet); return; } else if (!device->hal_data->firmware_base || is_iommu_present(device->res)) { @@ -691,10 +689,10 @@ static void __hal_sim_modify_msg_packet(u8 *packet, fw_bias = device->hal_data->firmware_base; init_done = (struct hfi_msg_sys_session_init_done_packet *)packet; - session = __get_session(device, init_done->session_id); + session = __get_session(device, init_done->sid); if (!session) { - dprintk(VIDC_ERR, "%s: Invalid session id: %x\n", - __func__, init_done->session_id); + d_vpr_e("%s: Invalid session id: %x\n", + __func__, init_done->sid); return; } @@ -737,12 +735,14 @@ static int __read_queue(struct vidc_iface_q_info *qinfo, u8 *packet, u32 receive_request = 0; u32 read_idx, write_idx; int rc = 0; + u32 sid; if (!qinfo || !packet || !pb_tx_req_is_set) { - dprintk(VIDC_ERR, "Invalid Params\n"); + d_vpr_e("%s: invalid params %pK %pK %pK\n", + __func__, qinfo, packet, pb_tx_req_is_set); return -EINVAL; } else if (!qinfo->q_array.align_virtual_addr) { - dprintk(VIDC_ERR, "Queues have already been freed\n"); + d_vpr_e("Queues have already been freed\n"); return -EINVAL; } @@ -754,7 +754,7 @@ static int __read_queue(struct vidc_iface_q_info *qinfo, u8 *packet, queue = (struct hfi_queue_header *) qinfo->q_hdr; if (!queue) { - dprintk(VIDC_ERR, "Queue memory is not allocated\n"); + d_vpr_e("Queue memory is not allocated\n"); return -ENOMEM; } @@ -780,7 +780,7 @@ static int __read_queue(struct vidc_iface_q_info *qinfo, u8 *packet, */ mb(); *pb_tx_req_is_set = 0; - dprintk(VIDC_LOW, + d_vpr_l( "%s queue is empty, rx_req = %u, tx_req = %u, read_idx = %u\n", receive_request ? "message" : "debug", queue->qhdr_rx_req, queue->qhdr_tx_req, @@ -793,13 +793,13 @@ static int __read_queue(struct vidc_iface_q_info *qinfo, u8 *packet, if (read_ptr < (u32 *)qinfo->q_array.align_virtual_addr || read_ptr > (u32 *)(qinfo->q_array.align_virtual_addr + qinfo->q_array.mem_size - sizeof(*read_ptr))) { - dprintk(VIDC_ERR, "Invalid read index\n"); + d_vpr_e("Invalid read index\n"); return -ENODATA; } packet_size_in_words = (*read_ptr) >> 2; if (!packet_size_in_words) { - dprintk(VIDC_ERR, "Zero packet size\n"); + d_vpr_e("Zero packet size\n"); return -ENODATA; } @@ -819,10 +819,9 @@ static int __read_queue(struct vidc_iface_q_info *qinfo, u8 *packet, new_read_idx << 2); } } else { - dprintk(VIDC_ERR, - "BAD packet received, read_idx: %#x, pkt_size: %d\n", + d_vpr_e("BAD packet received, read_idx: %#x, pkt_size: %d\n", read_idx, packet_size_in_words << 2); - dprintk(VIDC_ERR, "Dropping this packet\n"); + d_vpr_e("Dropping this packet\n"); new_read_idx = write_idx; rc = -ENODATA; } @@ -843,8 +842,9 @@ static int __read_queue(struct vidc_iface_q_info *qinfo, u8 *packet, if ((msm_vidc_debug & VIDC_PKT) && !(queue->qhdr_type & HFI_Q_ID_CTRL_TO_HOST_DEBUG_Q)) { - dprintk(VIDC_PKT, "%s: %pK\n", __func__, qinfo); - __dump_packet(packet, VIDC_PKT); + sid = *((u32 *)packet + 2); + s_vpr_t(sid, "%s: %pK\n", __func__, qinfo); + __dump_packet(packet, sid); } return rc; @@ -858,21 +858,22 @@ static int __smem_alloc(struct venus_hfi_device *dev, int rc = 0; if (!dev || !mem || !size) { - dprintk(VIDC_ERR, "Invalid Params\n"); + d_vpr_e("%s: invalid params %pK %pK %pK\n", + __func__, dev, mem, size); return -EINVAL; } - dprintk(VIDC_HIGH, "start to alloc size: %d, flags: %d\n", size, flags); + d_vpr_h("start to alloc size: %d, flags: %d\n", size, flags); rc = msm_smem_alloc( size, align, flags, usage, 1, (void *)dev->res, - MSM_VIDC_UNKNOWN, alloc); + MSM_VIDC_UNKNOWN, alloc, DEFAULT_SID); if (rc) { - dprintk(VIDC_ERR, "Alloc failed\n"); + d_vpr_e("%s: alloc failed\n", __func__); rc = -ENOMEM; goto fail_smem_alloc; } - dprintk(VIDC_HIGH, "%s: ptr = %pK, size = %d\n", __func__, + d_vpr_h("%s: ptr = %pK, size = %d\n", __func__, alloc->kvaddr, size); mem->mem_size = alloc->size; @@ -887,35 +888,35 @@ fail_smem_alloc: static void __smem_free(struct venus_hfi_device *dev, struct msm_smem *mem) { if (!dev || !mem) { - dprintk(VIDC_ERR, "invalid param %pK %pK\n", dev, mem); + d_vpr_e("%s: invalid params %pK %pK\n", + __func__, dev, mem); return; } - msm_smem_free(mem); + msm_smem_free(mem, DEFAULT_SID); } void __write_register(struct venus_hfi_device *device, - u32 reg, u32 value) + u32 reg, u32 value, u32 sid) { u32 hwiosymaddr = reg; u8 *base_addr; if (!device) { - dprintk(VIDC_ERR, "Invalid params: %pK\n", device); + s_vpr_e(sid, "%s: invalid params\n", __func__); return; } __strict_check(device); if (!device->power_enabled) { - dprintk(VIDC_ERR, - "HFI Write register failed : Power is OFF\n"); + s_vpr_e(sid, "HFI Write register failed : Power is OFF\n"); msm_vidc_res_handle_fatal_hw_error(device->res, true); return; } base_addr = device->hal_data->register_base; - dprintk(VIDC_LOW, "Base addr: %pK, writing to: %#x, Value: %#x...\n", + s_vpr_l(sid, "Base addr: %pK, writing to: %#x, Value: %#x...\n", base_addr, hwiosymaddr, value); base_addr += hwiosymaddr; writel_relaxed(value, base_addr); @@ -926,21 +927,20 @@ void __write_register(struct venus_hfi_device *device, wmb(); } -int __read_register(struct venus_hfi_device *device, u32 reg) +int __read_register(struct venus_hfi_device *device, u32 reg, u32 sid) { int rc = 0; u8 *base_addr; if (!device) { - dprintk(VIDC_ERR, "Invalid params: %pK\n", device); + s_vpr_e(sid, "%s: invalid params\n", __func__); return -EINVAL; } __strict_check(device); if (!device->power_enabled) { - dprintk(VIDC_ERR, - "HFI Read register failed : Power is OFF\n"); + s_vpr_e(sid, "HFI Read register failed : Power is OFF\n"); msm_vidc_res_handle_fatal_hw_error(device->res, true); return -EINVAL; } @@ -953,47 +953,47 @@ int __read_register(struct venus_hfi_device *device, u32 reg) * register. */ rmb(); - dprintk(VIDC_LOW, "Base addr: %pK, read from: %#x, value: %#x...\n", + s_vpr_l(sid, "Base addr: %pK, read from: %#x, value: %#x...\n", base_addr, reg, rc); return rc; } -static void __set_registers(struct venus_hfi_device *device) +static void __set_registers(struct venus_hfi_device *device, u32 sid) { struct reg_set *reg_set; int i; if (!device->res) { - dprintk(VIDC_ERR, - "device resources null, cannot set registers\n"); + s_vpr_e(sid, "device resources null, cannot set registers\n"); return; } reg_set = &device->res->reg_set; for (i = 0; i < reg_set->count; i++) { __write_register(device, reg_set->reg_tbl[i].reg, - reg_set->reg_tbl[i].value); + reg_set->reg_tbl[i].value, sid); } } -static int __vote_bandwidth(struct bus_info *bus, unsigned long bw_kbps) +static int __vote_bandwidth(struct bus_info *bus, + unsigned long bw_kbps, u32 sid) { int rc = 0; uint64_t ab = 0; /* Bus Driver expects values in Bps */ ab = bw_kbps * 1000; - dprintk(VIDC_PERF, "Voting bus %s to ab %llu bps\n", bus->name, ab); + s_vpr_p(sid, "Voting bus %s to ab %llu bps\n", bus->name, ab); rc = msm_bus_scale_update_bw(bus->client, ab, 0); if (rc) - dprintk(VIDC_ERR, "Failed voting bus %s to ab %llu, rc=%d\n", + s_vpr_e(sid, "Failed voting bus %s to ab %llu, rc=%d\n", bus->name, ab, rc); return rc; } -int __unvote_buses(struct venus_hfi_device *device) +int __unvote_buses(struct venus_hfi_device *device, u32 sid) { int rc = 0; struct bus_info *bus = NULL; @@ -1001,7 +1001,7 @@ int __unvote_buses(struct venus_hfi_device *device) device->bus_vote = DEFAULT_BUS_VOTE; venus_hfi_for_each_bus(device, bus) { - rc = __vote_bandwidth(bus, 0); + rc = __vote_bandwidth(bus, 0, sid); if (rc) goto err_unknown_device; } @@ -1011,7 +1011,7 @@ err_unknown_device: } static int __vote_buses(struct venus_hfi_device *device, - unsigned long bw_ddr, unsigned long bw_llcc) + unsigned long bw_ddr, unsigned long bw_llcc, u32 sid) { int rc = 0; struct bus_info *bus = NULL; @@ -1039,20 +1039,19 @@ static int __vote_buses(struct venus_hfi_device *device, bus->range[0], bus->range[1]); if (TRIVIAL_BW_CHANGE(bw_kbps, bw_prev) && bw_prev) { - dprintk(VIDC_PERF, - "Skip voting bus %s to %llu bps", + s_vpr_p(sid, "Skip voting bus %s to %llu bps", bus->name, bw_kbps * 1000); continue; } - rc = __vote_bandwidth(bus, bw_kbps); + rc = __vote_bandwidth(bus, bw_kbps, sid); if (type == DDR) device->bus_vote.total_bw_ddr = bw_kbps; else if (type == LLCC) device->bus_vote.total_bw_llcc = bw_kbps; } else { - dprintk(VIDC_ERR, "No BUS to Vote\n"); + s_vpr_e(sid, "No BUS to Vote\n"); } } @@ -1060,7 +1059,7 @@ static int __vote_buses(struct venus_hfi_device *device, } static int venus_hfi_vote_buses(void *dev, unsigned long bw_ddr, - unsigned long bw_llcc) + unsigned long bw_llcc, u32 sid) { int rc = 0; struct venus_hfi_device *device = dev; @@ -1069,7 +1068,7 @@ static int venus_hfi_vote_buses(void *dev, unsigned long bw_ddr, return -EINVAL; mutex_lock(&device->lock); - rc = __vote_buses(device, bw_ddr, bw_llcc); + rc = __vote_buses(device, bw_ddr, bw_llcc, sid); mutex_unlock(&device->lock); return rc; @@ -1082,7 +1081,8 @@ static int __core_set_resource(struct venus_hfi_device *device, int rc = 0; if (!device || !resource_hdr || !resource_value) { - dprintk(VIDC_ERR, "set_res: Invalid Params\n"); + d_vpr_e("%s: invalid params %pK %pK %pK\n", __func__, + device, resource_hdr, resource_value); return -EINVAL; } @@ -1091,11 +1091,11 @@ static int __core_set_resource(struct venus_hfi_device *device, rc = call_hfi_pkt_op(device, sys_set_resource, pkt, resource_hdr, resource_value); if (rc) { - dprintk(VIDC_ERR, "set_res: failed to create packet\n"); + d_vpr_e("set_res: failed to create packet\n"); goto err_create_pkt; } - rc = __iface_cmdq_write(device, pkt); + rc = __iface_cmdq_write(device, pkt, DEFAULT_SID); if (rc) rc = -ENOTEMPTY; @@ -1111,7 +1111,8 @@ static int __core_release_resource(struct venus_hfi_device *device, int rc = 0; if (!device || !resource_hdr) { - dprintk(VIDC_ERR, "release_res: Invalid Params\n"); + d_vpr_e("%s: invalid params %pK %pK\n", + __func__, device, resource_hdr); return -EINVAL; } @@ -1121,11 +1122,11 @@ static int __core_release_resource(struct venus_hfi_device *device, pkt, resource_hdr); if (rc) { - dprintk(VIDC_ERR, "release_res: failed to create packet\n"); + d_vpr_e("release_res: failed to create packet\n"); goto err_create_pkt; } - rc = __iface_cmdq_write(device, pkt); + rc = __iface_cmdq_write(device, pkt, DEFAULT_SID); if (rc) rc = -ENOTEMPTY; @@ -1133,7 +1134,7 @@ err_create_pkt: return rc; } -static int __tzbsp_set_video_state(enum tzbsp_video_state state) +static int __tzbsp_set_video_state(enum tzbsp_video_state state, u32 sid) { struct tzbsp_video_set_state_req cmd = {0}; int tzbsp_rsp = 0; @@ -1149,22 +1150,22 @@ static int __tzbsp_set_video_state(enum tzbsp_video_state state) tzbsp_rsp = desc.ret[0]; if (rc) { - dprintk(VIDC_ERR, "Failed scm_call %d\n", rc); + s_vpr_e(sid, "Failed scm_call %d\n", rc); return rc; } - dprintk(VIDC_LOW, "Set state %d, resp %d\n", state, tzbsp_rsp); + s_vpr_l(sid, "Set state %d, resp %d\n", state, tzbsp_rsp); if (tzbsp_rsp) { - dprintk(VIDC_ERR, - "Failed to set video core state to suspend: %d\n", - tzbsp_rsp); + s_vpr_e(sid, "Failed to set video core state to suspend: %d\n", + tzbsp_rsp); return -EINVAL; } return 0; } -static inline int __boot_firmware_common(struct venus_hfi_device *device) +static inline int __boot_firmware_common( + struct venus_hfi_device *device, u32 sid) { int rc = 0; u32 ctrl_init_val = 0, ctrl_status = 0, count = 0, max_tries = 1000; @@ -1173,11 +1174,11 @@ static inline int __boot_firmware_common(struct venus_hfi_device *device) if (device->res->cvp_internal) ctrl_init_val |= BIT(1); - __write_register(device, CTRL_INIT, ctrl_init_val); + __write_register(device, CTRL_INIT, ctrl_init_val, sid); while (!ctrl_status && count < max_tries) { - ctrl_status = __read_register(device, CTRL_STATUS); + ctrl_status = __read_register(device, CTRL_STATUS, sid); if ((ctrl_status & CTRL_ERROR_STATUS__M) == 0x4) { - dprintk(VIDC_ERR, "invalid setting for UC_REGION\n"); + s_vpr_e(sid, "invalid setting for UC_REGION\n"); break; } @@ -1186,7 +1187,7 @@ static inline int __boot_firmware_common(struct venus_hfi_device *device) } if (count >= max_tries) { - dprintk(VIDC_ERR, "Error booting up vidc firmware\n"); + s_vpr_e(sid, "Error booting up vidc firmware\n"); rc = -ETIME; } @@ -1199,17 +1200,17 @@ static int venus_hfi_suspend(void *dev) struct venus_hfi_device *device = (struct venus_hfi_device *) dev; if (!device) { - dprintk(VIDC_ERR, "%s invalid device\n", __func__); + d_vpr_e("%s: invalid device\n", __func__); return -EINVAL; } else if (!device->res->sw_power_collapsible) { return -ENOTSUPP; } - dprintk(VIDC_HIGH, "Suspending Venus\n"); + d_vpr_h("Suspending Venus\n"); mutex_lock(&device->lock); rc = __power_collapse(device, true); if (rc) { - dprintk(VIDC_ERR, "%s: Venus is busy\n", __func__); + d_vpr_e("%s: Venus is busy\n", __func__); rc = -EBUSY; } mutex_unlock(&device->lock); @@ -1227,13 +1228,13 @@ static int venus_hfi_flush_debug_queue(void *dev) struct venus_hfi_device *device = (struct venus_hfi_device *) dev; if (!device) { - dprintk(VIDC_ERR, "%s invalid device\n", __func__); + d_vpr_e("%s: invalid device\n", __func__); return -EINVAL; } mutex_lock(&device->lock); if (!device->power_enabled) { - dprintk(VIDC_ERR, "%s: venus power off\n", __func__); + d_vpr_e("%s: venus power off\n", __func__); rc = -EINVAL; goto exit; } @@ -1243,26 +1244,8 @@ exit: return rc; } -static enum hal_default_properties venus_hfi_get_default_properties(void *dev) -{ - enum hal_default_properties prop = 0; - struct venus_hfi_device *device = (struct venus_hfi_device *) dev; - - if (!device) { - dprintk(VIDC_ERR, "%s invalid device\n", __func__); - return -EINVAL; - } - - mutex_lock(&device->lock); - - prop = HAL_VIDEO_DYNAMIC_BUF_MODE; - - mutex_unlock(&device->lock); - return prop; -} - static int __set_clk_rate(struct venus_hfi_device *device, - struct clock_info *cl, u64 rate) + struct clock_info *cl, u64 rate, u32 sid) { int rc = 0; u64 threshold_freq = device->res->clk_freq_threshold; @@ -1272,18 +1255,17 @@ static int __set_clk_rate(struct venus_hfi_device *device, if (ipeak && device->clk_freq < threshold_freq && rate >= threshold_freq) { rc = cx_ipeak_update(ipeak, true); if (rc) { - dprintk(VIDC_ERR, - "%s: cx_ipeak_update failed!\n", __func__); + s_vpr_e(sid, "%s: cx_ipeak_update failed!\n", __func__); return rc; } - dprintk(VIDC_PERF, - "cx_ipeak_update: up, clk freq = %lu rate = %lu threshold_freq = %lu\n", - device->clk_freq, rate, threshold_freq); + s_vpr_p(sid, + "cx_ipeak_update: up, clk freq = %lu rate = %lu threshold_freq = %lu\n", + device->clk_freq, rate, threshold_freq); } rc = clk_set_rate(clk, rate); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(sid, "%s: Failed to set clock rate %llu %s: %d\n", __func__, rate, cl->name, rc); return rc; @@ -1292,14 +1274,14 @@ static int __set_clk_rate(struct venus_hfi_device *device, if (ipeak && device->clk_freq >= threshold_freq && rate < threshold_freq) { rc = cx_ipeak_update(ipeak, false); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(sid, "cx_ipeak_update failed! ipeak %pK\n", ipeak); device->clk_freq = rate; return rc; } - dprintk(VIDC_PERF, - "cx_ipeak_update: up, clk freq = %lu rate = %lu threshold_freq = %lu\n", - device->clk_freq, rate, threshold_freq); + s_vpr_p(sid, + "cx_ipeak_update: up, clk freq = %lu rate = %lu threshold_freq = %lu\n", + device->clk_freq, rate, threshold_freq); } device->clk_freq = rate; @@ -1307,7 +1289,7 @@ static int __set_clk_rate(struct venus_hfi_device *device, return rc; } -static int __set_clocks(struct venus_hfi_device *device, u32 freq) +static int __set_clocks(struct venus_hfi_device *device, u32 freq, u32 sid) { struct clock_info *cl; int rc = 0; @@ -1318,12 +1300,12 @@ static int __set_clocks(struct venus_hfi_device *device, u32 freq) venus_hfi_for_each_clock(device, cl) { if (cl->has_scaling) {/* has_scaling */ - rc = __set_clk_rate(device, cl, freq); + rc = __set_clk_rate(device, cl, freq, sid); if (rc) return rc; trace_msm_vidc_perf_clock_scale(cl->name, freq); - dprintk(VIDC_PERF, "Scaling clock %s to %u\n", + s_vpr_p(sid, "Scaling clock %s to %u\n", cl->name, freq); } } @@ -1331,32 +1313,32 @@ static int __set_clocks(struct venus_hfi_device *device, u32 freq) return 0; } -static int venus_hfi_scale_clocks(void *dev, u32 freq) +static int venus_hfi_scale_clocks(void *dev, u32 freq, u32 sid) { int rc = 0; struct venus_hfi_device *device = dev; if (!device) { - dprintk(VIDC_ERR, "Invalid args: %pK\n", device); + s_vpr_e(sid, "Invalid args: %pK\n", device); return -EINVAL; } mutex_lock(&device->lock); - if (__resume(device)) { - dprintk(VIDC_ERR, "Resume from power collapse failed\n"); + if (__resume(device, sid)) { + s_vpr_e(sid, "Resume from power collapse failed\n"); rc = -ENODEV; goto exit; } - rc = __set_clocks(device, freq); + rc = __set_clocks(device, freq, sid); exit: mutex_unlock(&device->lock); return rc; } -static int __scale_clocks(struct venus_hfi_device *device) +static int __scale_clocks(struct venus_hfi_device *device, u32 sid) { int rc = 0; struct allowed_clock_rates_table *allowed_clks_tbl = NULL; @@ -1366,27 +1348,28 @@ static int __scale_clocks(struct venus_hfi_device *device) rate = device->clk_freq ? device->clk_freq : allowed_clks_tbl[0].clock_rate; - rc = __set_clocks(device, rate); + rc = __set_clocks(device, rate, sid); return rc; } /* Writes into cmdq without raising an interrupt */ static int __iface_cmdq_write_relaxed(struct venus_hfi_device *device, - void *pkt, bool *requires_interrupt) + void *pkt, bool *requires_interrupt, u32 sid) { struct vidc_iface_q_info *q_info; struct vidc_hal_cmd_pkt_hdr *cmd_packet; int result = -E2BIG; if (!device || !pkt) { - dprintk(VIDC_ERR, "Invalid Params\n"); + s_vpr_e(sid, "%s: invalid params %pK %pK\n", + __func__, device, pkt); return -EINVAL; } __strict_check(device); if (!__core_in_valid_state(device)) { - dprintk(VIDC_ERR, "%s - fw not in init state\n", __func__); + s_vpr_e(sid, "%s: fw not in init state\n", __func__); result = -EINVAL; goto err_q_null; } @@ -1396,37 +1379,36 @@ static int __iface_cmdq_write_relaxed(struct venus_hfi_device *device, q_info = &device->iface_queues[VIDC_IFACEQ_CMDQ_IDX]; if (!q_info) { - dprintk(VIDC_ERR, "cannot write to shared Q's\n"); + s_vpr_e(sid, "cannot write to shared Q's\n"); goto err_q_null; } if (!q_info->q_array.align_virtual_addr) { - dprintk(VIDC_ERR, "cannot write to shared CMD Q's\n"); + s_vpr_e(sid, "cannot write to shared CMD Q's\n"); result = -ENODATA; goto err_q_null; } __sim_modify_cmd_packet((u8 *)pkt, device); - if (__resume(device)) { - dprintk(VIDC_ERR, "%s: Power on failed\n", __func__); + if (__resume(device, sid)) { + s_vpr_e(sid, "%s: Power on failed\n", __func__); goto err_q_write; } - if (!__write_queue(q_info, (u8 *)pkt, requires_interrupt)) { + if (!__write_queue(q_info, (u8 *)pkt, requires_interrupt, sid)) { if (device->res->sw_power_collapsible) { cancel_delayed_work(&venus_hfi_pm_work); if (!queue_delayed_work(device->venus_pm_workq, &venus_hfi_pm_work, msecs_to_jiffies( device->res->msm_vidc_pwr_collapse_delay))) { - dprintk(VIDC_LOW, - "PM work already scheduled\n"); + s_vpr_l(sid, "PM work already scheduled\n"); } } result = 0; } else { - dprintk(VIDC_ERR, "__iface_cmdq_write: queue full\n"); + s_vpr_e(sid, "__iface_cmdq_write: queue full\n"); } err_q_write: @@ -1434,19 +1416,20 @@ err_q_null: return result; } -static void __raise_interrupt_common(struct venus_hfi_device *device) +static void __raise_interrupt_common(struct venus_hfi_device *device, u32 sid) { __write_register(device, CPU_IC_SOFTINT, - 1 << CPU_IC_SOFTINT_H2A_SHFT); + 1 << CPU_IC_SOFTINT_H2A_SHFT, sid); } -static int __iface_cmdq_write(struct venus_hfi_device *device, void *pkt) +static int __iface_cmdq_write(struct venus_hfi_device *device, + void *pkt, u32 sid) { bool needs_interrupt = false; - int rc = __iface_cmdq_write_relaxed(device, pkt, &needs_interrupt); + int rc = __iface_cmdq_write_relaxed(device, pkt, &needs_interrupt, sid); if (!rc && needs_interrupt) - call_venus_op(device, raise_interrupt, device); + call_venus_op(device, raise_interrupt, device, sid); return rc; } @@ -1458,21 +1441,21 @@ static int __iface_msgq_read(struct venus_hfi_device *device, void *pkt) struct vidc_iface_q_info *q_info; if (!pkt) { - dprintk(VIDC_ERR, "Invalid Params\n"); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } __strict_check(device); if (!__core_in_valid_state(device)) { - dprintk(VIDC_ERR, "%s - fw not in init state\n", __func__); + d_vpr_e("%s: fw not in init state\n", __func__); rc = -EINVAL; goto read_error_null; } q_info = &device->iface_queues[VIDC_IFACEQ_MSGQ_IDX]; if (!q_info->q_array.align_virtual_addr) { - dprintk(VIDC_ERR, "cannot read from shared MSG Q's\n"); + d_vpr_e("cannot read from shared MSG Q's\n"); rc = -ENODATA; goto read_error_null; } @@ -1480,7 +1463,8 @@ static int __iface_msgq_read(struct venus_hfi_device *device, void *pkt) if (!__read_queue(q_info, (u8 *)pkt, &tx_req_is_set)) { __hal_sim_modify_msg_packet((u8 *)pkt, device); if (tx_req_is_set) - call_venus_op(device, raise_interrupt, device); + call_venus_op(device, raise_interrupt, device, + DEFAULT_SID); rc = 0; } else rc = -ENODATA; @@ -1496,7 +1480,7 @@ static int __iface_dbgq_read(struct venus_hfi_device *device, void *pkt) struct vidc_iface_q_info *q_info; if (!pkt) { - dprintk(VIDC_ERR, "Invalid Params\n"); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } @@ -1504,14 +1488,15 @@ static int __iface_dbgq_read(struct venus_hfi_device *device, void *pkt) q_info = &device->iface_queues[VIDC_IFACEQ_DBGQ_IDX]; if (!q_info->q_array.align_virtual_addr) { - dprintk(VIDC_ERR, "cannot read from shared DBG Q's\n"); + d_vpr_e("cannot read from shared DBG Q's\n"); rc = -ENODATA; goto dbg_error_null; } if (!__read_queue(q_info, (u8 *)pkt, &tx_req_is_set)) { if (tx_req_is_set) - call_venus_op(device, raise_interrupt, device); + call_venus_op(device, raise_interrupt, device, + DEFAULT_SID); rc = 0; } else rc = -ENODATA; @@ -1543,7 +1528,7 @@ static void __interface_dsp_queues_release(struct venus_hfi_device *device) struct context_bank_info *cb = mem_data->mapping_info.cb_info; if (!device->dsp_iface_q_table.align_virtual_addr) { - dprintk(VIDC_ERR, "%s: already released\n", __func__); + d_vpr_e("%s: already released\n", __func__); return; } @@ -1584,24 +1569,22 @@ static int __interface_dsp_queues_init(struct venus_hfi_device *dev) kvaddr = dma_alloc_coherent(dev->res->mem_cdsp.dev, q_size, &dma_handle, GFP_KERNEL); if (IS_ERR_OR_NULL(kvaddr)) { - dprintk(VIDC_ERR, "%s: failed dma allocation\n", __func__); + d_vpr_e("%s: failed dma allocation\n", __func__); goto fail_dma_alloc; } cb = msm_smem_get_context_bank(MSM_VIDC_UNKNOWN, 0, - dev->res, HAL_BUFFER_INTERNAL_CMD_QUEUE); + dev->res, HAL_BUFFER_INTERNAL_CMD_QUEUE, DEFAULT_SID); if (!cb) { - dprintk(VIDC_ERR, - "%s: failed to get context bank\n", __func__); + d_vpr_e("%s: failed to get context bank\n", __func__); goto fail_dma_map; } iova = dma_map_single_attrs(cb->dev, phys_to_virt(dma_handle), q_size, DMA_BIDIRECTIONAL, 0); if (dma_mapping_error(cb->dev, iova)) { - dprintk(VIDC_ERR, "%s: failed dma mapping\n", __func__); + d_vpr_e("%s: failed dma mapping\n", __func__); goto fail_dma_map; } - dprintk(VIDC_HIGH, - "%s: kvaddr %pK dma_handle %#llx iova %#llx size %zd\n", + d_vpr_h("%s: kvaddr %pK dma_handle %#llx iova %#llx size %zd\n", __func__, kvaddr, dma_handle, iova, q_size); memset(mem_data, 0, sizeof(struct msm_smem)); @@ -1690,14 +1673,14 @@ static void __interface_queues_release(struct venus_hfi_device *device) (u32)mem_map_table_base_addr; if ((unsigned long)qdss->mem_map_table_base_addr != mem_map_table_base_addr) { - dprintk(VIDC_ERR, - "Invalid mem_map_table_base_addr %#lx", + d_vpr_e("Invalid mem_map_table_base_addr %#lx", mem_map_table_base_addr); } mem_map = (struct hfi_mem_map *)(qdss + 1); cb = msm_smem_get_context_bank(MSM_VIDC_UNKNOWN, - false, device->res, HAL_BUFFER_INTERNAL_CMD_QUEUE); + false, device->res, HAL_BUFFER_INTERNAL_CMD_QUEUE, + DEFAULT_SID); for (i = 0; cb && i < num_entries; i++) { iommu_unmap(cb->domain, @@ -1753,9 +1736,9 @@ static int __get_qdss_iommu_virtual_addr(struct venus_hfi_device *dev, IOMMU_READ | IOMMU_WRITE); if (rc) { - dprintk(VIDC_ERR, - "IOMMU QDSS mapping failed for addr %#x\n", - qdss_addr_tbl[i].start); + d_vpr_e( + "IOMMU QDSS mapping failed for addr %#x\n", + qdss_addr_tbl[i].start); rc = -ENOMEM; break; } @@ -1772,8 +1755,7 @@ static int __get_qdss_iommu_virtual_addr(struct venus_hfi_device *dev, } if (i < num_entries) { - dprintk(VIDC_ERR, - "QDSS mapping failed, Freeing other entries %d\n", i); + d_vpr_e("QDSS mapping failed, Freeing other entries %d\n", i); for (--i; domain && i >= 0; i--) { iommu_unmap(domain, @@ -1785,20 +1767,21 @@ static int __get_qdss_iommu_virtual_addr(struct venus_hfi_device *dev, return rc; } -static void __setup_ucregion_memory_map_common(struct venus_hfi_device *device) +static void __setup_ucregion_memory_map_common(struct venus_hfi_device *device, + u32 sid) { __write_register(device, UC_REGION_ADDR, - (u32)device->iface_q_table.align_device_addr); - __write_register(device, UC_REGION_SIZE, SHARED_QSIZE); + (u32)device->iface_q_table.align_device_addr, sid); + __write_register(device, UC_REGION_SIZE, SHARED_QSIZE, sid); __write_register(device, QTBL_ADDR, - (u32)device->iface_q_table.align_device_addr); - __write_register(device, QTBL_INFO, 0x01); + (u32)device->iface_q_table.align_device_addr, sid); + __write_register(device, QTBL_INFO, 0x01, sid); if (device->sfr.align_device_addr) __write_register(device, SFR_ADDR, - (u32)device->sfr.align_device_addr); + (u32)device->sfr.align_device_addr, sid); if (device->qdss.align_device_addr) __write_register(device, MMAP_ADDR, - (u32)device->qdss.align_device_addr); + (u32)device->qdss.align_device_addr, sid); } static int __interface_queues_init(struct venus_hfi_device *dev) @@ -1826,7 +1809,7 @@ static int __interface_queues_init(struct venus_hfi_device *dev) rc = __smem_alloc(dev, mem_addr, q_size, 1, SMEM_UNCACHED, HAL_BUFFER_INTERNAL_CMD_QUEUE); if (rc) { - dprintk(VIDC_ERR, "iface_q_table_alloc_fail\n"); + d_vpr_e("iface_q_table_alloc_fail\n"); goto fail_alloc_queue; } @@ -1855,7 +1838,7 @@ static int __interface_queues_init(struct venus_hfi_device *dev) ALIGNED_QDSS_SIZE, 1, SMEM_UNCACHED, HAL_BUFFER_INTERNAL_CMD_QUEUE); if (rc) { - dprintk(VIDC_ERR, + d_vpr_e( "qdss_alloc_fail: QDSS messages logging will not work\n"); dev->qdss.align_device_addr = 0; } else { @@ -1872,7 +1855,7 @@ static int __interface_queues_init(struct venus_hfi_device *dev) ALIGNED_SFR_SIZE, 1, SMEM_UNCACHED, HAL_BUFFER_INTERNAL_CMD_QUEUE); if (rc) { - dprintk(VIDC_ERR, "sfr_alloc_fail: SFR not will work\n"); + d_vpr_e("sfr_alloc_fail: SFR not will work\n"); dev->sfr.align_device_addr = 0; } else { dev->sfr.align_device_addr = mem_addr->align_device_addr - @@ -1924,17 +1907,15 @@ static int __interface_queues_init(struct venus_hfi_device *dev) mem_map = (struct hfi_mem_map *)(qdss + 1); cb = msm_smem_get_context_bank(MSM_VIDC_UNKNOWN, false, - dev->res, HAL_BUFFER_INTERNAL_CMD_QUEUE); + dev->res, HAL_BUFFER_INTERNAL_CMD_QUEUE, DEFAULT_SID); if (!cb) { - dprintk(VIDC_ERR, - "%s: failed to get context bank\n", __func__); + d_vpr_e("%s: failed to get context bank\n", __func__); return -EINVAL; } rc = __get_qdss_iommu_virtual_addr(dev, mem_map, cb->domain); if (rc) { - dprintk(VIDC_ERR, - "IOMMU mapping failed, Freeing qdss memdata\n"); + d_vpr_e("IOMMU mapping failed, Freeing qdss memdata\n"); __smem_free(dev, &dev->qdss.mem_data); dev->qdss.align_virtual_addr = NULL; dev->qdss.align_device_addr = 0; @@ -1945,18 +1926,18 @@ static int __interface_queues_init(struct venus_hfi_device *dev) if (dev->res->cvp_internal) { rc = __interface_dsp_queues_init(dev); if (rc) { - dprintk(VIDC_ERR, "dsp_queues_init failed\n"); + d_vpr_e("dsp_queues_init failed\n"); goto fail_alloc_queue; } } - call_venus_op(dev, setup_ucregion_memmap, dev); + call_venus_op(dev, setup_ucregion_memmap, dev, DEFAULT_SID); return 0; fail_alloc_queue: return -ENOMEM; } -static int __sys_set_debug(struct venus_hfi_device *device, u32 debug) +static int __sys_set_debug(struct venus_hfi_device *device, u32 debug, u32 sid) { u8 packet[VIDC_IFACEQ_VAR_SMALL_PKT_SIZE]; int rc = 0; @@ -1965,17 +1946,17 @@ static int __sys_set_debug(struct venus_hfi_device *device, u32 debug) rc = call_hfi_pkt_op(device, sys_debug_config, pkt, debug); if (rc) { - dprintk(VIDC_ERR, - "Debug mode setting to FW failed\n"); + s_vpr_e(sid, "Debug mode setting to FW failed\n"); return -ENOTEMPTY; } - if (__iface_cmdq_write(device, pkt)) + if (__iface_cmdq_write(device, pkt, sid)) return -ENOTEMPTY; return 0; } -static int __sys_set_coverage(struct venus_hfi_device *device, u32 mode) +static int __sys_set_coverage(struct venus_hfi_device *device, + u32 mode, u32 sid) { u8 packet[VIDC_IFACEQ_VAR_SMALL_PKT_SIZE]; int rc = 0; @@ -1983,15 +1964,14 @@ static int __sys_set_coverage(struct venus_hfi_device *device, u32 mode) (struct hfi_cmd_sys_set_property_packet *) &packet; rc = call_hfi_pkt_op(device, sys_coverage_config, - pkt, mode); + pkt, mode, sid); if (rc) { - dprintk(VIDC_ERR, - "Coverage mode setting to FW failed\n"); + s_vpr_e(sid, "Coverage mode setting to FW failed\n"); return -ENOTEMPTY; } - if (__iface_cmdq_write(device, pkt)) { - dprintk(VIDC_ERR, "Failed to send coverage pkt to f/w\n"); + if (__iface_cmdq_write(device, pkt, sid)) { + s_vpr_e(sid, "Failed to send coverage pkt to f/w\n"); return -ENOTEMPTY; } @@ -1999,7 +1979,7 @@ static int __sys_set_coverage(struct venus_hfi_device *device, u32 mode) } static int __sys_set_power_control(struct venus_hfi_device *device, - bool enable) + bool enable, u32 sid) { struct regulator_info *rinfo; bool supported = false; @@ -2018,7 +1998,7 @@ static int __sys_set_power_control(struct venus_hfi_device *device, return 0; call_hfi_pkt_op(device, sys_power_control, pkt, enable); - if (__iface_cmdq_write(device, pkt)) + if (__iface_cmdq_write(device, pkt, sid)) return -ENOTEMPTY; return 0; } @@ -2031,13 +2011,13 @@ static int venus_hfi_core_init(void *device) struct venus_hfi_device *dev; if (!device) { - dprintk(VIDC_ERR, "Invalid device\n"); + d_vpr_e("Invalid device\n"); return -ENODEV; } dev = device; - dprintk(VIDC_HIGH, "Core initializing\n"); + d_vpr_h("Core initializing\n"); mutex_lock(&dev->lock); @@ -2045,50 +2025,51 @@ static int venus_hfi_core_init(void *device) rc = __load_fw(dev); if (rc) { - dprintk(VIDC_ERR, "Failed to load Venus FW\n"); + d_vpr_e("Failed to load Venus FW\n"); goto err_load_fw; } __set_state(dev, VENUS_STATE_INIT); - dprintk(VIDC_HIGH, "Dev_Virt: %pa, Reg_Virt: %pK\n", + d_vpr_h("Dev_Virt: %pa, Reg_Virt: %pK\n", &dev->hal_data->firmware_base, dev->hal_data->register_base); rc = __interface_queues_init(dev); if (rc) { - dprintk(VIDC_ERR, "failed to init queues\n"); + d_vpr_e("failed to init queues\n"); rc = -ENOMEM; goto err_core_init; } - rc = call_venus_op(dev, boot_firmware, dev); + rc = call_venus_op(dev, boot_firmware, dev, DEFAULT_SID); if (rc) { - dprintk(VIDC_ERR, "Failed to start core\n"); + d_vpr_e("Failed to start core\n"); rc = -ENODEV; goto err_core_init; } rc = call_hfi_pkt_op(dev, sys_init, &pkt, HFI_VIDEO_ARCH_OX); if (rc) { - dprintk(VIDC_ERR, "Failed to create sys init pkt\n"); + d_vpr_e("Failed to create sys init pkt\n"); goto err_core_init; } - if (__iface_cmdq_write(dev, &pkt)) { + if (__iface_cmdq_write(dev, &pkt, DEFAULT_SID)) { rc = -ENOTEMPTY; goto err_core_init; } rc = call_hfi_pkt_op(dev, sys_image_version, &version_pkt); - if (rc || __iface_cmdq_write(dev, &version_pkt)) - dprintk(VIDC_ERR, "Failed to send image version pkt to f/w\n"); + if (rc || __iface_cmdq_write(dev, &version_pkt, DEFAULT_SID)) + d_vpr_e("Failed to send image version pkt to f/w\n"); - __sys_set_debug(device, (msm_vidc_debug & FW_LOGMASK) >> FW_LOGSHIFT); + __sys_set_debug(device, (msm_vidc_debug & FW_LOGMASK) >> FW_LOGSHIFT, + DEFAULT_SID); - __enable_subcaches(device); - __set_subcaches(device); + __enable_subcaches(device, DEFAULT_SID); + __set_subcaches(device, DEFAULT_SID); __dsp_send_hfi_queue(device); __set_ubwc_config(device); @@ -2101,14 +2082,14 @@ static int venus_hfi_core_init(void *device) pm_qos_add_request(&dev->qos, PM_QOS_CPU_DMA_LATENCY, dev->res->pm_qos_latency_us); } - dprintk(VIDC_HIGH, "Core inited successfully\n"); + d_vpr_h("Core inited successfully\n"); mutex_unlock(&dev->lock); return rc; err_core_init: __set_state(dev, VENUS_STATE_DEINIT); __unload_fw(dev); err_load_fw: - dprintk(VIDC_ERR, "Core init failed\n"); + d_vpr_e("Core init failed\n"); mutex_unlock(&dev->lock); return rc; } @@ -2120,17 +2101,17 @@ static int venus_hfi_core_release(void *dev) struct hal_session *session, *next; if (!device) { - dprintk(VIDC_ERR, "invalid device\n"); + d_vpr_e("invalid device\n"); return -ENODEV; } mutex_lock(&device->lock); - dprintk(VIDC_HIGH, "Core releasing\n"); + d_vpr_h("Core releasing\n"); if (device->res->pm_qos_latency_us && pm_qos_request_active(&device->qos)) pm_qos_remove_request(&device->qos); - __resume(device); + __resume(device, DEFAULT_SID); __set_state(device, VENUS_STATE_DEINIT); __dsp_shutdown(device, 0); @@ -2140,7 +2121,7 @@ static int venus_hfi_core_release(void *dev) list_for_each_entry_safe(session, next, &device->sess_head, list) list_del(&session->list); - dprintk(VIDC_HIGH, "Core released successfully\n"); + d_vpr_h("Core released successfully\n"); mutex_unlock(&device->lock); return rc; @@ -2153,19 +2134,19 @@ static int __get_q_size(struct venus_hfi_device *dev, unsigned int q_index) u32 write_ptr, read_ptr; if (q_index >= VIDC_IFACEQ_NUMQ) { - dprintk(VIDC_ERR, "Invalid q index: %d\n", q_index); + d_vpr_e("Invalid q index: %d\n", q_index); return -ENOENT; } q_info = &dev->iface_queues[q_index]; if (!q_info) { - dprintk(VIDC_ERR, "cannot read shared Q's\n"); + d_vpr_e("cannot read shared Q's\n"); return -ENOENT; } queue = (struct hfi_queue_header *)q_info->q_hdr; if (!queue) { - dprintk(VIDC_ERR, "queue not present\n"); + d_vpr_e("queue not present\n"); return -ENOENT; } @@ -2179,11 +2160,11 @@ static void __core_clear_interrupt_common(struct venus_hfi_device *device) u32 intr_status = 0, mask = 0; if (!device) { - dprintk(VIDC_ERR, "%s: NULL device\n", __func__); + d_vpr_e("%s: NULL device\n", __func__); return; } - intr_status = __read_register(device, WRAPPER_INTR_STATUS); + intr_status = __read_register(device, WRAPPER_INTR_STATUS, DEFAULT_SID); mask = (WRAPPER_INTR_STATUS_A2H_BMSK | WRAPPER_INTR_STATUS_A2HWD_BMSK | CTRL_INIT_IDLE_MSG_BMSK); @@ -2191,15 +2172,14 @@ static void __core_clear_interrupt_common(struct venus_hfi_device *device) if (intr_status & mask) { device->intr_status |= intr_status; device->reg_count++; - dprintk(VIDC_LOW, - "INTERRUPT for device: %pK: times: %d interrupt_status: %d\n", - device, device->reg_count, intr_status); + d_vpr_l("INTERRUPT: times: %d interrupt_status: %d\n", + device->reg_count, intr_status); } else { device->spur_count++; } - __write_register(device, CPU_CS_A2HSOFTINTCLR, 1); - __write_register(device, WRAPPER_INTR_CLEAR, intr_status); + __write_register(device, CPU_CS_A2HSOFTINTCLR, 1, DEFAULT_SID); + __write_register(device, WRAPPER_INTR_CLEAR, intr_status, DEFAULT_SID); } static int venus_hfi_core_trigger_ssr(void *device, @@ -2210,7 +2190,7 @@ static int venus_hfi_core_trigger_ssr(void *device, struct venus_hfi_device *dev; if (!device) { - dprintk(VIDC_ERR, "invalid device\n"); + d_vpr_e("invalid device\n"); return -ENODEV; } @@ -2219,11 +2199,11 @@ static int venus_hfi_core_trigger_ssr(void *device, rc = call_hfi_pkt_op(dev, ssr_cmd, type, &pkt); if (rc) { - dprintk(VIDC_ERR, "core_ping: failed to create packet\n"); + d_vpr_e("core_ping: failed to create packet\n"); goto err_create_pkt; } - if (__iface_cmdq_write(dev, &pkt)) + if (__iface_cmdq_write(dev, &pkt, DEFAULT_SID)) rc = -ENOTEMPTY; err_create_pkt: @@ -2243,27 +2223,28 @@ static int venus_hfi_session_set_property(void *sess, mutex_lock(&device->lock); - dprintk(VIDC_HIGH, "in set_prop,with prop id: %#x\n", ptype); if (!__is_session_valid(device, session, __func__)) { rc = -EINVAL; goto err_set_prop; } + s_vpr_h(session->sid, "in set_prop,with prop id: %#x\n", ptype); rc = call_hfi_pkt_op(device, session_set_property, - pkt, session, ptype, pdata, size); + pkt, session->sid, ptype, pdata, size); if (rc == -ENOTSUPP) { - dprintk(VIDC_ERR, + s_vpr_e(session->sid, "set property: unsupported prop id: %#x\n", ptype); rc = 0; goto err_set_prop; } else if (rc) { - dprintk(VIDC_ERR, "set property: failed to create packet\n"); + s_vpr_e(session->sid, + "set property: failed to create packet\n"); rc = -EINVAL; goto err_set_prop; } - if (__iface_cmdq_write(device, pkt)) { + if (__iface_cmdq_write(device, pkt, session->sid)) { rc = -ENOTEMPTY; goto err_set_prop; } @@ -2273,13 +2254,14 @@ err_set_prop: return rc; } -static void __set_default_sys_properties(struct venus_hfi_device *device) +static void __set_default_sys_properties(struct venus_hfi_device *device, + u32 sid) { if (__sys_set_debug(device, - (msm_vidc_debug & FW_LOGMASK) >> FW_LOGSHIFT)) - dprintk(VIDC_ERR, "Setting fw_debug msg ON failed\n"); - if (__sys_set_power_control(device, true)) - dprintk(VIDC_ERR, "Setting h/w power collapse ON failed\n"); + (msm_vidc_debug & FW_LOGMASK) >> FW_LOGSHIFT, sid)) + s_vpr_e(sid, "Setting fw_debug msg ON failed\n"); + if (__sys_set_power_control(device, true, sid)) + s_vpr_e(sid, "Setting h/w power collapse ON failed\n"); } static void __session_clean(struct hal_session *session) @@ -2289,7 +2271,7 @@ static void __session_clean(struct hal_session *session) if (!__is_session_valid(device, session, __func__)) return; - dprintk(VIDC_HIGH, "deleted the session: %pK\n", session); + s_vpr_h(session->sid, "deleted the session: %pK\n", session); /* * session might have been removed from the device list in * core_release, so check and remove if it is in the list @@ -2316,16 +2298,16 @@ static int venus_hfi_session_clean(void *sess) return 0; } -static int venus_hfi_session_init(void *device, void *session_id, +static int venus_hfi_session_init(void *device, void *inst_id, enum hal_domain session_type, enum hal_video_codec codec_type, - void **new_session) + void **new_session, u32 sid) { struct hfi_cmd_sys_session_init_packet pkt; struct venus_hfi_device *dev; struct hal_session *s; if (!device || !new_session) { - dprintk(VIDC_ERR, "%s - invalid input\n", __func__); + d_vpr_e("%s: invalid input\n", __func__); return -EINVAL; } @@ -2334,30 +2316,30 @@ static int venus_hfi_session_init(void *device, void *session_id, s = kzalloc(sizeof(struct hal_session), GFP_KERNEL); if (!s) { - dprintk(VIDC_ERR, "new session fail: Out of memory\n"); + s_vpr_e(sid, "new session fail: Out of memory\n"); goto err_session_init_fail; } - s->session_id = session_id; + s->inst_id = inst_id; s->is_decoder = (session_type == HAL_VIDEO_DOMAIN_DECODER); s->codec = codec_type; s->domain = session_type; - dprintk(VIDC_HIGH|VIDC_PERF, - "%s: inst %pK, session %pK, codec 0x%x, domain 0x%x\n", - __func__, session_id, s, s->codec, s->domain); + s->sid = sid; + s_vpr_hp(sid, "%s: inst %pK, session %pK, codec 0x%x, domain 0x%x\n", + __func__, inst_id, s, s->codec, s->domain); list_add_tail(&s->list, &dev->sess_head); - __set_default_sys_properties(device); + __set_default_sys_properties(device, sid); if (call_hfi_pkt_op(dev, session_init, &pkt, - s, session_type, codec_type)) { - dprintk(VIDC_ERR, "session_init: failed to create packet\n"); + sid, session_type, codec_type)) { + s_vpr_e(sid, "session_init: failed to create packet\n"); goto err_session_init_fail; } *new_session = s; - if (__iface_cmdq_write(dev, &pkt)) + if (__iface_cmdq_write(dev, &pkt, sid)) goto err_session_init_fail; mutex_unlock(&dev->lock); @@ -2381,16 +2363,16 @@ static int __send_session_cmd(struct hal_session *session, int pkt_type) return -EINVAL; rc = call_hfi_pkt_op(device, session_cmd, - &pkt, pkt_type, session); + &pkt, pkt_type, session->sid); if (rc == -EPERM) return 0; if (rc) { - dprintk(VIDC_ERR, "send session cmd: create pkt failed\n"); + s_vpr_e(session->sid, "send session cmd: create pkt failed\n"); goto err_create_pkt; } - if (__iface_cmdq_write(device, &pkt)) + if (__iface_cmdq_write(device, &pkt, session->sid)) rc = -ENOTEMPTY; err_create_pkt: @@ -2403,15 +2385,16 @@ static int venus_hfi_session_end(void *sess) struct venus_hfi_device *device = &venus_hfi_dev; int rc = 0; + if (!__is_session_valid(device, session, __func__)) + return -EINVAL; + mutex_lock(&device->lock); - if (msm_vidc_fw_coverage) { - if (__sys_set_coverage(device, msm_vidc_fw_coverage)) - dprintk(VIDC_ERR, "Fw_coverage msg ON failed\n"); + if (__sys_set_coverage(device, msm_vidc_fw_coverage, + session->sid)) + s_vpr_e(session->sid, "Fw_coverage msg ON failed\n"); } - rc = __send_session_cmd(session, HFI_CMD_SYS_SESSION_END); - mutex_unlock(&device->lock); return rc; @@ -2443,7 +2426,7 @@ static int venus_hfi_session_set_buffers(void *sess, struct venus_hfi_device *device = &venus_hfi_dev; if (!buffer_info) { - dprintk(VIDC_ERR, "Invalid Params\n"); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } @@ -2465,14 +2448,14 @@ static int venus_hfi_session_set_buffers(void *sess, pkt = (struct hfi_cmd_session_set_buffers_packet *)packet; rc = call_hfi_pkt_op(device, session_set_buffers, - pkt, session, buffer_info); + pkt, session->sid, buffer_info); if (rc) { - dprintk(VIDC_ERR, "set buffers: failed to create packet\n"); + s_vpr_e(session->sid, "set buffers: failed to create packet\n"); goto err_create_pkt; } - dprintk(VIDC_HIGH, "set buffers: %#x\n", buffer_info->buffer_type); - if (__iface_cmdq_write(device, pkt)) + s_vpr_h(session->sid, "set buffers: %#x\n", buffer_info->buffer_type); + if (__iface_cmdq_write(device, pkt, session->sid)) rc = -ENOTEMPTY; err_create_pkt: @@ -2490,7 +2473,7 @@ static int venus_hfi_session_release_buffers(void *sess, struct venus_hfi_device *device = &venus_hfi_dev; if (!buffer_info) { - dprintk(VIDC_ERR, "Invalid Params\n"); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } @@ -2508,14 +2491,16 @@ static int venus_hfi_session_release_buffers(void *sess, pkt = (struct hfi_cmd_session_release_buffer_packet *) packet; rc = call_hfi_pkt_op(device, session_release_buffers, - pkt, session, buffer_info); + pkt, session->sid, buffer_info); if (rc) { - dprintk(VIDC_ERR, "release buffers: failed to create packet\n"); + s_vpr_e(session->sid, "%s: failed to create packet\n", + __func__); goto err_create_pkt; } - dprintk(VIDC_HIGH, "Release buffers: %#x\n", buffer_info->buffer_type); - if (__iface_cmdq_write(device, pkt)) + s_vpr_h(session->sid, "Release buffers: %#x\n", + buffer_info->buffer_type); + if (__iface_cmdq_write(device, pkt, session->sid)) rc = -ENOTEMPTY; err_create_pkt: @@ -2533,7 +2518,7 @@ static int venus_hfi_session_register_buffer(void *sess, struct venus_hfi_device *device = &venus_hfi_dev; if (!buffer) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } @@ -2544,12 +2529,13 @@ static int venus_hfi_session_register_buffer(void *sess, } pkt = (struct hfi_cmd_session_register_buffers_packet *)packet; rc = call_hfi_pkt_op(device, session_register_buffer, pkt, - session, buffer); + session->sid, buffer); if (rc) { - dprintk(VIDC_ERR, "%s: failed to create packet\n", __func__); + s_vpr_e(session->sid, + "%s: failed to create packet\n", __func__); goto exit; } - if (__iface_cmdq_write(device, pkt)) + if (__iface_cmdq_write(device, pkt, session->sid)) rc = -ENOTEMPTY; exit: mutex_unlock(&device->lock); @@ -2567,7 +2553,7 @@ static int venus_hfi_session_unregister_buffer(void *sess, struct venus_hfi_device *device = &venus_hfi_dev; if (!buffer) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } @@ -2578,12 +2564,13 @@ static int venus_hfi_session_unregister_buffer(void *sess, } pkt = (struct hfi_cmd_session_unregister_buffers_packet *)packet; rc = call_hfi_pkt_op(device, session_unregister_buffer, pkt, - session, buffer); + session->sid, buffer); if (rc) { - dprintk(VIDC_ERR, "%s: failed to create packet\n", __func__); + s_vpr_e(session->sid, + "%s: failed to create packet\n", __func__); goto exit; } - if (__iface_cmdq_write(device, pkt)) + if (__iface_cmdq_write(device, pkt, session->sid)) rc = -ENOTEMPTY; exit: mutex_unlock(&device->lock); @@ -2669,17 +2656,18 @@ static int __session_etb(struct hal_session *session, struct hfi_cmd_session_empty_buffer_compressed_packet pkt; rc = call_hfi_pkt_op(device, session_etb_decoder, - &pkt, session, input_frame); + &pkt, session->sid, input_frame); if (rc) { - dprintk(VIDC_ERR, - "Session etb decoder: failed to create pkt\n"); + s_vpr_e(session->sid, + "etb decoder: failed to create pkt\n"); goto err_create_pkt; } if (!relaxed) - rc = __iface_cmdq_write(device, &pkt); + rc = __iface_cmdq_write(device, &pkt, session->sid); else - rc = __iface_cmdq_write_relaxed(device, &pkt, NULL); + rc = __iface_cmdq_write_relaxed(device, + &pkt, NULL, session->sid); if (rc) goto err_create_pkt; } else { @@ -2687,17 +2675,18 @@ static int __session_etb(struct hal_session *session, pkt; rc = call_hfi_pkt_op(device, session_etb_encoder, - &pkt, session, input_frame); + &pkt, session->sid, input_frame); if (rc) { - dprintk(VIDC_ERR, - "Session etb encoder: failed to create pkt\n"); + s_vpr_e(session->sid, + "etb encoder: failed to create pkt\n"); goto err_create_pkt; } if (!relaxed) - rc = __iface_cmdq_write(device, &pkt); + rc = __iface_cmdq_write(device, &pkt, session->sid); else - rc = __iface_cmdq_write_relaxed(device, &pkt, NULL); + rc = __iface_cmdq_write_relaxed(device, + &pkt, NULL, session->sid); if (rc) goto err_create_pkt; } @@ -2714,7 +2703,7 @@ static int venus_hfi_session_etb(void *sess, struct venus_hfi_device *device = &venus_hfi_dev; if (!input_frame) { - dprintk(VIDC_ERR, "Invalid Params\n"); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } @@ -2735,16 +2724,17 @@ static int __session_ftb(struct hal_session *session, return -EINVAL; rc = call_hfi_pkt_op(device, session_ftb, - &pkt, session, output_frame); + &pkt, session->sid, output_frame); if (rc) { - dprintk(VIDC_ERR, "Session ftb: failed to create pkt\n"); + s_vpr_e(session->sid, "Session ftb: failed to create pkt\n"); goto err_create_pkt; } if (!relaxed) - rc = __iface_cmdq_write(device, &pkt); + rc = __iface_cmdq_write(device, &pkt, session->sid); else - rc = __iface_cmdq_write_relaxed(device, &pkt, NULL); + rc = __iface_cmdq_write_relaxed(device, + &pkt, NULL, session->sid); err_create_pkt: return rc; @@ -2758,7 +2748,7 @@ static int venus_hfi_session_ftb(void *sess, struct venus_hfi_device *device = &venus_hfi_dev; if (!output_frame) { - dprintk(VIDC_ERR, "Invalid Params\n"); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } @@ -2787,8 +2777,8 @@ static int venus_hfi_session_process_batch(void *sess, for (c = 0; c < num_ftbs; ++c) { rc = __session_ftb(session, &ftbs[c], true); if (rc) { - dprintk(VIDC_ERR, "Failed to queue batched ftb: %d\n", - rc); + s_vpr_e(session->sid, + "Failed to queue batched ftb: %d\n", rc); goto err_etbs_and_ftbs; } } @@ -2796,19 +2786,19 @@ static int venus_hfi_session_process_batch(void *sess, for (c = 0; c < num_etbs; ++c) { rc = __session_etb(session, &etbs[c], true); if (rc) { - dprintk(VIDC_ERR, "Failed to queue batched etb: %d\n", - rc); + s_vpr_e(session->sid, + "Failed to queue batched etb: %d\n", rc); goto err_etbs_and_ftbs; } } - rc = call_hfi_pkt_op(device, session_sync_process, &pkt, session); + rc = call_hfi_pkt_op(device, session_sync_process, &pkt, session->sid); if (rc) { - dprintk(VIDC_ERR, "Failed to create sync packet\n"); + s_vpr_e(session->sid, "Failed to create sync packet\n"); goto err_etbs_and_ftbs; } - if (__iface_cmdq_write(device, &pkt)) + if (__iface_cmdq_write(device, &pkt, session->sid)) rc = -ENOTEMPTY; err_etbs_and_ftbs: @@ -2830,14 +2820,13 @@ static int venus_hfi_session_get_buf_req(void *sess) goto err_create_pkt; } rc = call_hfi_pkt_op(device, session_get_buf_req, - &pkt, session); + &pkt, session->sid); if (rc) { - dprintk(VIDC_ERR, - "Session get buf req: failed to create pkt\n"); + s_vpr_e(session->sid, "%s: failed to create pkt\n", __func__); goto err_create_pkt; } - if (__iface_cmdq_write(device, &pkt)) + if (__iface_cmdq_write(device, &pkt, session->sid)) rc = -ENOTEMPTY; err_create_pkt: mutex_unlock(&device->lock); @@ -2852,19 +2841,18 @@ static int venus_hfi_session_flush(void *sess, enum hal_flush flush_mode) struct venus_hfi_device *device = &venus_hfi_dev; mutex_lock(&device->lock); - if (!__is_session_valid(device, session, __func__)) { rc = -ENODEV; goto err_create_pkt; } rc = call_hfi_pkt_op(device, session_flush, - &pkt, session, flush_mode); + &pkt, session->sid, flush_mode); if (rc) { - dprintk(VIDC_ERR, "Session flush: failed to create pkt\n"); + s_vpr_e(session->sid, "Session flush: failed to create pkt\n"); goto err_create_pkt; } - if (__iface_cmdq_write(device, &pkt)) + if (__iface_cmdq_write(device, &pkt, session->sid)) rc = -ENOTEMPTY; err_create_pkt: mutex_unlock(&device->lock); @@ -2880,7 +2868,7 @@ static int __check_core_registered(struct hal_device_data core, struct list_head *curr, *next; if (!core.dev_count) { - dprintk(VIDC_ERR, "no device Registered\n"); + d_vpr_e("no device Registered\n"); return -EINVAL; } @@ -2911,7 +2899,7 @@ static int __check_core_registered(struct hal_device_data core, return 0; } - dprintk(VIDC_ERR, "Device not registered\n"); + d_vpr_e("Device not registered\n"); return -EINVAL; } return -EINVAL; @@ -2933,14 +2921,14 @@ int __prepare_pc(struct venus_hfi_device *device) rc = call_hfi_pkt_op(device, sys_pc_prep, &pkt); if (rc) { - dprintk(VIDC_ERR, "Failed to create sys pc prep pkt\n"); + d_vpr_e("Failed to create sys pc prep pkt\n"); goto err_pc_prep; } - if (__iface_cmdq_write(device, &pkt)) + if (__iface_cmdq_write(device, &pkt, DEFAULT_SID)) rc = -ENOTEMPTY; if (rc) - dprintk(VIDC_ERR, "Failed to prepare venus for power off"); + d_vpr_e("Failed to prepare venus for power off"); err_pc_prep: return rc; } @@ -2952,17 +2940,17 @@ static void venus_hfi_pm_handler(struct work_struct *work) &hal_ctxt.dev_head, struct venus_hfi_device, list); if (!device) { - dprintk(VIDC_ERR, "%s: NULL device\n", __func__); + d_vpr_e("%s: NULL device\n", __func__); return; } - dprintk(VIDC_HIGH, "Entering %s\n", __func__); + d_vpr_h("Entering %s\n", __func__); /* * It is ok to check this variable outside the lock since * it is being updated in this context only */ if (device->skip_pc_count >= VIDC_MAX_PC_SKIP_COUNT) { - dprintk(VIDC_ERR, "Failed to PC for %d times\n", + d_vpr_e("Failed to PC for %d times\n", device->skip_pc_count); device->skip_pc_count = 0; __process_fatal_error(device); @@ -2977,26 +2965,25 @@ static void venus_hfi_pm_handler(struct work_struct *work) device->skip_pc_count = 0; /* Cancel pending delayed works if any */ cancel_delayed_work(&venus_hfi_pm_work); - dprintk(VIDC_HIGH, "%s: power collapse successful!\n", - __func__); + d_vpr_h("%s: power collapse successful!\n", __func__); break; case -EBUSY: device->skip_pc_count = 0; - dprintk(VIDC_HIGH, "%s: retry PC as dsp is busy\n", __func__); + d_vpr_h("%s: retry PC as dsp is busy\n", __func__); queue_delayed_work(device->venus_pm_workq, &venus_hfi_pm_work, msecs_to_jiffies( device->res->msm_vidc_pwr_collapse_delay)); break; case -EAGAIN: device->skip_pc_count++; - dprintk(VIDC_ERR, "%s: retry power collapse (count %d)\n", + d_vpr_e("%s: retry power collapse (count %d)\n", __func__, device->skip_pc_count); queue_delayed_work(device->venus_pm_workq, &venus_hfi_pm_work, msecs_to_jiffies( device->res->msm_vidc_pwr_collapse_delay)); break; default: - dprintk(VIDC_ERR, "%s: power collapse failed\n", __func__); + d_vpr_e("%s: power collapse failed\n", __func__); break; } } @@ -3009,32 +2996,32 @@ static int __prepare_pc_common(struct venus_hfi_device *device) int count = 0; const int max_tries = 10; - ctrl_status = __read_register(device, CTRL_STATUS); + ctrl_status = __read_register(device, CTRL_STATUS, DEFAULT_SID); pc_ready = ctrl_status & CTRL_STATUS_PC_READY; idle_status = ctrl_status & BIT(30); if (pc_ready) { - dprintk(VIDC_HIGH, "Already in pc_ready state\n"); + d_vpr_h("Already in pc_ready state\n"); return 0; } wfi_status = BIT(0) & __read_register(device, - WRAPPER_CPU_STATUS); + WRAPPER_CPU_STATUS, DEFAULT_SID); if (!wfi_status || !idle_status) { - dprintk(VIDC_ERR, "Skipping PC, wfi status not set\n"); + d_vpr_e("Skipping PC, wfi status not set\n"); goto skip_power_off; } rc = __prepare_pc(device); if (rc) { - dprintk(VIDC_ERR, "Failed __prepare_pc %d\n", rc); + d_vpr_e("Failed __prepare_pc %d\n", rc); goto skip_power_off; } while (count < max_tries) { wfi_status = BIT(0) & __read_register(device, - WRAPPER_CPU_STATUS); - ctrl_status = __read_register(device, CTRL_STATUS); + WRAPPER_CPU_STATUS, DEFAULT_SID); + ctrl_status = __read_register(device, CTRL_STATUS, DEFAULT_SID); if (wfi_status && (ctrl_status & CTRL_STATUS_PC_READY)) break; usleep_range(150, 250); @@ -3042,14 +3029,14 @@ static int __prepare_pc_common(struct venus_hfi_device *device) } if (count == max_tries) { - dprintk(VIDC_ERR, "Skip PC. Core is not in right state\n"); + d_vpr_e("Skip PC. Core is not in right state\n"); goto skip_power_off; } return rc; skip_power_off: - dprintk(VIDC_ERR, "Skip PC, wfi=%#x, idle=%#x, pcr=%#x, ctrl=%#x)\n", + d_vpr_e("Skip PC, wfi=%#x, idle=%#x, pcr=%#x, ctrl=%#x)\n", wfi_status, idle_status, pc_ready, ctrl_status); return -EAGAIN; } @@ -3060,17 +3047,16 @@ static int __power_collapse(struct venus_hfi_device *device, bool force) u32 flags = 0; if (!device) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } if (!device->power_enabled) { - dprintk(VIDC_HIGH, "%s: Power already disabled\n", - __func__); + d_vpr_h("%s: Power already disabled\n", __func__); goto exit; } if (!__core_in_valid_state(device)) { - dprintk(VIDC_ERR, "%s - Core not in init state\n", __func__); + d_vpr_e("%s: Core not in init state\n", __func__); return -EINVAL; } @@ -3088,7 +3074,7 @@ static int __power_collapse(struct venus_hfi_device *device, bool force) rc = __suspend(device); if (rc) - dprintk(VIDC_ERR, "Failed __suspend\n"); + d_vpr_e("Failed __suspend\n"); exit: return rc; @@ -3112,8 +3098,7 @@ static void __process_sys_error(struct venus_hfi_device *device) if (p == NULL) vsfr->rg_data[vsfr->bufSize - 1] = '\0'; - dprintk(VIDC_ERR, "SFR Message from FW: %s\n", - vsfr->rg_data); + d_vpr_e("SFR Message from FW: %s\n", vsfr->rg_data); } } @@ -3123,15 +3108,14 @@ static void __flush_debug_queue(struct venus_hfi_device *device, u8 *packet) enum vidc_msg_prio log_level = msm_vidc_debug; if (!device) { - dprintk(VIDC_ERR, "%s: Invalid params\n", __func__); + d_vpr_e("%s: invalid params\n", __func__); return; } if (!packet) { packet = kzalloc(VIDC_IFACEQ_VAR_HUGE_PKT_SIZE, GFP_KERNEL); if (!packet) { - dprintk(VIDC_ERR, "In %s() Fail to allocate mem\n", - __func__); + d_vpr_e("In %s() Fail to allocate mem\n", __func__); return; } @@ -3149,8 +3133,7 @@ static void __flush_debug_queue(struct venus_hfi_device *device, u8 *packet) payload_size < MIN_PAYLOAD_SIZE || \ payload_size > \ (pkt_size - pkt_hdr_size + sizeof(u8))) { \ - dprintk(VIDC_ERR, \ - "%s: invalid msg size - %d\n", \ + d_vpr_e("%s: invalid msg size - %d\n", \ __func__, pkt->msg_size); \ continue; \ } \ @@ -3161,8 +3144,7 @@ static void __flush_debug_queue(struct venus_hfi_device *device, u8 *packet) (struct hfi_packet_header *) packet; if (pkt->size < sizeof(struct hfi_packet_header)) { - dprintk(VIDC_ERR, "Invalid pkt size - %s\n", - __func__); + d_vpr_e("Invalid pkt size - %s\n", __func__); continue; } @@ -3177,8 +3159,7 @@ static void __flush_debug_queue(struct venus_hfi_device *device, u8 *packet) stm_size = stm_log_inv_ts(0, 0, pkt->rg_msg_data, pkt->msg_size); if (stm_size == 0) - dprintk(VIDC_ERR, - "In %s, stm_log returned size of 0\n", + d_vpr_e("In %s, stm_log returned size of 0\n", __func__); } else if (pkt->packet_type == HFI_MSG_SYS_DEBUG) { @@ -3218,18 +3199,17 @@ static bool __is_session_valid(struct venus_hfi_device *device, return true; invalid: - dprintk(VIDC_ERR, "%s: device %pK, invalid session %pK\n", - func, device, session); + d_vpr_e("%s: device %pK, invalid session %pK\n", func, device, session); return false; } static struct hal_session *__get_session(struct venus_hfi_device *device, - u32 session_id) + u32 sid) { struct hal_session *temp = NULL; list_for_each_entry(temp, &device->sess_head, list) { - if (session_id == hash32_ptr(temp)) + if (sid == temp->sid) return temp; } @@ -3261,9 +3241,8 @@ static int __response_handler(struct venus_hfi_device *device) raw_packet = device->raw_packet; if (!raw_packet || !packets) { - dprintk(VIDC_ERR, - "%s: Invalid args : Res packet = %pK, Raw packet = %pK\n", - __func__, packets, raw_packet); + d_vpr_e("%s: Invalid args %pK, %pK\n", + __func__, raw_packet, packets); return 0; } @@ -3278,25 +3257,23 @@ static int __response_handler(struct venus_hfi_device *device) }; if (vsfr) - dprintk(VIDC_ERR, "SFR Message from FW: %s\n", - vsfr->rg_data); + d_vpr_e("SFR Message from FW: %s\n", vsfr->rg_data); - dprintk(VIDC_ERR, "Received watchdog timeout\n"); + d_vpr_e("Received watchdog timeout\n"); packets[packet_count++] = info; goto exit; } /* Bleed the msg queue dry of packets */ while (!__iface_msgq_read(device, raw_packet)) { - void **session_id = NULL; + void **inst_id = NULL; struct msm_vidc_cb_info *info = &packets[packet_count++]; int rc = 0; rc = hfi_process_msg_packet(device->device_id, (struct vidc_hal_msg_pkt_hdr *)raw_packet, info); if (rc) { - dprintk(VIDC_ERR, - "Corrupt/unknown packet found, discarding\n"); + d_vpr_e("Corrupt/unknown packet found, discarding\n"); --packet_count; continue; } @@ -3307,10 +3284,10 @@ static int __response_handler(struct venus_hfi_device *device) __process_sys_error(device); break; case HAL_SYS_RELEASE_RESOURCE_DONE: - dprintk(VIDC_HIGH, "Received SYS_RELEASE_RESOURCE\n"); + d_vpr_h("Received SYS_RELEASE_RESOURCE\n"); break; case HAL_SYS_INIT_DONE: - dprintk(VIDC_HIGH, "Received SYS_INIT_DONE\n"); + d_vpr_h("Received SYS_INIT_DONE\n"); break; case HAL_SESSION_LOAD_RESOURCE_DONE: break; @@ -3336,55 +3313,52 @@ static int __response_handler(struct venus_hfi_device *device) case HAL_SESSION_UNREGISTER_BUFFER_DONE: case HAL_SESSION_RELEASE_RESOURCE_DONE: case HAL_SESSION_PROPERTY_INFO: - session_id = &info->response.cmd.session_id; + inst_id = &info->response.cmd.inst_id; break; case HAL_SESSION_ERROR: case HAL_SESSION_ETB_DONE: case HAL_SESSION_FTB_DONE: - session_id = &info->response.data.session_id; + inst_id = &info->response.data.inst_id; break; case HAL_SESSION_EVENT_CHANGE: - session_id = &info->response.event.session_id; + inst_id = &info->response.event.inst_id; break; case HAL_RESPONSE_UNUSED: default: - session_id = NULL; + inst_id = NULL; break; } /* - * hfi_process_msg_packet provides a session_id that's a hashed - * value of struct hal_session, we need to coerce the hashed - * value back to pointer that we can use. Ideally, hfi_process\ - * _msg_packet should take care of this, but it doesn't have - * required information for it + * hfi_process_msg_packet provides a sid, we need to coerce + * the sid value back to pointer(inst_id) that we can + * use. Ideally, hfi_process_msg_packet should take care of + * this, but it doesn't have required information for it */ - if (session_id) { + if (inst_id) { struct hal_session *session = NULL; - if (upper_32_bits((uintptr_t)*session_id) != 0) { - dprintk(VIDC_ERR, - "Upper 32-bits != 0 for sess_id=%pK\n", - *session_id); + if (upper_32_bits((uintptr_t)*inst_id) != 0) { + d_vpr_e("Upper 32-bits != 0 for sess_id=%pK\n", + *inst_id); } session = __get_session(device, - (u32)(uintptr_t)*session_id); + (u32)(uintptr_t)*inst_id); if (!session) { - dprintk(VIDC_ERR, - "Received a packet (%#x) for an unrecognized session (%pK), discarding\n", - info->response_type, - *session_id); + d_vpr_e( + "Received a packet (%#x) for an unrecognized session (%pK), discarding\n", + info->response_type, *inst_id); --packet_count; continue; } - *session_id = session->session_id; + *inst_id = session->inst_id; } if (packet_count >= max_packets && __get_q_size(device, VIDC_IFACEQ_MSGQ_IDX)) { - dprintk(VIDC_ERR, - "Too many packets in message queue to handle at once, deferring read\n"); + d_vpr_e( + "Too many packets in message queue to handle at once, deferring read\n"); break; } @@ -3399,7 +3373,7 @@ static int __response_handler(struct venus_hfi_device *device) &venus_hfi_pm_work, msecs_to_jiffies( device->res->msm_vidc_pwr_collapse_delay))) { - dprintk(VIDC_ERR, "PM work already scheduled\n"); + d_vpr_e("PM work already scheduled\n"); } } @@ -3417,21 +3391,19 @@ static void venus_hfi_core_work_handler(struct work_struct *work) u32 intr_status; mutex_lock(&device->lock); - - if (!__core_in_valid_state(device)) { - dprintk(VIDC_ERR, "%s - Core not in init state\n", __func__); + d_vpr_e("%s: Core not in init state\n", __func__); goto err_no_work; } if (!device->callback) { - dprintk(VIDC_ERR, "No interrupt callback function: %pK\n", + d_vpr_e("No interrupt callback function: %pK\n", device); goto err_no_work; } - if (__resume(device)) { - dprintk(VIDC_ERR, "%s: Power enable failed\n", __func__); + if (__resume(device, DEFAULT_SID)) { + d_vpr_e("%s: Power enable failed\n", __func__); goto err_no_work; } @@ -3454,13 +3426,11 @@ err_no_work: struct msm_vidc_cb_info *r = &device->response_pkt[i]; if (!__core_in_valid_state(device)) { - dprintk(VIDC_ERR, + d_vpr_e( "Ignore responses from %d to %d as device is in invalid state", (i + 1), num_responses); break; } - dprintk(VIDC_LOW, "Processing response %d of %d, type %d\n", - (i + 1), num_responses, r->response_type); device->callback(r->response_type, &r->response); } @@ -3495,15 +3465,15 @@ static int __init_regs_and_interrupts(struct venus_hfi_device *device, (u8 *)(uintptr_t)res->register_base, res->register_size, res->irq); if (!rc) { - dprintk(VIDC_ERR, "Core present/Already added\n"); + d_vpr_e("Core present/Already added\n"); rc = -EEXIST; goto err_core_init; } - dprintk(VIDC_HIGH, "HAL_DATA will be assigned now\n"); + d_vpr_h("HAL_DATA will be assigned now\n"); hal = kzalloc(sizeof(struct hal_data), GFP_KERNEL); if (!hal) { - dprintk(VIDC_ERR, "Failed to alloc\n"); + d_vpr_e("Failed to alloc\n"); rc = -ENOMEM; goto err_core_init; } @@ -3514,8 +3484,7 @@ static int __init_regs_and_interrupts(struct venus_hfi_device *device, res->register_base, res->register_size); hal->register_size = res->register_size; if (!hal->register_base) { - dprintk(VIDC_ERR, - "could not map reg addr %pa of size %d\n", + d_vpr_e("could not map reg addr %pa of size %d\n", &res->register_base, res->register_size); goto error_irq_fail; } @@ -3524,13 +3493,12 @@ static int __init_regs_and_interrupts(struct venus_hfi_device *device, rc = request_irq(res->irq, venus_hfi_isr, IRQF_TRIGGER_HIGH, "msm_vidc", device); if (unlikely(rc)) { - dprintk(VIDC_ERR, "() :request_irq failed\n"); + d_vpr_e("%s: request_irq failed\n", __func__); goto error_irq_fail; } disable_irq_nosync(res->irq); - dprintk(VIDC_HIGH, - "firmware_base = %pa, register_base = %pa, register_size = %d\n", + d_vpr_h("firmware_base = %pa, reg_base = %pa, reg_size = %d\n", &res->firmware_base, &res->register_base, res->register_size); @@ -3562,13 +3530,12 @@ static inline int __init_clocks(struct venus_hfi_device *device) struct clock_info *cl = NULL; if (!device) { - dprintk(VIDC_ERR, "Invalid params: %pK\n", device); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } venus_hfi_for_each_clock(device, cl) { - - dprintk(VIDC_HIGH, "%s: scalable? %d, count %d\n", + d_vpr_h("%s: scalable? %d, count %d\n", cl->name, cl->has_scaling, cl->count); } @@ -3576,8 +3543,7 @@ static inline int __init_clocks(struct venus_hfi_device *device) if (!cl->clk) { cl->clk = clk_get(&device->res->pdev->dev, cl->name); if (IS_ERR_OR_NULL(cl->clk)) { - dprintk(VIDC_ERR, - "Failed to get clock: %s\n", cl->name); + d_vpr_e("Failed to get clock: %s\n", cl->name); rc = PTR_ERR(cl->clk) ? PTR_ERR(cl->clk) : -EINVAL; cl->clk = NULL; @@ -3594,7 +3560,7 @@ err_clk_get: } static int __handle_reset_clk(struct msm_vidc_platform_resources *res, - int reset_index, enum reset_state state) + int reset_index, enum reset_state state, u32 sid) { int rc = 0; struct reset_control *rst; @@ -3604,7 +3570,7 @@ static int __handle_reset_clk(struct msm_vidc_platform_resources *res, return 0; rst = rst_set->reset_tbl[reset_index].rst; - dprintk(VIDC_HIGH, "reset_clk: name %s reset_state %d rst %pK\n", + s_vpr_h(sid, "reset_clk: name %s reset_state %d rst %pK\n", rst_set->reset_tbl[reset_index].name, state, rst); switch (state) { @@ -3635,7 +3601,7 @@ static int __handle_reset_clk(struct msm_vidc_platform_resources *res, rc = reset_control_deassert(rst); break; default: - dprintk(VIDC_ERR, "Invalid reset request\n"); + s_vpr_e(sid, "Invalid reset request\n"); if (rc) goto failed_to_reset; } @@ -3653,63 +3619,59 @@ void __disable_unprepare_clks(struct venus_hfi_device *device) int rc = 0; if (!device) { - dprintk(VIDC_ERR, "Invalid params: %pK\n", device); + d_vpr_e("%s: invalid params\n", __func__); return; } venus_hfi_for_each_clock_reverse(device, cl) { - dprintk(VIDC_HIGH, "Clock: %s disable and unprepare\n", + d_vpr_h("Clock: %s disable and unprepare\n", cl->name); rc = clk_set_flags(cl->clk, CLKFLAG_NORETAIN_PERIPH); if (rc) { - dprintk(VIDC_ERR, - "Failed set flag NORETAIN_PERIPH %s\n", + d_vpr_e("Failed set flag NORETAIN_PERIPH %s\n", cl->name); } rc = clk_set_flags(cl->clk, CLKFLAG_NORETAIN_MEM); if (rc) { - dprintk(VIDC_ERR, - "Failed set flag NORETAIN_MEM %s\n", + d_vpr_e("Failed set flag NORETAIN_MEM %s\n", cl->name); } if (!__clk_is_enabled(cl->clk)) - dprintk(VIDC_ERR, "%s: clock %s already disabled\n", + d_vpr_e("%s: clock %s already disabled\n", __func__, cl->name); clk_disable_unprepare(cl->clk); if (__clk_is_enabled(cl->clk)) - dprintk(VIDC_ERR, "%s: clock %s not disabled\n", + d_vpr_e("%s: clock %s not disabled\n", __func__, cl->name); } } -int __reset_ahb2axi_bridge_common(struct venus_hfi_device *device) +int __reset_ahb2axi_bridge_common(struct venus_hfi_device *device, u32 sid) { int rc, i; if (!device) { - dprintk(VIDC_ERR, "NULL device\n"); + s_vpr_e(sid, "NULL device\n"); rc = -EINVAL; goto failed_to_reset; } for (i = 0; i < device->res->reset_set.count; i++) { - rc = __handle_reset_clk(device->res, i, ASSERT); + rc = __handle_reset_clk(device->res, i, ASSERT, sid); if (rc) { - dprintk(VIDC_ERR, - "failed to assert reset clocks\n"); + s_vpr_e(sid, "failed to assert reset clocks\n"); goto failed_to_reset; } /* wait for deassert */ usleep_range(150, 250); - rc = __handle_reset_clk(device->res, i, DEASSERT); + rc = __handle_reset_clk(device->res, i, DEASSERT, sid); if (rc) { - dprintk(VIDC_ERR, - "failed to deassert reset clocks\n"); + s_vpr_e(sid, "failed to deassert reset clocks\n"); goto failed_to_reset; } } @@ -3720,13 +3682,14 @@ failed_to_reset: return rc; } -static inline int __prepare_enable_clks(struct venus_hfi_device *device) +static inline int __prepare_enable_clks(struct venus_hfi_device *device, + u32 sid) { struct clock_info *cl = NULL, *cl_fail = NULL; int rc = 0, c = 0; if (!device) { - dprintk(VIDC_ERR, "Invalid params: %pK\n", device); + s_vpr_e(sid, "%s: invalid params\n", __func__); return -EINVAL; } @@ -3737,47 +3700,45 @@ static inline int __prepare_enable_clks(struct venus_hfi_device *device) * it to the lowest frequency possible */ if (cl->has_scaling) - __set_clk_rate(device, cl, clk_round_rate(cl->clk, 0)); + __set_clk_rate(device, cl, + clk_round_rate(cl->clk, 0), sid); rc = clk_set_flags(cl->clk, CLKFLAG_RETAIN_PERIPH); if (rc) { - dprintk(VIDC_ERR, - "Failed set flag RETAIN_PERIPH %s\n", + s_vpr_e(sid, "Failed set flag RETAIN_PERIPH %s\n", cl->name); } rc = clk_set_flags(cl->clk, CLKFLAG_RETAIN_MEM); if (rc) { - dprintk(VIDC_ERR, - "Failed set flag RETAIN_MEM %s\n", + s_vpr_e(sid, "Failed set flag RETAIN_MEM %s\n", cl->name); } if (__clk_is_enabled(cl->clk)) - dprintk(VIDC_ERR, "%s: clock %s already enabled\n", + s_vpr_e(sid, "%s: clock %s already enabled\n", __func__, cl->name); rc = clk_prepare_enable(cl->clk); if (rc) { - dprintk(VIDC_ERR, "Failed to enable clocks\n"); + s_vpr_e(sid, "Failed to enable clocks\n"); cl_fail = cl; goto fail_clk_enable; } if (!__clk_is_enabled(cl->clk)) - dprintk(VIDC_ERR, "%s: clock %s not enabled\n", + s_vpr_e(sid, "%s: clock %s not enabled\n", __func__, cl->name); c++; - dprintk(VIDC_HIGH, - "Clock: %s prepared and enabled\n", cl->name); + s_vpr_h(sid, "Clock: %s prepared and enabled\n", cl->name); } - call_venus_op(device, clock_config_on_enable, device); + call_venus_op(device, clock_config_on_enable, device, sid); return rc; fail_clk_enable: venus_hfi_for_each_clock_reverse_continue(device, cl, c) { - dprintk(VIDC_ERR, "Clock: %s disable and unprepare\n", + s_vpr_e(sid, "Clock: %s disable and unprepare\n", cl->name); clk_disable_unprepare(cl->clk); } @@ -3811,8 +3772,7 @@ static int __init_bus(struct venus_hfi_device *device) venus_hfi_for_each_bus(device, bus) { if (!strcmp(bus->mode, "msm-vidc-llcc")) { if (msm_vidc_syscache_disable) { - dprintk(VIDC_HIGH, - "Skipping LLC bus init %s: %s\n", + d_vpr_h("Skipping LLC bus init %s: %s\n", bus->name, bus->mode); continue; } @@ -3822,7 +3782,7 @@ static int __init_bus(struct venus_hfi_device *device) if (IS_ERR_OR_NULL(bus->client)) { rc = PTR_ERR(bus->client) ? PTR_ERR(bus->client) : -EBADHANDLE; - dprintk(VIDC_ERR, "Failed to register bus %s: %d\n", + d_vpr_e("Failed to register bus %s: %d\n", bus->name, rc); bus->client = NULL; goto err_add_dev; @@ -3859,8 +3819,7 @@ static int __init_regulators(struct venus_hfi_device *device) if (IS_ERR_OR_NULL(rinfo->regulator)) { rc = PTR_ERR(rinfo->regulator) ? PTR_ERR(rinfo->regulator) : -EBADHANDLE; - dprintk(VIDC_ERR, "Failed to get regulator: %s\n", - rinfo->name); + d_vpr_e("Failed to get regulator: %s\n", rinfo->name); rinfo->regulator = NULL; goto err_reg_get; } @@ -3878,8 +3837,7 @@ static void __deinit_subcaches(struct venus_hfi_device *device) struct subcache_info *sinfo = NULL; if (!device) { - dprintk(VIDC_ERR, "deinit_subcaches: invalid device %pK\n", - device); + d_vpr_e("deinit_subcaches: invalid device %pK\n", device); goto exit; } @@ -3888,8 +3846,7 @@ static void __deinit_subcaches(struct venus_hfi_device *device) venus_hfi_for_each_subcache_reverse(device, sinfo) { if (sinfo->subcache) { - dprintk(VIDC_HIGH, "deinit_subcaches: %s\n", - sinfo->name); + d_vpr_h("deinit_subcaches: %s\n", sinfo->name); llcc_slice_putd(sinfo->subcache); sinfo->subcache = NULL; } @@ -3905,7 +3862,7 @@ static int __init_subcaches(struct venus_hfi_device *device) struct subcache_info *sinfo = NULL; if (!device) { - dprintk(VIDC_ERR, "init_subcaches: invalid device %pK\n", + d_vpr_e("init_subcaches: invalid device %pK\n", device); return -EINVAL; } @@ -3921,20 +3878,18 @@ static int __init_subcaches(struct venus_hfi_device *device) } else if (!strcmp("vidscfw", sinfo->name)) { sinfo->subcache = llcc_slice_getd(LLCC_VIDFW); } else { - dprintk(VIDC_ERR, "Invalid subcache name %s\n", + d_vpr_e("Invalid subcache name %s\n", sinfo->name); } if (IS_ERR_OR_NULL(sinfo->subcache)) { rc = PTR_ERR(sinfo->subcache) ? PTR_ERR(sinfo->subcache) : -EBADHANDLE; - dprintk(VIDC_ERR, - "init_subcaches: invalid subcache: %s rc %d\n", + d_vpr_e("init_subcaches: invalid subcache: %s rc %d\n", sinfo->name, rc); sinfo->subcache = NULL; goto err_subcache_get; } - dprintk(VIDC_HIGH, "init_subcaches: %s\n", - sinfo->name); + d_vpr_h("init_subcaches: %s\n", sinfo->name); } return 0; @@ -3951,21 +3906,21 @@ static int __init_resources(struct venus_hfi_device *device, rc = __init_regulators(device); if (rc) { - dprintk(VIDC_ERR, "Failed to get all regulators\n"); + d_vpr_e("Failed to get all regulators\n"); return -ENODEV; } rc = __init_clocks(device); if (rc) { - dprintk(VIDC_ERR, "Failed to init clocks\n"); + d_vpr_e("Failed to init clocks\n"); rc = -ENODEV; goto err_init_clocks; } for (i = 0; i < device->res->reset_set.count; i++) { - rc = __handle_reset_clk(res, i, INIT); + rc = __handle_reset_clk(res, i, INIT, DEFAULT_SID); if (rc) { - dprintk(VIDC_ERR, "Failed to init reset clocks\n"); + d_vpr_e("Failed to init reset clocks\n"); rc = -ENODEV; goto err_init_reset_clk; } @@ -3973,13 +3928,13 @@ static int __init_resources(struct venus_hfi_device *device, rc = __init_bus(device); if (rc) { - dprintk(VIDC_ERR, "Failed to init bus: %d\n", rc); + d_vpr_e("Failed to init bus: %d\n", rc); goto err_init_bus; } rc = __init_subcaches(device); if (rc) - dprintk(VIDC_ERR, "Failed to init subcaches: %d\n", rc); + d_vpr_e("Failed to init subcaches: %d\n", rc); return rc; @@ -4019,7 +3974,7 @@ static int __protect_cp_mem(struct venus_hfi_device *device) if (!strcmp(cb->name, "venus_ns")) { desc.args[1] = memprot.cp_size = cb->addr_range.start; - dprintk(VIDC_HIGH, "%s memprot.cp_size: %#x\n", + d_vpr_h("%s: memprot.cp_size: %#x\n", __func__, memprot.cp_size); } @@ -4028,8 +3983,7 @@ static int __protect_cp_mem(struct venus_hfi_device *device) cb->addr_range.start; desc.args[3] = memprot.cp_nonpixel_size = cb->addr_range.size; - dprintk(VIDC_HIGH, - "%s memprot.cp_nonpixel_start: %#x size: %#x\n", + d_vpr_h("%s: cp_nonpixel_start: %#x size: %#x\n", __func__, memprot.cp_nonpixel_start, memprot.cp_nonpixel_size); } @@ -4041,7 +3995,7 @@ static int __protect_cp_mem(struct venus_hfi_device *device) resp = desc.ret[0]; if (rc) { - dprintk(VIDC_ERR, "Failed to protect memory(%d) response: %d\n", + d_vpr_e("Failed to protect memory(%d) response: %d\n", rc, resp); } @@ -4056,7 +4010,7 @@ static int __disable_regulator(struct regulator_info *rinfo, { int rc = 0; - dprintk(VIDC_HIGH, "Disabling regulator %s\n", rinfo->name); + d_vpr_h("Disabling regulator %s\n", rinfo->name); /* * This call is needed. Driver needs to acquire the control back @@ -4064,34 +4018,32 @@ static int __disable_regulator(struct regulator_info *rinfo, * is unknown. */ - rc = __acquire_regulator(rinfo, device); + rc = __acquire_regulator(rinfo, device, DEFAULT_SID); if (rc) { /* * This is somewhat fatal, but nothing we can do * about it. We can't disable the regulator w/o * getting it back under s/w control */ - dprintk(VIDC_ERR, - "Failed to acquire control on %s\n", + d_vpr_e("Failed to acquire control on %s\n", rinfo->name); goto disable_regulator_failed; } if (!regulator_is_enabled(rinfo->regulator)) - dprintk(VIDC_ERR, "%s: regulator %s already disabled\n", + d_vpr_e("%s: regulator %s already disabled\n", __func__, rinfo->name); rc = regulator_disable(rinfo->regulator); if (rc) { - dprintk(VIDC_ERR, - "Failed to disable %s: %d\n", + d_vpr_e("Failed to disable %s: %d\n", rinfo->name, rc); goto disable_regulator_failed; } if (regulator_is_enabled(rinfo->regulator)) - dprintk(VIDC_ERR, "%s: regulator %s not disabled\n", + d_vpr_e("%s: regulator %s not disabled\n", __func__, rinfo->name); return 0; @@ -4102,43 +4054,41 @@ disable_regulator_failed: return rc; } -static int __enable_hw_power_collapse(struct venus_hfi_device *device) +static int __enable_hw_power_collapse(struct venus_hfi_device *device, u32 sid) { int rc = 0; - rc = __hand_off_regulators(device); + rc = __hand_off_regulators(device, sid); if (rc) - dprintk(VIDC_ERR, - "%s : Failed to enable HW power collapse %d\n", + s_vpr_e(sid, "%s: Failed to enable HW power collapse %d\n", __func__, rc); return rc; } -static int __enable_regulators(struct venus_hfi_device *device) +static int __enable_regulators(struct venus_hfi_device *device, u32 sid) { int rc = 0, c = 0; struct regulator_info *rinfo; - dprintk(VIDC_HIGH, "Enabling regulators\n"); + s_vpr_h(sid, "Enabling regulators\n"); venus_hfi_for_each_regulator(device, rinfo) { if (regulator_is_enabled(rinfo->regulator)) - dprintk(VIDC_ERR, "%s: regulator %s already enabled\n", + s_vpr_e(sid, "%s: regulator %s already enabled\n", __func__, rinfo->name); rc = regulator_enable(rinfo->regulator); if (rc) { - dprintk(VIDC_ERR, - "Failed to enable %s: %d\n", + s_vpr_e(sid, "Failed to enable %s: %d\n", rinfo->name, rc); goto err_reg_enable_failed; } if (!regulator_is_enabled(rinfo->regulator)) - dprintk(VIDC_ERR, "%s: regulator %s not enabled\n", + s_vpr_e(sid, "%s: regulator %s not enabled\n", __func__, rinfo->name); - dprintk(VIDC_HIGH, "Enabled regulator %s\n", + s_vpr_h(sid, "Enabled regulator %s\n", rinfo->name); c++; } @@ -4156,15 +4106,14 @@ int __disable_regulators(struct venus_hfi_device *device) { struct regulator_info *rinfo; - dprintk(VIDC_HIGH, "Disabling regulators\n"); - + d_vpr_h("Disabling regulators\n"); venus_hfi_for_each_regulator_reverse(device, rinfo) __disable_regulator(rinfo, device); return 0; } -static int __enable_subcaches(struct venus_hfi_device *device) +static int __enable_subcaches(struct venus_hfi_device *device, u32 sid) { int rc = 0; u32 c = 0; @@ -4177,27 +4126,27 @@ static int __enable_subcaches(struct venus_hfi_device *device) venus_hfi_for_each_subcache(device, sinfo) { rc = llcc_slice_activate(sinfo->subcache); if (rc) { - dprintk(VIDC_ERR, "Failed to activate %s: %d\n", + s_vpr_e(sid, "Failed to activate %s: %d\n", sinfo->name, rc); msm_vidc_res_handle_fatal_hw_error(device->res, true); goto err_activate_fail; } sinfo->isactive = true; - dprintk(VIDC_HIGH, "Activated subcache %s\n", sinfo->name); + s_vpr_h(sid, "Activated subcache %s\n", sinfo->name); c++; } - dprintk(VIDC_HIGH, "Activated %d Subcaches to Venus\n", c); + s_vpr_h(sid, "Activated %d Subcaches to Venus\n", c); return 0; err_activate_fail: - __release_subcaches(device); - __disable_subcaches(device); + __release_subcaches(device, sid); + __disable_subcaches(device, sid); return 0; } -static int __set_subcaches(struct venus_hfi_device *device) +static int __set_subcaches(struct venus_hfi_device *device, u32 sid) { int rc = 0; u32 c = 0; @@ -4208,7 +4157,7 @@ static int __set_subcaches(struct venus_hfi_device *device) struct vidc_resource_hdr rhdr; if (device->res->sys_cache_res_set) { - dprintk(VIDC_HIGH, "Subcaches already set to Venus\n"); + s_vpr_h(sid, "Subcaches already set to Venus\n"); return 0; } @@ -4227,7 +4176,7 @@ static int __set_subcaches(struct venus_hfi_device *device) /* Set resource to Venus for activated subcaches */ if (c) { - dprintk(VIDC_HIGH, "Setting %d Subcaches\n", c); + s_vpr_h(sid, "Setting %d Subcaches\n", c); rhdr.resource_handle = sc_res_info; /* cookie */ rhdr.resource_id = VIDC_RESOURCE_SYSCACHE; @@ -4236,7 +4185,7 @@ static int __set_subcaches(struct venus_hfi_device *device) rc = __core_set_resource(device, &rhdr, (void *)sc_res_info); if (rc) { - dprintk(VIDC_ERR, "Failed to set subcaches %d\n", rc); + s_vpr_e(sid, "Failed to set subcaches %d\n", rc); goto err_fail_set_subacaches; } @@ -4245,19 +4194,19 @@ static int __set_subcaches(struct venus_hfi_device *device) sinfo->isset = true; } - dprintk(VIDC_HIGH, "Set Subcaches done to Venus\n"); + s_vpr_h(sid, "Set Subcaches done to Venus\n"); device->res->sys_cache_res_set = true; } return 0; err_fail_set_subacaches: - __disable_subcaches(device); + __disable_subcaches(device, sid); return 0; } -static int __release_subcaches(struct venus_hfi_device *device) +static int __release_subcaches(struct venus_hfi_device *device, u32 sid) { struct subcache_info *sinfo; int rc = 0; @@ -4287,14 +4236,13 @@ static int __release_subcaches(struct venus_hfi_device *device) } if (c > 0) { - dprintk(VIDC_HIGH, "Releasing %d subcaches\n", c); + s_vpr_h(sid, "Releasing %d subcaches\n", c); rhdr.resource_handle = sc_res_info; /* cookie */ rhdr.resource_id = VIDC_RESOURCE_SYSCACHE; rc = __core_release_resource(device, &rhdr); if (rc) - dprintk(VIDC_ERR, - "Failed to release %d subcaches\n", c); + s_vpr_e(sid, "Failed to release %d subcaches\n", c); } device->res->sys_cache_res_set = false; @@ -4302,7 +4250,7 @@ static int __release_subcaches(struct venus_hfi_device *device) return 0; } -static int __disable_subcaches(struct venus_hfi_device *device) +static int __disable_subcaches(struct venus_hfi_device *device, u32 sid) { struct subcache_info *sinfo; int rc = 0; @@ -4313,12 +4261,11 @@ static int __disable_subcaches(struct venus_hfi_device *device) /* De-activate subcaches */ venus_hfi_for_each_subcache_reverse(device, sinfo) { if (sinfo->isactive) { - dprintk(VIDC_HIGH, "De-activate subcache %s\n", + s_vpr_h(sid, "De-activate subcache %s\n", sinfo->name); rc = llcc_slice_deactivate(sinfo->subcache); if (rc) { - dprintk(VIDC_ERR, - "Failed to de-activate %s: %d\n", + s_vpr_e(sid, "Failed to de-activate %s: %d\n", sinfo->name, rc); } sinfo->isactive = false; @@ -4342,62 +4289,59 @@ static int __set_ubwc_config(struct venus_hfi_device *device) rc = call_hfi_pkt_op(device, sys_ubwc_config, pkt, device->res->ubwc_config); if (rc) { - dprintk(VIDC_ERR, - "ubwc config setting to FW failed\n"); + d_vpr_e("ubwc config setting to FW failed\n"); rc = -ENOTEMPTY; goto fail_to_set_ubwc_config; } - if (__iface_cmdq_write(device, pkt)) { + if (__iface_cmdq_write(device, pkt, DEFAULT_SID)) { rc = -ENOTEMPTY; goto fail_to_set_ubwc_config; } - dprintk(VIDC_HIGH, - "Configured UBWC Config to Venus\n"); + d_vpr_h("Configured UBWC Config to Venus\n"); fail_to_set_ubwc_config: return rc; } -static int __venus_power_on(struct venus_hfi_device *device) +static int __venus_power_on(struct venus_hfi_device *device, u32 sid) { int rc = 0; - if (device->power_enabled) return 0; device->power_enabled = true; /* Vote for all hardware resources */ - rc = __vote_buses(device, INT_MAX, INT_MAX); + rc = __vote_buses(device, INT_MAX, INT_MAX, sid); if (rc) { - dprintk(VIDC_ERR, "Failed to vote buses, err: %d\n", rc); + s_vpr_e(sid, "Failed to vote buses, err: %d\n", rc); goto fail_vote_buses; } - rc = __enable_regulators(device); + rc = __enable_regulators(device, sid); if (rc) { - dprintk(VIDC_ERR, "Failed to enable GDSC, err = %d\n", rc); + s_vpr_e(sid, "Failed to enable GDSC, err = %d\n", rc); goto fail_enable_gdsc; } - rc = call_venus_op(device, reset_ahb2axi_bridge, device); + rc = call_venus_op(device, reset_ahb2axi_bridge, device, sid); if (rc) { - dprintk(VIDC_ERR, "Failed to reset ahb2axi: %d\n", rc); + s_vpr_e(sid, "Failed to reset ahb2axi: %d\n", rc); goto fail_enable_clks; } - rc = __prepare_enable_clks(device); + rc = __prepare_enable_clks(device, sid); if (rc) { - dprintk(VIDC_ERR, "Failed to enable clocks: %d\n", rc); + s_vpr_e(sid, "Failed to enable clocks: %d\n", rc); goto fail_enable_clks; } - rc = __scale_clocks(device); + rc = __scale_clocks(device, sid); if (rc) { - dprintk(VIDC_ERR, - "Failed to scale clocks, performance might be affected\n"); + s_vpr_e(sid, + "Failed to scale clocks, performance might be affected\n"); rc = 0; } @@ -4405,9 +4349,9 @@ static int __venus_power_on(struct venus_hfi_device *device) * Re-program all of the registers that get reset as a result of * regulator_disable() and _enable() */ - __set_registers(device); + __set_registers(device, sid); - call_venus_op(device, interrupt_init, device); + call_venus_op(device, interrupt_init, device, sid); device->intr_status = 0; enable_irq(device->hal_data->irq); @@ -4416,7 +4360,7 @@ static int __venus_power_on(struct venus_hfi_device *device) fail_enable_clks: __disable_regulators(device); fail_enable_gdsc: - __unvote_buses(device); + __unvote_buses(device, sid); fail_vote_buses: device->power_enabled = false; return rc; @@ -4432,14 +4376,14 @@ static void __power_off_common(struct venus_hfi_device *device) device->intr_status = 0; __disable_unprepare_clks(device); - if (call_venus_op(device, reset_ahb2axi_bridge, device)) - dprintk(VIDC_ERR, "Failed to reset ahb2axi\n"); + if (call_venus_op(device, reset_ahb2axi_bridge, device, DEFAULT_SID)) + d_vpr_e("Failed to reset ahb2axi\n"); if (__disable_regulators(device)) - dprintk(VIDC_ERR, "Failed to disable regulators\n"); + d_vpr_e("Failed to disable regulators\n"); - if (__unvote_buses(device)) - dprintk(VIDC_ERR, "Failed to unvote for buses\n"); + if (__unvote_buses(device, DEFAULT_SID)) + d_vpr_e("Failed to unvote for buses\n"); device->power_enabled = false; } @@ -4448,61 +4392,61 @@ static inline int __suspend(struct venus_hfi_device *device) int rc = 0; if (!device) { - dprintk(VIDC_ERR, "Invalid params: %pK\n", device); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } else if (!device->power_enabled) { - dprintk(VIDC_HIGH, "Power already disabled\n"); + d_vpr_h("Power already disabled\n"); return 0; } - dprintk(VIDC_HIGH, "Entering suspend\n"); + d_vpr_h("Entering suspend\n"); if (device->res->pm_qos_latency_us && pm_qos_request_active(&device->qos)) pm_qos_remove_request(&device->qos); - rc = __tzbsp_set_video_state(TZBSP_VIDEO_STATE_SUSPEND); + rc = __tzbsp_set_video_state(TZBSP_VIDEO_STATE_SUSPEND, DEFAULT_SID); if (rc) { - dprintk(VIDC_ERR, "Failed to suspend video core %d\n", rc); + d_vpr_e("Failed to suspend video core %d\n", rc); goto err_tzbsp_suspend; } - __disable_subcaches(device); + __disable_subcaches(device, DEFAULT_SID); call_venus_op(device, power_off, device); - dprintk(VIDC_HIGH, "Venus power off\n"); + d_vpr_h("Venus power off\n"); return rc; err_tzbsp_suspend: return rc; } -static inline int __resume(struct venus_hfi_device *device) +static inline int __resume(struct venus_hfi_device *device, u32 sid) { int rc = 0; u32 flags = 0; if (!device) { - dprintk(VIDC_ERR, "Invalid params: %pK\n", device); + s_vpr_e(sid, "%s: invalid params\n", __func__); return -EINVAL; } else if (device->power_enabled) { goto exit; } else if (!__core_in_valid_state(device)) { - dprintk(VIDC_ERR, "venus_hfi_device in deinit state."); + s_vpr_e(sid, "venus_hfi_device in deinit state."); return -EINVAL; } - dprintk(VIDC_HIGH, "Resuming from power collapse\n"); - rc = __venus_power_on(device); + s_vpr_h(sid, "Resuming from power collapse\n"); + rc = __venus_power_on(device, sid); if (rc) { - dprintk(VIDC_ERR, "Failed to power on venus\n"); + s_vpr_e(sid, "Failed to power on venus\n"); goto err_venus_power_on; } /* Reboot the firmware */ - rc = __tzbsp_set_video_state(TZBSP_VIDEO_STATE_RESUME); + rc = __tzbsp_set_video_state(TZBSP_VIDEO_STATE_RESUME, sid); if (rc) { - dprintk(VIDC_ERR, "Failed to resume video core %d\n", rc); + s_vpr_e(sid, "Failed to resume video core %d\n", rc); goto err_set_video_state; } @@ -4512,15 +4456,15 @@ static inline int __resume(struct venus_hfi_device *device) * (s/w triggered) to fast (HW triggered) unless the h/w vote is * present. */ - if (__enable_hw_power_collapse(device)) - dprintk(VIDC_ERR, "Failed to enabled inter-frame PC\n"); + if (__enable_hw_power_collapse(device, sid)) + s_vpr_e(sid, "Failed to enabled inter-frame PC\n"); - call_venus_op(device, setup_ucregion_memmap, device); + call_venus_op(device, setup_ucregion_memmap, device, sid); /* Wait for boot completion */ - rc = call_venus_op(device, boot_firmware, device); + rc = call_venus_op(device, boot_firmware, device, sid); if (rc) { - dprintk(VIDC_ERR, "Failed to reset venus core\n"); + s_vpr_e(sid, "Failed to reset venus core\n"); goto err_reset_core; } @@ -4533,24 +4477,25 @@ static inline int __resume(struct venus_hfi_device *device) device->res->pm_qos_latency_us); } - __sys_set_debug(device, (msm_vidc_debug & FW_LOGMASK) >> FW_LOGSHIFT); + __sys_set_debug(device, (msm_vidc_debug & FW_LOGMASK) >> FW_LOGSHIFT, + sid); - __enable_subcaches(device); - __set_subcaches(device); + __enable_subcaches(device, sid); + __set_subcaches(device, sid); __dsp_resume(device, flags); - dprintk(VIDC_HIGH, "Resumed from power collapse\n"); + s_vpr_h(sid, "Resumed from power collapse\n"); exit: /* Don't reset skip_pc_count for SYS_PC_PREP cmd */ if (device->last_packet_type != HFI_CMD_SYS_PC_PREP) device->skip_pc_count = 0; return rc; err_reset_core: - __tzbsp_set_video_state(TZBSP_VIDEO_STATE_SUSPEND); + __tzbsp_set_video_state(TZBSP_VIDEO_STATE_SUSPEND, sid); err_set_video_state: call_venus_op(device, power_off, device); err_venus_power_on: - dprintk(VIDC_ERR, "Failed to resume from power collapse\n"); + s_vpr_e(sid, "Failed to resume from power collapse\n"); return rc; } @@ -4561,20 +4506,20 @@ static int __load_fw(struct venus_hfi_device *device) /* Initialize resources */ rc = __init_resources(device, device->res); if (rc) { - dprintk(VIDC_ERR, "Failed to init resources: %d\n", rc); + d_vpr_e("Failed to init resources: %d\n", rc); goto fail_init_res; } rc = __initialize_packetization(device); if (rc) { - dprintk(VIDC_ERR, "Failed to initialize packetization\n"); + d_vpr_e("Failed to initialize packetization\n"); goto fail_init_pkt; } trace_msm_v4l2_vidc_fw_load_start("msm_v4l2_vidc venus_fw load start"); - rc = __venus_power_on(device); + rc = __venus_power_on(device, DEFAULT_SID); if (rc) { - dprintk(VIDC_ERR, "Failed to power on venus in in load_fw\n"); + d_vpr_e("Failed to power on venus in in load_fw\n"); goto fail_venus_power_on; } @@ -4585,19 +4530,19 @@ static int __load_fw(struct venus_hfi_device *device) device->res->fw_name); if (IS_ERR_OR_NULL(device->resources.fw.cookie)) { - dprintk(VIDC_ERR, "Failed to download firmware\n"); + d_vpr_e("Failed to download firmware\n"); device->resources.fw.cookie = NULL; rc = -ENOMEM; goto fail_load_fw; } } else { - dprintk(VIDC_ERR, "Firmware base must be 0\n"); + d_vpr_e("Firmware base must be 0\n"); } if (!device->res->firmware_base) { rc = __protect_cp_mem(device); if (rc) { - dprintk(VIDC_ERR, "Failed to protect memory\n"); + d_vpr_e("Failed to protect memory\n"); goto fail_protect_mem; } } @@ -4607,8 +4552,8 @@ static int __load_fw(struct venus_hfi_device *device) * (s/w triggered) to fast (HW triggered) unless the h/w vote is * present. */ - if (__enable_hw_power_collapse(device)) - dprintk(VIDC_ERR, "Failed to enabled inter-frame PC\n"); + if (__enable_hw_power_collapse(device, DEFAULT_SID)) + d_vpr_e("Failed to enabled inter-frame PC\n"); trace_msm_v4l2_vidc_fw_load_end("msm_v4l2_vidc venus_fw load end"); return rc; @@ -4641,7 +4586,7 @@ static void __unload_fw(struct venus_hfi_device *device) device->resources.fw.cookie = NULL; __deinit_resources(device); - dprintk(VIDC_HIGH, "Firmware unloaded successfully\n"); + d_vpr_h("Firmware unloaded successfully\n"); } static int venus_hfi_get_fw_info(void *dev, struct hal_fw_info *fw_info) @@ -4654,8 +4599,7 @@ static int venus_hfi_get_fw_info(void *dev, struct hal_fw_info *fw_info) const u32 smem_image_index_venus = 14 * 128; if (!device || !fw_info) { - dprintk(VIDC_ERR, - "%s Invalid parameter: device = %pK fw_info = %pK\n", + d_vpr_e("%s: Invalid parameter: device = %pK fw_info = %pK\n", __func__, device, fw_info); return -EINVAL; } @@ -4675,7 +4619,7 @@ static int venus_hfi_get_fw_info(void *dev, struct hal_fw_info *fw_info) ; if (i == VENUS_VERSION_LENGTH - 1) { - dprintk(VIDC_ERR, "Venus version string is not proper\n"); + d_vpr_e("Venus version string is not proper\n"); fw_info->version[0] = '\0'; goto fail_version_string; } @@ -4685,7 +4629,7 @@ static int venus_hfi_get_fw_info(void *dev, struct hal_fw_info *fw_info) fw_info->version[j] = '\0'; fail_version_string: - dprintk(VIDC_HIGH, "F/W version retrieved : %s\n", fw_info->version); + d_vpr_h("F/W version retrieved : %s\n", fw_info->version); fw_info->base_addr = device->hal_data->firmware_base; fw_info->register_base = device->res->register_base; fw_info->register_size = device->hal_data->register_size; @@ -4718,9 +4662,10 @@ static int venus_hfi_get_core_capabilities(void *dev) static void __noc_error_info(struct venus_hfi_device *device, u32 core_num) { u32 vcodec_core_video_noc_base_offs, val; + u32 sid = DEFAULT_SID; if (!device) { - dprintk(VIDC_ERR, "%s: null device\n", __func__); + d_vpr_e("%s: null device\n", __func__); return; } if (!core_num) { @@ -4730,44 +4675,43 @@ static void __noc_error_info(struct venus_hfi_device *device, u32 core_num) vcodec_core_video_noc_base_offs = VCODEC_CORE1_VIDEO_NOC_BASE_OFFS; } else { - dprintk(VIDC_ERR, "%s: invalid core_num %u\n", - __func__, core_num); + d_vpr_e("%s: invalid core_num %u\n", __func__, core_num); return; } val = __read_register(device, vcodec_core_video_noc_base_offs + - VCODEC_COREX_VIDEO_NOC_ERR_SWID_LOW_OFFS); - dprintk(VIDC_ERR, "CORE%d_NOC_ERR_SWID_LOW: %#x\n", core_num, val); + VCODEC_COREX_VIDEO_NOC_ERR_SWID_LOW_OFFS, sid); + d_vpr_e("CORE%d_NOC_ERR_SWID_LOW: %#x\n", core_num, val); val = __read_register(device, vcodec_core_video_noc_base_offs + - VCODEC_COREX_VIDEO_NOC_ERR_SWID_HIGH_OFFS); - dprintk(VIDC_ERR, "CORE%d_NOC_ERR_SWID_HIGH: %#x\n", core_num, val); + VCODEC_COREX_VIDEO_NOC_ERR_SWID_HIGH_OFFS, sid); + d_vpr_e("CORE%d_NOC_ERR_SWID_HIGH: %#x\n", core_num, val); val = __read_register(device, vcodec_core_video_noc_base_offs + - VCODEC_COREX_VIDEO_NOC_ERR_MAINCTL_LOW_OFFS); - dprintk(VIDC_ERR, "CORE%d_NOC_ERR_MAINCTL_LOW: %#x\n", core_num, val); + VCODEC_COREX_VIDEO_NOC_ERR_MAINCTL_LOW_OFFS, sid); + d_vpr_e("CORE%d_NOC_ERR_MAINCTL_LOW: %#x\n", core_num, val); val = __read_register(device, vcodec_core_video_noc_base_offs + - VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG0_LOW_OFFS); - dprintk(VIDC_ERR, "CORE%d_NOC_ERR_ERRLOG0_LOW: %#x\n", core_num, val); + VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG0_LOW_OFFS, sid); + d_vpr_e("CORE%d_NOC_ERR_ERRLOG0_LOW: %#x\n", core_num, val); val = __read_register(device, vcodec_core_video_noc_base_offs + - VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG0_HIGH_OFFS); - dprintk(VIDC_ERR, "CORE%d_NOC_ERR_ERRLOG0_HIGH: %#x\n", core_num, val); + VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG0_HIGH_OFFS, sid); + d_vpr_e("CORE%d_NOC_ERR_ERRLOG0_HIGH: %#x\n", core_num, val); val = __read_register(device, vcodec_core_video_noc_base_offs + - VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG1_LOW_OFFS); - dprintk(VIDC_ERR, "CORE%d_NOC_ERR_ERRLOG1_LOW: %#x\n", core_num, val); + VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG1_LOW_OFFS, sid); + d_vpr_e("CORE%d_NOC_ERR_ERRLOG1_LOW: %#x\n", core_num, val); val = __read_register(device, vcodec_core_video_noc_base_offs + - VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG1_HIGH_OFFS); - dprintk(VIDC_ERR, "CORE%d_NOC_ERR_ERRLOG1_HIGH: %#x\n", core_num, val); + VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG1_HIGH_OFFS, sid); + d_vpr_e("CORE%d_NOC_ERR_ERRLOG1_HIGH: %#x\n", core_num, val); val = __read_register(device, vcodec_core_video_noc_base_offs + - VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG2_LOW_OFFS); - dprintk(VIDC_ERR, "CORE%d_NOC_ERR_ERRLOG2_LOW: %#x\n", core_num, val); + VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG2_LOW_OFFS, sid); + d_vpr_e("CORE%d_NOC_ERR_ERRLOG2_LOW: %#x\n", core_num, val); val = __read_register(device, vcodec_core_video_noc_base_offs + - VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG2_HIGH_OFFS); - dprintk(VIDC_ERR, "CORE%d_NOC_ERR_ERRLOG2_HIGH: %#x\n", core_num, val); + VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG2_HIGH_OFFS, sid); + d_vpr_e("CORE%d_NOC_ERR_ERRLOG2_HIGH: %#x\n", core_num, val); val = __read_register(device, vcodec_core_video_noc_base_offs + - VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG3_LOW_OFFS); - dprintk(VIDC_ERR, "CORE%d_NOC_ERR_ERRLOG3_LOW: %#x\n", core_num, val); + VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG3_LOW_OFFS, sid); + d_vpr_e("CORE%d_NOC_ERR_ERRLOG3_LOW: %#x\n", core_num, val); val = __read_register(device, vcodec_core_video_noc_base_offs + - VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG3_HIGH_OFFS); - dprintk(VIDC_ERR, "CORE%d_NOC_ERR_ERRLOG3_HIGH: %#x\n", core_num, val); + VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG3_HIGH_OFFS, sid); + d_vpr_e("CORE%d_NOC_ERR_ERRLOG3_HIGH: %#x\n", core_num, val); } static void __noc_error_info_common(struct venus_hfi_device *device) @@ -4775,11 +4719,13 @@ static void __noc_error_info_common(struct venus_hfi_device *device) const u32 core0 = 0, core1 = 1; if (__read_register(device, VCODEC_CORE0_VIDEO_NOC_BASE_OFFS + - VCODEC_COREX_VIDEO_NOC_ERR_ERRVLD_LOW_OFFS)) + VCODEC_COREX_VIDEO_NOC_ERR_ERRVLD_LOW_OFFS, + DEFAULT_SID)) __noc_error_info(device, core0); if (__read_register(device, VCODEC_CORE1_VIDEO_NOC_BASE_OFFS + - VCODEC_COREX_VIDEO_NOC_ERR_ERRVLD_LOW_OFFS)) + VCODEC_COREX_VIDEO_NOC_ERR_ERRVLD_LOW_OFFS, + DEFAULT_SID)) __noc_error_info(device, core1); } @@ -4788,13 +4734,13 @@ static int venus_hfi_noc_error_info(void *dev) struct venus_hfi_device *device; if (!dev) { - dprintk(VIDC_ERR, "%s: null device\n", __func__); + d_vpr_e("%s: null device\n", __func__); return -EINVAL; } device = dev; mutex_lock(&device->lock); - dprintk(VIDC_ERR, "%s: non error information\n", __func__); + d_vpr_e("%s: non error information\n", __func__); call_venus_op(device, noc_error_info, device); @@ -4808,7 +4754,7 @@ static int __initialize_packetization(struct venus_hfi_device *device) int rc = 0; if (!device || !device->res) { - dprintk(VIDC_ERR, "%s - invalid param\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, device); return -EINVAL; } @@ -4817,7 +4763,7 @@ static int __initialize_packetization(struct venus_hfi_device *device) device->pkt_ops = hfi_get_pkt_ops_handle(device->packetization_type); if (!device->pkt_ops) { rc = -EINVAL; - dprintk(VIDC_ERR, "Failed to get pkt_ops handle\n"); + d_vpr_e("Failed to get pkt_ops handle\n"); } return rc; @@ -4841,23 +4787,24 @@ static struct venus_hfi_device *__add_device(u32 device_id, int rc = 0; if (!res || !callback) { - dprintk(VIDC_ERR, "Invalid Parameters\n"); + d_vpr_e("%s: Invalid Parameters %pK %pK\n", + __func__, res, callback); return NULL; } - dprintk(VIDC_HIGH, "entered , device_id: %d\n", device_id); + d_vpr_h("%s: entered, device_id: %d\n", __func__, device_id); hdevice->response_pkt = kmalloc_array(max_packets, sizeof(*hdevice->response_pkt), GFP_KERNEL); if (!hdevice->response_pkt) { - dprintk(VIDC_ERR, "failed to allocate response_pkt\n"); + d_vpr_e("failed to allocate response_pkt\n"); goto err_cleanup; } hdevice->raw_packet = kzalloc(VIDC_IFACEQ_VAR_HUGE_PKT_SIZE, GFP_KERNEL); if (!hdevice->raw_packet) { - dprintk(VIDC_ERR, "failed to allocate raw packet\n"); + d_vpr_e("failed to allocate raw packet\n"); goto err_cleanup; } @@ -4874,14 +4821,14 @@ static struct venus_hfi_device *__add_device(u32 device_id, hdevice->vidc_workq = create_singlethread_workqueue( "msm_vidc_workerq_venus"); if (!hdevice->vidc_workq) { - dprintk(VIDC_ERR, ": create vidc workq failed\n"); + d_vpr_e("%s: create vidc workq failed\n", __func__); goto err_cleanup; } hdevice->venus_pm_workq = create_singlethread_workqueue( "pm_workerq_venus"); if (!hdevice->venus_pm_workq) { - dprintk(VIDC_ERR, ": create pm workq failed\n"); + d_vpr_e("%s: create pm workq failed\n", __func__); goto err_cleanup; } @@ -4909,7 +4856,8 @@ static struct venus_hfi_device *__get_device(u32 device_id, hfi_cmd_response_callback callback) { if (!res || !callback) { - dprintk(VIDC_ERR, "Invalid params: %pK %pK\n", res, callback); + d_vpr_e("%s: invalid params: %pK %pK\n", + __func__, res, callback); return NULL; } @@ -4975,7 +4923,6 @@ static void venus_init_hfi_callbacks(struct hfi_device *hdev) hdev->suspend = venus_hfi_suspend; hdev->flush_debug_queue = venus_hfi_flush_debug_queue; hdev->noc_error_info = venus_hfi_noc_error_info; - hdev->get_default_properties = venus_hfi_get_default_properties; } int venus_hfi_initialize(struct hfi_device *hdev, u32 device_id, @@ -4985,8 +4932,8 @@ int venus_hfi_initialize(struct hfi_device *hdev, u32 device_id, int rc = 0; if (!hdev || !res || !callback) { - dprintk(VIDC_ERR, "Invalid params: %pK %pK %pK\n", - hdev, res, callback); + d_vpr_e("%s: invalid params: %pK %pK %pK\n", + __func__, hdev, res, callback); rc = -EINVAL; goto err_venus_hfi_init; } diff --git a/msm/vidc/hfi_common.h b/msm/vidc/hfi_common.h index dc6c5706489a..500d73091a2a 100644 --- a/msm/vidc/hfi_common.h +++ b/msm/vidc/hfi_common.h @@ -235,17 +235,18 @@ enum reset_state { struct venus_hfi_device; struct venus_hfi_vpu_ops { - void (*interrupt_init)(struct venus_hfi_device *device); - void (*setup_ucregion_memmap)(struct venus_hfi_device *device); - void (*clock_config_on_enable)(struct venus_hfi_device *device); - int (*reset_ahb2axi_bridge)(struct venus_hfi_device *device); + void (*interrupt_init)(struct venus_hfi_device *device, u32 sid); + void (*setup_ucregion_memmap)(struct venus_hfi_device *device, u32 sid); + void (*clock_config_on_enable)(struct venus_hfi_device *device, + u32 sid); + int (*reset_ahb2axi_bridge)(struct venus_hfi_device *device, u32 sid); void (*power_off)(struct venus_hfi_device *device); int (*prepare_pc)(struct venus_hfi_device *device); - void (*raise_interrupt)(struct venus_hfi_device *device); + void (*raise_interrupt)(struct venus_hfi_device *device, u32 sid); bool (*watchdog)(u32 intr_status); void (*noc_error_info)(struct venus_hfi_device *device); void (*core_clear_interrupt)(struct venus_hfi_device *device); - int (*boot_firmware)(struct venus_hfi_device *device); + int (*boot_firmware)(struct venus_hfi_device *device, u32 sid); }; struct venus_hfi_device { @@ -290,30 +291,34 @@ int venus_hfi_initialize(struct hfi_device *hdev, u32 device_id, struct msm_vidc_platform_resources *res, hfi_cmd_response_callback callback); -void __write_register(struct venus_hfi_device *device, u32 reg, u32 value); -int __read_register(struct venus_hfi_device *device, u32 reg); +void __write_register(struct venus_hfi_device *device, + u32 reg, u32 value, u32 sid); +int __read_register(struct venus_hfi_device *device, u32 reg, u32 sid); void __disable_unprepare_clks(struct venus_hfi_device *device); int __disable_regulators(struct venus_hfi_device *device); -int __unvote_buses(struct venus_hfi_device *device); -int __reset_ahb2axi_bridge_common(struct venus_hfi_device *device); +int __unvote_buses(struct venus_hfi_device *device, u32 sid); +int __reset_ahb2axi_bridge_common(struct venus_hfi_device *device, u32 sid); int __prepare_pc(struct venus_hfi_device *device); /* AR50 specific */ -void __interrupt_init_ar50(struct venus_hfi_device *device); +void __interrupt_init_ar50(struct venus_hfi_device *device, u32 sid); /* IRIS1 specific */ -void __interrupt_init_iris1(struct venus_hfi_device *device); +void __interrupt_init_iris1(struct venus_hfi_device *device, u32 sid); void __setup_dsp_uc_memmap_iris1(struct venus_hfi_device *device); -void __clock_config_on_enable_iris1(struct venus_hfi_device *device); -void __setup_ucregion_memory_map_iris1(struct venus_hfi_device *device); +void __clock_config_on_enable_iris1(struct venus_hfi_device *device, + u32 sid); +void __setup_ucregion_memory_map_iris1(struct venus_hfi_device *device, + u32 sid); /* IRIS2 specific */ -void __interrupt_init_iris2(struct venus_hfi_device *device); -void __setup_ucregion_memory_map_iris2(struct venus_hfi_device *device); +void __interrupt_init_iris2(struct venus_hfi_device *device, u32 sid); +void __setup_ucregion_memory_map_iris2(struct venus_hfi_device *device, + u32 sid); void __power_off_iris2(struct venus_hfi_device *device); int __prepare_pc_iris2(struct venus_hfi_device *device); -void __raise_interrupt_iris2(struct venus_hfi_device *device); +void __raise_interrupt_iris2(struct venus_hfi_device *device, u32 sid); bool __watchdog_iris2(u32 intr_status); void __noc_error_info_iris2(struct venus_hfi_device *device); void __core_clear_interrupt_iris2(struct venus_hfi_device *device); -int __boot_firmware_iris2(struct venus_hfi_device *device); +int __boot_firmware_iris2(struct venus_hfi_device *device, u32 sid); #endif diff --git a/msm/vidc/hfi_iris1.c b/msm/vidc/hfi_iris1.c index 5789bd856394..b08eb68d9358 100644 --- a/msm/vidc/hfi_iris1.c +++ b/msm/vidc/hfi_iris1.c @@ -6,55 +6,55 @@ #include "hfi_common.h" #include "hfi_io_common.h" -void __interrupt_init_iris1(struct venus_hfi_device *device) +void __interrupt_init_iris1(struct venus_hfi_device *device, u32 sid) { u32 mask_val = 0; /* All interrupts should be disabled initially 0x1F6 : Reset value */ - mask_val = __read_register(device, WRAPPER_INTR_MASK); + mask_val = __read_register(device, WRAPPER_INTR_MASK, sid); /* Write 0 to unmask CPU and WD interrupts */ mask_val &= ~(WRAPPER_INTR_MASK_A2HWD_BMSK | WRAPPER_INTR_MASK_A2HCPU_BMSK); - __write_register(device, WRAPPER_INTR_MASK, mask_val); + __write_register(device, WRAPPER_INTR_MASK, mask_val, sid); } -void __setup_ucregion_memory_map_iris1(struct venus_hfi_device *device) +void __setup_ucregion_memory_map_iris1(struct venus_hfi_device *device, u32 sid) { /* initialize CPU QTBL & UCREGION */ __write_register(device, UC_REGION_ADDR, - (u32)device->iface_q_table.align_device_addr); - __write_register(device, UC_REGION_SIZE, SHARED_QSIZE); + (u32)device->iface_q_table.align_device_addr, sid); + __write_register(device, UC_REGION_SIZE, SHARED_QSIZE, sid); __write_register(device, QTBL_ADDR, - (u32)device->iface_q_table.align_device_addr); - __write_register(device, QTBL_INFO, 0x01); - if (device->sfr.align_device_addr) + (u32)device->iface_q_table.align_device_addr, sid); + __write_register(device, QTBL_INFO, 0x01, sid); + if (device->sfr.align_device_addr, sid) __write_register(device, SFR_ADDR, - (u32)device->sfr.align_device_addr); + (u32)device->sfr.align_device_addr, sid); if (device->qdss.align_device_addr) __write_register(device, MMAP_ADDR, - (u32)device->qdss.align_device_addr); + (u32)device->qdss.align_device_addr, sid); /* initialize DSP QTBL & UCREGION with CPU queues by default */ __write_register(device, HFI_DSP_QTBL_ADDR, - (u32)device->iface_q_table.align_device_addr); + (u32)device->iface_q_table.align_device_addr, sid); __write_register(device, HFI_DSP_UC_REGION_ADDR, - (u32)device->iface_q_table.align_device_addr); - __write_register(device, HFI_DSP_UC_REGION_SIZE, SHARED_QSIZE); + (u32)device->iface_q_table.align_device_addr, sid); + __write_register(device, HFI_DSP_UC_REGION_SIZE, SHARED_QSIZE, sid); if (device->res->cvp_internal) { /* initialize DSP QTBL & UCREGION with DSP queues */ __write_register(device, HFI_DSP_QTBL_ADDR, - (u32)device->dsp_iface_q_table.align_device_addr); + (u32)device->dsp_iface_q_table.align_device_addr, sid); __write_register(device, HFI_DSP_UC_REGION_ADDR, - (u32)device->dsp_iface_q_table.align_device_addr); + (u32)device->dsp_iface_q_table.align_device_addr, sid); __write_register(device, HFI_DSP_UC_REGION_SIZE, - device->dsp_iface_q_table.mem_data.size); + device->dsp_iface_q_table.mem_data.size, sid); } } -void __clock_config_on_enable_iris1(struct venus_hfi_device *device) +void __clock_config_on_enable_iris1(struct venus_hfi_device *device, u32 sid) { - __write_register(device, WRAPPER_CPU_CGC_DIS, 0); - __write_register(device, WRAPPER_CPU_CLOCK_CONFIG, 0); + __write_register(device, WRAPPER_CPU_CGC_DIS, 0, sid); + __write_register(device, WRAPPER_CPU_CLOCK_CONFIG, 0, sid); } diff --git a/msm/vidc/hfi_iris2.c b/msm/vidc/hfi_iris2.c index a352fbd4625c..e6eb40cd8f17 100644 --- a/msm/vidc/hfi_iris2.c +++ b/msm/vidc/hfi_iris2.c @@ -138,43 +138,45 @@ #define VCODEC_NOC_ERL_MAIN_ERRLOG3_LOW 0x00011238 #define VCODEC_NOC_ERL_MAIN_ERRLOG3_HIGH 0x0001123C -void __interrupt_init_iris2(struct venus_hfi_device *device) +void __interrupt_init_iris2(struct venus_hfi_device *device, u32 sid) { u32 mask_val = 0; /* All interrupts should be disabled initially 0x1F6 : Reset value */ - mask_val = __read_register(device, WRAPPER_INTR_MASK_IRIS2); + mask_val = __read_register(device, WRAPPER_INTR_MASK_IRIS2, sid); /* Write 0 to unmask CPU and WD interrupts */ mask_val &= ~(WRAPPER_INTR_MASK_A2HWD_BMSK_IRIS2| WRAPPER_INTR_MASK_A2HCPU_BMSK_IRIS2); - __write_register(device, WRAPPER_INTR_MASK_IRIS2, mask_val); + __write_register(device, WRAPPER_INTR_MASK_IRIS2, mask_val, sid); } -void __setup_ucregion_memory_map_iris2(struct venus_hfi_device *device) +void __setup_ucregion_memory_map_iris2(struct venus_hfi_device *device, u32 sid) { __write_register(device, UC_REGION_ADDR_IRIS2, - (u32)device->iface_q_table.align_device_addr); - __write_register(device, UC_REGION_SIZE_IRIS2, SHARED_QSIZE); + (u32)device->iface_q_table.align_device_addr, sid); + __write_register(device, UC_REGION_SIZE_IRIS2, SHARED_QSIZE, sid); __write_register(device, QTBL_ADDR_IRIS2, - (u32)device->iface_q_table.align_device_addr); - __write_register(device, QTBL_INFO_IRIS2, 0x01); + (u32)device->iface_q_table.align_device_addr, sid); + __write_register(device, QTBL_INFO_IRIS2, 0x01, sid); if (device->sfr.align_device_addr) __write_register(device, SFR_ADDR_IRIS2, - (u32)device->sfr.align_device_addr); + (u32)device->sfr.align_device_addr, sid); if (device->qdss.align_device_addr) __write_register(device, MMAP_ADDR_IRIS2, - (u32)device->qdss.align_device_addr); + (u32)device->qdss.align_device_addr, sid); /* update queues vaddr for debug purpose */ __write_register(device, CPU_CS_VCICMDARG0_IRIS2, - (u32)device->iface_q_table.align_virtual_addr); + (u32)device->iface_q_table.align_virtual_addr, sid); __write_register(device, CPU_CS_VCICMDARG1_IRIS2, - (u32)((u64)device->iface_q_table.align_virtual_addr >> 32)); + (u32)((u64)device->iface_q_table.align_virtual_addr >> 32), + sid); } void __power_off_iris2(struct venus_hfi_device *device) { u32 lpi_status, reg_status = 0, count = 0, max_count = 10; + u32 sid = DEFAULT_SID; if (!device->power_enabled) return; @@ -184,78 +186,70 @@ void __power_off_iris2(struct venus_hfi_device *device) device->intr_status = 0; /* HPG 6.1.2 Step 1 */ - __write_register(device, CPU_CS_X2RPMh_IRIS2, 0x3); + __write_register(device, CPU_CS_X2RPMh_IRIS2, 0x3, sid); /* HPG 6.1.2 Step 2, noc to low power */ - __write_register(device, AON_WRAPPER_MVP_NOC_LPI_CONTROL, 0x1); + __write_register(device, AON_WRAPPER_MVP_NOC_LPI_CONTROL, 0x1, sid); while (!reg_status && count < max_count) { lpi_status = __read_register(device, - AON_WRAPPER_MVP_NOC_LPI_STATUS); + AON_WRAPPER_MVP_NOC_LPI_STATUS, sid); reg_status = lpi_status & BIT(0); - dprintk(VIDC_HIGH, - "Noc: lpi_status %d noc_status %d (count %d)\n", + d_vpr_h("Noc: lpi_status %d noc_status %d (count %d)\n", lpi_status, reg_status, count); usleep_range(50, 100); count++; } if (count == max_count) { - dprintk(VIDC_ERR, - "NOC not in qaccept status %d\n", reg_status); + d_vpr_e("NOC not in qaccept status %d\n", reg_status); } /* HPG 6.1.2 Step 3, debug bridge to low power */ __write_register(device, - WRAPPER_DEBUG_BRIDGE_LPI_CONTROL_IRIS2, 0x7); + WRAPPER_DEBUG_BRIDGE_LPI_CONTROL_IRIS2, 0x7, sid); reg_status = 0; count = 0; while ((reg_status != 0x7) && count < max_count) { lpi_status = __read_register(device, - WRAPPER_DEBUG_BRIDGE_LPI_STATUS_IRIS2); + WRAPPER_DEBUG_BRIDGE_LPI_STATUS_IRIS2, sid); reg_status = lpi_status & 0x7; - dprintk(VIDC_HIGH, - "DBLP Set : lpi_status %d reg_status %d (count %d)\n", + d_vpr_h("DBLP Set : lpi_status %d reg_status %d (count %d)\n", lpi_status, reg_status, count); usleep_range(50, 100); count++; } - if (count == max_count) { - dprintk(VIDC_ERR, - "DBLP Set: status %d\n", reg_status); - } + if (count == max_count) + d_vpr_e("DBLP Set: status %d\n", reg_status); /* HPG 6.1.2 Step 4, debug bridge to lpi release */ __write_register(device, - WRAPPER_DEBUG_BRIDGE_LPI_CONTROL_IRIS2, 0x0); + WRAPPER_DEBUG_BRIDGE_LPI_CONTROL_IRIS2, 0x0, sid); lpi_status = 0x1; count = 0; while (lpi_status && count < max_count) { lpi_status = __read_register(device, - WRAPPER_DEBUG_BRIDGE_LPI_STATUS_IRIS2); - dprintk(VIDC_HIGH, - "DBLP Release: lpi_status %d(count %d)\n", + WRAPPER_DEBUG_BRIDGE_LPI_STATUS_IRIS2, sid); + d_vpr_h("DBLP Release: lpi_status %d(count %d)\n", lpi_status, count); usleep_range(50, 100); count++; } - if (count == max_count) { - dprintk(VIDC_ERR, - "DBLP Release: lpi_status %d\n", lpi_status); - } + if (count == max_count) + d_vpr_e("DBLP Release: lpi_status %d\n", lpi_status); /* HPG 6.1.2 Step 6 */ __disable_unprepare_clks(device); /* HPG 6.1.2 Step 7 & 8 */ - if (call_venus_op(device, reset_ahb2axi_bridge, device)) - dprintk(VIDC_ERR, "Failed to reset ahb2axi\n"); + if (call_venus_op(device, reset_ahb2axi_bridge, device, sid)) + d_vpr_e("%s: Failed to reset ahb2axi\n", __func__); /* HPG 6.1.2 Step 5 */ if (__disable_regulators(device)) - dprintk(VIDC_ERR, "Failed to disable regulators\n"); + d_vpr_e("%s: Failed to disable regulators\n", __func__); - if (__unvote_buses(device)) - dprintk(VIDC_ERR, "Failed to unvote for buses\n"); + if (__unvote_buses(device, sid)) + d_vpr_e("%s: Failed to unvote for buses\n", __func__); device->power_enabled = false; } @@ -267,32 +261,33 @@ int __prepare_pc_iris2(struct venus_hfi_device *device) int count = 0; const int max_tries = 10; - ctrl_status = __read_register(device, CTRL_STATUS_IRIS2); + ctrl_status = __read_register(device, CTRL_STATUS_IRIS2, DEFAULT_SID); pc_ready = ctrl_status & CTRL_STATUS_PC_READY_IRIS2; idle_status = ctrl_status & BIT(30); if (pc_ready) { - dprintk(VIDC_HIGH, "Already in pc_ready state\n"); + d_vpr_h("Already in pc_ready state\n"); return 0; } - wfi_status = BIT(0) & __read_register(device, - WRAPPER_TZ_CPU_STATUS); + wfi_status = BIT(0) & __read_register(device, WRAPPER_TZ_CPU_STATUS, + DEFAULT_SID); if (!wfi_status || !idle_status) { - dprintk(VIDC_ERR, "Skipping PC, wfi status not set\n"); + d_vpr_e("Skipping PC, wfi status not set\n"); goto skip_power_off; } rc = __prepare_pc(device); if (rc) { - dprintk(VIDC_ERR, "Failed __prepare_pc %d\n", rc); + d_vpr_e("Failed __prepare_pc %d\n", rc); goto skip_power_off; } while (count < max_tries) { wfi_status = BIT(0) & __read_register(device, - WRAPPER_TZ_CPU_STATUS); - ctrl_status = __read_register(device, CTRL_STATUS_IRIS2); + WRAPPER_TZ_CPU_STATUS, DEFAULT_SID); + ctrl_status = __read_register(device, + CTRL_STATUS_IRIS2, DEFAULT_SID); if (wfi_status && (ctrl_status & CTRL_STATUS_PC_READY_IRIS2)) break; usleep_range(150, 250); @@ -300,22 +295,22 @@ int __prepare_pc_iris2(struct venus_hfi_device *device) } if (count == max_tries) { - dprintk(VIDC_ERR, "Skip PC. Core is not in right state\n"); + d_vpr_e("Skip PC. Core is not in right state\n"); goto skip_power_off; } return rc; skip_power_off: - dprintk(VIDC_ERR, "Skip PC, wfi=%#x, idle=%#x, pcr=%#x, ctrl=%#x)\n", + d_vpr_e("Skip PC, wfi=%#x, idle=%#x, pcr=%#x, ctrl=%#x)\n", wfi_status, idle_status, pc_ready, ctrl_status); return -EAGAIN; } -void __raise_interrupt_iris2(struct venus_hfi_device *device) +void __raise_interrupt_iris2(struct venus_hfi_device *device, u32 sid) { __write_register(device, CPU_IC_SOFTINT_IRIS2, - 1 << CPU_IC_SOFTINT_H2A_SHFT_IRIS2); + 1 << CPU_IC_SOFTINT_H2A_SHFT_IRIS2, sid); } bool __watchdog_iris2(u32 intr_status) @@ -331,33 +326,34 @@ bool __watchdog_iris2(u32 intr_status) void __noc_error_info_iris2(struct venus_hfi_device *device) { u32 val = 0; + u32 sid = DEFAULT_SID; - val = __read_register(device, VCODEC_NOC_ERL_MAIN_SWID_LOW); - dprintk(VIDC_ERR, "VCODEC_NOC_ERL_MAIN_SWID_LOW: %#x\n", val); - val = __read_register(device, VCODEC_NOC_ERL_MAIN_SWID_HIGH); - dprintk(VIDC_ERR, "VCODEC_NOC_ERL_MAIN_SWID_HIGH: %#x\n", val); - val = __read_register(device, VCODEC_NOC_ERL_MAIN_MAINCTL_LOW); - dprintk(VIDC_ERR, "VCODEC_NOC_ERL_MAIN_MAINCTL_LOW: %#x\n", val); - val = __read_register(device, VCODEC_NOC_ERL_MAIN_ERRVLD_LOW); - dprintk(VIDC_ERR, "VCODEC_NOC_ERL_MAIN_ERRVLD_LOW: %#x\n", val); - val = __read_register(device, VCODEC_NOC_ERL_MAIN_ERRCLR_LOW); - dprintk(VIDC_ERR, "VCODEC_NOC_ERL_MAIN_ERRCLR_LOW: %#x\n", val); - val = __read_register(device, VCODEC_NOC_ERL_MAIN_ERRLOG0_LOW); - dprintk(VIDC_ERR, "VCODEC_NOC_ERL_MAIN_ERRLOG0_LOW: %#x\n", val); - val = __read_register(device, VCODEC_NOC_ERL_MAIN_ERRLOG0_HIGH); - dprintk(VIDC_ERR, "VCODEC_NOC_ERL_MAIN_ERRLOG0_HIGH: %#x\n", val); - val = __read_register(device, VCODEC_NOC_ERL_MAIN_ERRLOG1_LOW); - dprintk(VIDC_ERR, "VCODEC_NOC_ERL_MAIN_ERRLOG1_LOW: %#x\n", val); - val = __read_register(device, VCODEC_NOC_ERL_MAIN_ERRLOG1_HIGH); - dprintk(VIDC_ERR, "VCODEC_NOC_ERL_MAIN_ERRLOG1_HIGH: %#x\n", val); - val = __read_register(device, VCODEC_NOC_ERL_MAIN_ERRLOG2_LOW); - dprintk(VIDC_ERR, "VCODEC_NOC_ERL_MAIN_ERRLOG2_LOW: %#x\n", val); - val = __read_register(device, VCODEC_NOC_ERL_MAIN_ERRLOG2_HIGH); - dprintk(VIDC_ERR, "VCODEC_NOC_ERL_MAIN_ERRLOG2_HIGH: %#x\n", val); - val = __read_register(device, VCODEC_NOC_ERL_MAIN_ERRLOG3_LOW); - dprintk(VIDC_ERR, "VCODEC_NOC_ERL_MAIN_ERRLOG3_LOW: %#x\n", val); - val = __read_register(device, VCODEC_NOC_ERL_MAIN_ERRLOG3_HIGH); - dprintk(VIDC_ERR, "VCODEC_NOC_ERL_MAIN_ERRLOG3_HIGH: %#x\n", val); + val = __read_register(device, VCODEC_NOC_ERL_MAIN_SWID_LOW, sid); + d_vpr_e("VCODEC_NOC_ERL_MAIN_SWID_LOW: %#x\n", val); + val = __read_register(device, VCODEC_NOC_ERL_MAIN_SWID_HIGH, sid); + d_vpr_e("VCODEC_NOC_ERL_MAIN_SWID_HIGH: %#x\n", val); + val = __read_register(device, VCODEC_NOC_ERL_MAIN_MAINCTL_LOW, sid); + d_vpr_e("VCODEC_NOC_ERL_MAIN_MAINCTL_LOW: %#x\n", val); + val = __read_register(device, VCODEC_NOC_ERL_MAIN_ERRVLD_LOW, sid); + d_vpr_e("VCODEC_NOC_ERL_MAIN_ERRVLD_LOW: %#x\n", val); + val = __read_register(device, VCODEC_NOC_ERL_MAIN_ERRCLR_LOW, sid); + d_vpr_e("VCODEC_NOC_ERL_MAIN_ERRCLR_LOW: %#x\n", val); + val = __read_register(device, VCODEC_NOC_ERL_MAIN_ERRLOG0_LOW, sid); + d_vpr_e("VCODEC_NOC_ERL_MAIN_ERRLOG0_LOW: %#x\n", val); + val = __read_register(device, VCODEC_NOC_ERL_MAIN_ERRLOG0_HIGH, sid); + d_vpr_e("VCODEC_NOC_ERL_MAIN_ERRLOG0_HIGH: %#x\n", val); + val = __read_register(device, VCODEC_NOC_ERL_MAIN_ERRLOG1_LOW, sid); + d_vpr_e("VCODEC_NOC_ERL_MAIN_ERRLOG1_LOW: %#x\n", val); + val = __read_register(device, VCODEC_NOC_ERL_MAIN_ERRLOG1_HIGH, sid); + d_vpr_e("VCODEC_NOC_ERL_MAIN_ERRLOG1_HIGH: %#x\n", val); + val = __read_register(device, VCODEC_NOC_ERL_MAIN_ERRLOG2_LOW, sid); + d_vpr_e("VCODEC_NOC_ERL_MAIN_ERRLOG2_LOW: %#x\n", val); + val = __read_register(device, VCODEC_NOC_ERL_MAIN_ERRLOG2_HIGH, sid); + d_vpr_e("VCODEC_NOC_ERL_MAIN_ERRLOG2_HIGH: %#x\n", val); + val = __read_register(device, VCODEC_NOC_ERL_MAIN_ERRLOG3_LOW, sid); + d_vpr_e("VCODEC_NOC_ERL_MAIN_ERRLOG3_LOW: %#x\n", val); + val = __read_register(device, VCODEC_NOC_ERL_MAIN_ERRLOG3_HIGH, sid); + d_vpr_e("VCODEC_NOC_ERL_MAIN_ERRLOG3_HIGH: %#x\n", val); } void __core_clear_interrupt_iris2(struct venus_hfi_device *device) @@ -365,11 +361,12 @@ void __core_clear_interrupt_iris2(struct venus_hfi_device *device) u32 intr_status = 0, mask = 0; if (!device) { - dprintk(VIDC_ERR, "%s: NULL device\n", __func__); + d_vpr_e("%s: NULL device\n", __func__); return; } - intr_status = __read_register(device, WRAPPER_INTR_STATUS_IRIS2); + intr_status = __read_register(device, WRAPPER_INTR_STATUS_IRIS2, + DEFAULT_SID); mask = (WRAPPER_INTR_STATUS_A2H_BMSK_IRIS2| WRAPPER_INTR_STATUS_A2HWD_BMSK_IRIS2| CTRL_INIT_IDLE_MSG_BMSK_IRIS2); @@ -377,17 +374,16 @@ void __core_clear_interrupt_iris2(struct venus_hfi_device *device) if (intr_status & mask) { device->intr_status |= intr_status; device->reg_count++; - dprintk(VIDC_LOW, - "INTERRUPT for device: %pK: times: %d interrupt_status: %d\n", - device, device->reg_count, intr_status); + d_vpr_l("INTERRUPT: times: %d interrupt_status: %d\n", + device->reg_count, intr_status); } else { device->spur_count++; } - __write_register(device, CPU_CS_A2HSOFTINTCLR_IRIS2, 1); + __write_register(device, CPU_CS_A2HSOFTINTCLR_IRIS2, 1, DEFAULT_SID); } -int __boot_firmware_iris2(struct venus_hfi_device *device) +int __boot_firmware_iris2(struct venus_hfi_device *device, u32 sid) { int rc = 0; u32 ctrl_init_val = 0, ctrl_status = 0, count = 0, max_tries = 1000; @@ -396,11 +392,11 @@ int __boot_firmware_iris2(struct venus_hfi_device *device) if (device->res->cvp_internal) ctrl_init_val |= BIT(1); - __write_register(device, CTRL_INIT_IRIS2, ctrl_init_val); + __write_register(device, CTRL_INIT_IRIS2, ctrl_init_val, sid); while (!ctrl_status && count < max_tries) { - ctrl_status = __read_register(device, CTRL_STATUS_IRIS2); + ctrl_status = __read_register(device, CTRL_STATUS_IRIS2, sid); if ((ctrl_status & CTRL_ERROR_STATUS__M_IRIS2) == 0x4) { - dprintk(VIDC_ERR, "invalid setting for UC_REGION\n"); + s_vpr_e(sid, "invalid setting for UC_REGION\n"); break; } @@ -409,13 +405,13 @@ int __boot_firmware_iris2(struct venus_hfi_device *device) } if (count >= max_tries) { - dprintk(VIDC_ERR, "Error booting up vidc firmware\n"); + s_vpr_e(sid, "Error booting up vidc firmware\n"); rc = -ETIME; } /* Enable interrupt before sending commands to venus */ - __write_register(device, CPU_CS_H2XSOFTINTEN_IRIS2, 0x1); - __write_register(device, CPU_CS_X2RPMh_IRIS2, 0x0); + __write_register(device, CPU_CS_H2XSOFTINTEN_IRIS2, 0x1, sid); + __write_register(device, CPU_CS_X2RPMh_IRIS2, 0x0, sid); return rc; } diff --git a/msm/vidc/hfi_packetization.c b/msm/vidc/hfi_packetization.c index ebd8066aeba9..27cd92c17c70 100644 --- a/msm/vidc/hfi_packetization.c +++ b/msm/vidc/hfi_packetization.c @@ -5,81 +5,7 @@ #include "hfi_packetization.h" #include "msm_vidc_debug.h" -/* Set up look-up tables to convert HAL_* to HFI_*. - * - * The tables below mostly take advantage of the fact that most - * HAL_* types are defined bitwise. So if we index them normally - * when declaring the tables, we end up with huge arrays with wasted - * space. So before indexing them, we apply log2 to use a more - * sensible index. - */ - -enum hal_domain vidc_get_hal_domain(u32 hfi_domain) -{ - enum hal_domain hal_domain = 0; - - switch (hfi_domain) { - case HFI_VIDEO_DOMAIN_VPE: - hal_domain = HAL_VIDEO_DOMAIN_VPE; - break; - case HFI_VIDEO_DOMAIN_ENCODER: - hal_domain = HAL_VIDEO_DOMAIN_ENCODER; - break; - case HFI_VIDEO_DOMAIN_DECODER: - hal_domain = HAL_VIDEO_DOMAIN_DECODER; - break; - case HFI_VIDEO_DOMAIN_CVP: - hal_domain = HAL_VIDEO_DOMAIN_CVP; - break; - default: - dprintk(VIDC_ERR, "%s: invalid domain %x\n", - __func__, hfi_domain); - hal_domain = 0; - break; - } - return hal_domain; -} - -enum hal_video_codec vidc_get_hal_codec(u32 hfi_codec) -{ - enum hal_video_codec hal_codec = 0; - - switch (hfi_codec) { - case HFI_VIDEO_CODEC_H264: - hal_codec = HAL_VIDEO_CODEC_H264; - break; - case HFI_VIDEO_CODEC_MPEG1: - hal_codec = HAL_VIDEO_CODEC_MPEG1; - break; - case HFI_VIDEO_CODEC_MPEG2: - hal_codec = HAL_VIDEO_CODEC_MPEG2; - break; - case HFI_VIDEO_CODEC_VP8: - hal_codec = HAL_VIDEO_CODEC_VP8; - break; - case HFI_VIDEO_CODEC_HEVC: - hal_codec = HAL_VIDEO_CODEC_HEVC; - break; - case HFI_VIDEO_CODEC_VP9: - hal_codec = HAL_VIDEO_CODEC_VP9; - break; - case HFI_VIDEO_CODEC_TME: - hal_codec = HAL_VIDEO_CODEC_TME; - break; - case HFI_VIDEO_CODEC_CVP: - hal_codec = HAL_VIDEO_CODEC_CVP; - break; - default: - dprintk(VIDC_HIGH, "%s: invalid codec 0x%x\n", - __func__, hfi_codec); - hal_codec = 0; - break; - } - return hal_codec; -} - - -u32 vidc_get_hfi_domain(enum hal_domain hal_domain) +u32 vidc_get_hfi_domain(enum hal_domain hal_domain, u32 sid) { u32 hfi_domain; @@ -97,7 +23,7 @@ u32 vidc_get_hfi_domain(enum hal_domain hal_domain) hfi_domain = HFI_VIDEO_DOMAIN_CVP; break; default: - dprintk(VIDC_ERR, "%s: invalid domain 0x%x\n", + s_vpr_e(sid, "%s: invalid domain 0x%x\n", __func__, hal_domain); hfi_domain = 0; break; @@ -105,7 +31,7 @@ u32 vidc_get_hfi_domain(enum hal_domain hal_domain) return hfi_domain; } -u32 vidc_get_hfi_codec(enum hal_video_codec hal_codec) +u32 vidc_get_hfi_codec(enum hal_video_codec hal_codec, u32 sid) { u32 hfi_codec = 0; @@ -135,7 +61,7 @@ u32 vidc_get_hfi_codec(enum hal_video_codec hal_codec) hfi_codec = HFI_VIDEO_CODEC_CVP; break; default: - dprintk(VIDC_HIGH, "%s: invalid codec 0x%x\n", + s_vpr_h(sid, "%s: invalid codec 0x%x\n", __func__, hal_codec); hfi_codec = 0; break; @@ -194,10 +120,10 @@ int create_pkt_cmd_sys_debug_config( int create_pkt_cmd_sys_coverage_config( struct hfi_cmd_sys_set_property_packet *pkt, - u32 mode) + u32 mode, u32 sid) { if (!pkt) { - dprintk(VIDC_ERR, "In %s(), No input packet\n", __func__); + s_vpr_e(sid, "In %s(), No input packet\n", __func__); return -EINVAL; } @@ -207,8 +133,7 @@ int create_pkt_cmd_sys_coverage_config( pkt->num_properties = 1; pkt->rg_property_data[0] = HFI_PROPERTY_SYS_CONFIG_COVERAGE; pkt->rg_property_data[1] = mode; - dprintk(VIDC_HIGH, "Firmware coverage mode %d\n", - pkt->rg_property_data[1]); + s_vpr_h(sid, "Firmware coverage mode %d\n", pkt->rg_property_data[1]); return 0; } @@ -221,8 +146,7 @@ int create_pkt_cmd_sys_set_resource( u32 i = 0; if (!pkt || !res_hdr || !res_value) { - dprintk(VIDC_ERR, - "Invalid paramas pkt %pK res_hdr %pK res_value %pK\n", + d_vpr_e("Invalid paramas pkt %pK res_hdr %pK res_value %pK\n", pkt, res_hdr, res_value); return -EINVAL; } @@ -256,14 +180,13 @@ int create_pkt_cmd_sys_set_resource( for (i = 0; i < hfi_sc_info->num_entries; i++) { hfi_sc[i] = res_sc[i]; - dprintk(VIDC_HIGH, "entry hfi#%d, sc_id %d, size %d\n", + d_vpr_h("entry hfi#%d, sc_id %d, size %d\n", i, hfi_sc[i].sc_id, hfi_sc[i].size); } break; } default: - dprintk(VIDC_ERR, - "Invalid resource_id %d\n", res_hdr->resource_id); + d_vpr_e("Invalid resource_id %d\n", res_hdr->resource_id); rc = -ENOTSUPP; } @@ -277,8 +200,7 @@ int create_pkt_cmd_sys_release_resource( int rc = 0; if (!pkt || !res_hdr) { - dprintk(VIDC_ERR, - "Invalid paramas pkt %pK res_hdr %pK\n", + d_vpr_e("Invalid paramas pkt %pK res_hdr %pK\n", pkt, res_hdr); return -EINVAL; } @@ -292,13 +214,11 @@ int create_pkt_cmd_sys_release_resource( pkt->resource_type = HFI_RESOURCE_SYSCACHE; break; default: - dprintk(VIDC_ERR, - "Invalid resource_id %d\n", res_hdr->resource_id); + d_vpr_e("Invalid resource_id %d\n", res_hdr->resource_id); rc = -ENOTSUPP; } - dprintk(VIDC_HIGH, - "rel_res: pkt_type 0x%x res_type 0x%x prepared\n", + d_vpr_h("rel_res: pkt_type 0x%x res_type 0x%x prepared\n", pkt->packet_type, pkt->resource_type); return rc; @@ -306,8 +226,7 @@ int create_pkt_cmd_sys_release_resource( inline int create_pkt_cmd_sys_session_init( struct hfi_cmd_sys_session_init_packet *pkt, - struct hal_session *session, - u32 session_domain, u32 session_codec) + u32 sid, u32 session_domain, u32 session_codec) { int rc = 0; @@ -316,9 +235,9 @@ inline int create_pkt_cmd_sys_session_init( pkt->size = sizeof(struct hfi_cmd_sys_session_init_packet); pkt->packet_type = HFI_CMD_SYS_SESSION_INIT; - pkt->session_id = hash32_ptr(session); - pkt->session_domain = vidc_get_hfi_domain(session_domain); - pkt->session_codec = vidc_get_hfi_codec(session_codec); + pkt->sid = sid; + pkt->session_domain = vidc_get_hfi_domain(session_domain, sid); + pkt->session_codec = vidc_get_hfi_codec(session_codec, sid); if (!pkt->session_codec) return -EINVAL; @@ -369,9 +288,8 @@ int create_pkt_cmd_sys_ubwc_config( return rc; } - int create_pkt_cmd_session_cmd(struct vidc_hal_session_cmd_pkt *pkt, - int pkt_type, struct hal_session *session) + int pkt_type, u32 sid) { int rc = 0; @@ -380,7 +298,7 @@ int create_pkt_cmd_session_cmd(struct vidc_hal_session_cmd_pkt *pkt, pkt->size = sizeof(struct vidc_hal_session_cmd_pkt); pkt->packet_type = pkt_type; - pkt->session_id = hash32_ptr(session); + pkt->sid = sid; return rc; } @@ -391,7 +309,7 @@ int create_pkt_cmd_sys_power_control( struct hfi_enable *hfi; if (!pkt) { - dprintk(VIDC_ERR, "No input packet\n"); + d_vpr_e("%s: No input packet\n", __func__); return -EINVAL; } @@ -405,7 +323,7 @@ int create_pkt_cmd_sys_power_control( return 0; } -static u32 get_hfi_buffer(int hal_buffer) +static u32 get_hfi_buffer(int hal_buffer, u32 sid) { u32 buffer; @@ -444,8 +362,7 @@ static u32 get_hfi_buffer(int hal_buffer) buffer = HFI_BUFFER_INTERNAL_PERSIST_1; break; default: - dprintk(VIDC_ERR, "Invalid buffer: %#x\n", - hal_buffer); + s_vpr_e(sid, "Invalid buffer: %#x\n", hal_buffer); buffer = 0; break; } @@ -454,17 +371,16 @@ static u32 get_hfi_buffer(int hal_buffer) int create_pkt_cmd_session_set_buffers( struct hfi_cmd_session_set_buffers_packet *pkt, - struct hal_session *session, - struct vidc_buffer_addr_info *buffer_info) + u32 sid, struct vidc_buffer_addr_info *buffer_info) { int rc = 0; u32 i = 0; - if (!pkt || !session) + if (!pkt) return -EINVAL; pkt->packet_type = HFI_CMD_SESSION_SET_BUFFERS; - pkt->session_id = hash32_ptr(session); + pkt->sid = sid; pkt->buffer_size = buffer_info->buffer_size; pkt->min_buffer_size = buffer_info->buffer_size; pkt->num_buffers = buffer_info->num_buffers; @@ -495,7 +411,8 @@ int create_pkt_cmd_session_set_buffers( } } - pkt->buffer_type = get_hfi_buffer(buffer_info->buffer_type); + pkt->buffer_type = + get_hfi_buffer(buffer_info->buffer_type, pkt->sid); if (!pkt->buffer_type) return -EINVAL; @@ -504,17 +421,16 @@ int create_pkt_cmd_session_set_buffers( int create_pkt_cmd_session_release_buffers( struct hfi_cmd_session_release_buffer_packet *pkt, - struct hal_session *session, - struct vidc_buffer_addr_info *buffer_info) + u32 sid, struct vidc_buffer_addr_info *buffer_info) { int rc = 0; u32 i = 0; - if (!pkt || !session) + if (!pkt) return -EINVAL; pkt->packet_type = HFI_CMD_SESSION_RELEASE_BUFFERS; - pkt->session_id = hash32_ptr(session); + pkt->sid = sid; pkt->buffer_size = buffer_info->buffer_size; pkt->num_buffers = buffer_info->num_buffers; @@ -542,7 +458,8 @@ int create_pkt_cmd_session_release_buffers( ((buffer_info->num_buffers - 1) * sizeof(u32)); } pkt->response_req = buffer_info->response_required; - pkt->buffer_type = get_hfi_buffer(buffer_info->buffer_type); + pkt->buffer_type = + get_hfi_buffer(buffer_info->buffer_type, pkt->sid); if (!pkt->buffer_type) return -EINVAL; return rc; @@ -550,20 +467,18 @@ int create_pkt_cmd_session_release_buffers( int create_pkt_cmd_session_register_buffer( struct hfi_cmd_session_register_buffers_packet *pkt, - struct hal_session *session, - struct vidc_register_buffer *buffer) + u32 sid, struct vidc_register_buffer *buffer) { int rc = 0; u32 i; struct hfi_buffer_mapping_type *buf; - if (!pkt || !session) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + if (!pkt) { + d_vpr_e("%s: invalid params %pK\n", __func__, pkt); return -EINVAL; } - pkt->packet_type = HFI_CMD_SESSION_REGISTER_BUFFERS; - pkt->session_id = hash32_ptr(session); + pkt->sid = sid; pkt->client_data = buffer->client_data; pkt->response_req = buffer->response_required; pkt->num_buffers = 1; @@ -584,20 +499,18 @@ int create_pkt_cmd_session_register_buffer( int create_pkt_cmd_session_unregister_buffer( struct hfi_cmd_session_unregister_buffers_packet *pkt, - struct hal_session *session, - struct vidc_unregister_buffer *buffer) + u32 sid, struct vidc_unregister_buffer *buffer) { int rc = 0; u32 i; struct hfi_buffer_mapping_type *buf; - if (!pkt || !session) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + if (!pkt) { + d_vpr_e("%s: invalid params %pK\n", __func__, pkt); return -EINVAL; } - pkt->packet_type = HFI_CMD_SESSION_UNREGISTER_BUFFERS; - pkt->session_id = hash32_ptr(session); + pkt->sid = sid; pkt->client_data = buffer->client_data; pkt->response_req = buffer->response_required; pkt->num_buffers = 1; @@ -618,17 +531,17 @@ int create_pkt_cmd_session_unregister_buffer( int create_pkt_cmd_session_etb_decoder( struct hfi_cmd_session_empty_buffer_compressed_packet *pkt, - struct hal_session *session, struct vidc_frame_data *input_frame) + u32 sid, struct vidc_frame_data *input_frame) { int rc = 0; - if (!pkt || !session) + if (!pkt) return -EINVAL; pkt->size = sizeof(struct hfi_cmd_session_empty_buffer_compressed_packet); pkt->packet_type = HFI_CMD_SESSION_EMPTY_BUFFER; - pkt->session_id = hash32_ptr(session); + pkt->sid = sid; pkt->time_stamp_hi = upper_32_bits(input_frame->timestamp); pkt->time_stamp_lo = lower_32_bits(input_frame->timestamp); pkt->flags = input_frame->flags; @@ -650,17 +563,17 @@ int create_pkt_cmd_session_etb_decoder( int create_pkt_cmd_session_etb_encoder( struct hfi_cmd_session_empty_buffer_uncompressed_plane0_packet *pkt, - struct hal_session *session, struct vidc_frame_data *input_frame) + u32 sid, struct vidc_frame_data *input_frame) { int rc = 0; - if (!pkt || !session) + if (!pkt) return -EINVAL; pkt->size = sizeof(struct hfi_cmd_session_empty_buffer_uncompressed_plane0_packet); pkt->packet_type = HFI_CMD_SESSION_EMPTY_BUFFER; - pkt->session_id = hash32_ptr(session); + pkt->sid = sid; pkt->view_id = 0; pkt->time_stamp_hi = upper_32_bits(input_frame->timestamp); pkt->time_stamp_lo = lower_32_bits(input_frame->timestamp); @@ -683,17 +596,16 @@ int create_pkt_cmd_session_etb_encoder( } int create_pkt_cmd_session_ftb(struct hfi_cmd_session_fill_buffer_packet *pkt, - struct hal_session *session, - struct vidc_frame_data *output_frame) + u32 sid, struct vidc_frame_data *output_frame) { int rc = 0; - if (!pkt || !session || !output_frame) + if (!pkt || !output_frame) return -EINVAL; pkt->size = sizeof(struct hfi_cmd_session_fill_buffer_packet); pkt->packet_type = HFI_CMD_SESSION_FILL_BUFFER; - pkt->session_id = hash32_ptr(session); + pkt->sid = sid; if (output_frame->buffer_type == HAL_BUFFER_OUTPUT) pkt->stream_id = 0; @@ -720,16 +632,16 @@ int create_pkt_cmd_session_ftb(struct hfi_cmd_session_fill_buffer_packet *pkt, int create_pkt_cmd_session_get_buf_req( struct hfi_cmd_session_get_property_packet *pkt, - struct hal_session *session) + u32 sid) { int rc = 0; - if (!pkt || !session) + if (!pkt) return -EINVAL; pkt->size = sizeof(struct hfi_cmd_session_get_property_packet); pkt->packet_type = HFI_CMD_SESSION_GET_PROPERTY; - pkt->session_id = hash32_ptr(session); + pkt->sid = sid; pkt->num_properties = 1; pkt->rg_property_data[0] = HFI_PROPERTY_CONFIG_BUFFER_REQUIREMENTS; @@ -737,16 +649,16 @@ int create_pkt_cmd_session_get_buf_req( } int create_pkt_cmd_session_flush(struct hfi_cmd_session_flush_packet *pkt, - struct hal_session *session, enum hal_flush flush_mode) + u32 sid, enum hal_flush flush_mode) { int rc = 0; - if (!pkt || !session) + if (!pkt) return -EINVAL; pkt->size = sizeof(struct hfi_cmd_session_flush_packet); pkt->packet_type = HFI_CMD_SESSION_FLUSH; - pkt->session_id = hash32_ptr(session); + pkt->sid = sid; switch (flush_mode) { case HAL_FLUSH_INPUT: pkt->flush_type = HFI_FLUSH_INPUT; @@ -758,7 +670,7 @@ int create_pkt_cmd_session_flush(struct hfi_cmd_session_flush_packet *pkt, pkt->flush_type = HFI_FLUSH_ALL; break; default: - dprintk(VIDC_ERR, "Invalid flush mode: %#x\n", flush_mode); + s_vpr_e(pkt->sid, "Invalid flush mode: %#x\n", flush_mode); return -EINVAL; } return rc; @@ -766,22 +678,22 @@ int create_pkt_cmd_session_flush(struct hfi_cmd_session_flush_packet *pkt, int create_pkt_cmd_session_set_property( struct hfi_cmd_session_set_property_packet *pkt, - struct hal_session *session, + u32 sid, u32 ptype, void *pdata, u32 size) { - if (!pkt || !session) + if (!pkt) return -EINVAL; pkt->size = sizeof(struct hfi_cmd_session_set_property_packet); pkt->packet_type = HFI_CMD_SESSION_SET_PROPERTY; - pkt->session_id = hash32_ptr(session); + pkt->sid = sid; pkt->num_properties = 1; pkt->size += size; pkt->rg_property_data[0] = ptype; if (size && pdata) memcpy(&pkt->rg_property_data[1], pdata, size); - dprintk(VIDC_HIGH, "Setting HAL Property = 0x%x\n", ptype); + s_vpr_h(pkt->sid, "Setting HAL Property = 0x%x\n", ptype); return 0; } @@ -800,8 +712,7 @@ static int get_hfi_ssr_type(enum hal_ssr_trigger_type type) rc = HFI_TEST_SSR_HW_WDOG_IRQ; break; default: - dprintk(VIDC_ERR, - "SSR trigger type not recognized, using WDOG.\n"); + d_vpr_e("SSR trigger type not recognized, using WDOG.\n"); } return rc; } @@ -810,7 +721,7 @@ int create_pkt_ssr_cmd(enum hal_ssr_trigger_type type, struct hfi_cmd_sys_test_ssr_packet *pkt) { if (!pkt) { - dprintk(VIDC_ERR, "Invalid params, device: %pK\n", pkt); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } pkt->size = sizeof(struct hfi_cmd_sys_test_ssr_packet); @@ -823,7 +734,7 @@ int create_pkt_cmd_sys_image_version( struct hfi_cmd_sys_get_property_packet *pkt) { if (!pkt) { - dprintk(VIDC_ERR, "%s invalid param :%pK\n", __func__, pkt); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } pkt->size = sizeof(struct hfi_cmd_sys_get_property_packet); @@ -834,16 +745,15 @@ int create_pkt_cmd_sys_image_version( } int create_pkt_cmd_session_sync_process( - struct hfi_cmd_session_sync_process_packet *pkt, - struct hal_session *session) + struct hfi_cmd_session_sync_process_packet *pkt, u32 sid) { - if (!pkt || !session) + if (!pkt) return -EINVAL; *pkt = (struct hfi_cmd_session_sync_process_packet) {0}; pkt->size = sizeof(*pkt); pkt->packet_type = HFI_CMD_SESSION_SYNC; - pkt->session_id = hash32_ptr(session); + pkt->sid = sid; pkt->sync_id = 0; return 0; @@ -878,8 +788,7 @@ static struct hfi_packetization_ops hfi_default = { struct hfi_packetization_ops *hfi_get_pkt_ops_handle( enum hfi_packetization_type type) { - dprintk(VIDC_HIGH, "%s selected\n", - type == HFI_PACKETIZATION_4XX ? + d_vpr_h("%s selected\n", type == HFI_PACKETIZATION_4XX ? "4xx packetization" : "Unknown hfi"); switch (type) { diff --git a/msm/vidc/hfi_packetization.h b/msm/vidc/hfi_packetization.h index d3bb415c27d7..95278637bd0b 100644 --- a/msm/vidc/hfi_packetization.h +++ b/msm/vidc/hfi_packetization.h @@ -30,7 +30,7 @@ struct hfi_packetization_ops { int (*sys_debug_config)(struct hfi_cmd_sys_set_property_packet *pkt, u32 mode); int (*sys_coverage_config)(struct hfi_cmd_sys_set_property_packet *pkt, - u32 mode); + u32 mode, u32 sid); int (*sys_release_resource)( struct hfi_cmd_sys_release_resource_packet *pkt, struct vidc_resource_hdr *resource_hdr); @@ -41,49 +41,38 @@ struct hfi_packetization_ops { struct hfi_cmd_sys_test_ssr_packet *pkt); int (*session_init)( struct hfi_cmd_sys_session_init_packet *pkt, - struct hal_session *session, - u32 session_domain, u32 session_codec); + u32 sid, u32 session_domain, u32 session_codec); int (*session_cmd)(struct vidc_hal_session_cmd_pkt *pkt, - int pkt_type, struct hal_session *session); + int pkt_type, u32 sid); int (*session_set_buffers)( struct hfi_cmd_session_set_buffers_packet *pkt, - struct hal_session *session, - struct vidc_buffer_addr_info *buffer_info); + u32 sid, struct vidc_buffer_addr_info *buffer_info); int (*session_release_buffers)( struct hfi_cmd_session_release_buffer_packet *pkt, - struct hal_session *session, - struct vidc_buffer_addr_info *buffer_info); + u32 sid, struct vidc_buffer_addr_info *buffer_info); int (*session_register_buffer)( struct hfi_cmd_session_register_buffers_packet *pkt, - struct hal_session *session, - struct vidc_register_buffer *buffer); + u32 sid, struct vidc_register_buffer *buffer); int (*session_unregister_buffer)( struct hfi_cmd_session_unregister_buffers_packet *pkt, - struct hal_session *session, - struct vidc_unregister_buffer *buffer); + u32 sid, struct vidc_unregister_buffer *buffer); int (*session_etb_decoder)( struct hfi_cmd_session_empty_buffer_compressed_packet *pkt, - struct hal_session *session, - struct vidc_frame_data *input_frame); + u32 sid, struct vidc_frame_data *input_frame); int (*session_etb_encoder)( struct hfi_cmd_session_empty_buffer_uncompressed_plane0_packet - *pkt, struct hal_session *session, - struct vidc_frame_data *input_frame); + *pkt, u32 sid, struct vidc_frame_data *input_frame); int (*session_ftb)(struct hfi_cmd_session_fill_buffer_packet *pkt, - struct hal_session *session, - struct vidc_frame_data *output_frame); + u32 sid, struct vidc_frame_data *output_frame); int (*session_get_buf_req)( - struct hfi_cmd_session_get_property_packet *pkt, - struct hal_session *session); + struct hfi_cmd_session_get_property_packet *pkt, u32 sid); int (*session_flush)(struct hfi_cmd_session_flush_packet *pkt, - struct hal_session *session, enum hal_flush flush_mode); + u32 sid, enum hal_flush flush_mode); int (*session_set_property)( struct hfi_cmd_session_set_property_packet *pkt, - struct hal_session *session, - u32 ptype, void *pdata, u32 size); + u32 sid, u32 ptype, void *pdata, u32 size); int (*session_sync_process)( - struct hfi_cmd_session_sync_process_packet *pkt, - struct hal_session *session); + struct hfi_cmd_session_sync_process_packet *pkt, u32 sid); }; struct hfi_packetization_ops *hfi_get_pkt_ops_handle( diff --git a/msm/vidc/hfi_response_handler.c b/msm/vidc/hfi_response_handler.c index d452a33515e7..81d833dc3920 100644 --- a/msm/vidc/hfi_response_handler.c +++ b/msm/vidc/hfi_response_handler.c @@ -79,22 +79,21 @@ static enum vidc_status hfi_map_err_status(u32 hfi_err) return vidc_err; } -static int get_hal_pixel_depth(u32 hfi_bit_depth) +static int get_hal_pixel_depth(u32 hfi_bit_depth, u32 sid) { switch (hfi_bit_depth) { case HFI_BITDEPTH_8: return MSM_VIDC_BIT_DEPTH_8; case HFI_BITDEPTH_9: case HFI_BITDEPTH_10: return MSM_VIDC_BIT_DEPTH_10; } - dprintk(VIDC_ERR, "Unsupported bit depth: %d\n", hfi_bit_depth); + s_vpr_e(sid, "Unsupported bit depth: %d\n", hfi_bit_depth); return MSM_VIDC_BIT_DEPTH_UNSUPPORTED; } static inline int validate_pkt_size(u32 rem_size, u32 msg_size) { if (rem_size < msg_size) { - dprintk(VIDC_ERR, "%s: bad_packet_size: %d\n", - __func__, rem_size); + d_vpr_e("%s: bad_packet_size: %d\n", __func__, rem_size); return false; } return true; @@ -117,13 +116,15 @@ static int hfi_process_sess_evt_seq_changed(u32 device_id, int prop_id; int luma_bit_depth, chroma_bit_depth; struct hfi_colour_space *colour_info; + u32 sid; if (!validate_pkt_size(pkt->size, sizeof(struct hfi_msg_event_notify_packet))) return -E2BIG; + sid = pkt->sid; event_notify.device_id = device_id; - event_notify.session_id = (void *)(uintptr_t)pkt->session_id; + event_notify.inst_id = (void *)(uintptr_t)pkt->sid; event_notify.status = VIDC_ERR_NONE; num_properties_changed = pkt->event_data2; switch (pkt->event_data1) { @@ -158,8 +159,7 @@ static int hfi_process_sess_evt_seq_changed(u32 device_id, (struct hfi_frame_size *) data_ptr; event_notify.width = frame_sz->width; event_notify.height = frame_sz->height; - dprintk(VIDC_HIGH|VIDC_PERF, - "height: %d width: %d\n", + s_vpr_hp(sid, "height: %d width: %d\n", frame_sz->height, frame_sz->width); data_ptr += sizeof(struct hfi_frame_size); @@ -174,8 +174,7 @@ static int hfi_process_sess_evt_seq_changed(u32 device_id, (struct hfi_profile_level *) data_ptr; event_notify.profile = profile_level->profile; event_notify.level = profile_level->level; - dprintk(VIDC_HIGH|VIDC_PERF, - "profile: %d level: %d\n", + s_vpr_hp(sid, "profile: %d level: %d\n", profile_level->profile, profile_level->level); data_ptr += @@ -200,10 +199,10 @@ static int hfi_process_sess_evt_seq_changed(u32 device_id, */ luma_bit_depth = get_hal_pixel_depth( pixel_depth->bit_depth & - GENMASK(15, 0)); + GENMASK(15, 0), sid); chroma_bit_depth = get_hal_pixel_depth( (pixel_depth->bit_depth & - GENMASK(31, 16)) >> 16); + GENMASK(31, 16)) >> 16, sid); if (luma_bit_depth == MSM_VIDC_BIT_DEPTH_10 || chroma_bit_depth == MSM_VIDC_BIT_DEPTH_10) @@ -211,7 +210,7 @@ static int hfi_process_sess_evt_seq_changed(u32 device_id, MSM_VIDC_BIT_DEPTH_10; else event_notify.bit_depth = luma_bit_depth; - dprintk(VIDC_HIGH|VIDC_PERF, + s_vpr_hp(sid, "bitdepth(%d), luma_bit_depth(%d), chroma_bit_depth(%d)\n", event_notify.bit_depth, luma_bit_depth, chroma_bit_depth); @@ -226,8 +225,7 @@ static int hfi_process_sess_evt_seq_changed(u32 device_id, pic_struct = (struct hfi_pic_struct *) data_ptr; event_notify.pic_struct = pic_struct->progressive_only; - dprintk(VIDC_HIGH|VIDC_PERF, - "Progressive only flag: %d\n", + s_vpr_hp(sid, "Progressive only flag: %d\n", pic_struct->progressive_only); data_ptr += sizeof(struct hfi_pic_struct); @@ -242,8 +240,7 @@ static int hfi_process_sess_evt_seq_changed(u32 device_id, (struct hfi_colour_space *) data_ptr; event_notify.colour_space = colour_info->colour_space; - dprintk(VIDC_HIGH, - "Colour space value is: %d\n", + s_vpr_h(sid, "Colour space value is: %d\n", colour_info->colour_space); data_ptr += sizeof(struct hfi_colour_space); @@ -255,8 +252,8 @@ static int hfi_process_sess_evt_seq_changed(u32 device_id, data_ptr = data_ptr + sizeof(u32); entropy_mode = *(u32 *)data_ptr; event_notify.entropy_mode = entropy_mode; - dprintk(VIDC_HIGH|VIDC_PERF, - "Entropy Mode: 0x%x\n", entropy_mode); + s_vpr_hp(sid, "Entropy Mode: 0x%x\n", + entropy_mode); data_ptr += sizeof(u32); rem_size -= sizeof(u32); @@ -271,8 +268,7 @@ static int hfi_process_sess_evt_seq_changed(u32 device_id, data_ptr; event_notify.capture_buf_count = buf_req->buffer_count_min; - dprintk(VIDC_HIGH|VIDC_PERF, - "Capture Count : 0x%x\n", + s_vpr_hp(sid, "Capture Count : 0x%x\n", event_notify.capture_buf_count); data_ptr += sizeof(struct hfi_buffer_requirements); @@ -292,14 +288,12 @@ static int hfi_process_sess_evt_seq_changed(u32 device_id, event_notify.crop_data.width = crop_info->width; event_notify.crop_data.height = crop_info->height; - dprintk(VIDC_HIGH, + s_vpr_h(sid, "CROP info : Left = %d Top = %d\n", - crop_info->left, - crop_info->top); - dprintk(VIDC_HIGH, + crop_info->left, crop_info->top); + s_vpr_h(sid, "CROP info : Width = %d Height = %d\n", - crop_info->width, - crop_info->height); + crop_info->width, crop_info->height); data_ptr += sizeof(struct hfi_index_extradata_input_crop_payload); @@ -307,8 +301,7 @@ static int hfi_process_sess_evt_seq_changed(u32 device_id, hfi_index_extradata_input_crop_payload); break; default: - dprintk(VIDC_ERR, - "%s cmd: %#x not supported\n", + s_vpr_e(sid, "%s: cmd: %#x not supported\n", __func__, prop_id); break; } @@ -329,25 +322,24 @@ static int hfi_process_evt_release_buffer_ref(u32 device_id, struct msm_vidc_cb_event event_notify = {0}; struct hfi_msg_release_buffer_ref_event_packet *data; - dprintk(VIDC_LOW, - "RECEIVED: EVENT_NOTIFY - release_buffer_reference\n"); if (sizeof(struct hfi_msg_event_notify_packet) > pkt->size) { - dprintk(VIDC_ERR, "%s: bad_pkt_size\n", __func__); + d_vpr_e("%s: bad_pkt_size\n", __func__); return -E2BIG; } if (pkt->size < sizeof(struct hfi_msg_event_notify_packet) - sizeof(u32) + sizeof(struct hfi_msg_release_buffer_ref_event_packet)) { - dprintk(VIDC_ERR, "%s: bad_pkt_size: %d\n", - __func__, pkt->size); + d_vpr_e("%s: bad_pkt_size: %d\n", __func__, pkt->size); return -E2BIG; } data = (struct hfi_msg_release_buffer_ref_event_packet *) pkt->rg_ext_event_data; + s_vpr_l(pkt->sid, + "RECEIVED: EVENT_NOTIFY - release_buffer_reference\n"); event_notify.device_id = device_id; - event_notify.session_id = (void *)(uintptr_t)pkt->session_id; + event_notify.inst_id = (void *)(uintptr_t)pkt->sid; event_notify.status = VIDC_ERR_NONE; event_notify.hal_event_type = HAL_EVENT_RELEASE_BUFFER_REFERENCE; event_notify.packet_buffer = data->packet_buffer; @@ -379,24 +371,24 @@ static int hfi_process_session_error(u32 device_id, struct msm_vidc_cb_info *info) { struct msm_vidc_cb_cmd_done cmd_done = {0}; + u32 sid = pkt->sid; cmd_done.device_id = device_id; - cmd_done.session_id = (void *)(uintptr_t)pkt->session_id; + cmd_done.inst_id = (void *)(uintptr_t)pkt->sid; cmd_done.status = hfi_map_err_status(pkt->event_data1); info->response.cmd = cmd_done; - dprintk(VIDC_HIGH, "Received: SESSION_ERROR with event id : %#x %#x\n", + s_vpr_h(sid, "RECEIVED: SESSION_ERROR with event id : %#x %#x\n", pkt->event_data1, pkt->event_data2); switch (pkt->event_data1) { /* Ignore below errors */ case HFI_ERR_SESSION_INVALID_SCALE_FACTOR: case HFI_ERR_SESSION_UPSCALE_NOT_SUPPORTED: - dprintk(VIDC_HIGH, "Non Fatal: HFI_EVENT_SESSION_ERROR\n"); + s_vpr_h(sid, "Non Fatal: HFI_EVENT_SESSION_ERROR\n"); info->response_type = HAL_RESPONSE_UNUSED; break; default: - dprintk(VIDC_ERR, - "%s: session %x data1 %#x, data2 %#x\n", __func__, - pkt->session_id, pkt->event_data1, pkt->event_data2); + s_vpr_e(sid, "%s: data1 %#x, data2 %#x\n", __func__, + pkt->event_data1, pkt->event_data2); info->response_type = HAL_SESSION_ERROR; break; } @@ -409,31 +401,30 @@ static int hfi_process_event_notify(u32 device_id, struct msm_vidc_cb_info *info) { struct hfi_msg_event_notify_packet *pkt = _pkt; - dprintk(VIDC_LOW, "Received: EVENT_NOTIFY\n"); if (pkt->size < sizeof(struct hfi_msg_event_notify_packet)) { - dprintk(VIDC_ERR, "Invalid Params\n"); + d_vpr_e("%s: invalid params %u %u\n", __func__, + pkt->size, sizeof(struct hfi_msg_event_notify_packet)); return -E2BIG; } + s_vpr_l(pkt->sid, "RECEIVED: EVENT_NOTIFY\n"); + switch (pkt->event_id) { case HFI_EVENT_SYS_ERROR: - dprintk(VIDC_ERR, "HFI_EVENT_SYS_ERROR: %d, %#x\n", + s_vpr_e(pkt->sid, "HFI_EVENT_SYS_ERROR: %d, %#x\n", pkt->event_data1, pkt->event_data2); return hfi_process_sys_error(device_id, pkt, info); case HFI_EVENT_SESSION_ERROR: - dprintk(VIDC_HIGH, "HFI_EVENT_SESSION_ERROR[%#x]\n", - pkt->session_id); + s_vpr_h(pkt->sid, "HFI_EVENT_SESSION_ERROR\n"); return hfi_process_session_error(device_id, pkt, info); case HFI_EVENT_SESSION_SEQUENCE_CHANGED: - dprintk(VIDC_HIGH, "HFI_EVENT_SESSION_SEQUENCE_CHANGED[%#x]\n", - pkt->session_id); + s_vpr_h(pkt->sid, "HFI_EVENT_SESSION_SEQUENCE_CHANGED\n"); return hfi_process_sess_evt_seq_changed(device_id, pkt, info); case HFI_EVENT_RELEASE_BUFFER_REFERENCE: - dprintk(VIDC_LOW, "HFI_EVENT_RELEASE_BUFFER_REFERENCE[%#x]\n", - pkt->session_id); + s_vpr_l(pkt->sid, "HFI_EVENT_RELEASE_BUFFER_REFERENCE\n"); return hfi_process_evt_release_buffer_ref(device_id, pkt, info); case HFI_EVENT_SESSION_PROPERTY_CHANGED: @@ -454,19 +445,19 @@ static int hfi_process_sys_init_done(u32 device_id, struct msm_vidc_cb_cmd_done cmd_done = {0}; enum vidc_status status = VIDC_ERR_NONE; - dprintk(VIDC_HIGH, "RECEIVED: SYS_INIT_DONE\n"); if (sizeof(struct hfi_msg_sys_init_done_packet) > pkt->size) { - dprintk(VIDC_ERR, "%s: bad_pkt_size: %d\n", __func__, + d_vpr_e("%s: bad_pkt_size: %d\n", __func__, pkt->size); return -E2BIG; } + d_vpr_h("RECEIVED: SYS_INIT_DONE\n"); + status = hfi_map_err_status(pkt->error_type); if (status) - dprintk(VIDC_ERR, "%s: status %#x\n", - __func__, status); + d_vpr_e("%s: status %#x\n", __func__, status); cmd_done.device_id = device_id; - cmd_done.session_id = NULL; + cmd_done.inst_id = NULL; cmd_done.status = (u32)status; cmd_done.size = sizeof(struct vidc_hal_sys_init_done); @@ -485,18 +476,17 @@ static int hfi_process_sys_rel_resource_done(u32 device_id, enum vidc_status status = VIDC_ERR_NONE; u32 pkt_size; - dprintk(VIDC_HIGH, "RECEIVED: SYS_RELEASE_RESOURCE_DONE\n"); pkt_size = sizeof(struct hfi_msg_sys_release_resource_done_packet); if (pkt_size > pkt->size) { - dprintk(VIDC_ERR, - "hal_process_sys_rel_resource_done: bad size: %d\n", + d_vpr_e("hal_process_sys_rel_resource_done: bad size: %d\n", pkt->size); return -E2BIG; } + d_vpr_h("RECEIVED: SYS_RELEASE_RESOURCE_DONE\n"); status = hfi_map_err_status(pkt->error_type); cmd_done.device_id = device_id; - cmd_done.session_id = NULL; + cmd_done.inst_id = NULL; cmd_done.status = (u32) status; cmd_done.size = 0; @@ -508,15 +498,13 @@ static int hfi_process_sys_rel_resource_done(u32 device_id, static void hfi_process_sess_get_prop_buf_req( struct hfi_msg_session_property_info_packet *prop, - struct buffer_requirements *buffreq) + struct buffer_requirements *buffreq, u32 sid) { struct hfi_buffer_requirements *hfi_buf_req; u32 req_bytes; if (!prop) { - dprintk(VIDC_ERR, - "hal_process_sess_get_prop_buf_req: bad_prop: %pK\n", - prop); + s_vpr_e(sid, "%s: bad_prop: %pK\n", __func__, prop); return; } @@ -524,9 +512,7 @@ static void hfi_process_sess_get_prop_buf_req( struct hfi_msg_session_property_info_packet); if (!req_bytes || req_bytes % sizeof(struct hfi_buffer_requirements) || !prop->rg_property_data[1]) { - dprintk(VIDC_ERR, - "hal_process_sess_get_prop_buf_req: bad_pkt: %d\n", - req_bytes); + s_vpr_e(sid, "%s: bad_pkt: %d\n", __func__, req_bytes); return; } @@ -534,13 +520,12 @@ static void hfi_process_sess_get_prop_buf_req( &prop->rg_property_data[1]; if (!hfi_buf_req) { - dprintk(VIDC_ERR, "%s - invalid buffer req pointer\n", - __func__); + s_vpr_e(sid, "%s: invalid buffer req pointer\n", __func__); return; } while (req_bytes) { - dprintk(VIDC_HIGH, "got buffer requirements for: %d\n", + s_vpr_h(sid, "got buffer requirements for: %d\n", hfi_buf_req->buffer_type); switch (hfi_buf_req->buffer_type) { case HFI_BUFFER_INPUT: @@ -613,9 +598,8 @@ static void hfi_process_sess_get_prop_buf_req( HAL_BUFFER_INTERNAL_RECON; break; default: - dprintk(VIDC_ERR, - "hal_process_sess_get_prop_buf_req: bad_buffer_type: %d\n", - hfi_buf_req->buffer_type); + s_vpr_e(sid, "%s: bad_buffer_type: %d\n", + __func__, hfi_buf_req->buffer_type); break; } req_bytes -= sizeof(struct hfi_buffer_requirements); @@ -631,24 +615,20 @@ static int hfi_process_session_prop_info(u32 device_id, struct msm_vidc_cb_cmd_done cmd_done = {0}; struct buffer_requirements buff_req = { { {0} } }; - dprintk(VIDC_HIGH, "Received SESSION_PROPERTY_INFO[%#x]\n", - pkt->session_id); - if (pkt->size < sizeof(struct hfi_msg_session_property_info_packet)) { - dprintk(VIDC_ERR, - "hal_process_session_prop_info: bad_pkt_size\n"); + d_vpr_e("hal_process_session_prop_info: bad_pkt_size\n"); return -E2BIG; } else if (!pkt->num_properties) { - dprintk(VIDC_ERR, - "hal_process_session_prop_info: no_properties\n"); + d_vpr_e("hal_process_session_prop_info: no_properties\n"); return -EINVAL; } + s_vpr_h(pkt->sid, "Received SESSION_PROPERTY_INFO\n"); switch (pkt->rg_property_data[0]) { case HFI_PROPERTY_CONFIG_BUFFER_REQUIREMENTS: - hfi_process_sess_get_prop_buf_req(pkt, &buff_req); + hfi_process_sess_get_prop_buf_req(pkt, &buff_req, pkt->sid); cmd_done.device_id = device_id; - cmd_done.session_id = (void *)(uintptr_t)pkt->session_id; + cmd_done.inst_id = (void *)(uintptr_t)pkt->sid; cmd_done.status = VIDC_ERR_NONE; cmd_done.data.property.buf_req = buff_req; cmd_done.size = sizeof(buff_req); @@ -658,9 +638,8 @@ static int hfi_process_session_prop_info(u32 device_id, return 0; default: - dprintk(VIDC_HIGH, - "hal_process_session_prop_info: unknown_prop_id: %x\n", - pkt->rg_property_data[0]); + s_vpr_h(pkt->sid, "%s: unknown_prop_id: %x\n", + __func__, pkt->rg_property_data[0]); return -ENOTSUPP; } } @@ -672,16 +651,14 @@ static int hfi_process_session_init_done(u32 device_id, struct hfi_msg_sys_session_init_done_packet *pkt = _pkt; struct msm_vidc_cb_cmd_done cmd_done = {0}; - dprintk(VIDC_HIGH, "RECEIVED: SESSION_INIT_DONE[%x]\n", pkt->session_id); - if (sizeof(struct hfi_msg_sys_session_init_done_packet) > pkt->size) { - dprintk(VIDC_ERR, - "hal_process_session_init_done: bad_pkt_size\n"); + d_vpr_e("hal_process_session_init_done: bad_pkt_size\n"); return -E2BIG; } + s_vpr_h(pkt->sid, "RECEIVED: SESSION_INIT_DONE\n"); cmd_done.device_id = device_id; - cmd_done.session_id = (void *)(uintptr_t)pkt->session_id; + cmd_done.inst_id = (void *)(uintptr_t)pkt->sid; cmd_done.status = hfi_map_err_status(pkt->error_type); info->response_type = HAL_SESSION_INIT_DONE; @@ -697,19 +674,15 @@ static int hfi_process_session_load_res_done(u32 device_id, struct hfi_msg_session_load_resources_done_packet *pkt = _pkt; struct msm_vidc_cb_cmd_done cmd_done = {0}; - dprintk(VIDC_HIGH, "RECEIVED: SESSION_LOAD_RESOURCES_DONE[%#x]\n", - pkt->session_id); - if (sizeof(struct hfi_msg_session_load_resources_done_packet) != pkt->size) { - dprintk(VIDC_ERR, - "hal_process_session_load_res_done: bad packet size: %d\n", - pkt->size); + d_vpr_e("%s: bad packet size: %d\n", __func__, pkt->size); return -E2BIG; } + s_vpr_h(pkt->sid, "RECEIVED: SESSION_LOAD_RESOURCES_DONE\n"); cmd_done.device_id = device_id; - cmd_done.session_id = (void *)(uintptr_t)pkt->session_id; + cmd_done.inst_id = (void *)(uintptr_t)pkt->sid; cmd_done.status = hfi_map_err_status(pkt->error_type); cmd_done.size = 0; @@ -726,18 +699,15 @@ static int hfi_process_session_flush_done(u32 device_id, struct hfi_msg_session_flush_done_packet *pkt = _pkt; struct msm_vidc_cb_cmd_done cmd_done = {0}; - dprintk(VIDC_HIGH, "RECEIVED: SESSION_FLUSH_DONE[%#x]\n", - pkt->session_id); - if (sizeof(struct hfi_msg_session_flush_done_packet) != pkt->size) { - dprintk(VIDC_ERR, - "hal_process_session_flush_done: bad packet size: %d\n", + d_vpr_e("hal_process_session_flush_done: bad packet size: %d\n", pkt->size); return -E2BIG; } + s_vpr_h(pkt->sid, "RECEIVED: SESSION_FLUSH_DONE\n"); cmd_done.device_id = device_id; - cmd_done.session_id = (void *)(uintptr_t)pkt->session_id; + cmd_done.inst_id = (void *)(uintptr_t)pkt->sid; cmd_done.status = hfi_map_err_status(pkt->error_type); cmd_done.size = sizeof(u32); @@ -752,8 +722,7 @@ static int hfi_process_session_flush_done(u32 device_id, cmd_done.data.flush_type = HAL_FLUSH_ALL; break; default: - dprintk(VIDC_ERR, - "%s: invalid flush type!", __func__); + s_vpr_e(pkt->sid, "%s: invalid flush type!", __func__); return -EINVAL; } @@ -770,14 +739,14 @@ static int hfi_process_session_etb_done(u32 device_id, struct hfi_msg_session_empty_buffer_done_packet *pkt = _pkt; struct msm_vidc_cb_data_done data_done = {0}; - dprintk(VIDC_LOW, "RECEIVED: SESSION_ETB_DONE[%#x]\n", pkt->session_id); - if (!pkt || pkt->size < sizeof(struct hfi_msg_session_empty_buffer_done_packet)) goto bad_packet_size; + s_vpr_l(pkt->sid, "RECEIVED: SESSION_ETB_DONE\n"); + data_done.device_id = device_id; - data_done.session_id = (void *)(uintptr_t)pkt->session_id; + data_done.inst_id = (void *)(uintptr_t)pkt->sid; data_done.status = hfi_map_err_status(pkt->error_type); data_done.size = sizeof(struct msm_vidc_cb_data_done); data_done.input_done.input_tag = pkt->input_tag; @@ -805,7 +774,7 @@ static int hfi_process_session_etb_done(u32 device_id, return 0; bad_packet_size: - dprintk(VIDC_ERR, "%s: bad_pkt_size: %d\n", + d_vpr_e("%s: ebd - bad_pkt_size: %d\n", __func__, pkt ? pkt->size : 0); return -E2BIG; } @@ -819,7 +788,7 @@ static int hfi_process_session_ftb_done( bool is_decoder = false, is_encoder = false; if (!msg_hdr) { - dprintk(VIDC_ERR, "Invalid Params\n"); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } @@ -829,7 +798,7 @@ static int hfi_process_session_ftb_done( hfi_msg_session_fbd_uncompressed_plane0_packet) + 4; if (!(is_encoder ^ is_decoder)) { - dprintk(VIDC_ERR, "Ambiguous packet (%#x) received (size %d)\n", + d_vpr_e("Ambiguous packet (%#x) received (size %d)\n", msg_hdr->packet, msg_hdr->size); return -EBADHANDLE; } @@ -838,23 +807,20 @@ static int hfi_process_session_ftb_done( struct hfi_msg_session_fill_buffer_done_compressed_packet *pkt = (struct hfi_msg_session_fill_buffer_done_compressed_packet *) msg_hdr; - dprintk(VIDC_LOW, "RECEIVED: SESSION_FTB_DONE[%#x]\n", - pkt->session_id); if (sizeof(struct hfi_msg_session_fill_buffer_done_compressed_packet) > pkt->size) { - dprintk(VIDC_ERR, - "hal_process_session_ftb_done: bad_pkt_size\n"); + d_vpr_e("hal_process_session_ftb_done: bad_pkt_size\n"); return -E2BIG; } else if (pkt->error_type != HFI_ERR_NONE) { - dprintk(VIDC_ERR, - "got buffer back with error %x\n", + s_vpr_e(pkt->sid, "got buffer back with error %x\n", pkt->error_type); /* Proceed with the FBD */ } + s_vpr_l(pkt->sid, "RECEIVED: SESSION_FTB_DONE\n"); data_done.device_id = device_id; - data_done.session_id = (void *)(uintptr_t)pkt->session_id; + data_done.inst_id = (void *)(uintptr_t)pkt->sid; data_done.status = hfi_map_err_status(pkt->error_type); data_done.size = sizeof(struct msm_vidc_cb_data_done); @@ -875,19 +841,16 @@ static int hfi_process_session_ftb_done( struct hfi_msg_session_fbd_uncompressed_plane0_packet *pkt = (struct hfi_msg_session_fbd_uncompressed_plane0_packet *) msg_hdr; - - dprintk(VIDC_LOW, "RECEIVED: SESSION_FTB_DONE[%#x]\n", - pkt->session_id); if (sizeof( struct hfi_msg_session_fbd_uncompressed_plane0_packet) > pkt->size) { - dprintk(VIDC_ERR, - "hal_process_session_ftb_done: bad_pkt_size\n"); + d_vpr_e("hal_process_session_ftb_done: bad_pkt_size\n"); return -E2BIG; } + s_vpr_l(pkt->sid, "RECEIVED: SESSION_FTB_DONE\n"); data_done.device_id = device_id; - data_done.session_id = (void *)(uintptr_t)pkt->session_id; + data_done.inst_id = (void *)(uintptr_t)pkt->sid; data_done.status = hfi_map_err_status(pkt->error_type); data_done.size = sizeof(struct msm_vidc_cb_data_done); @@ -938,18 +901,15 @@ static int hfi_process_session_start_done(u32 device_id, struct hfi_msg_session_start_done_packet *pkt = _pkt; struct msm_vidc_cb_cmd_done cmd_done = {0}; - dprintk(VIDC_HIGH, "RECEIVED: SESSION_START_DONE[%#x]\n", - pkt->session_id); - if (!pkt || pkt->size != sizeof(struct hfi_msg_session_start_done_packet)) { - dprintk(VIDC_ERR, "%s: bad packet/packet size\n", - __func__); + d_vpr_e("%s: bad packet/packet size\n", __func__); return -E2BIG; } + s_vpr_h(pkt->sid, "RECEIVED: SESSION_START_DONE\n"); cmd_done.device_id = device_id; - cmd_done.session_id = (void *)(uintptr_t)pkt->session_id; + cmd_done.inst_id = (void *)(uintptr_t)pkt->sid; cmd_done.status = hfi_map_err_status(pkt->error_type); cmd_done.size = 0; @@ -965,18 +925,15 @@ static int hfi_process_session_stop_done(u32 device_id, struct hfi_msg_session_stop_done_packet *pkt = _pkt; struct msm_vidc_cb_cmd_done cmd_done = {0}; - dprintk(VIDC_HIGH, "RECEIVED: SESSION_STOP_DONE[%#x]\n", - pkt->session_id); - if (!pkt || pkt->size != sizeof(struct hfi_msg_session_stop_done_packet)) { - dprintk(VIDC_ERR, "%s: bad packet/packet size\n", - __func__); + d_vpr_e("%s: bad packet/packet size\n", __func__); return -E2BIG; } + s_vpr_h(pkt->sid, "RECEIVED: SESSION_STOP_DONE\n"); cmd_done.device_id = device_id; - cmd_done.session_id = (void *)(uintptr_t)pkt->session_id; + cmd_done.inst_id = (void *)(uintptr_t)pkt->sid; cmd_done.status = hfi_map_err_status(pkt->error_type); cmd_done.size = 0; @@ -993,18 +950,15 @@ static int hfi_process_session_rel_res_done(u32 device_id, struct hfi_msg_session_release_resources_done_packet *pkt = _pkt; struct msm_vidc_cb_cmd_done cmd_done = {0}; - dprintk(VIDC_HIGH, "RECEIVED: SESSION_RELEASE_RESOURCES_DONE[%#x]\n", - pkt->session_id); - if (!pkt || pkt->size != sizeof(struct hfi_msg_session_release_resources_done_packet)) { - dprintk(VIDC_ERR, "%s: bad packet/packet size\n", - __func__); + d_vpr_e("%s: bad packet/packet size\n", __func__); return -E2BIG; } + s_vpr_h(pkt->sid, "RECEIVED: SESSION_RELEASE_RESOURCES_DONE\n"); cmd_done.device_id = device_id; - cmd_done.session_id = (void *)(uintptr_t)pkt->session_id; + cmd_done.inst_id = (void *)(uintptr_t)pkt->sid; cmd_done.status = hfi_map_err_status(pkt->error_type); cmd_done.size = 0; @@ -1023,16 +977,15 @@ static int hfi_process_session_rel_buf_done(u32 device_id, if (!pkt || pkt->size < sizeof(struct hfi_msg_session_release_buffers_done_packet)) { - dprintk(VIDC_ERR, "bad packet/packet size %d\n", + d_vpr_e("bad packet/packet size %d\n", pkt ? pkt->size : 0); return -E2BIG; } - dprintk(VIDC_HIGH, "RECEIVED:SESSION_RELEASE_BUFFER_DONE[%#x]\n", - pkt->session_id); + s_vpr_h(pkt->sid, "RECEIVED:SESSION_RELEASE_BUFFER_DONE\n"); cmd_done.device_id = device_id; cmd_done.size = sizeof(struct msm_vidc_cb_cmd_done); - cmd_done.session_id = (void *)(uintptr_t)pkt->session_id; + cmd_done.inst_id = (void *)(uintptr_t)pkt->sid; cmd_done.status = hfi_map_err_status(pkt->error_type); cmd_done.data.buffer_info.buffer_addr = *pkt->rg_buffer_info; cmd_done.size = sizeof(struct hal_buffer_info); @@ -1052,16 +1005,15 @@ static int hfi_process_session_register_buffer_done(u32 device_id, if (!pkt || pkt->size < sizeof(struct hfi_msg_session_register_buffers_done_packet)) { - dprintk(VIDC_ERR, "%s: bad packet/packet size %d\n", + d_vpr_e("%s: bad packet/packet size %d\n", __func__, pkt ? pkt->size : 0); return -E2BIG; } - dprintk(VIDC_HIGH, "RECEIVED: SESSION_REGISTER_BUFFERS_DONE[%#x]\n", - pkt->session_id); + s_vpr_h(pkt->sid, "RECEIVED: SESSION_REGISTER_BUFFERS_DONE\n"); cmd_done.device_id = device_id; cmd_done.size = sizeof(struct msm_vidc_cb_cmd_done); - cmd_done.session_id = (void *)(uintptr_t)pkt->session_id; + cmd_done.inst_id = (void *)(uintptr_t)pkt->sid; cmd_done.status = hfi_map_err_status(pkt->error_type); cmd_done.data.regbuf.client_data = pkt->client_data; @@ -1080,16 +1032,15 @@ static int hfi_process_session_unregister_buffer_done(u32 device_id, if (!pkt || pkt->size < sizeof(struct hfi_msg_session_unregister_buffers_done_packet)) { - dprintk(VIDC_ERR, "%s: bad packet/packet size %d\n", + d_vpr_e("%s: bad packet/packet size %d\n", __func__, pkt ? pkt->size : 0); return -E2BIG; } - dprintk(VIDC_HIGH, "RECEIVED: SESSION_UNREGISTER_BUFFERS_DONE[%#x]\n", - pkt->session_id); + s_vpr_h(pkt->sid, "RECEIVED: SESSION_UNREGISTER_BUFFERS_DONE\n"); cmd_done.device_id = device_id; cmd_done.size = sizeof(struct msm_vidc_cb_cmd_done); - cmd_done.session_id = (void *)(uintptr_t)pkt->session_id; + cmd_done.inst_id = (void *)(uintptr_t)pkt->sid; cmd_done.status = hfi_map_err_status(pkt->error_type); cmd_done.data.unregbuf.client_data = pkt->client_data; @@ -1106,16 +1057,15 @@ static int hfi_process_session_end_done(u32 device_id, struct hfi_msg_sys_session_end_done_packet *pkt = _pkt; struct msm_vidc_cb_cmd_done cmd_done = {0}; - dprintk(VIDC_HIGH, "RECEIVED: SESSION_END_DONE[%#x]\n", pkt->session_id); - if (!pkt || pkt->size != sizeof(struct hfi_msg_sys_session_end_done_packet)) { - dprintk(VIDC_ERR, "%s: bad packet/packet size\n", __func__); + d_vpr_e("%s: bad packet/packet size\n", __func__); return -E2BIG; } + s_vpr_h(pkt->sid, "RECEIVED: SESSION_END_DONE\n"); cmd_done.device_id = device_id; - cmd_done.session_id = (void *)(uintptr_t)pkt->session_id; + cmd_done.inst_id = (void *)(uintptr_t)pkt->sid; cmd_done.status = hfi_map_err_status(pkt->error_type); cmd_done.size = 0; @@ -1132,17 +1082,15 @@ static int hfi_process_session_abort_done(u32 device_id, struct hfi_msg_sys_session_abort_done_packet *pkt = _pkt; struct msm_vidc_cb_cmd_done cmd_done = {0}; - dprintk(VIDC_HIGH, "RECEIVED: SESSION_ABORT_DONE[%#x]\n", - pkt->session_id); - if (!pkt || pkt->size != sizeof(struct hfi_msg_sys_session_abort_done_packet)) { - dprintk(VIDC_ERR, "%s: bad packet/packet size: %d\n", + d_vpr_e("%s: bad packet/packet size: %d\n", __func__, pkt ? pkt->size : 0); return -E2BIG; } + s_vpr_h(pkt->sid, "RECEIVED: SESSION_ABORT_DONE\n"); cmd_done.device_id = device_id; - cmd_done.session_id = (void *)(uintptr_t)pkt->session_id; + cmd_done.inst_id = (void *)(uintptr_t)pkt->sid; cmd_done.status = hfi_map_err_status(pkt->error_type); cmd_done.size = 0; @@ -1168,7 +1116,7 @@ static void hfi_process_sys_get_prop_image_version( if (req_bytes < version_string_size || !pkt->rg_property_data[1] || pkt->num_properties > 1) { - dprintk(VIDC_ERR, "%s: bad_pkt: %d\n", __func__, req_bytes); + d_vpr_e("%s: bad_pkt: %d\n", __func__, req_bytes); return; } str_image_version = (u8 *)&pkt->rg_property_data[1]; @@ -1184,7 +1132,7 @@ static void hfi_process_sys_get_prop_image_version( version[i] = ' '; } version[i] = '\0'; - dprintk(VIDC_HIGH, "F/W version: %s\n", version); + d_vpr_h("F/W version: %s\n", version); smem_table_ptr = qcom_smem_get(QCOM_SMEM_HOST_ANY, SMEM_IMAGE_VERSION_TABLE, &smem_block_size); @@ -1200,15 +1148,13 @@ static int hfi_process_sys_property_info(u32 device_id, { struct hfi_msg_sys_property_info_packet *pkt = _pkt; if (!pkt) { - dprintk(VIDC_ERR, "%s: invalid param\n", __func__); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } else if (pkt->size < sizeof(*pkt)) { - dprintk(VIDC_ERR, - "%s: bad_pkt_size\n", __func__); + d_vpr_e("%s: bad_pkt_size\n", __func__); return -E2BIG; } else if (!pkt->num_properties) { - dprintk(VIDC_ERR, - "%s: no_properties\n", __func__); + d_vpr_e("%s: no_properties\n", __func__); return -EINVAL; } @@ -1221,8 +1167,7 @@ static int hfi_process_sys_property_info(u32 device_id, }; return 0; default: - dprintk(VIDC_HIGH, - "%s: unknown_prop_id: %x\n", + d_vpr_h("%s: unknown_prop_id: %x\n", __func__, pkt->rg_property_data[0]); return -ENOTSUPP; } @@ -1236,6 +1181,7 @@ static int hfi_process_ignore(u32 device_id, *info = (struct msm_vidc_cb_info) { .response_type = HAL_RESPONSE_UNUSED, }; + d_vpr_h("RECEIVED: SESSION_SYNC_DONE\n"); return 0; } @@ -1247,17 +1193,15 @@ int hfi_process_msg_packet(u32 device_id, struct vidc_hal_msg_pkt_hdr *msg_hdr, pkt_func_def pkt_func = NULL; if (!info || !msg_hdr || msg_hdr->size < VIDC_IFACEQ_MIN_PKT_SIZE) { - dprintk(VIDC_ERR, "%s: bad packet/packet size\n", - __func__); + d_vpr_e("%s: bad packet/packet size\n", __func__); return -EINVAL; } - dprintk(VIDC_LOW, "Parse response %#x\n", msg_hdr->packet); switch (msg_hdr->packet) { case HFI_MSG_EVENT_NOTIFY: pkt_func = (pkt_func_def)hfi_process_event_notify; break; - case HFI_MSG_SYS_INIT_DONE: + case HFI_MSG_SYS_INIT_DONE: pkt_func = (pkt_func_def)hfi_process_sys_init_done; break; case HFI_MSG_SYS_SESSION_INIT_DONE: @@ -1314,8 +1258,7 @@ int hfi_process_msg_packet(u32 device_id, struct vidc_hal_msg_pkt_hdr *msg_hdr, pkt_func = (pkt_func_def)hfi_process_ignore; break; default: - dprintk(VIDC_LOW, "Unable to parse message: %#x\n", - msg_hdr->packet); + d_vpr_l("Unable to parse message: %#x\n", msg_hdr->packet); break; } diff --git a/msm/vidc/msm_cvp_external.c b/msm/vidc/msm_cvp_external.c index 730e4b5e2983..5fb23bbe1c5a 100644 --- a/msm/vidc/msm_cvp_external.c +++ b/msm/vidc/msm_cvp_external.c @@ -19,17 +19,18 @@ static void print_cvp_buffer(u32 tag, const char *str, return; cvp = inst->cvp; - dprintk(tag, + dprintk(tag, inst->sid, "%s: %x : idx %d fd %d size %d offset %d dbuf %pK kvaddr %pK\n", - str, cvp->session_id, cbuf->index, cbuf->fd, cbuf->size, + str, cvp->sid, cbuf->index, cbuf->fd, cbuf->size, cbuf->offset, cbuf->dbuf, cbuf->kvaddr); } static int fill_cvp_buffer(struct msm_cvp_buffer_type *dst, - struct msm_cvp_buf *src) + struct msm_cvp_buf *src, u32 sid) { if (!dst || !src) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + s_vpr_e(sid, "%s: invalid params %pK %pK\n", + __func__, dst, src); return -EINVAL; } @@ -50,8 +51,9 @@ static int msm_cvp_get_version_info(struct msm_vidc_inst *inst) struct cvp_kmd_sys_property *prop_data; u32 version; + if (!inst || !inst->cvp) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } cvp = inst->cvp; @@ -66,11 +68,11 @@ static int msm_cvp_get_version_info(struct msm_vidc_inst *inst) prop_data->prop_type = CVP_KMD_HFI_VERSION_PROP_TYPE; rc = msm_cvp_private(cvp->priv, CVP_KMD_GET_SYS_PROPERTY, arg); if (rc) { - dprintk(VIDC_ERR, "%s: failed, rc %d\n", __func__, rc); + s_vpr_e(inst->sid, "%s: failed, rc %d\n", __func__, rc); return rc; } version = prop_data->data; - dprintk(VIDC_HIGH, "%s: version %#x\n", __func__, version); + s_vpr_h(inst->sid, "%s: version %#x\n", __func__, version); return 0; } @@ -84,7 +86,7 @@ static int msm_cvp_set_priority(struct msm_vidc_inst *inst) struct cvp_kmd_sys_property *prop_array; if (!inst || !inst->cvp) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } cvp = inst->cvp; @@ -101,10 +103,10 @@ static int msm_cvp_set_priority(struct msm_vidc_inst *inst) prop_array[0].data = VIDEO_REALTIME; else prop_array[0].data = VIDEO_NONREALTIME; - dprintk(VIDC_HIGH, "%s: %d\n", __func__, prop_array[0].data); + s_vpr_h(inst->sid, "%s: %d\n", __func__, prop_array[0].data); rc = msm_cvp_private(cvp->priv, CVP_KMD_SET_SYS_PROPERTY, arg); if (rc) { - dprintk(VIDC_ERR, "%s: failed, rc %d\n", __func__, rc); + s_vpr_e(inst->sid, "%s: failed, rc %d\n", __func__, rc); return rc; } @@ -112,7 +114,7 @@ static int msm_cvp_set_priority(struct msm_vidc_inst *inst) } static int msm_cvp_fill_planeinfo(struct msm_cvp_color_plane_info *plane_info, - u32 color_fmt, u32 width, u32 height) + u32 color_fmt, u32 width, u32 height, u32 sid) { int rc = 0; u32 y_stride, y_sclines, uv_stride, uv_sclines; @@ -169,7 +171,7 @@ static int msm_cvp_fill_planeinfo(struct msm_cvp_color_plane_info *plane_info, break; } default: - dprintk(VIDC_ERR, "%s: invalid color_fmt %#x\n", + s_vpr_e(sid, "%s: invalid color_fmt %#x\n", __func__, color_fmt); rc = -EINVAL; break; @@ -184,7 +186,8 @@ static int msm_cvp_free_buffer(struct msm_vidc_inst *inst, struct msm_cvp_external *cvp; if (!inst || !inst->cvp || !buffer) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK %pK\n", + __func__, inst, buffer); return -EINVAL; } cvp = inst->cvp; @@ -210,7 +213,8 @@ static int msm_cvp_allocate_buffer(struct msm_vidc_inst *inst, struct dma_buf *dbuf; if (!inst || !inst->cvp || !buffer) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK %pK\n", + __func__, inst, buffer); return -EINVAL; } cvp = inst->cvp; @@ -223,7 +227,7 @@ static int msm_cvp_allocate_buffer(struct msm_vidc_inst *inst, dbuf = ion_alloc(buffer->size, heap_mask, ion_flags); if (IS_ERR_OR_NULL(dbuf)) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: failed to allocate, size %d heap_mask %#lx flags %d\n", __func__, buffer->size, heap_mask, ion_flags); rc = -ENOMEM; @@ -235,7 +239,7 @@ static int msm_cvp_allocate_buffer(struct msm_vidc_inst *inst, if (kernel_map) { buffer->kvaddr = dma_buf_vmap(dbuf); if (!buffer->kvaddr) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: dma_buf_vmap failed\n", __func__); rc = -EINVAL; goto error; @@ -263,7 +267,7 @@ static int msm_cvp_set_clocks_and_bus(struct msm_vidc_inst *inst) const u32 fps_max = CVP_FRAME_RATE_MAX; if (!inst || !inst->cvp) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } cvp = inst->cvp; @@ -279,14 +283,15 @@ static int msm_cvp_set_clocks_and_bus(struct msm_vidc_inst *inst) desc.is_downscale = cvp->downscale; desc.fps = min(cvp->frame_rate >> 16, fps_max); desc.op_rate = cvp->operating_rate >> 16; - desc.colorfmt = msm_comm_convert_color_fmt(fmt->fmt.pix_mp.pixelformat); + desc.colorfmt = + msm_comm_convert_color_fmt(fmt->fmt.pix_mp.pixelformat, + inst->sid); rc = msm_cvp_est_cycles(&desc, &power); if (rc) { - dprintk(VIDC_ERR, "%s: estimate failed\n", __func__); + s_vpr_e(inst->sid, "%s: estimate failed\n", __func__); return rc; } - dprintk(VIDC_HIGH, - "%s: core %d controller %d ddr bw %d\n", + s_vpr_h(inst->sid, "%s: core %d controller %d ddr bw %d\n", __func__, power.clock_cycles_a, power.clock_cycles_b, power.ddr_bw); @@ -296,8 +301,8 @@ static int msm_cvp_set_clocks_and_bus(struct msm_vidc_inst *inst) sizeof(struct cvp_kmd_request_power)); rc = msm_cvp_private(cvp->priv, CVP_KMD_REQUEST_POWER, arg); if (rc) { - dprintk(VIDC_ERR, - "%s: request_power failed with %d\n", __func__, rc); + s_vpr_e(inst->sid, "%s: request_power failed with %d\n", + __func__, rc); return rc; } @@ -311,7 +316,7 @@ static int msm_cvp_init_downscale_resolution(struct msm_vidc_inst *inst) u32 width, height, ds_width, ds_height, temp; if (!inst || !inst->cvp) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } cvp = inst->cvp; @@ -320,7 +325,7 @@ static int msm_cvp_init_downscale_resolution(struct msm_vidc_inst *inst) ds_height = cvp->height; if (!cvp->downscale) { - dprintk(VIDC_HIGH, "%s: downscaling not enabled\n", __func__); + s_vpr_h(inst->sid, "%s: downscaling not enabled\n", __func__); goto exit; } @@ -369,11 +374,11 @@ static void msm_cvp_deinit_downscale_buffers(struct msm_vidc_inst *inst) struct msm_cvp_external *cvp; if (!inst || !inst->cvp) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return; } cvp = inst->cvp; - dprintk(VIDC_HIGH, "%s:\n", __func__); + s_vpr_h(inst->sid, "%s:\n", __func__); if (cvp->src_buffer.dbuf) { print_cvp_buffer(VIDC_HIGH, "free: src_buffer", @@ -399,16 +404,16 @@ static int msm_cvp_init_downscale_buffers(struct msm_vidc_inst *inst) struct msm_cvp_external *cvp; if (!inst || !inst->cvp) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } cvp = inst->cvp; if (!cvp->downscale) { - dprintk(VIDC_HIGH, "%s: downscaling not enabled\n", __func__); + s_vpr_h(inst->sid, "%s: downscaling not enabled\n", __func__); return 0; } - dprintk(VIDC_HIGH, "%s:\n", __func__); + s_vpr_h(inst->sid, "%s:\n", __func__); cvp->src_buffer.size = VENUS_BUFFER_SIZE(COLOR_FMT_NV12_UBWC, cvp->ds_width, cvp->ds_height); @@ -445,11 +450,11 @@ static void msm_cvp_deinit_context_buffers(struct msm_vidc_inst *inst) struct msm_cvp_external *cvp; if (!inst || !inst->cvp) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return; } cvp = inst->cvp; - dprintk(VIDC_HIGH, "%s:\n", __func__); + s_vpr_h(inst->sid, "%s:\n", __func__); if (cvp->context_buffer.dbuf) { print_cvp_buffer(VIDC_HIGH, "free: context_buffer", @@ -475,11 +480,11 @@ static int msm_cvp_init_context_buffers(struct msm_vidc_inst *inst) struct msm_cvp_external *cvp; if (!inst || !inst->cvp) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } cvp = inst->cvp; - dprintk(VIDC_HIGH, "%s:\n", __func__); + s_vpr_h(inst->sid, "%s:\n", __func__); cvp->context_buffer.size = HFI_DME_FRAME_CONTEXT_BUFFER_SIZE; rc = msm_cvp_allocate_buffer(inst, &cvp->context_buffer, false); @@ -516,12 +521,12 @@ static void msm_cvp_deinit_internal_buffers(struct msm_vidc_inst *inst) struct msm_cvp_external *cvp; if (!inst || !inst->cvp) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return; } cvp = inst->cvp; - dprintk(VIDC_HIGH, "%s:\n", __func__); + s_vpr_h(inst->sid, "%s:\n", __func__); if (cvp->output_buffer.dbuf) { print_cvp_buffer(VIDC_HIGH, "free: output_buffer", @@ -552,7 +557,7 @@ static int msm_cvp_set_persist_buffer(struct msm_vidc_inst *inst) struct msm_cvp_session_set_persist_buffers_packet persist2_packet = {0}; if (!inst || !inst->cvp || !inst->cvp->arg) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } cvp = inst->cvp; @@ -561,10 +566,10 @@ static int msm_cvp_set_persist_buffer(struct msm_vidc_inst *inst) persist2_packet.size = sizeof(struct msm_cvp_session_set_persist_buffers_packet); persist2_packet.packet_type = HFI_CMD_SESSION_CVP_SET_PERSIST_BUFFERS; - persist2_packet.session_id = cvp->session_id; + persist2_packet.sid = cvp->sid; persist2_packet.cvp_op = CVP_DME; fill_cvp_buffer(&persist2_packet.persist2_buffer, - &cvp->persist2_buffer); + &cvp->persist2_buffer, inst->sid); memset(arg, 0, sizeof(struct cvp_kmd_arg)); arg->type = CVP_KMD_HFI_PERSIST_CMD; @@ -593,7 +598,7 @@ static int msm_cvp_init_internal_buffers(struct msm_vidc_inst *inst) struct msm_cvp_external *cvp; if (!inst || !inst->cvp) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } cvp = inst->cvp; @@ -643,38 +648,39 @@ static int msm_cvp_prepare_extradata(struct msm_vidc_inst *inst, int nIsValid_offset = 232; if (!inst || !inst->cvp || !mbuf) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK %pK\n", + __func__, inst, mbuf); return -EINVAL; } cvp = inst->cvp; vb = &mbuf->vvb.vb2_buf; if (vb->num_planes <= 1) { - dprintk(VIDC_ERR, "%s: extradata plane not enabled\n", + s_vpr_e(inst->sid, "%s: extradata plane not enabled\n", __func__); return -EINVAL; } dbuf = dma_buf_get(vb->planes[1].m.fd); if (!dbuf) { - dprintk(VIDC_ERR, "%s: dma_buf_get(%d) failed\n", + s_vpr_e(inst->sid, "%s: dma_buf_get(%d) failed\n", __func__, vb->planes[1].m.fd); return -EINVAL; } if (dbuf->size < vb->planes[1].length) { - dprintk(VIDC_ERR, "%s: invalid size %d vs %d\n", __func__, + s_vpr_e(inst->sid, "%s: invalid size %d vs %d\n", __func__, dbuf->size, vb->planes[1].length); rc = -EINVAL; goto error; } rc = dma_buf_begin_cpu_access(dbuf, DMA_BIDIRECTIONAL); if (rc) { - dprintk(VIDC_ERR, "%s: begin_cpu_access failed\n", __func__); + s_vpr_e(inst->sid, "%s: begin_cpu_access failed\n", __func__); goto error; } kvaddr = dma_buf_vmap(dbuf); if (!kvaddr) { - dprintk(VIDC_ERR, "%s: dma_buf_vmap(%d) failed\n", + s_vpr_e(inst->sid, "%s: dma_buf_vmap(%d) failed\n", __func__, vb->planes[1].m.fd); rc = -EINVAL; goto error; @@ -698,7 +704,7 @@ static int msm_cvp_prepare_extradata(struct msm_vidc_inst *inst, e_hdr += e_hdr->size; } if (!found_end) { - dprintk(VIDC_ERR, "%s: extradata_none not found\n", __func__); + s_vpr_e(inst->sid, "%s: extradata_none not found\n", __func__); e_hdr = (struct msm_vidc_extradata_header *)((char *)kvaddr + vb->planes[1].data_offset); } @@ -707,7 +713,7 @@ static int msm_cvp_prepare_extradata(struct msm_vidc_inst *inst, sizeof(struct msm_vidc_enc_cvp_metadata_payload) + sizeof(struct msm_vidc_extradata_header)) > (kvaddr + dbuf->size)) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: couldn't append extradata, (e_hdr[%pK] - kvaddr[%pK]) %#x, size %d\n", __func__, e_hdr, kvaddr, (char *)e_hdr - (char *)kvaddr, dbuf->size); @@ -730,8 +736,7 @@ static int msm_cvp_prepare_extradata(struct msm_vidc_inst *inst, sizeof(struct msm_vidc_enc_cvp_metadata_payload)); cvpframe = (char *) e_hdr->data; cvp_metadata_valid_flag = *(u32*)(cvpframe + nIsValid_offset); - dprintk(VIDC_HIGH, - "CVP metadata nIsValid flag = %u frame: %u", + s_vpr_h(inst->sid, "CVP metadata nIsValid flag = %u frame: %u", cvp_metadata_valid_flag, cvp->framecount); dma_buf_end_cpu_access(cvp->output_buffer.dbuf, DMA_BIDIRECTIONAL); @@ -770,7 +775,7 @@ static int msm_cvp_reference_management(struct msm_vidc_inst *inst) struct msm_cvp_buf temp; if (!inst || !inst->cvp) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } cvp = inst->cvp; @@ -800,7 +805,7 @@ static int msm_vidc_cvp_session_start(struct msm_vidc_inst *inst) struct cvp_kmd_arg *arg = NULL; if (!inst || !inst->cvp || !inst->cvp->arg) { - dprintk(VIDC_ERR, "%s: invalid param\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } cvp = inst->cvp; @@ -813,7 +818,7 @@ static int msm_vidc_cvp_session_start(struct msm_vidc_inst *inst) rc = msm_cvp_private(cvp->priv, CVP_KMD_SESSION_CONTROL, arg); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: CVP_KMD_SESSION_CONTROL failed, rc %d\n", __func__, rc); return rc; @@ -830,7 +835,7 @@ static int msm_vidc_cvp_session_stop(struct msm_vidc_inst *inst) struct cvp_kmd_arg *arg = NULL; if (!inst || !inst->cvp || !inst->cvp->arg) { - dprintk(VIDC_ERR, "%s: invalid param\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } @@ -846,7 +851,7 @@ static int msm_vidc_cvp_session_stop(struct msm_vidc_inst *inst) rc = msm_cvp_private(cvp->priv, CVP_KMD_SESSION_CONTROL, arg); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: CVP_KMD_SESSION_CONTROL failed, rc %d\n", __func__, rc); return rc; @@ -869,7 +874,8 @@ static int msm_cvp_frame_process(struct msm_vidc_inst *inst, bool first_frame = false; if (!inst || !inst->cvp || !inst->cvp->arg || !mbuf) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK %pK\n", + __func__, inst, mbuf); return -EINVAL; } cvp = inst->cvp; @@ -894,7 +900,7 @@ static int msm_cvp_frame_process(struct msm_vidc_inst *inst, cvp->operating_rate = inst->clk_data.operating_rate; rc = msm_cvp_set_clocks_and_bus(inst); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: unsupported dynamic changes %#x %#x\n", __func__, cvp->frame_rate, cvp->operating_rate); goto error; @@ -945,7 +951,7 @@ static int msm_cvp_frame_process(struct msm_vidc_inst *inst, frame = (struct msm_cvp_dme_frame_packet *)&arg->data.hfi_pkt.pkt_data; frame->size = sizeof(struct msm_cvp_dme_frame_packet); frame->packet_type = HFI_CMD_SESSION_CVP_DME_FRAME; - frame->session_id = cvp->session_id; + frame->sid = cvp->sid; if (first_frame) frame->skip_mv_calc = 1; else @@ -957,18 +963,20 @@ static int msm_cvp_frame_process(struct msm_vidc_inst *inst, frame->ncc_robustness_threshold = 0; fill_cvp_buffer(&frame->fullres_srcbuffer, - &cvp->fullres_buffer); + &cvp->fullres_buffer, inst->sid); fill_cvp_buffer(&frame->videospatialtemporal_statsbuffer, - &cvp->output_buffer); - fill_cvp_buffer(&frame->src_buffer, &cvp->fullres_buffer); + &cvp->output_buffer, inst->sid); + fill_cvp_buffer(&frame->src_buffer, &cvp->fullres_buffer, inst->sid); if (cvp->downscale) { - fill_cvp_buffer(&frame->src_buffer, &cvp->src_buffer); - fill_cvp_buffer(&frame->ref_buffer, &cvp->ref_buffer); + fill_cvp_buffer(&frame->src_buffer, &cvp->src_buffer, + inst->sid); + fill_cvp_buffer(&frame->ref_buffer, &cvp->ref_buffer, + inst->sid); } fill_cvp_buffer(&frame->srcframe_contextbuffer, - &cvp->context_buffer); + &cvp->context_buffer, inst->sid); fill_cvp_buffer(&frame->refframe_contextbuffer, - &cvp->refcontext_buffer); + &cvp->refcontext_buffer, inst->sid); print_cvp_buffer(VIDC_LOW, "input frame", inst, &cvp->fullres_buffer); rc = msm_cvp_private(cvp->priv, CVP_KMD_SEND_CMD_PKT, arg); @@ -999,11 +1007,12 @@ int msm_vidc_cvp_preprocess(struct msm_vidc_inst *inst, struct msm_cvp_external *cvp; if (!inst || !inst->cvp || !mbuf) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK %pK\n", + __func__, inst, mbuf); return -EINVAL; } if (inst->state != MSM_VIDC_START_DONE) { - dprintk(VIDC_ERR, "%s: invalid inst state %d\n", + s_vpr_e(inst->sid, "%s: invalid inst state %d\n", __func__, inst->state); return -EINVAL; } @@ -1011,19 +1020,19 @@ int msm_vidc_cvp_preprocess(struct msm_vidc_inst *inst, rc = msm_cvp_frame_process(inst, mbuf); if (rc) { - dprintk(VIDC_ERR, "%s: cvp process failed\n", __func__); + s_vpr_e(inst->sid, "%s: cvp process failed\n", __func__); return rc; } rc = msm_cvp_prepare_extradata(inst, mbuf); if (rc) { - dprintk(VIDC_ERR, "%s: prepare extradata failed\n", __func__); + s_vpr_e(inst->sid, "%s: prepare extradata failed\n", __func__); return rc; } rc = msm_cvp_reference_management(inst); if (rc) { - dprintk(VIDC_ERR, "%s: ref management failed\n", __func__); + s_vpr_e(inst->sid, "%s: ref management failed\n", __func__); return rc; } @@ -1038,7 +1047,7 @@ static int msm_vidc_cvp_session_delete(struct msm_vidc_inst *inst) struct cvp_kmd_arg *arg = NULL; if (!inst || !inst->cvp || !inst->cvp->arg) { - dprintk(VIDC_ERR, "%s: invalid param\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } cvp = inst->cvp; @@ -1051,7 +1060,7 @@ static int msm_vidc_cvp_session_delete(struct msm_vidc_inst *inst) rc = msm_cvp_private(cvp->priv, CVP_KMD_SESSION_CONTROL, arg); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: CVP_KMD_SESSION_CONTROL failed, rc %d\n", __func__, rc); return rc; @@ -1066,12 +1075,12 @@ static int msm_cvp_mem_deinit(struct msm_vidc_inst *inst) struct msm_cvp_external *cvp; if (!inst || !inst->cvp) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } cvp = inst->cvp; - dprintk(VIDC_HIGH, "%s: cvp session %#x\n", __func__, cvp->session_id); + s_vpr_h(inst->sid, "%s: cvp session %#x\n", __func__, cvp->sid); msm_cvp_deinit_internal_buffers(inst); msm_cvp_deinit_context_buffers(inst); msm_cvp_deinit_downscale_buffers(inst); @@ -1090,13 +1099,13 @@ static int msm_vidc_cvp_deinit(struct msm_vidc_inst *inst) int rc = 0; if (!inst || !inst->cvp) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } rc = msm_vidc_cvp_session_stop(inst); if (rc) { - dprintk(VIDC_ERR, "%s: cvp stop failed with error %d\n", + s_vpr_e(inst->sid, "%s: cvp stop failed with error %d\n", __func__, rc); } @@ -1111,16 +1120,16 @@ static int msm_vidc_cvp_close(struct msm_vidc_inst *inst) struct msm_cvp_external *cvp; if (!inst || !inst->cvp) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } cvp = inst->cvp; - dprintk(VIDC_HIGH, "%s: cvp session %#x\n", __func__, cvp->session_id); + s_vpr_h(inst->sid, "%s: cvp session %#x\n", __func__, cvp->sid); rc = msm_cvp_close(cvp->priv); if (rc) { - dprintk(VIDC_ERR, - "%s: cvp close failed with error %d\n", __func__, rc); + s_vpr_e(inst->sid, "%s: cvp close failed with error %d\n", + __func__, rc); } return rc; @@ -1129,11 +1138,11 @@ static int msm_vidc_cvp_close(struct msm_vidc_inst *inst) int msm_vidc_cvp_unprepare_preprocess(struct msm_vidc_inst *inst) { if (!inst) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } if (!inst->cvp) { - dprintk(VIDC_HIGH, "%s: cvp not enabled or closed\n", __func__); + s_vpr_h(inst->sid, "%s: cvp not enabled or closed\n", __func__); return 0; } @@ -1152,7 +1161,7 @@ static int msm_vidc_cvp_session_create(struct msm_vidc_inst *inst) struct cvp_kmd_arg *arg = NULL; if (!inst || !inst->cvp || !inst->cvp->arg) { - dprintk(VIDC_ERR, "%s: invalid param\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } cvp = inst->cvp; @@ -1165,7 +1174,7 @@ static int msm_vidc_cvp_session_create(struct msm_vidc_inst *inst) rc = msm_cvp_private(cvp->priv, CVP_KMD_SESSION_CONTROL, arg); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: CVP_KMD_SESSION_CONTROL failed, rc %d\n", __func__, rc); return rc; @@ -1181,7 +1190,7 @@ static int msm_vidc_cvp_getsessioninfo(struct msm_vidc_inst *inst) struct cvp_kmd_arg *arg; if (!inst || !inst->cvp || !inst->cvp->arg) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } cvp = inst->cvp; @@ -1191,16 +1200,16 @@ static int msm_vidc_cvp_getsessioninfo(struct msm_vidc_inst *inst) arg->type = CVP_KMD_GET_SESSION_INFO; rc = msm_cvp_private(cvp->priv, CVP_KMD_GET_SESSION_INFO, arg); if (rc) { - dprintk(VIDC_ERR, "%s: get_session_info failed\n", __func__); + s_vpr_e(inst->sid, "%s: get_session_info failed\n", __func__); goto error; } - cvp->session_id = arg->data.session.session_id; - dprintk(VIDC_HIGH, "%s: cvp session id %#x\n", - __func__, cvp->session_id); + cvp->sid = arg->data.session.session_id; + s_vpr_h(inst->sid, "%s: cvp session id %#x\n", + __func__, cvp->sid); rc = msm_cvp_get_version_info(inst); if (rc) { - dprintk(VIDC_ERR, "%s: get_version_info failed\n", __func__); + s_vpr_e(inst->sid, "%s: get_version_info failed\n", __func__); goto error; } return rc; @@ -1220,7 +1229,7 @@ static int msm_vidc_cvp_dme_basic_config(struct msm_vidc_inst *inst) u32 color_fmt; if (!inst || !inst->cvp || !inst->cvp->arg) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } cvp = inst->cvp; @@ -1232,24 +1241,28 @@ static int msm_vidc_cvp_dme_basic_config(struct msm_vidc_inst *inst) &arg->data.hfi_pkt.pkt_data; dmecfg->size = sizeof(struct msm_cvp_dme_basic_config_packet); dmecfg->packet_type = HFI_CMD_SESSION_CVP_DME_BASIC_CONFIG; - dmecfg->session_id = cvp->session_id; + dmecfg->sid = cvp->sid; /* source buffer format should be NV12_UBWC always */ dmecfg->srcbuffer_format = HFI_COLOR_FORMAT_NV12_UBWC; dmecfg->src_width = cvp->ds_width; dmecfg->src_height = cvp->ds_height; rc = msm_cvp_fill_planeinfo(&dmecfg->srcbuffer_planeinfo, - COLOR_FMT_NV12_UBWC, dmecfg->src_width, dmecfg->src_height); + COLOR_FMT_NV12_UBWC, dmecfg->src_width, + dmecfg->src_height, inst->sid); if (rc) goto error; fmt = &inst->fmts[INPUT_PORT].v4l2_fmt; - color_fmt = msm_comm_convert_color_fmt(fmt->fmt.pix_mp.pixelformat); + color_fmt = + msm_comm_convert_color_fmt(fmt->fmt.pix_mp.pixelformat, + inst->sid); dmecfg->fullresbuffer_format = msm_comm_get_hfi_uncompressed( - fmt->fmt.pix_mp.pixelformat); + fmt->fmt.pix_mp.pixelformat, inst->sid); dmecfg->fullres_width = cvp->width; dmecfg->fullres_height = cvp->height; rc = msm_cvp_fill_planeinfo(&dmecfg->fullresbuffer_planeinfo, - color_fmt, dmecfg->fullres_width, dmecfg->fullres_height); + color_fmt, dmecfg->fullres_width, + dmecfg->fullres_height, inst->sid); if (rc) goto error; dmecfg->ds_enable = cvp->downscale; @@ -1257,7 +1270,7 @@ static int msm_vidc_cvp_dme_basic_config(struct msm_vidc_inst *inst) dmecfg->enable_inlier_tracking = 1; rc = msm_cvp_private(cvp->priv, CVP_KMD_SEND_CMD_PKT, arg); if (rc) { - dprintk(VIDC_ERR, "%s: cvp configuration failed\n", __func__); + s_vpr_e(inst->sid, "%s: cvp configuration failed\n", __func__); goto error; } @@ -1272,13 +1285,13 @@ static int msm_cvp_mem_init(struct msm_vidc_inst *inst) struct v4l2_format *fmt; if (!inst) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } inst->cvp = kzalloc(sizeof(struct msm_cvp_external), GFP_KERNEL); if (!inst->cvp) { - dprintk(VIDC_ERR, "%s: failed to allocate\n", __func__); + s_vpr_e(inst->sid, "%s: failed to allocate\n", __func__); return -ENOMEM; } cvp = inst->cvp; @@ -1304,7 +1317,7 @@ static int msm_cvp_mem_init(struct msm_vidc_inst *inst) if (rc) goto error; - dprintk(VIDC_HIGH, + s_vpr_h(inst->sid, "%s: pixelformat %#x, wxh %dx%d downscale %d ds_wxh %dx%d fps %d op_rate %d\n", __func__, fmt->fmt.pix_mp.pixelformat, cvp->width, cvp->height, cvp->downscale, @@ -1334,15 +1347,16 @@ static int msm_vidc_cvp_open(struct msm_vidc_inst *inst) struct msm_cvp_external *cvp; if (!inst || !inst->cvp) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } cvp = inst->cvp; - dprintk(VIDC_HIGH, "%s: opening cvp\n", __func__); + s_vpr_h(inst->sid, "%s: opening cvp\n", __func__); cvp->priv = msm_cvp_open(0, MSM_VIDC_CVP); if (!cvp->priv) { - dprintk(VIDC_ERR, "%s: failed to open cvp session\n", __func__); + s_vpr_e(inst->sid, + "%s: failed to open cvp session\n", __func__); rc = -EINVAL; } @@ -1393,7 +1407,7 @@ int msm_vidc_cvp_prepare_preprocess(struct msm_vidc_inst *inst) int rc; if (!inst) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } diff --git a/msm/vidc/msm_cvp_external.h b/msm/vidc/msm_cvp_external.h index 90b3e7722ced..b0f14c8127d2 100644 --- a/msm/vidc/msm_cvp_external.h +++ b/msm/vidc/msm_cvp_external.h @@ -82,7 +82,7 @@ struct msm_cvp_buffer_type { struct msm_cvp_session_release_persist_buffers_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; struct msm_cvp_client_data client_data; u32 cvp_op; struct msm_cvp_buffer_type persist1_buffer; @@ -92,7 +92,7 @@ struct msm_cvp_session_release_persist_buffers_packet { struct msm_cvp_session_set_persist_buffers_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; struct msm_cvp_client_data client_data; u32 cvp_op; struct msm_cvp_buffer_type persist1_buffer; @@ -102,7 +102,7 @@ struct msm_cvp_session_set_persist_buffers_packet { struct msm_cvp_dme_frame_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; struct msm_cvp_client_data client_data; u32 stream_idx; u32 skip_mv_calc; @@ -126,7 +126,7 @@ struct msm_cvp_dme_frame_packet { struct msm_cvp_dme_basic_config_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; struct msm_cvp_client_data client_data; u32 stream_idx; u32 srcbuffer_format; @@ -167,7 +167,7 @@ struct msm_cvp_buf { struct msm_cvp_external { void *priv; void *arg; - u32 session_id; + u32 sid; u32 width; u32 height; u32 ds_width; diff --git a/msm/vidc/msm_cvp_internal.c b/msm/vidc/msm_cvp_internal.c index b5c7350b70c9..f0788d9ba41d 100644 --- a/msm/vidc/msm_cvp_internal.c +++ b/msm/vidc/msm_cvp_internal.c @@ -19,9 +19,9 @@ static void print_client_buffer(u32 tag, const char *str, if (!(tag & msm_vidc_debug) || !inst || !cbuf) return; - dprintk(tag, - "%s: %x : idx %2d fd %d off %d size %d type %d flags 0x%x\n", - str, hash32_ptr(inst->session), cbuf->index, cbuf->fd, + dprintk(tag, inst->sid, + "%s: idx %2d fd %d off %d size %d type %d flags 0x%x\n", + str, cbuf->index, cbuf->fd, cbuf->offset, cbuf->size, cbuf->type, cbuf->flags); } @@ -31,14 +31,15 @@ static void print_cvp_buffer(u32 tag, const char *str, if (!(tag & msm_vidc_debug) || !inst || !cbuf) return; - dprintk(tag, - "%s: %x : idx %2d fd %d off %d daddr %x size %d type %d flags 0x%x\n", - str, hash32_ptr(inst->session), cbuf->buf.index, cbuf->buf.fd, + dprintk(tag, inst->sid, + "%s: idx %2d fd %d off %d daddr %x size %d type %d flags 0x%x\n", + str, cbuf->buf.index, cbuf->buf.fd, cbuf->buf.offset, cbuf->smem.device_addr, cbuf->buf.size, cbuf->buf.type, cbuf->buf.flags); } -static enum hal_buffer get_hal_buftype(const char *str, unsigned int type) +static enum hal_buffer get_hal_buftype(const char *str, + unsigned int type, u32 sid) { enum hal_buffer buftype = HAL_BUFFER_NONE; @@ -51,7 +52,7 @@ static enum hal_buffer get_hal_buftype(const char *str, unsigned int type) else if (type == MSM_CVP_BUFTYPE_INTERNAL_2) buftype = HAL_BUFFER_INTERNAL_SCRATCH_1; else - dprintk(VIDC_ERR, "%s: unknown buffer type %#x\n", + s_vpr_e(sid, "%s: unknown buffer type %#x\n", str, type); return buftype; @@ -68,14 +69,14 @@ void handle_session_register_buffer_done(enum hal_command_response cmd, bool found; if (!response) { - dprintk(VIDC_ERR, "%s: invalid response\n", __func__); + d_vpr_e("%s: invalid response\n", __func__); return; } inst = get_inst(get_vidc_core(response->device_id), - response->session_id); + response->inst_id); if (!inst) { - dprintk(VIDC_ERR, "%s: invalid session %pK\n", __func__, - response->session_id); + d_vpr_e("%s: invalid session %pK\n", __func__, + response->inst_id); return; } @@ -90,7 +91,7 @@ void handle_session_register_buffer_done(enum hal_command_response cmd, } mutex_unlock(&inst->cvpbufs.lock); if (!found) { - dprintk(VIDC_ERR, "%s: client_data %x not found\n", + s_vpr_e(inst->sid, "%s: client_data %x not found\n", __func__, response->data.regbuf.client_data); goto exit; } @@ -106,6 +107,7 @@ void handle_session_register_buffer_done(enum hal_command_response cmd, exit: put_inst(inst); + s_vpr_l(inst->sid, "handled: SESSION_REGISTER_BUFFER_DONE\n"); } void handle_session_unregister_buffer_done(enum hal_command_response cmd, @@ -120,14 +122,14 @@ void handle_session_unregister_buffer_done(enum hal_command_response cmd, bool found; if (!response) { - dprintk(VIDC_ERR, "%s: invalid response\n", __func__); + d_vpr_e("%s: invalid response\n", __func__); return; } inst = get_inst(get_vidc_core(response->device_id), - response->session_id); + response->inst_id); if (!inst) { - dprintk(VIDC_ERR, "%s: invalid session %pK\n", __func__, - response->session_id); + d_vpr_e("%s: invalid session %pK\n", __func__, + response->inst_id); return; } @@ -142,7 +144,7 @@ void handle_session_unregister_buffer_done(enum hal_command_response cmd, } mutex_unlock(&inst->cvpbufs.lock); if (!found) { - dprintk(VIDC_ERR, "%s: client_data %x not found\n", + s_vpr_e(inst->sid, "%s: client_data %x not found\n", __func__, response->data.unregbuf.client_data); goto exit; } @@ -169,6 +171,7 @@ void handle_session_unregister_buffer_done(enum hal_command_response cmd, cbuf = NULL; exit: put_inst(inst); + s_vpr_l(inst->sid, "handled: SESSION_UNREGISTER_BUFFER_DONE\n"); } static void print_cvp_cycles(struct msm_vidc_inst *inst) @@ -183,8 +186,7 @@ static void print_cvp_cycles(struct msm_vidc_inst *inst) mutex_lock(&core->lock); list_for_each_entry(temp, &core->instances, list) { if (temp->session_type == MSM_VIDC_CVP) { - dprintk(VIDC_ERR, "session %#x, vpss %d ise %d\n", - hash32_ptr(temp->session), + s_vpr_e(temp->sid, "vpss %d ise %d\n", temp->clk_data.vpss_cycles, temp->clk_data.ise_cycles); } @@ -201,7 +203,7 @@ static bool msm_cvp_check_session_supported(struct msm_vidc_inst *inst, u32 total_ise_cycles = 0; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return false; } core = inst->core; @@ -227,23 +229,21 @@ static int msm_cvp_scale_clocks_and_bus(struct msm_vidc_inst *inst) int rc = 0; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } - rc = msm_vidc_set_clocks(inst->core); + rc = msm_vidc_set_clocks(inst->core, inst->sid); if (rc) { - dprintk(VIDC_ERR, - "%s: failed set_clocks for inst %pK (%#x)\n", - __func__, inst, hash32_ptr(inst->session)); + s_vpr_e(inst->sid, "%s: failed set_clocks for inst %pK\n", + __func__, inst); goto exit; } rc = msm_comm_vote_bus(inst); if (rc) { - dprintk(VIDC_ERR, - "%s: failed vote_bus for inst %pK (%#x)\n", - __func__, inst, hash32_ptr(inst->session)); + s_vpr_e(inst->sid, + "%s: failed vote_bus for inst %pK\n", __func__, inst); goto exit; } @@ -257,12 +257,13 @@ static int msm_cvp_get_session_info(struct msm_vidc_inst *inst, int rc = 0; if (!inst || !inst->core || !session) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK %pK\n", + __func__, inst, session); return -EINVAL; } - session->session_id = hash32_ptr(inst->session); - dprintk(VIDC_HIGH, "%s: id 0x%x\n", __func__, session->session_id); + session->session_id = inst->sid; + s_vpr_h(inst->sid, "%s: id 0x%x\n", __func__, session->session_id); return rc; } @@ -273,11 +274,12 @@ static int msm_cvp_request_power(struct msm_vidc_inst *inst, int rc = 0; if (!inst || !power) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK %pK\n", + __func__, inst, power); return -EINVAL; } - dprintk(VIDC_HIGH, + s_vpr_h(inst->sid, "%s: clock_cycles_a %d, clock_cycles_b %d, ddr_bw %d sys_cache_bw %d\n", __func__, power->clock_cycles_a, power->clock_cycles_b, power->ddr_bw, power->sys_cache_bw); @@ -285,10 +287,8 @@ static int msm_cvp_request_power(struct msm_vidc_inst *inst, rc = msm_cvp_check_session_supported(inst, power->clock_cycles_a, power->clock_cycles_b); if (!rc) { - dprintk(VIDC_ERR, - "%s: session %#x rejected, cycles: vpss %d, ise %d\n", - __func__, hash32_ptr(inst->session), - power->clock_cycles_a, power->clock_cycles_b); + s_vpr_e(inst->sid, "%s: rejected, cycles: vpss %d, ise %d\n", + __func__, power->clock_cycles_a, power->clock_cycles_b); print_cvp_cycles(inst); msm_comm_kill_session(inst); return -EOVERFLOW; @@ -301,9 +301,9 @@ static int msm_cvp_request_power(struct msm_vidc_inst *inst, inst->clk_data.sys_cache_bw = power->sys_cache_bw / 1000; rc = msm_cvp_scale_clocks_and_bus(inst); if (rc) { - dprintk(VIDC_ERR, - "%s: failed to scale clocks and bus for inst %pK (%#x)\n", - __func__, inst, hash32_ptr(inst->session)); + s_vpr_e(inst->sid, + "%s: failed to scale clocks and bus for inst %pK\n", + __func__, inst); goto exit; } @@ -311,17 +311,13 @@ static int msm_cvp_request_power(struct msm_vidc_inst *inst, !inst->clk_data.sys_cache_bw) { rc = msm_cvp_inst_pause(inst); if (rc) { - dprintk(VIDC_ERR, - "%s: failed to pause inst %pK (%#x)\n", - __func__, inst, hash32_ptr(inst->session)); + s_vpr_e(inst->sid, "%s: failed to pause\n", __func__); goto exit; } } else { rc = msm_cvp_inst_resume(inst); if (rc) { - dprintk(VIDC_ERR, - "%s: failed to resume inst %pK (%#x)\n", - __func__, inst, hash32_ptr(inst->session)); + s_vpr_e(inst->sid, "%s: failed to resume\n", __func__); goto exit; } } @@ -340,7 +336,8 @@ static int msm_cvp_register_buffer(struct msm_vidc_inst *inst, struct vidc_register_buffer vbuf; if (!inst || !inst->core || !buf) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK %pK\n", + __func__, inst, buf); return -EINVAL; } hdev = inst->core->device; @@ -364,7 +361,7 @@ static int msm_cvp_register_buffer(struct msm_vidc_inst *inst, cbuf = kzalloc(sizeof(struct msm_vidc_cvp_buffer), GFP_KERNEL); if (!cbuf) { - dprintk(VIDC_ERR, "%s: cbuf alloc failed\n", __func__); + s_vpr_e(inst->sid, "%s: cbuf alloc failed\n", __func__); return -ENOMEM; } mutex_lock(&inst->cvpbufs.lock); @@ -372,7 +369,8 @@ static int msm_cvp_register_buffer(struct msm_vidc_inst *inst, mutex_unlock(&inst->cvpbufs.lock); memcpy(&cbuf->buf, buf, sizeof(struct msm_cvp_buffer)); - cbuf->smem.buffer_type = get_hal_buftype(__func__, buf->type); + cbuf->smem.buffer_type = get_hal_buftype(__func__, buf->type, + inst->sid); cbuf->smem.fd = buf->fd; cbuf->smem.offset = buf->offset; cbuf->smem.size = buf->size; @@ -384,7 +382,7 @@ static int msm_cvp_register_buffer(struct msm_vidc_inst *inst, memset(&vbuf, 0, sizeof(struct vidc_register_buffer)); vbuf.index = buf->index; - vbuf.type = get_hal_buftype(__func__, buf->type); + vbuf.type = get_hal_buftype(__func__, buf->type, inst->sid); vbuf.size = buf->size; vbuf.device_addr = cbuf->smem.device_addr; vbuf.client_data = cbuf->smem.device_addr; @@ -419,7 +417,8 @@ static int msm_cvp_unregister_buffer(struct msm_vidc_inst *inst, struct vidc_unregister_buffer vbuf; if (!inst || !inst->core || !buf) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK %pK\n", + __func__, inst, buf); return -EINVAL; } hdev = inst->core->device; @@ -443,7 +442,7 @@ static int msm_cvp_unregister_buffer(struct msm_vidc_inst *inst, memset(&vbuf, 0, sizeof(struct vidc_unregister_buffer)); vbuf.index = cbuf->buf.index; - vbuf.type = get_hal_buftype(__func__, cbuf->buf.type); + vbuf.type = get_hal_buftype(__func__, cbuf->buf.type, inst->sid); vbuf.size = cbuf->buf.size; vbuf.device_addr = cbuf->smem.device_addr; vbuf.client_data = cbuf->smem.device_addr; @@ -461,7 +460,8 @@ int msm_vidc_cvp(struct msm_vidc_inst *inst, struct msm_vidc_arg *arg) int rc = 0; if (!inst || !arg) { - dprintk(VIDC_ERR, "%s: invalid args\n", __func__); + d_vpr_e("%s: invalid args %pK %pK\n", + __func__, inst, arg); return -EINVAL; } @@ -499,7 +499,7 @@ int msm_vidc_cvp(struct msm_vidc_inst *inst, struct msm_vidc_arg *arg) break; } default: - dprintk(VIDC_ERR, "%s: unknown arg type 0x%x\n", + s_vpr_e(inst->sid, "%s: unknown arg type 0x%x\n", __func__, arg->type); rc = -ENOTSUPP; break; @@ -535,15 +535,14 @@ int msm_cvp_inst_pause(struct msm_vidc_inst *inst) struct hfi_device *hdev; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; rc = call_hfi_op(hdev, session_pause, (void *)inst->session); if (rc) - dprintk(VIDC_ERR, "%s: failed to pause inst %pK (%#x)\n", - __func__, inst, hash32_ptr(inst->session)); + s_vpr_e(inst->sid, "%s: failed to pause\n", __func__); return rc; } @@ -554,15 +553,14 @@ int msm_cvp_inst_resume(struct msm_vidc_inst *inst) struct hfi_device *hdev; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; rc = call_hfi_op(hdev, session_resume, (void *)inst->session); if (rc) - dprintk(VIDC_ERR, "%s: failed to resume inst %pK (%#x)\n", - __func__, inst, hash32_ptr(inst->session)); + s_vpr_e(inst->sid, "%s: failed to resume\n", __func__); return rc; } @@ -573,22 +571,21 @@ int msm_cvp_inst_deinit(struct msm_vidc_inst *inst) struct msm_vidc_cvp_buffer *cbuf, *temp; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } - dprintk(VIDC_HIGH, "%s: inst %pK (%#x)\n", __func__, - inst, hash32_ptr(inst->session)); + s_vpr_h(inst->sid, "%s: inst %pK\n", __func__, inst); rc = msm_comm_try_state(inst, MSM_VIDC_CLOSE_DONE); if (rc) - dprintk(VIDC_ERR, "%s: close failed\n", __func__); + s_vpr_e(inst->sid, "%s: close failed\n", __func__); mutex_lock(&inst->cvpbufs.lock); list_for_each_entry_safe(cbuf, temp, &inst->cvpbufs.list, list) { print_cvp_buffer(VIDC_ERR, "unregistered", inst, cbuf); rc = inst->smem_ops->smem_unmap_dma_buf(inst, &cbuf->smem); if (rc) - dprintk(VIDC_ERR, "%s: unmap failed\n", __func__); + s_vpr_e(inst->sid, "%s: unmap failed\n", __func__); list_del(&cbuf->list); kfree(cbuf); } @@ -599,7 +596,7 @@ int msm_cvp_inst_deinit(struct msm_vidc_inst *inst) inst->clk_data.sys_cache_bw = 0; rc = msm_cvp_scale_clocks_and_bus(inst); if (rc) - dprintk(VIDC_ERR, "%s: failed to scale_clocks_and_bus\n", + s_vpr_e(inst->sid, "%s: failed to scale_clocks_and_bus\n", __func__); return rc; @@ -610,12 +607,11 @@ int msm_cvp_inst_init(struct msm_vidc_inst *inst) int rc = 0; if (!inst) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } - dprintk(VIDC_HIGH, "%s: inst %pK (%#x)\n", __func__, - inst, hash32_ptr(inst->session)); + s_vpr_h(inst->sid, "%s: inst %pK\n", __func__, inst); /* set default frequency */ inst->clk_data.core_id = VIDC_CORE_ID_2; diff --git a/msm/vidc/msm_smem.c b/msm/vidc/msm_smem.c index 6a748bf09647..12f645981e37 100644 --- a/msm/vidc/msm_smem.c +++ b/msm/vidc/msm_smem.c @@ -21,7 +21,7 @@ static int msm_dma_get_device_address(struct dma_buf *dbuf, unsigned long align, dma_addr_t *iova, unsigned long *buffer_size, unsigned long flags, enum hal_buffer buffer_type, unsigned long session_type, struct msm_vidc_platform_resources *res, - struct dma_mapping_info *mapping_info) + struct dma_mapping_info *mapping_info, u32 sid) { int rc = 0; struct dma_buf_attachment *attach; @@ -29,18 +29,17 @@ static int msm_dma_get_device_address(struct dma_buf *dbuf, unsigned long align, struct context_bank_info *cb = NULL; if (!dbuf || !iova || !buffer_size || !mapping_info) { - dprintk(VIDC_ERR, "Invalid params: %pK, %pK, %pK, %pK\n", - dbuf, iova, buffer_size, mapping_info); + s_vpr_e(sid, "%s: invalid params: %pK, %pK, %pK, %pK\n", + __func__, dbuf, iova, buffer_size, mapping_info); return -EINVAL; } if (is_iommu_present(res)) { cb = msm_smem_get_context_bank( session_type, (flags & SMEM_SECURE), - res, buffer_type); + res, buffer_type, sid); if (!cb) { - dprintk(VIDC_ERR, - "%s: Failed to get context bank device\n", + s_vpr_e(sid, "%s: Failed to get context bank device\n", __func__); rc = -EIO; goto mem_map_failed; @@ -49,7 +48,7 @@ static int msm_dma_get_device_address(struct dma_buf *dbuf, unsigned long align, /* Check if the dmabuf size matches expected size */ if (dbuf->size < *buffer_size) { rc = -EINVAL; - dprintk(VIDC_ERR, + s_vpr_e(sid, "Size mismatch: Dmabuf size: %zu Expected Size: %lu", dbuf->size, *buffer_size); msm_vidc_res_handle_fatal_hw_error(res, @@ -61,7 +60,7 @@ static int msm_dma_get_device_address(struct dma_buf *dbuf, unsigned long align, attach = dma_buf_attach(dbuf, cb->dev); if (IS_ERR_OR_NULL(attach)) { rc = PTR_ERR(attach) ? PTR_ERR(attach) : -ENOMEM; - dprintk(VIDC_ERR, "Failed to attach dmabuf\n"); + s_vpr_e(sid, "Failed to attach dmabuf\n"); goto mem_buf_attach_failed; } @@ -84,7 +83,7 @@ static int msm_dma_get_device_address(struct dma_buf *dbuf, unsigned long align, table = dma_buf_map_attachment(attach, DMA_BIDIRECTIONAL); if (IS_ERR_OR_NULL(table)) { rc = PTR_ERR(table) ? PTR_ERR(table) : -ENOMEM; - dprintk(VIDC_ERR, "Failed to map table\n"); + s_vpr_e(sid, "Failed to map table\n"); goto mem_map_table_failed; } @@ -96,7 +95,7 @@ static int msm_dma_get_device_address(struct dma_buf *dbuf, unsigned long align, *iova = table->sgl->dma_address; *buffer_size = table->sgl->dma_length; } else { - dprintk(VIDC_ERR, "sgl is NULL\n"); + s_vpr_e(sid, "sgl is NULL\n"); rc = -ENOMEM; goto mem_map_sg_failed; } @@ -111,7 +110,7 @@ static int msm_dma_get_device_address(struct dma_buf *dbuf, unsigned long align, trace_msm_smem_buffer_iommu_op_end("MAP", 0, 0, align, *iova, *buffer_size); } else { - dprintk(VIDC_HIGH, "iommu not present, use phys mem addr\n"); + s_vpr_h(sid, "iommu not present, use phys mem addr\n"); } return 0; @@ -127,19 +126,19 @@ mem_map_failed: static int msm_dma_put_device_address(u32 flags, struct dma_mapping_info *mapping_info, - enum hal_buffer buffer_type) + enum hal_buffer buffer_type, u32 sid) { int rc = 0; if (!mapping_info) { - dprintk(VIDC_ERR, "Invalid mapping_info\n"); + s_vpr_e(sid, "Invalid mapping_info\n"); return -EINVAL; } if (!mapping_info->dev || !mapping_info->table || !mapping_info->buf || !mapping_info->attach || !mapping_info->cb_info) { - dprintk(VIDC_ERR, "Invalid params\n"); + s_vpr_e(sid, "%s: invalid params\n", __func__); return -EINVAL; } @@ -156,17 +155,16 @@ static int msm_dma_put_device_address(u32 flags, mapping_info->buf = NULL; mapping_info->cb_info = NULL; - return rc; } -struct dma_buf *msm_smem_get_dma_buf(int fd) +struct dma_buf *msm_smem_get_dma_buf(int fd, u32 sid) { struct dma_buf *dma_buf; dma_buf = dma_buf_get(fd); if (IS_ERR_OR_NULL(dma_buf)) { - dprintk(VIDC_ERR, "Failed to get dma_buf for %d, error %ld\n", + s_vpr_e(sid, "Failed to get dma_buf for %d, error %ld\n", fd, PTR_ERR(dma_buf)); dma_buf = NULL; } @@ -174,10 +172,10 @@ struct dma_buf *msm_smem_get_dma_buf(int fd) return dma_buf; } -void msm_smem_put_dma_buf(void *dma_buf) +void msm_smem_put_dma_buf(void *dma_buf, u32 sid) { if (!dma_buf) { - dprintk(VIDC_ERR, "%s: NULL dma_buf\n", __func__); + s_vpr_e(sid, "%s: NULL dma_buf\n", __func__); return; } @@ -196,7 +194,7 @@ int msm_smem_map_dma_buf(struct msm_vidc_inst *inst, struct msm_smem *smem) unsigned long ion_flags = 0; if (!inst || !smem) { - dprintk(VIDC_ERR, "%s: Invalid params: %pK %pK\n", + d_vpr_e("%s: invalid params: %pK %pK\n", __func__, inst, smem); rc = -EINVAL; goto exit; @@ -207,7 +205,7 @@ int msm_smem_map_dma_buf(struct msm_vidc_inst *inst, struct msm_smem *smem) goto exit; } - dbuf = msm_smem_get_dma_buf(smem->fd); + dbuf = msm_smem_get_dma_buf(smem->fd, inst->sid); if (!dbuf) { rc = -EINVAL; goto exit; @@ -217,7 +215,7 @@ int msm_smem_map_dma_buf(struct msm_vidc_inst *inst, struct msm_smem *smem) rc = dma_buf_get_flags(dbuf, &ion_flags); if (rc) { - dprintk(VIDC_ERR, "Failed to get dma buf flags: %d\n", rc); + s_vpr_e(inst->sid, "Failed to get dma buf flags: %d\n", rc); goto exit; } if (ion_flags & ION_FLAG_CACHED) @@ -230,14 +228,15 @@ int msm_smem_map_dma_buf(struct msm_vidc_inst *inst, struct msm_smem *smem) rc = msm_dma_get_device_address(dbuf, align, &iova, &buffer_size, smem->flags, smem->buffer_type, inst->session_type, - &(inst->core->resources), &smem->mapping_info); + &(inst->core->resources), &smem->mapping_info, + inst->sid); if (rc) { - dprintk(VIDC_ERR, "Failed to get device address: %d\n", rc); + s_vpr_e(inst->sid, "Failed to get device address: %d\n", rc); goto exit; } temp = (u32)iova; if ((dma_addr_t)temp != iova) { - dprintk(VIDC_ERR, "iova(%pa) truncated to %#x", &iova, temp); + s_vpr_e(inst->sid, "iova(%pa) truncated to %#x", &iova, temp); rc = -EINVAL; goto exit; } @@ -254,7 +253,7 @@ int msm_smem_unmap_dma_buf(struct msm_vidc_inst *inst, struct msm_smem *smem) int rc = 0; if (!inst || !smem) { - dprintk(VIDC_ERR, "%s: Invalid params: %pK %pK\n", + d_vpr_e("%s: invalid params: %pK %pK\n", __func__, inst, smem); rc = -EINVAL; goto exit; @@ -263,7 +262,7 @@ int msm_smem_unmap_dma_buf(struct msm_vidc_inst *inst, struct msm_smem *smem) if (smem->refcount) { smem->refcount--; } else { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "unmap called while refcount is zero already\n"); return -EINVAL; } @@ -272,13 +271,13 @@ int msm_smem_unmap_dma_buf(struct msm_vidc_inst *inst, struct msm_smem *smem) goto exit; rc = msm_dma_put_device_address(smem->flags, &smem->mapping_info, - smem->buffer_type); + smem->buffer_type, inst->sid); if (rc) { - dprintk(VIDC_ERR, "Failed to put device address: %d\n", rc); + s_vpr_e(inst->sid, "Failed to put device address: %d\n", rc); goto exit; } - msm_smem_put_dma_buf(smem->dma_buf); + msm_smem_put_dma_buf(smem->dma_buf, inst->sid); smem->device_addr = 0x0; smem->dma_buf = NULL; @@ -325,7 +324,7 @@ static int get_secure_flag_for_buffer_type( static int alloc_dma_mem(size_t size, u32 align, u32 flags, enum hal_buffer buffer_type, int map_kernel, struct msm_vidc_platform_resources *res, u32 session_type, - struct msm_smem *mem) + struct msm_smem *mem, u32 sid) { dma_addr_t iova = 0; unsigned long buffer_size = 0; @@ -335,7 +334,7 @@ static int alloc_dma_mem(size_t size, u32 align, u32 flags, struct dma_buf *dbuf = NULL; if (!res) { - dprintk(VIDC_ERR, "%s: NULL res\n", __func__); + s_vpr_e(sid, "%s: NULL res\n", __func__); return -EINVAL; } @@ -344,13 +343,13 @@ static int alloc_dma_mem(size_t size, u32 align, u32 flags, if (is_iommu_present(res)) { if (flags & SMEM_ADSP) { - dprintk(VIDC_HIGH, "Allocating from ADSP heap\n"); + s_vpr_h(sid, "Allocating from ADSP heap\n"); heap_mask = ION_HEAP(ION_ADSP_HEAP_ID); } else { heap_mask = ION_HEAP(ION_SYSTEM_HEAP_ID); } } else { - dprintk(VIDC_HIGH, + s_vpr_h(sid, "allocate shared memory from adsp heap size %zx align %d\n", size, align); heap_mask = ION_HEAP(ION_ADSP_HEAP_ID); @@ -385,8 +384,7 @@ static int alloc_dma_mem(size_t size, u32 align, u32 flags, heap_mask, size, align, flags, map_kernel); dbuf = ion_alloc(size, heap_mask, ion_flags); if (IS_ERR_OR_NULL(dbuf)) { - dprintk(VIDC_ERR, - "Failed to allocate shared memory = %zx, %#x\n", + s_vpr_e(sid, "Failed to allocate shared memory = %zx, %#x\n", size, flags); rc = -ENOMEM; goto fail_shared_mem_alloc; @@ -403,15 +401,15 @@ static int alloc_dma_mem(size_t size, u32 align, u32 flags, rc = msm_dma_get_device_address(dbuf, align, &iova, &buffer_size, flags, buffer_type, - session_type, res, &mem->mapping_info); + session_type, res, &mem->mapping_info, sid); if (rc) { - dprintk(VIDC_ERR, "Failed to get device address: %d\n", + s_vpr_e(sid, "Failed to get device address: %d\n", rc); goto fail_device_address; } mem->device_addr = (u32)iova; if ((dma_addr_t)mem->device_addr != iova) { - dprintk(VIDC_ERR, "iova(%pa) truncated to %#x", + s_vpr_e(sid, "iova(%pa) truncated to %#x", &iova, mem->device_addr); goto fail_device_address; } @@ -420,14 +418,13 @@ static int alloc_dma_mem(size_t size, u32 align, u32 flags, dma_buf_begin_cpu_access(dbuf, DMA_BIDIRECTIONAL); mem->kvaddr = dma_buf_vmap(dbuf); if (!mem->kvaddr) { - dprintk(VIDC_ERR, - "Failed to map shared mem in kernel\n"); + s_vpr_e(sid, "Failed to map shared mem in kernel\n"); rc = -EIO; goto fail_map; } } - dprintk(VIDC_HIGH, + s_vpr_h(sid, "%s: dma_buf = %pK, device_addr = %x, size = %d, kvaddr = %pK, buffer_type = %#x, flags = %#lx\n", __func__, mem->dma_buf, mem->device_addr, mem->size, mem->kvaddr, mem->buffer_type, mem->flags); @@ -442,16 +439,16 @@ fail_shared_mem_alloc: return rc; } -static int free_dma_mem(struct msm_smem *mem) +static int free_dma_mem(struct msm_smem *mem, u32 sid) { - dprintk(VIDC_HIGH, + s_vpr_h(sid, "%s: dma_buf = %pK, device_addr = %x, size = %d, kvaddr = %pK, buffer_type = %#x\n", __func__, mem->dma_buf, mem->device_addr, mem->size, mem->kvaddr, mem->buffer_type); if (mem->device_addr) { msm_dma_put_device_address(mem->flags, - &mem->mapping_info, mem->buffer_type); + &mem->mapping_info, mem->buffer_type, sid); mem->device_addr = 0x0; } @@ -476,51 +473,52 @@ static int free_dma_mem(struct msm_smem *mem) int msm_smem_alloc(size_t size, u32 align, u32 flags, enum hal_buffer buffer_type, int map_kernel, - void *res, u32 session_type, struct msm_smem *smem) + void *res, u32 session_type, struct msm_smem *smem, u32 sid) { int rc = 0; if (!smem || !size) { - dprintk(VIDC_ERR, "%s: NULL smem or %d size\n", + s_vpr_e(sid, "%s: NULL smem or %d size\n", __func__, (u32)size); return -EINVAL; } rc = alloc_dma_mem(size, align, flags, buffer_type, map_kernel, (struct msm_vidc_platform_resources *)res, - session_type, smem); + session_type, smem, sid); return rc; } -int msm_smem_free(struct msm_smem *smem) +int msm_smem_free(struct msm_smem *smem, u32 sid) { int rc = 0; if (!smem) { - dprintk(VIDC_ERR, "NULL smem passed\n"); + s_vpr_e(sid, "NULL smem passed\n"); return -EINVAL; } - rc = free_dma_mem(smem); + rc = free_dma_mem(smem, sid); return rc; }; int msm_smem_cache_operations(struct dma_buf *dbuf, - enum smem_cache_ops cache_op, unsigned long offset, unsigned long size) + enum smem_cache_ops cache_op, unsigned long offset, + unsigned long size, u32 sid) { int rc = 0; unsigned long flags = 0; if (!dbuf) { - dprintk(VIDC_ERR, "%s: Invalid params\n", __func__); + s_vpr_e(sid, "%s: invalid params\n", __func__); return -EINVAL; } /* Return if buffer doesn't support caching */ rc = dma_buf_get_flags(dbuf, &flags); if (rc) { - dprintk(VIDC_ERR, "%s: dma_buf_get_flags failed, err %d\n", + s_vpr_e(sid, "%s: dma_buf_get_flags failed, err %d\n", __func__, rc); return rc; } else if (!(flags & ION_FLAG_CACHED)) { @@ -546,7 +544,7 @@ int msm_smem_cache_operations(struct dma_buf *dbuf, offset, size); break; default: - dprintk(VIDC_ERR, "%s: cache (%d) operation not supported\n", + s_vpr_e(sid, "%s: cache (%d) operation not supported\n", __func__, cache_op); rc = -EINVAL; break; @@ -557,7 +555,7 @@ int msm_smem_cache_operations(struct dma_buf *dbuf, struct context_bank_info *msm_smem_get_context_bank(u32 session_type, bool is_secure, struct msm_vidc_platform_resources *res, - enum hal_buffer buffer_type) + enum hal_buffer buffer_type, u32 sid) { struct context_bank_info *cb = NULL, *match = NULL; @@ -585,7 +583,7 @@ struct context_bank_info *msm_smem_get_context_bank(u32 session_type, } } if (!match) - dprintk(VIDC_ERR, + s_vpr_e(sid, "%s: cb not found for buffer_type %x, is_secure %d\n", __func__, buffer_type, is_secure); diff --git a/msm/vidc/msm_v4l2_private.c b/msm/vidc/msm_v4l2_private.c index 6200054e0dbd..7155c2d42bc3 100644 --- a/msm/vidc/msm_v4l2_private.c +++ b/msm/vidc/msm_v4l2_private.c @@ -12,7 +12,7 @@ static int convert_from_user(struct msm_vidc_arg *kp, unsigned long arg) struct msm_vidc_arg __user *up = compat_ptr(arg); if (!kp || !up) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params%pK %pK\n", __func__, kp, up); return -EINVAL; } @@ -88,7 +88,7 @@ static int convert_from_user(struct msm_vidc_arg *kp, unsigned long arg) break; } default: - dprintk(VIDC_ERR, "%s: unknown cmd type 0x%x\n", + d_vpr_e("%s: unknown cmd type 0x%x\n", __func__, kp->type); rc = -EINVAL; break; @@ -104,7 +104,7 @@ static int convert_to_user(struct msm_vidc_arg *kp, unsigned long arg) struct msm_vidc_arg __user *up = compat_ptr(arg); if (!kp || !up) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK %pK\n", __func__, kp, up); return -EINVAL; } @@ -180,8 +180,7 @@ static int convert_to_user(struct msm_vidc_arg *kp, unsigned long arg) break; } default: - dprintk(VIDC_ERR, "%s: unknown cmd type 0x%x\n", - __func__, kp->type); + d_vpr_e("%s: unknown cmd type 0x%x\n", __func__, kp->type); rc = -EINVAL; break; } @@ -196,7 +195,7 @@ long msm_v4l2_private(struct file *filp, unsigned int cmd, unsigned long arg) struct msm_vidc_arg karg; if (!filp || !filp->private_data) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, filp); return -EINVAL; } @@ -214,8 +213,7 @@ long msm_v4l2_private(struct file *filp, unsigned int cmd, unsigned long arg) rc = msm_vidc_private((void *)inst, cmd, &karg); if (rc) { - dprintk(VIDC_ERR, "%s: failed cmd type %x\n", - __func__, karg.type); + d_vpr_e("%s: failed cmd type %x\n", __func__, karg.type); return -EINVAL; } diff --git a/msm/vidc/msm_v4l2_vidc.c b/msm/vidc/msm_v4l2_vidc.c index 804c9b124f96..22a8683a0820 100644 --- a/msm/vidc/msm_v4l2_vidc.c +++ b/msm/vidc/msm_v4l2_vidc.c @@ -49,8 +49,7 @@ static int msm_v4l2_open(struct file *filp) trace_msm_v4l2_vidc_open_start("msm v4l2_open start"); vidc_inst = msm_vidc_open(core->id, vid_dev->type); if (!vidc_inst) { - dprintk(VIDC_ERR, - "Failed to create video instance, core: %d, type = %d\n", + d_vpr_e("Failed to create instance, core: %d, type = %d\n", core->id, vid_dev->type); return -ENOMEM; } @@ -270,11 +269,10 @@ static int read_platform_resources(struct msm_vidc_core *core, int rc = 0; if (!core || !pdev) { - dprintk(VIDC_ERR, "%s: Invalid params %pK %pK\n", + d_vpr_e("%s: invalid params %pK %pK\n", __func__, core, pdev); return -EINVAL; } - core->hfi_type = VIDC_HFI_VENUS; core->resources.pdev = pdev; if (pdev->dev.of_node) { @@ -282,7 +280,7 @@ static int read_platform_resources(struct msm_vidc_core *core, rc = read_platform_resources_from_drv_data(core); rc = read_platform_resources_from_dt(&core->resources); } else { - dprintk(VIDC_ERR, "pdev node is NULL\n"); + d_vpr_e("pdev node is NULL\n"); rc = -EINVAL; } return rc; @@ -298,7 +296,7 @@ static int msm_vidc_initialize_core(struct platform_device *pdev, return -EINVAL; rc = read_platform_resources(core, pdev); if (rc) { - dprintk(VIDC_ERR, "Failed to get platform resources\n"); + d_vpr_e("Failed to get platform resources\n"); return rc; } @@ -391,11 +389,10 @@ static ssize_t thermal_level_store(struct device *dev, rc = kstrtoint(buf, 0, &val); if (rc || val < 0) { - dprintk(VIDC_ERR, - "Invalid thermal level value: %s\n", buf); + d_vpr_e("Invalid thermal level value: %s\n", buf); return -EINVAL; } - dprintk(VIDC_HIGH, "Thermal level old %d new %d\n", + d_vpr_h("Thermal level old %d new %d\n", vidc_driver->thermal_level, val); if (val == vidc_driver->thermal_level) @@ -451,14 +448,14 @@ static int msm_vidc_register_video_device(enum session_type sess_type, rc = video_register_device(&core->vdev[sess_type].vdev, VFL_TYPE_GRABBER, nr); if (rc) { - dprintk(VIDC_ERR, "Failed to register the video device\n"); + d_vpr_e("Failed to register the video device\n"); return rc; } video_set_drvdata(&core->vdev[sess_type].vdev, core); dev = &core->vdev[sess_type].vdev.dev; rc = device_create_file(dev, &dev_attr_link_name); if (rc) { - dprintk(VIDC_ERR, "Failed to create video device file\n"); + d_vpr_e("Failed to create video device file\n"); video_unregister_device(&core->vdev[sess_type].vdev); return rc; } @@ -472,7 +469,7 @@ static int msm_vidc_probe_vidc_device(struct platform_device *pdev) int nr = BASE_DEVICE_NUMBER; if (!vidc_driver) { - dprintk(VIDC_ERR, "Invalid vidc driver\n"); + d_vpr_e("Invalid vidc driver\n"); return -EINVAL; } @@ -484,13 +481,12 @@ static int msm_vidc_probe_vidc_device(struct platform_device *pdev) dev_set_drvdata(&pdev->dev, core); rc = msm_vidc_initialize_core(pdev, core); if (rc) { - dprintk(VIDC_ERR, "Failed to init core\n"); + d_vpr_e("Failed to init core\n"); goto err_core_init; } rc = sysfs_create_group(&pdev->dev.kobj, &msm_vidc_core_attr_group); if (rc) { - dprintk(VIDC_ERR, - "Failed to create attributes\n"); + d_vpr_e("Failed to create attributes\n"); goto err_core_init; } @@ -498,7 +494,7 @@ static int msm_vidc_probe_vidc_device(struct platform_device *pdev) rc = v4l2_device_register(&pdev->dev, &core->v4l2_dev); if (rc) { - dprintk(VIDC_ERR, "Failed to register v4l2 device\n"); + d_vpr_e("Failed to register v4l2 device\n"); goto err_v4l2_register; } @@ -506,7 +502,7 @@ static int msm_vidc_probe_vidc_device(struct platform_device *pdev) rc = msm_vidc_register_video_device(MSM_VIDC_DECODER, nr, core, dev); if (rc) { - dprintk(VIDC_ERR, "Failed to register video decoder\n"); + d_vpr_e("Failed to register video decoder\n"); goto err_dec; } @@ -514,7 +510,7 @@ static int msm_vidc_probe_vidc_device(struct platform_device *pdev) rc = msm_vidc_register_video_device(MSM_VIDC_ENCODER, nr + 1, core, dev); if (rc) { - dprintk(VIDC_ERR, "Failed to register video encoder\n"); + d_vpr_e("Failed to register video encoder\n"); goto err_enc; } @@ -523,7 +519,7 @@ static int msm_vidc_probe_vidc_device(struct platform_device *pdev) rc = msm_vidc_register_video_device(MSM_VIDC_CVP, nr + 2, core, dev); if (rc) { - dprintk(VIDC_ERR, "Failed to register video CVP\n"); + d_vpr_e("Failed to register video CVP\n"); goto err_cvp; } } @@ -532,8 +528,8 @@ static int msm_vidc_probe_vidc_device(struct platform_device *pdev) mutex_lock(&vidc_driver->lock); if (vidc_driver->num_cores + 1 > MSM_VIDC_CORES_MAX) { mutex_unlock(&vidc_driver->lock); - dprintk(VIDC_ERR, "Maximum cores already exist, core_no = %d\n", - vidc_driver->num_cores); + d_vpr_e("Maximum cores already exist, core_no = %d\n", + vidc_driver->num_cores); goto err_cores_exceeded; } vidc_driver->num_cores++; @@ -549,16 +545,16 @@ static int msm_vidc_probe_vidc_device(struct platform_device *pdev) rc = PTR_ERR(core->device) ? PTR_ERR(core->device) : -EBADHANDLE; if (rc != -EPROBE_DEFER) - dprintk(VIDC_ERR, "Failed to create HFI device\n"); + d_vpr_e("Failed to create HFI device\n"); else - dprintk(VIDC_HIGH, "msm_vidc: request probe defer\n"); + d_vpr_h("msm_vidc: request probe defer\n"); goto err_cores_exceeded; } core->vidc_core_workq = create_singlethread_workqueue( "vidc_core_workq"); if (!core->vidc_core_workq) { - dprintk(VIDC_ERR, "%s: create core workq failed\n", __func__); + d_vpr_e("%s: create core workq failed\n", __func__); goto err_core_workq; } mutex_lock(&vidc_driver->lock); @@ -570,7 +566,7 @@ static int msm_vidc_probe_vidc_device(struct platform_device *pdev) vidc_driver->sku_version = core->resources.sku_version; - dprintk(VIDC_HIGH, "populating sub devices\n"); + d_vpr_h("populating sub devices\n"); /* * Trigger probe for each sub-device i.e. qcom,msm-vidc,context-bank. * When msm_vidc_probe is called for each sub-device, parse the @@ -580,7 +576,7 @@ static int msm_vidc_probe_vidc_device(struct platform_device *pdev) rc = of_platform_populate(pdev->dev.of_node, msm_vidc_dt_match, NULL, &pdev->dev); if (rc) { - dprintk(VIDC_ERR, "Failed to trigger probe for sub-devices\n"); + d_vpr_e("Failed to trigger probe for sub-devices\n"); goto err_fail_sub_device_probe; } @@ -661,13 +657,13 @@ static int msm_vidc_remove(struct platform_device *pdev) struct msm_vidc_core *core; if (!pdev) { - dprintk(VIDC_ERR, "%s invalid input %pK", __func__, pdev); + d_vpr_e("%s: invalid input %pK", __func__, pdev); return -EINVAL; } core = dev_get_drvdata(&pdev->dev); if (!core) { - dprintk(VIDC_ERR, "%s invalid core", __func__); + d_vpr_e("%s: invalid core", __func__); return -EINVAL; } @@ -712,7 +708,7 @@ static int msm_vidc_pm_suspend(struct device *dev) core = dev_get_drvdata(dev); if (!core) { - dprintk(VIDC_ERR, "%s invalid core\n", __func__); + d_vpr_e("%s: invalid core\n", __func__); return -EINVAL; } @@ -720,7 +716,7 @@ static int msm_vidc_pm_suspend(struct device *dev) if (rc == -ENOTSUPP) rc = 0; else if (rc) - dprintk(VIDC_ERR, "Failed to suspend: %d\n", rc); + d_vpr_e("Failed to suspend: %d\n", rc); return rc; @@ -728,7 +724,7 @@ static int msm_vidc_pm_suspend(struct device *dev) static int msm_vidc_pm_resume(struct device *dev) { - dprintk(VIDC_HIGH, "%s\n", __func__); + d_vpr_h("%s\n", __func__); return 0; } @@ -755,8 +751,7 @@ static int __init msm_vidc_init(void) vidc_driver = kzalloc(sizeof(*vidc_driver), GFP_KERNEL); if (!vidc_driver) { - dprintk(VIDC_ERR, - "Failed to allocate memroy for msm_vidc_drv\n"); + d_vpr_e("Failed to allocate memroy for msm_vidc_drv\n"); return -ENOMEM; } @@ -764,13 +759,11 @@ static int __init msm_vidc_init(void) mutex_init(&vidc_driver->lock); vidc_driver->debugfs_root = msm_vidc_debugfs_init_drv(); if (!vidc_driver->debugfs_root) - dprintk(VIDC_ERR, - "Failed to create debugfs for msm_vidc\n"); + d_vpr_e("Failed to create debugfs for msm_vidc\n"); rc = platform_driver_register(&msm_vidc_driver); if (rc) { - dprintk(VIDC_ERR, - "Failed to register platform driver\n"); + d_vpr_e("Failed to register platform driver\n"); debugfs_remove_recursive(vidc_driver->debugfs_root); kfree(vidc_driver); vidc_driver = NULL; diff --git a/msm/vidc/msm_vdec.c b/msm/vidc/msm_vdec.c index 4e309de188bd..edc8d26a9182 100644 --- a/msm/vidc/msm_vdec.c +++ b/msm/vidc/msm_vdec.c @@ -515,7 +515,7 @@ int msm_vdec_update_stream_output_mode(struct msm_vidc_inst *inst) u32 fourcc; if (!inst) { - dprintk(VIDC_ERR, "%s invalid parameters\n", __func__); + d_vpr_e("%s: invalid parameters\n", __func__); return -EINVAL; } @@ -548,7 +548,7 @@ int msm_vdec_s_fmt(struct msm_vidc_inst *inst, struct v4l2_format *f) u32 color_format; if (!inst || !f) { - dprintk(VIDC_ERR, "%s invalid parameters\n", __func__); + d_vpr_e("%s: invalid parameters %pK %pK\n", __func__, inst, f); return -EINVAL; } @@ -562,9 +562,9 @@ int msm_vdec_s_fmt(struct msm_vidc_inst *inst, struct v4l2_format *f) fmt = &inst->fmts[OUTPUT_PORT]; fmt_desc = msm_comm_get_pixel_fmt_fourcc(vdec_output_formats, ARRAY_SIZE(vdec_output_formats), - f->fmt.pix_mp.pixelformat); + f->fmt.pix_mp.pixelformat, inst->sid); if (!fmt_desc) { - dprintk(VIDC_ERR, "Invalid fmt set : %x\n", + s_vpr_e(inst->sid, "Invalid fmt set : %x\n", f->fmt.pix_mp.pixelformat); return -EINVAL; } @@ -586,7 +586,7 @@ int msm_vdec_s_fmt(struct msm_vidc_inst *inst, struct v4l2_format *f) mplane->plane_fmt[1].sizeimage = msm_vidc_calculate_dec_output_extra_size(inst); color_format = msm_comm_convert_color_fmt( - f->fmt.pix_mp.pixelformat); + f->fmt.pix_mp.pixelformat, inst->sid); mplane->plane_fmt[0].bytesperline = VENUS_Y_STRIDE(color_format, f->fmt.pix_mp.width); mplane->plane_fmt[0].reserved[0] = @@ -601,14 +601,14 @@ int msm_vdec_s_fmt(struct msm_vidc_inst *inst, struct v4l2_format *f) rc = msm_vidc_check_session_supported(inst); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: session not supported\n", __func__); goto err_invalid_fmt; } rc = msm_vdec_update_stream_output_mode(inst); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: failed to update output stream mode\n", __func__); goto err_invalid_fmt; @@ -619,9 +619,9 @@ int msm_vdec_s_fmt(struct msm_vidc_inst *inst, struct v4l2_format *f) fmt = &inst->fmts[INPUT_PORT]; fmt_desc = msm_comm_get_pixel_fmt_fourcc(vdec_input_formats, ARRAY_SIZE(vdec_input_formats), - f->fmt.pix_mp.pixelformat); + f->fmt.pix_mp.pixelformat, inst->sid); if (!fmt_desc) { - dprintk(VIDC_ERR, "Invalid fmt set : %x\n", + s_vpr_e(inst->sid, "Invalid fmt set : %x\n", f->fmt.pix_mp.pixelformat); return -EINVAL; } @@ -631,7 +631,7 @@ int msm_vdec_s_fmt(struct msm_vidc_inst *inst, struct v4l2_format *f) if (f->fmt.pix_mp.pixelformat == V4L2_PIX_FMT_VP9) { if (msm_vidc_check_for_vp9d_overload(inst->core)) { - dprintk(VIDC_ERR, "VP9 Decode overload\n"); + s_vpr_e(inst->sid, "VP9 Decode overload\n"); rc = -ENOTSUPP; goto err_invalid_fmt; } @@ -644,7 +644,7 @@ int msm_vdec_s_fmt(struct msm_vidc_inst *inst, struct v4l2_format *f) mplane->pixelformat = f->fmt.pix_mp.pixelformat; rc = msm_comm_try_state(inst, MSM_VIDC_OPEN_DONE); if (rc) { - dprintk(VIDC_ERR, "Failed to open instance\n"); + s_vpr_e(inst->sid, "Failed to open instance\n"); goto err_invalid_fmt; } @@ -653,7 +653,7 @@ int msm_vdec_s_fmt(struct msm_vidc_inst *inst, struct v4l2_format *f) rc = msm_vidc_check_session_supported(inst); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: session not supported\n", __func__); goto err_invalid_fmt; } @@ -694,7 +694,7 @@ int msm_vdec_g_fmt(struct msm_vidc_inst *inst, struct v4l2_format *f) msm_vidc_calculate_dec_input_frame_size(inst); memcpy(f, fmt, sizeof(struct v4l2_format)); } else { - dprintk(VIDC_ERR, "%s - Unsupported buf type: %d\n", + s_vpr_e(inst->sid, "%s: Unsupported buf type: %d\n", __func__, f->type); return -EINVAL; } @@ -708,16 +708,15 @@ int msm_vdec_enum_fmt(struct msm_vidc_inst *inst, struct v4l2_fmtdesc *f) int rc = 0; if (!inst || !f) { - dprintk(VIDC_ERR, - "Invalid input, inst = %pK, f = %pK\n", inst, f); + d_vpr_e("Invalid input, inst = %pK, f = %pK\n", inst, f); return -EINVAL; } if (f->type == OUTPUT_MPLANE) { fmt_desc = msm_comm_get_pixel_fmt_index(vdec_output_formats, - ARRAY_SIZE(vdec_output_formats), f->index); + ARRAY_SIZE(vdec_output_formats), f->index, inst->sid); } else if (f->type == INPUT_MPLANE) { fmt_desc = msm_comm_get_pixel_fmt_index(vdec_input_formats, - ARRAY_SIZE(vdec_input_formats), f->index); + ARRAY_SIZE(vdec_input_formats), f->index, inst->sid); f->flags = V4L2_FMT_FLAG_COMPRESSED; } @@ -727,7 +726,7 @@ int msm_vdec_enum_fmt(struct msm_vidc_inst *inst, struct v4l2_fmtdesc *f) sizeof(f->description)); f->pixelformat = fmt_desc->fourcc; } else { - dprintk(VIDC_HIGH, "No more formats found\n"); + s_vpr_h(inst->sid, "No more formats found\n"); rc = -EINVAL; } return rc; @@ -741,7 +740,7 @@ int msm_vdec_inst_init(struct msm_vidc_inst *inst) struct v4l2_format *f = NULL; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "Invalid input = %pK\n", inst); + d_vpr_e("Invalid input = %pK\n", inst); return -EINVAL; } core = inst->core; @@ -757,9 +756,10 @@ int msm_vdec_inst_init(struct msm_vidc_inst *inst) f->fmt.pix_mp.plane_fmt[1].sizeimage = msm_vidc_calculate_dec_output_extra_size(inst); fmt_desc = msm_comm_get_pixel_fmt_fourcc(vdec_output_formats, - ARRAY_SIZE(vdec_output_formats), f->fmt.pix_mp.pixelformat); + ARRAY_SIZE(vdec_output_formats), + f->fmt.pix_mp.pixelformat, inst->sid); if (!fmt_desc) { - dprintk(VIDC_ERR, "Invalid fmt set : %x\n", + s_vpr_e(inst->sid, "Invalid fmt set: %x\n", f->fmt.pix_mp.pixelformat); return -EINVAL; } @@ -775,9 +775,10 @@ int msm_vdec_inst_init(struct msm_vidc_inst *inst) f->fmt.pix_mp.plane_fmt[0].sizeimage = msm_vidc_calculate_dec_input_frame_size(inst); fmt_desc = msm_comm_get_pixel_fmt_fourcc(vdec_input_formats, - ARRAY_SIZE(vdec_input_formats), f->fmt.pix_mp.pixelformat); + ARRAY_SIZE(vdec_input_formats), f->fmt.pix_mp.pixelformat, + inst->sid); if (!fmt_desc) { - dprintk(VIDC_ERR, "Invalid fmt set : %x\n", + s_vpr_e(inst->sid, "Invalid fmt set: %x\n", f->fmt.pix_mp.pixelformat); return -EINVAL; } @@ -829,14 +830,12 @@ int msm_vdec_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) int rc = 0; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, "%s invalid parameters\n", __func__); + d_vpr_e("%s: invalid parameters\n", __func__); return -EINVAL; } - dprintk(VIDC_HIGH, - "%s: %x : control name = %s, id = 0x%x value = %d\n", - __func__, hash32_ptr(inst->session), ctrl->name, - ctrl->id, ctrl->val); + s_vpr_h(inst->sid, "%s: control name = %s, id = 0x%x value = %d\n", + __func__, ctrl->name, ctrl->id, ctrl->val); switch (ctrl->id) { case V4L2_CID_MPEG_VIDEO_H264_PROFILE: @@ -844,18 +843,21 @@ int msm_vdec_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) case V4L2_CID_MPEG_VIDEO_VP8_PROFILE: case V4L2_CID_MPEG_VIDEO_VP9_PROFILE: case V4L2_CID_MPEG_VIDC_VIDEO_MPEG2_PROFILE: - inst->profile = msm_comm_v4l2_to_hfi(ctrl->id, ctrl->val); + inst->profile = msm_comm_v4l2_to_hfi(ctrl->id, ctrl->val, + inst->sid); break; case V4L2_CID_MPEG_VIDEO_H264_LEVEL: case V4L2_CID_MPEG_VIDEO_HEVC_LEVEL: case V4L2_CID_MPEG_VIDC_VIDEO_VP8_PROFILE_LEVEL: case V4L2_CID_MPEG_VIDC_VIDEO_VP9_LEVEL: case V4L2_CID_MPEG_VIDC_VIDEO_MPEG2_LEVEL: - inst->level = msm_comm_v4l2_to_hfi(ctrl->id, ctrl->val); + inst->level = msm_comm_v4l2_to_hfi(ctrl->id, ctrl->val, + inst->sid); break; case V4L2_CID_MPEG_VIDEO_HEVC_TIER: inst->level |= - (msm_comm_v4l2_to_hfi(ctrl->id, ctrl->val) << 28); + (msm_comm_v4l2_to_hfi(ctrl->id, ctrl->val, + inst->sid) << 28); break; case V4L2_CID_MPEG_VIDC_VIDEO_DECODE_ORDER: case V4L2_CID_MPEG_VIDC_VIDEO_CONCEAL_COLOR_8BIT: @@ -868,9 +870,9 @@ int msm_vdec_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) rc = msm_vidc_calculate_buffer_counts(inst); if (rc) { - dprintk(VIDC_ERR, - "%s: %x : failed to calculate thumbnail buffer count\n", - __func__, hash32_ptr(inst->session)); + s_vpr_e(inst->sid, + "%s: failed to calculate thumbnail buffer count\n", + __func__); return rc; } break; @@ -879,7 +881,7 @@ int msm_vdec_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) if (ctrl->val) inst->flags |= VIDC_SECURE; if (msm_comm_check_for_inst_overload(inst->core)) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: Instance count reached Max limit, rejecting session", __func__); return -ENOTSUPP; @@ -914,8 +916,7 @@ int msm_vdec_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) inst->clk_data.low_latency_mode = !!ctrl->val; break; default: - dprintk(VIDC_ERR, - "Unknown control %#x\n", ctrl->id); + s_vpr_e(inst->sid, "Unknown control %#x\n", ctrl->id); break; } @@ -930,7 +931,7 @@ int msm_vdec_set_frame_size(struct msm_vidc_inst *inst) struct v4l2_format *f; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -939,12 +940,12 @@ int msm_vdec_set_frame_size(struct msm_vidc_inst *inst) frame_size.buffer_type = HFI_BUFFER_INPUT; frame_size.width = f->fmt.pix_mp.width; frame_size.height = f->fmt.pix_mp.height; - dprintk(VIDC_HIGH, "%s: input wxh %dx%d\n", __func__, + s_vpr_h(inst->sid, "%s: input wxh %dx%d\n", __func__, frame_size.width, frame_size.height); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_FRAME_SIZE, &frame_size, sizeof(frame_size)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -956,7 +957,7 @@ int msm_vdec_set_color_format(struct msm_vidc_inst *inst) struct msm_vidc_format_constraint *fmt_constraint; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -965,21 +966,20 @@ int msm_vdec_set_color_format(struct msm_vidc_inst *inst) msm_comm_get_hal_output_buffer(inst), inst->clk_data.opb_fourcc); if (rc) { - dprintk(VIDC_ERR, - "%s: set color format (%#x) failed\n", + s_vpr_e(inst->sid, "%s: set color format (%#x) failed\n", __func__, inst->clk_data.opb_fourcc); return rc; } fmt_constraint = msm_comm_get_pixel_fmt_constraints( dec_pix_format_constraints, ARRAY_SIZE(dec_pix_format_constraints), - inst->clk_data.opb_fourcc); + inst->clk_data.opb_fourcc, inst->sid); if (fmt_constraint) { rc = msm_comm_set_color_format_constraints(inst, msm_comm_get_hal_output_buffer(inst), fmt_constraint); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: Set constraints for color format %#x failed\n", __func__, inst->clk_data.opb_fourcc); return rc; @@ -997,7 +997,7 @@ int msm_vdec_set_input_buffer_counts(struct msm_vidc_inst *inst) enum hal_buffer buffer_type; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -1009,7 +1009,7 @@ int msm_vdec_set_input_buffer_counts(struct msm_vidc_inst *inst) fmt->count_actual, buffer_type); if (rc) { - dprintk(VIDC_ERR, "%s: failed to set bufreqs(%#x)\n", + s_vpr_e(inst->sid, "%s: failed to set bufreqs(%#x)\n", __func__, buffer_type); return -EINVAL; } @@ -1025,7 +1025,7 @@ int msm_vdec_set_output_buffer_counts(struct msm_vidc_inst *inst) enum hal_buffer buffer_type; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -1043,7 +1043,7 @@ int msm_vdec_set_output_buffer_counts(struct msm_vidc_inst *inst) fmt->count_min, HAL_BUFFER_OUTPUT); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: failed to set buffer count(%#x)\n", __func__, buffer_type); return -EINVAL; @@ -1054,7 +1054,7 @@ int msm_vdec_set_output_buffer_counts(struct msm_vidc_inst *inst) fmt->count_actual, buffer_type); if (rc) { - dprintk(VIDC_ERR, "%s: failed to set bufreqs(%#x)\n", + s_vpr_e(inst->sid, "%s: failed to set bufreqs(%#x)\n", __func__, buffer_type); return -EINVAL; } @@ -1069,7 +1069,7 @@ int msm_vdec_set_profile_level(struct msm_vidc_inst *inst) struct hfi_profile_level profile_level; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -1077,13 +1077,13 @@ int msm_vdec_set_profile_level(struct msm_vidc_inst *inst) profile_level.profile = inst->profile; profile_level.level = inst->level; - dprintk(VIDC_HIGH, "%s: %#x %#x\n", __func__, + s_vpr_h(inst->sid, "%s: %#x %#x\n", __func__, profile_level.profile, profile_level.level); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_PROFILE_LEVEL_CURRENT, &profile_level, sizeof(profile_level)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -1096,13 +1096,13 @@ int msm_vdec_set_output_order(struct msm_vidc_inst *inst) u32 output_order; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_VIDEO_DECODE_ORDER); - dprintk(VIDC_HIGH, "%s: %d\n", __func__, ctrl->val); + s_vpr_h(inst->sid, "%s: %d\n", __func__, ctrl->val); if (ctrl->val == V4L2_MPEG_MSM_VIDC_ENABLE) output_order = HFI_OUTPUT_ORDER_DECODE; else @@ -1112,7 +1112,7 @@ int msm_vdec_set_output_order(struct msm_vidc_inst *inst) HFI_PROPERTY_PARAM_VDEC_OUTPUT_ORDER, &output_order, sizeof(u32)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -1125,7 +1125,7 @@ int msm_vdec_set_sync_frame_mode(struct msm_vidc_inst *inst) struct hfi_enable hfi_property; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -1133,12 +1133,12 @@ int msm_vdec_set_sync_frame_mode(struct msm_vidc_inst *inst) ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_VIDEO_SYNC_FRAME_DECODE); hfi_property.enable = (bool)ctrl->val; - dprintk(VIDC_HIGH, "%s: %#x\n", __func__, hfi_property.enable); + s_vpr_h(inst->sid, "%s: %#x\n", __func__, hfi_property.enable); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_VDEC_THUMBNAIL_MODE, &hfi_property, sizeof(hfi_property)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -1151,7 +1151,7 @@ int msm_vdec_set_secure_mode(struct msm_vidc_inst *inst) u32 codec; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -1164,18 +1164,18 @@ int msm_vdec_set_secure_mode(struct msm_vidc_inst *inst) codec == V4L2_PIX_FMT_H264 || codec == V4L2_PIX_FMT_VP9 || codec == V4L2_PIX_FMT_MPEG2)) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: Secure allowed for HEVC/H264/VP9/MPEG2\n", __func__); return -EINVAL; } } - dprintk(VIDC_HIGH, "%s: %#x\n", __func__, ctrl->val); + s_vpr_h(inst->sid, "%s: %#x\n", __func__, ctrl->val); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_SECURE_SESSION, &ctrl->val, sizeof(u32)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -1187,12 +1187,14 @@ int msm_vdec_set_output_stream_mode(struct msm_vidc_inst *inst) struct hfi_multi_stream multi_stream; struct hfi_frame_size frame_sz; struct v4l2_format *f; + u32 sid; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; + sid = inst->sid; if (is_primary_output_mode(inst)) { multi_stream.buffer_type = HFI_BUFFER_OUTPUT; @@ -1201,8 +1203,8 @@ int msm_vdec_set_output_stream_mode(struct msm_vidc_inst *inst) HFI_PROPERTY_PARAM_VDEC_MULTI_STREAM, &multi_stream, sizeof(multi_stream)); if (rc) { - dprintk(VIDC_ERR, - "%s: set prop multistream primary failed : %d\n", + s_vpr_e(sid, + "%s: set prop multistream primary failed: %d\n", __func__, rc); return rc; } @@ -1212,7 +1214,7 @@ int msm_vdec_set_output_stream_mode(struct msm_vidc_inst *inst) HFI_PROPERTY_PARAM_VDEC_MULTI_STREAM, &multi_stream, sizeof(multi_stream)); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(sid, "%s: set prop multistream primary2 failed : %d\n", __func__, rc); return rc; @@ -1229,7 +1231,7 @@ int msm_vdec_set_output_stream_mode(struct msm_vidc_inst *inst) HFI_PROPERTY_PARAM_VDEC_MULTI_STREAM, &multi_stream, sizeof(multi_stream)); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(sid, "%s: set prop multistream secondary failed : %d\n", __func__, rc); return rc; @@ -1240,8 +1242,8 @@ int msm_vdec_set_output_stream_mode(struct msm_vidc_inst *inst) HFI_PROPERTY_PARAM_VDEC_MULTI_STREAM, &multi_stream, sizeof(multi_stream)); if (rc) { - dprintk(VIDC_ERR, - "%s: set prop multistream secondary2 failed : %d\n", + s_vpr_e(sid, + "%s: set prop multistream secondary2 failed: %d\n", __func__, rc); return rc; } @@ -1249,15 +1251,14 @@ int msm_vdec_set_output_stream_mode(struct msm_vidc_inst *inst) f = &inst->fmts[OUTPUT_PORT].v4l2_fmt; frame_sz.width = f->fmt.pix_mp.width; frame_sz.height = f->fmt.pix_mp.height; - dprintk(VIDC_HIGH, + s_vpr_h(sid, "frame_size: hal buffer type %d, width %d, height %d\n", frame_sz.buffer_type, frame_sz.width, frame_sz.height); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_FRAME_SIZE, &frame_sz, sizeof(frame_sz)); if (rc) { - dprintk(VIDC_ERR, - "%s: set prop frame_size failed\n", + s_vpr_e(sid, "%s: set prop frame_size failed\n", __func__); return rc; } @@ -1273,19 +1274,19 @@ int msm_vdec_set_priority(struct msm_vidc_inst *inst) struct hfi_enable hfi_property; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; hfi_property.enable = is_realtime_session(inst); - dprintk(VIDC_HIGH, "%s: %#x\n", __func__, hfi_property.enable); + s_vpr_h(inst->sid, "%s: %#x\n", __func__, hfi_property.enable); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_CONFIG_REALTIME, &hfi_property, sizeof(hfi_property)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -1299,7 +1300,7 @@ int msm_vdec_set_conceal_color(struct msm_vidc_inst *inst) struct hfi_conceal_color conceal_color; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -1309,14 +1310,14 @@ int msm_vdec_set_conceal_color(struct msm_vidc_inst *inst) conceal_color.conceal_color_8bit = ctrl_8b->val; conceal_color.conceal_color_10bit = ctrl_10b->val; - dprintk(VIDC_HIGH, "%s: %#x %#x\n", __func__, + s_vpr_h(inst->sid, "%s: %#x %#x\n", __func__, conceal_color.conceal_color_8bit, conceal_color.conceal_color_10bit); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_VDEC_CONCEAL_COLOR, &conceal_color, sizeof(conceal_color)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -1439,9 +1440,9 @@ int msm_vdec_set_properties(struct msm_vidc_inst *inst) exit: if (rc) - dprintk(VIDC_ERR, "%s: failed with %d\n", __func__, rc); + s_vpr_e(inst->sid, "%s: failed with %d\n", __func__, rc); else - dprintk(VIDC_HIGH, "%s: set properties successful\n", __func__); + s_vpr_h(inst->sid, "%s: set properties successful\n", __func__); return rc; } diff --git a/msm/vidc/msm_venc.c b/msm/vidc/msm_venc.c index 59b7b3b2e078..3dc2bc192faf 100644 --- a/msm/vidc/msm_venc.c +++ b/msm/vidc/msm_venc.c @@ -1096,10 +1096,9 @@ int msm_venc_inst_init(struct msm_vidc_inst *inst) struct v4l2_format *f = NULL; if (!inst) { - dprintk(VIDC_ERR, "Invalid input = %pK\n", inst); + d_vpr_e("Invalid input = %pK\n", inst); return -EINVAL; } - f = &inst->fmts[OUTPUT_PORT].v4l2_fmt; f->fmt.pix_mp.height = DEFAULT_HEIGHT; f->fmt.pix_mp.width = DEFAULT_WIDTH; @@ -1108,9 +1107,10 @@ int msm_venc_inst_init(struct msm_vidc_inst *inst) f->fmt.pix_mp.plane_fmt[0].sizeimage = msm_vidc_calculate_enc_output_frame_size(inst); fmt_desc = msm_comm_get_pixel_fmt_fourcc(venc_output_formats, - ARRAY_SIZE(venc_output_formats), f->fmt.pix_mp.pixelformat); + ARRAY_SIZE(venc_output_formats), + f->fmt.pix_mp.pixelformat, inst->sid); if (!fmt_desc) { - dprintk(VIDC_ERR, "Invalid fmt set : %x\n", + s_vpr_e(inst->sid, "Invalid fmt set : %x\n", f->fmt.pix_mp.pixelformat); return -EINVAL; } @@ -1131,9 +1131,10 @@ int msm_venc_inst_init(struct msm_vidc_inst *inst) f->fmt.pix_mp.plane_fmt[1].sizeimage = msm_vidc_calculate_enc_input_extra_size(inst); fmt_desc = msm_comm_get_pixel_fmt_fourcc(venc_input_formats, - ARRAY_SIZE(venc_input_formats), f->fmt.pix_mp.pixelformat); + ARRAY_SIZE(venc_input_formats), f->fmt.pix_mp.pixelformat, + inst->sid); if (!fmt_desc) { - dprintk(VIDC_ERR, "Invalid fmt set : %x\n", + s_vpr_e(inst->sid, "Invalid fmt set : %x\n", f->fmt.pix_mp.pixelformat); return -EINVAL; } @@ -1183,16 +1184,15 @@ int msm_venc_enum_fmt(struct msm_vidc_inst *inst, struct v4l2_fmtdesc *f) int rc = 0; if (!inst || !f) { - dprintk(VIDC_ERR, - "Invalid input, inst = %pK, f = %pK\n", inst, f); + d_vpr_e("Invalid input, inst = %pK, f = %pK\n", inst, f); return -EINVAL; } if (f->type == OUTPUT_MPLANE) { fmt_desc = msm_comm_get_pixel_fmt_index(venc_output_formats, - ARRAY_SIZE(venc_output_formats), f->index); + ARRAY_SIZE(venc_output_formats), f->index, inst->sid); } else if (f->type == INPUT_MPLANE) { fmt_desc = msm_comm_get_pixel_fmt_index(venc_input_formats, - ARRAY_SIZE(venc_input_formats), f->index); + ARRAY_SIZE(venc_input_formats), f->index, inst->sid); f->flags = V4L2_FMT_FLAG_COMPRESSED; } @@ -1202,7 +1202,7 @@ int msm_venc_enum_fmt(struct msm_vidc_inst *inst, struct v4l2_fmtdesc *f) sizeof(f->description)); f->pixelformat = fmt_desc->fourcc; } else { - dprintk(VIDC_HIGH, "No more formats found\n"); + s_vpr_h(inst->sid, "No more formats found\n"); rc = -EINVAL; } return rc; @@ -1252,8 +1252,7 @@ static int msm_venc_set_csc(struct msm_vidc_inst *inst, HFI_PROPERTY_PARAM_VPE_COLOR_SPACE_CONVERSION, &vpe_csc, sizeof(vpe_csc)); if (rc) - dprintk(VIDC_ERR, - "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -1266,8 +1265,7 @@ int msm_venc_s_fmt(struct msm_vidc_inst *inst, struct v4l2_format *f) u32 color_format; if (!inst || !f) { - dprintk(VIDC_ERR, - "Invalid input, inst = %pK, format = %pK\n", inst, f); + d_vpr_e("Invalid input, inst = %pK, format = %pK\n", inst, f); return -EINVAL; } @@ -1281,9 +1279,9 @@ int msm_venc_s_fmt(struct msm_vidc_inst *inst, struct v4l2_format *f) fmt = &inst->fmts[OUTPUT_PORT]; fmt_desc = msm_comm_get_pixel_fmt_fourcc(venc_output_formats, ARRAY_SIZE(venc_output_formats), - f->fmt.pix_mp.pixelformat); + f->fmt.pix_mp.pixelformat, inst->sid); if (!fmt_desc) { - dprintk(VIDC_ERR, "Invalid fmt set : %x\n", + s_vpr_e(inst->sid, "Invalid fmt set : %x\n", f->fmt.pix_mp.pixelformat); return -EINVAL; } @@ -1300,14 +1298,16 @@ int msm_venc_s_fmt(struct msm_vidc_inst *inst, struct v4l2_format *f) if (!inst->profile) { rc = msm_venc_set_default_profile(inst); if (rc) { - dprintk(VIDC_ERR, "%s: Failed to set default profile type\n", __func__); + s_vpr_e(inst->sid, + "%s: Failed to set default profile type\n", + __func__); goto exit; } } rc = msm_comm_try_state(inst, MSM_VIDC_OPEN_DONE); if (rc) { - dprintk(VIDC_ERR, "Failed to open instance\n"); + s_vpr_e(inst->sid, "Failed to open instance\n"); goto exit; } @@ -1319,7 +1319,7 @@ int msm_venc_s_fmt(struct msm_vidc_inst *inst, struct v4l2_format *f) rc = msm_vidc_check_session_supported(inst); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: session not supported\n", __func__); goto exit; } @@ -1329,9 +1329,9 @@ int msm_venc_s_fmt(struct msm_vidc_inst *inst, struct v4l2_format *f) fmt = &inst->fmts[INPUT_PORT]; fmt_desc = msm_comm_get_pixel_fmt_fourcc(venc_input_formats, ARRAY_SIZE(venc_input_formats), - f->fmt.pix_mp.pixelformat); + f->fmt.pix_mp.pixelformat, inst->sid); if (!fmt_desc) { - dprintk(VIDC_ERR, "Invalid fmt set : %x\n", + s_vpr_e(inst->sid, "Invalid fmt set : %x\n", f->fmt.pix_mp.pixelformat); return -EINVAL; } @@ -1352,7 +1352,7 @@ int msm_venc_s_fmt(struct msm_vidc_inst *inst, struct v4l2_format *f) mplane->plane_fmt[1].sizeimage = msm_vidc_calculate_enc_input_extra_size(inst); color_format = msm_comm_convert_color_fmt( - f->fmt.pix_mp.pixelformat); + f->fmt.pix_mp.pixelformat, inst->sid); mplane->plane_fmt[0].bytesperline = VENUS_Y_STRIDE(color_format, f->fmt.pix_mp.width); mplane->plane_fmt[0].reserved[0] = @@ -1367,14 +1367,14 @@ int msm_venc_s_fmt(struct msm_vidc_inst *inst, struct v4l2_format *f) rc = msm_vidc_check_session_supported(inst); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: session not supported\n", __func__); goto exit; } memcpy(f, &fmt->v4l2_fmt, sizeof(struct v4l2_format)); } else { - dprintk(VIDC_ERR, "%s - Unsupported buf type: %d\n", + s_vpr_e(inst->sid, "%s: Unsupported buf type: %d\n", __func__, f->type); rc = -EINVAL; goto exit; @@ -1386,8 +1386,7 @@ exit: int msm_venc_set_default_profile(struct msm_vidc_inst *inst) { if (!inst) { - dprintk(VIDC_ERR, - "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } @@ -1398,8 +1397,8 @@ int msm_venc_set_default_profile(struct msm_vidc_inst *inst) else if (get_v4l2_codec(inst) == V4L2_PIX_FMT_H264) inst->profile = HFI_H264_PROFILE_HIGH; else - dprintk(VIDC_ERR, - "%s: Invalid codec type %#x\n", __func__, get_v4l2_codec(inst)); + s_vpr_e(inst->sid, "%s: Invalid codec type %#x\n", + __func__, get_v4l2_codec(inst)); return 0; } @@ -1425,7 +1424,7 @@ int msm_venc_g_fmt(struct msm_vidc_inst *inst, struct v4l2_format *f) } memcpy(f, fmt, sizeof(struct v4l2_format)); } else { - dprintk(VIDC_ERR, "%s - Unsupported buf type: %d\n", + s_vpr_e(inst->sid, "%s: Unsupported buf type: %d\n", __func__, f->type); return -EINVAL; } @@ -1447,8 +1446,7 @@ static int msm_venc_resolve_rc_enable(struct msm_vidc_inst *inst, u32 codec; if (!ctrl->val) { - dprintk(VIDC_HIGH, - "RC is not enabled. Setting RC OFF\n"); + s_vpr_h(inst->sid, "RC is not enabled. Setting RC OFF\n"); inst->rc_type = RATE_CONTROL_OFF; } else { rc_mode = get_ctrl(inst, V4L2_CID_MPEG_VIDEO_BITRATE_MODE); @@ -1459,7 +1457,7 @@ static int msm_venc_resolve_rc_enable(struct msm_vidc_inst *inst, if (msm_vidc_lossless_encode && (codec == V4L2_PIX_FMT_HEVC || codec == V4L2_PIX_FMT_H264)) { - dprintk(VIDC_HIGH, + s_vpr_h(inst->sid, "Reset RC mode to RC_LOSSLESS for HEVC lossless encoding\n"); inst->rc_type = RATE_CONTROL_LOSSLESS; } @@ -1470,20 +1468,19 @@ static int msm_venc_resolve_rate_control(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) { if (inst->rc_type == RATE_CONTROL_LOSSLESS) { - dprintk(VIDC_HIGH, + s_vpr_h(inst->sid, "Skip RC mode when enabling lossless encoding\n"); return 0; } if (inst->rc_type == RATE_CONTROL_OFF) { - dprintk(VIDC_ERR, - "RC is not enabled.\n"); + s_vpr_e(inst->sid, "RC is not enabled.\n"); return -EINVAL; } if ((ctrl->val == V4L2_MPEG_VIDEO_BITRATE_MODE_CQ) && get_v4l2_codec(inst) != V4L2_PIX_FMT_HEVC) { - dprintk(VIDC_ERR, "CQ supported only for HEVC\n"); + s_vpr_e(inst->sid, "CQ supported only for HEVC\n"); return -EINVAL; } inst->rc_type = ctrl->val; @@ -1498,34 +1495,33 @@ int msm_venc_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) u32 i_qp_min, i_qp_max, p_qp_min, p_qp_max, b_qp_min, b_qp_max; struct v4l2_format *f; u32 codec; + u32 sid; if (!inst || !inst->core || !inst->core->device || !ctrl) { - dprintk(VIDC_ERR, "%s invalid parameters\n", __func__); + d_vpr_e("%s: invalid parameters\n", __func__); return -EINVAL; } mdisp_sei = &(inst->hdr10_sei_params.disp_color_sei); cll_sei = &(inst->hdr10_sei_params.cll_sei); codec = get_v4l2_codec(inst); + sid = inst->sid; - dprintk(VIDC_HIGH, - "%s: %x : name %s, id 0x%x value %d\n", - __func__, hash32_ptr(inst->session), ctrl->name, - ctrl->id, ctrl->val); + s_vpr_h(sid, "%s: name %s, id 0x%x value %d\n", + __func__, ctrl->name, ctrl->id, ctrl->val); switch (ctrl->id) { case V4L2_CID_MPEG_VIDEO_GOP_SIZE: if (inst->state == MSM_VIDC_START_DONE) { if (inst->all_intra) { - dprintk(VIDC_HIGH, + s_vpr_h(sid, "%s: ignore dynamic gop size for all intra\n", __func__); break; } rc = msm_venc_set_intra_period(inst); if (rc) - dprintk(VIDC_ERR, - "%s: set intra period failed.\n", + s_vpr_e(sid, "%s: set intra period failed\n", __func__); } break; @@ -1533,16 +1529,15 @@ int msm_venc_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) if (inst->state == MSM_VIDC_START_DONE) { rc = msm_venc_set_request_keyframe(inst); if (rc) - dprintk(VIDC_ERR, - "%s: set bitrate failed\n", __func__); + s_vpr_e(sid, "%s: set bitrate failed\n", + __func__); } break; case V4L2_CID_MPEG_VIDEO_BITRATE_MODE: { rc = msm_venc_resolve_rate_control(inst, ctrl); if (rc) - dprintk(VIDC_ERR, - "%s: set bitrate mode failed\n", __func__); + s_vpr_e(sid, "%s: set bitrate mode failed\n", __func__); break; } case V4L2_CID_MPEG_VIDEO_BITRATE: @@ -1550,8 +1545,8 @@ int msm_venc_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) if (inst->state == MSM_VIDC_START_DONE) { rc = msm_venc_set_bitrate(inst); if (rc) - dprintk(VIDC_ERR, - "%s: set bitrate failed\n", __func__); + s_vpr_e(sid, "%s: set bitrate failed\n", + __func__); } break; case V4L2_CID_MPEG_VIDC_VIDEO_FRAME_RATE: @@ -1561,8 +1556,7 @@ int msm_venc_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) if (inst->state == MSM_VIDC_START_DONE) { rc = msm_venc_set_frame_rate(inst); if (rc) - dprintk(VIDC_ERR, - "%s: set frame rate failed\n", + s_vpr_e(sid, "%s: set frame rate failed\n", __func__); } break; @@ -1570,7 +1564,7 @@ int msm_venc_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE: case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB: if (codec != V4L2_PIX_FMT_HEVC && codec != V4L2_PIX_FMT_H264) { - dprintk(VIDC_ERR, + s_vpr_e(sid, "Slice mode not supported for encoder %#x\n", codec); rc = -ENOTSUPP; @@ -1585,8 +1579,7 @@ int msm_venc_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) if (inst->state == MSM_VIDC_START_DONE) { rc = msm_venc_set_ltr_useframe(inst); if (rc) - dprintk(VIDC_ERR, - "%s: ltr useframe failed\n", + s_vpr_e(sid, "%s: ltr useframe failed\n", __func__); } break; @@ -1594,8 +1587,7 @@ int msm_venc_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) if (inst->state == MSM_VIDC_START_DONE) { rc = msm_venc_set_ltr_markframe(inst); if (rc) - dprintk(VIDC_ERR, - "%s: ltr markframe failed\n", + s_vpr_e(sid, "%s: ltr markframe failed\n", __func__); } break; @@ -1610,8 +1602,7 @@ int msm_venc_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) if (inst->state == MSM_VIDC_START_DONE) { rc = msm_venc_set_operating_rate(inst); if (rc) - dprintk(VIDC_ERR, - "%s: set operating rate failed\n", + s_vpr_e(sid, "%s: set operating rate failed\n", __func__); } break; @@ -1622,7 +1613,7 @@ int msm_venc_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) u32 info_type = ((u32)ctrl->val >> 28) & 0xF; u32 val = (ctrl->val & 0xFFFFFFF); - dprintk(VIDC_HIGH, "Ctrl:%d, HDR Info with value %u (%#X)", + s_vpr_h(sid, "Ctrl:%d, HDR Info with value %u (%#X)", info_type, val, ctrl->val); switch (info_type) { case MSM_VIDC_RGB_PRIMARY_00: @@ -1662,9 +1653,9 @@ int msm_venc_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) cll_sei->nMaxPicAverageLight = val; break; default: - dprintk(VIDC_ERR, + s_vpr_e(sid, "Unknown Ctrl:%d, not part of HDR Info with value %u", - info_type, val); + info_type, val); } } break; @@ -1693,22 +1684,21 @@ int msm_venc_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE: rc = msm_venc_resolve_rc_enable(inst, ctrl); if (rc) - dprintk(VIDC_ERR, - "%s: set rc enable failed.\n", __func__); + s_vpr_e(sid, "%s: set rc enable failed\n", __func__); break; case V4L2_CID_MPEG_VIDEO_H264_PROFILE: case V4L2_CID_MPEG_VIDEO_HEVC_PROFILE: case V4L2_CID_MPEG_VIDEO_VP8_PROFILE: - inst->profile = msm_comm_v4l2_to_hfi(ctrl->id, ctrl->val); + inst->profile = msm_comm_v4l2_to_hfi(ctrl->id, ctrl->val, sid); break; case V4L2_CID_MPEG_VIDEO_H264_LEVEL: case V4L2_CID_MPEG_VIDEO_HEVC_LEVEL: case V4L2_CID_MPEG_VIDC_VIDEO_VP8_PROFILE_LEVEL: - inst->level = msm_comm_v4l2_to_hfi(ctrl->id, ctrl->val); + inst->level = msm_comm_v4l2_to_hfi(ctrl->id, ctrl->val, sid); break; case V4L2_CID_MPEG_VIDEO_HEVC_TIER: inst->level |= - (msm_comm_v4l2_to_hfi(ctrl->id, ctrl->val) << 28); + (msm_comm_v4l2_to_hfi(ctrl->id, ctrl->val, sid) << 28); break; case V4L2_CID_MPEG_VIDEO_HEVC_MIN_QP: case V4L2_CID_MPEG_VIDEO_HEVC_MAX_QP: @@ -1724,7 +1714,7 @@ int msm_venc_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) (ctrl->val & 0xff) > i_qp_max || ((ctrl->val >> 8) & 0xff) > p_qp_max || ((ctrl->val >> 16) & 0xff) > b_qp_max) { - dprintk(VIDC_ERR, "Invalid QP %#x\n", ctrl->val); + s_vpr_e(sid, "Invalid QP %#x\n", ctrl->val); return -EINVAL; } if (ctrl->id == V4L2_CID_MPEG_VIDEO_HEVC_MIN_QP) @@ -1736,14 +1726,14 @@ int msm_venc_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) i_qp_min = inst->capability.cap[CAP_I_FRAME_QP].min; i_qp_max = inst->capability.cap[CAP_I_FRAME_QP].max; if (ctrl->val < i_qp_min || ctrl->val > i_qp_max) { - dprintk(VIDC_ERR, "Invalid I QP %#x\n", ctrl->val); + s_vpr_e(sid, "Invalid I QP %#x\n", ctrl->val); return -EINVAL; } inst->client_set_ctrls |= CLIENT_SET_I_QP; if (inst->state == MSM_VIDC_START_DONE) { rc = msm_venc_set_dyn_qp(inst, ctrl); if (rc) - dprintk(VIDC_ERR, + s_vpr_e(sid, "%s: setting dyn frame QP failed\n", __func__); } @@ -1752,7 +1742,7 @@ int msm_venc_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) p_qp_min = inst->capability.cap[CAP_P_FRAME_QP].min; p_qp_max = inst->capability.cap[CAP_P_FRAME_QP].max; if (ctrl->val < p_qp_min || ctrl->val > p_qp_max) { - dprintk(VIDC_ERR, "Invalid P QP %#x\n", ctrl->val); + s_vpr_e(sid, "Invalid P QP %#x\n", ctrl->val); return -EINVAL; } inst->client_set_ctrls |= CLIENT_SET_P_QP; @@ -1761,7 +1751,7 @@ int msm_venc_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) b_qp_min = inst->capability.cap[CAP_B_FRAME_QP].min; b_qp_max = inst->capability.cap[CAP_B_FRAME_QP].max; if (ctrl->val < b_qp_min || ctrl->val > b_qp_max) { - dprintk(VIDC_ERR, "Invalid B QP %#x\n", ctrl->val); + s_vpr_e(sid, "Invalid B QP %#x\n", ctrl->val); return -EINVAL; } inst->client_set_ctrls |= CLIENT_SET_B_QP; @@ -1770,8 +1760,7 @@ int msm_venc_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) if (inst->state == MSM_VIDC_START_DONE) { rc = msm_venc_set_hp_layer(inst); if (rc) - dprintk(VIDC_ERR, - "%s: set dyn hp layer failed.\n", + s_vpr_e(sid, "%s: set dyn hp layer failed\n", __func__); } break; @@ -1779,8 +1768,7 @@ int msm_venc_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) if (inst->state == MSM_VIDC_START_DONE) { rc = msm_venc_set_base_layer_priority_id(inst); if (rc) - dprintk(VIDC_ERR, - "%s: set baselayer id failed.\n", + s_vpr_e(sid, "%s: set baselayer id failed\n", __func__); } break; @@ -1793,16 +1781,15 @@ int msm_venc_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) if (inst->state == MSM_VIDC_START_DONE) { rc = msm_venc_set_layer_bitrate(inst); if (rc) - dprintk(VIDC_ERR, - "%s: set layer bitrate failed\n", - __func__); + s_vpr_e(sid, "%s: set layer bitrate failed\n", + __func__); } break; case V4L2_CID_MPEG_VIDEO_B_FRAMES: if (inst->state == MSM_VIDC_START_DONE) { - dprintk(VIDC_ERR, - "%s: Dynamic setting of Bframe is not supported\n", - __func__); + s_vpr_e(sid, + "%s: Dynamic setting of Bframe is not supported\n", + __func__); return -EINVAL; } break; @@ -1810,8 +1797,7 @@ int msm_venc_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) if (inst->state == MSM_VIDC_START_DONE) { rc = msm_venc_set_blur_resolution(inst); if (rc) - dprintk(VIDC_ERR, - "%s: set blur resolution failed\n", + s_vpr_e(sid, "%s: set blur resolution failed\n", __func__); } break; @@ -1820,9 +1806,7 @@ int msm_venc_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) if (inst->state == MSM_VIDC_START_DONE) { rc = msm_venc_set_dynamic_flip(inst); if (rc) - dprintk(VIDC_ERR, - "%s: set flip failed\n", - __func__); + s_vpr_e(sid, "%s: set flip failed\n", __func__); } break; case V4L2_CID_MPEG_VIDC_COMPRESSION_QUALITY: @@ -1864,11 +1848,11 @@ int msm_venc_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) case V4L2_CID_MPEG_VIDEO_VBV_DELAY: case V4L2_CID_MPEG_VIDC_VENC_BITRATE_SAVINGS: case V4L2_CID_MPEG_VIDC_SUPERFRAME: - dprintk(VIDC_HIGH, "Control set: ID : %x Val : %d\n", + s_vpr_h(sid, "Control set: ID : %x Val : %d\n", ctrl->id, ctrl->val); break; default: - dprintk(VIDC_ERR, "Unsupported index: %x\n", ctrl->id); + s_vpr_e(sid, "Unsupported index: %x\n", ctrl->id); rc = -ENOTSUPP; break; } @@ -1884,7 +1868,7 @@ int msm_venc_set_frame_size(struct msm_vidc_inst *inst) struct v4l2_format *f; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -1893,12 +1877,12 @@ int msm_venc_set_frame_size(struct msm_vidc_inst *inst) frame_sz.buffer_type = HFI_BUFFER_INPUT; frame_sz.width = f->fmt.pix_mp.width; frame_sz.height = f->fmt.pix_mp.height; - dprintk(VIDC_HIGH, "%s: input %d %d\n", __func__, + s_vpr_h(inst->sid, "%s: input %d %d\n", __func__, frame_sz.width, frame_sz.height); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_FRAME_SIZE, &frame_sz, sizeof(frame_sz)); if (rc) { - dprintk(VIDC_ERR, "%s: failed to set input frame size %d %d\n", + s_vpr_e(inst->sid, "%s: failed to set input frame size %d %d\n", __func__, frame_sz.width, frame_sz.height); return rc; } @@ -1907,12 +1891,12 @@ int msm_venc_set_frame_size(struct msm_vidc_inst *inst) frame_sz.buffer_type = HFI_BUFFER_OUTPUT; frame_sz.width = f->fmt.pix_mp.width; frame_sz.height = f->fmt.pix_mp.height; - dprintk(VIDC_HIGH, "%s: output %d %d\n", __func__, + s_vpr_h(inst->sid, "%s: output %d %d\n", __func__, frame_sz.width, frame_sz.height); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_FRAME_SIZE, &frame_sz, sizeof(frame_sz)); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: failed to set output frame size %d %d\n", __func__, frame_sz.width, frame_sz.height); return rc; @@ -1930,7 +1914,7 @@ int msm_venc_set_frame_rate(struct msm_vidc_inst *inst) u32 fps_max; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -1943,21 +1927,22 @@ int msm_venc_set_frame_rate(struct msm_vidc_inst *inst) fps_max = capability->cap[CAP_FRAMERATE].max; if (inst->clk_data.frame_rate >> 16 > fps_max) { - dprintk(VIDC_ERR, "%s: Unsupported frame rate\n", - __func__); + s_vpr_e(inst->sid, + "%s: Unsupported frame rate, fps %u, max_fps %u\n", + __func__, inst->clk_data.frame_rate >> 16, fps_max); return -ENOTSUPP; } frame_rate.buffer_type = HFI_BUFFER_OUTPUT; frame_rate.frame_rate = inst->clk_data.frame_rate; - dprintk(VIDC_HIGH, "%s: %#x\n", __func__, frame_rate.frame_rate); + s_vpr_h(inst->sid, "%s: %#x\n", __func__, frame_rate.frame_rate); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_CONFIG_FRAME_RATE, &frame_rate, sizeof(frame_rate)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -1977,13 +1962,13 @@ int msm_venc_set_color_format(struct msm_vidc_inst *inst) fmt_constraints = msm_comm_get_pixel_fmt_constraints( enc_pix_format_constraints, ARRAY_SIZE(enc_pix_format_constraints), - f->fmt.pix_mp.pixelformat); + f->fmt.pix_mp.pixelformat, inst->sid); if (fmt_constraints) { rc = msm_comm_set_color_format_constraints(inst, HAL_BUFFER_INPUT, fmt_constraints); if (rc) { - dprintk(VIDC_ERR, "Set constraints for %d failed\n", + s_vpr_e(inst->sid, "Set constraints for %d failed\n", f->fmt.pix_mp.pixelformat); return rc; } @@ -1999,7 +1984,7 @@ int msm_venc_set_buffer_counts(struct msm_vidc_inst *inst) enum hal_buffer buffer_type; if (!inst) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } @@ -2010,7 +1995,7 @@ int msm_venc_set_buffer_counts(struct msm_vidc_inst *inst) fmt->count_actual, buffer_type); if (rc) { - dprintk(VIDC_ERR, "%s: failed to set bufcounts(%#x)\n", + s_vpr_e(inst->sid, "%s: failed to set bufcounts(%#x)\n", __func__, buffer_type); return -EINVAL; } @@ -2022,7 +2007,7 @@ int msm_venc_set_buffer_counts(struct msm_vidc_inst *inst) fmt->count_actual, buffer_type); if (rc) { - dprintk(VIDC_ERR, "%s: failed to set buf counts(%#x)\n", + s_vpr_e(inst->sid, "%s: failed to set buf counts(%#x)\n", __func__, buffer_type); return -EINVAL; } @@ -2039,7 +2024,7 @@ int msm_venc_set_secure_mode(struct msm_vidc_inst *inst) u32 codec; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -2051,18 +2036,18 @@ int msm_venc_set_secure_mode(struct msm_vidc_inst *inst) codec = get_v4l2_codec(inst); if (!(codec == V4L2_PIX_FMT_H264 || codec == V4L2_PIX_FMT_HEVC)) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: Secure mode only allowed for HEVC/H264\n", __func__); return -EINVAL; } } - dprintk(VIDC_HIGH, "%s: %d\n", __func__, enable.enable); + s_vpr_h(inst->sid, "%s: %d\n", __func__, enable.enable); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_SECURE_SESSION, &enable, sizeof(enable)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -2074,18 +2059,18 @@ int msm_venc_set_priority(struct msm_vidc_inst *inst) struct hfi_enable enable; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; enable.enable = is_realtime_session(inst); - dprintk(VIDC_HIGH, "%s: %d\n", __func__, enable.enable); + s_vpr_h(inst->sid, "%s: %d\n", __func__, enable.enable); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_CONFIG_REALTIME, &enable, sizeof(enable)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -2098,7 +2083,7 @@ int msm_venc_set_operating_rate(struct msm_vidc_inst *inst) struct hfi_operating_rate op_rate; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -2106,11 +2091,11 @@ int msm_venc_set_operating_rate(struct msm_vidc_inst *inst) ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_VIDEO_OPERATING_RATE); op_rate.operating_rate = ctrl->val; - dprintk(VIDC_HIGH, "%s: %d\n", __func__, op_rate.operating_rate >> 16); + s_vpr_h(inst->sid, "%s: %d\n", __func__, op_rate.operating_rate >> 16); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_CONFIG_OPERATING_RATE, &op_rate, sizeof(op_rate)); if (rc) { - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -2124,27 +2109,26 @@ int msm_venc_set_profile_level(struct msm_vidc_inst *inst) struct hfi_profile_level profile_level; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; if (!inst->profile) { - dprintk(VIDC_ERR, - "%s: skip as client did not set profile\n", + s_vpr_e(inst->sid, "%s: skip as client did not set profile\n", __func__); return -EINVAL; } profile_level.profile = inst->profile; profile_level.level = inst->level; - dprintk(VIDC_HIGH, "%s: %#x %#x\n", __func__, + s_vpr_h(inst->sid, "%s: %#x %#x\n", __func__, profile_level.profile, profile_level.level); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_PROFILE_LEVEL_CURRENT, &profile_level, sizeof(profile_level)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -2157,7 +2141,7 @@ int msm_venc_set_idr_period(struct msm_vidc_inst *inst) u32 codec; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -2168,12 +2152,12 @@ int msm_venc_set_idr_period(struct msm_vidc_inst *inst) idr_period.idr_period = 1; - dprintk(VIDC_HIGH, "%s: %d\n", __func__, idr_period.idr_period); + s_vpr_h(inst->sid, "%s: %d\n", __func__, idr_period.idr_period); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_CONFIG_VENC_IDR_PERIOD, &idr_period, sizeof(idr_period)); if (rc) { - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -2235,8 +2219,8 @@ void msm_venc_decide_bframe(struct msm_vidc_inst *inst) * Hence, forcefully enable bframe */ inst->prop.bframe_changed = true; - update_ctrl(bframe_ctrl, MAX_NUM_B_FRAMES); - dprintk(VIDC_HIGH, "Bframe is forcefully enabled\n"); + update_ctrl(bframe_ctrl, MAX_NUM_B_FRAMES, inst->sid); + s_vpr_h(inst->sid, "Bframe is forcefully enabled\n"); } else { /* * Native recorder is not enabled @@ -2251,7 +2235,7 @@ void msm_venc_decide_bframe(struct msm_vidc_inst *inst) if (ctrl->val) goto disable_bframe; - dprintk(VIDC_HIGH, "Bframe can be enabled!\n"); + s_vpr_h(inst->sid, "Bframe can be enabled!\n"); return; disable_bframe: @@ -2262,10 +2246,10 @@ disable_bframe: * Hence, forcefully disable bframe */ inst->prop.bframe_changed = true; - update_ctrl(bframe_ctrl, 0); - dprintk(VIDC_HIGH, "Bframe is forcefully disabled!\n"); + update_ctrl(bframe_ctrl, 0, inst->sid); + s_vpr_h(inst->sid, "Bframe is forcefully disabled!\n"); } else { - dprintk(VIDC_HIGH, "Bframe is disabled\n"); + s_vpr_h(inst->sid, "Bframe is disabled\n"); } } @@ -2276,18 +2260,18 @@ int msm_venc_set_adaptive_bframes(struct msm_vidc_inst *inst) struct hfi_enable enable; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; enable.enable = true; - dprintk(VIDC_HIGH, "%s: %d\n", __func__, enable.enable); + s_vpr_h(inst->sid, "%s: %d\n", __func__, enable.enable); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_VENC_ADAPTIVE_B, &enable, sizeof(enable)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -2313,7 +2297,7 @@ void msm_venc_adjust_gop_size(struct msm_vidc_inst *inst) /* Forcefully enabled */ val = gop_size_ctrl->val / (1 + MAX_NUM_B_FRAMES); - update_ctrl(gop_size_ctrl, val); + update_ctrl(gop_size_ctrl, val, inst->sid); } /* @@ -2333,7 +2317,7 @@ void msm_venc_adjust_gop_size(struct msm_vidc_inst *inst) else val = min_gop_size; - update_ctrl(gop_size_ctrl, val); + update_ctrl(gop_size_ctrl, val, inst->sid); } } @@ -2345,7 +2329,7 @@ int msm_venc_set_intra_period(struct msm_vidc_inst *inst) struct hfi_intra_period intra_period; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -2364,19 +2348,19 @@ int msm_venc_set_intra_period(struct msm_vidc_inst *inst) if (inst->state == MSM_VIDC_START_DONE && !intra_period.pframes && !intra_period.bframes) { - dprintk(VIDC_HIGH, + s_vpr_h(inst->sid, "%s: Switch from IPPP to All Intra is not allowed\n", __func__); return rc; } - dprintk(VIDC_HIGH, "%s: %d %d\n", __func__, intra_period.pframes, + s_vpr_h(inst->sid, "%s: %d %d\n", __func__, intra_period.pframes, intra_period.bframes); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_CONFIG_VENC_INTRA_PERIOD, &intra_period, sizeof(intra_period)); if (rc) { - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -2384,7 +2368,7 @@ int msm_venc_set_intra_period(struct msm_vidc_inst *inst) /* Enable adaptive bframes as nbframes!= 0 */ rc = msm_venc_set_adaptive_bframes(inst); if (rc) { - dprintk(VIDC_ERR, "%s: set property failed\n", + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -2398,16 +2382,16 @@ int msm_venc_set_request_keyframe(struct msm_vidc_inst *inst) struct hfi_device *hdev; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; - dprintk(VIDC_HIGH, "%s\n", __func__); + s_vpr_h(inst->sid, "%s\n", __func__); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_CONFIG_VENC_REQUEST_SYNC_FRAME, NULL, 0); if (rc) { - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -2423,7 +2407,7 @@ int msm_venc_set_rate_control(struct msm_vidc_inst *inst) struct v4l2_format *f; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } @@ -2466,17 +2450,17 @@ int msm_venc_set_rate_control(struct msm_vidc_inst *inst) break; default: hfi_rc = HFI_RATE_CONTROL_OFF; - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Invalid Rate control setting: %d Default RCOFF\n", inst->rc_type); break; } - dprintk(VIDC_HIGH, "%s: %d\n", __func__, inst->rc_type); + s_vpr_h(inst->sid, "%s: %d\n", __func__, inst->rc_type); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_VENC_RATE_CONTROL, &hfi_rc, sizeof(u32)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -2494,7 +2478,7 @@ int msm_venc_set_vbv_delay(struct msm_vidc_inst *inst) struct v4l2_format *f; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } @@ -2546,16 +2530,15 @@ int msm_venc_set_vbv_delay(struct msm_vidc_inst *inst) set_vbv_delay: inst->clk_data.is_legacy_cbr = is_legacy_cbr; hrd_buf_size.vbv_hrd_buf_size = buf_size; - dprintk(VIDC_HIGH, "Set hrd_buf_size %d", - hrd_buf_size.vbv_hrd_buf_size); + s_vpr_h(inst->sid, + "Set hrd_buf_size %d", hrd_buf_size.vbv_hrd_buf_size); rc = call_hfi_op(hdev, session_set_property, (void *)inst->session, HFI_PROPERTY_CONFIG_VENC_VBV_HRD_BUF_SIZE, (void *)&hrd_buf_size, sizeof(hrd_buf_size)); if (rc) { - dprintk(VIDC_ERR, "%s: set HRD_BUF_SIZE %u failed\n", - __func__, - hrd_buf_size.vbv_hrd_buf_size); + s_vpr_e(inst->sid, "%s: set HRD_BUF_SIZE %u failed\n", + __func__, hrd_buf_size.vbv_hrd_buf_size); } return rc; } @@ -2569,7 +2552,7 @@ int msm_venc_set_input_timestamp_rc(struct msm_vidc_inst *inst) struct hfi_enable enable; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -2583,12 +2566,12 @@ int msm_venc_set_input_timestamp_rc(struct msm_vidc_inst *inst) */ enable.enable = !!ctrl->val; - dprintk(VIDC_HIGH, "%s: %d\n", __func__, enable.enable); + s_vpr_h(inst->sid, "%s: %d\n", __func__, enable.enable); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_VENC_DISABLE_RC_TIMESTAMP, &enable, sizeof(enable)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -2602,36 +2585,36 @@ int msm_venc_set_bitrate(struct msm_vidc_inst *inst) struct hfi_enable enable; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; if (inst->layer_bitrate) { - dprintk(VIDC_HIGH, "%s: Layer bitrate is enabled\n", __func__); + s_vpr_h(inst->sid, "%s: Layer bitrate is enabled\n", __func__); return 0; } enable.enable = 0; - dprintk(VIDC_HIGH, "%s: bitrate type: %d\n", + s_vpr_h(inst->sid, "%s: bitrate type: %d\n", __func__, enable.enable); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_VENC_BITRATE_TYPE, &enable, sizeof(enable)); if (rc) { - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDEO_BITRATE); bitrate.bit_rate = ctrl->val; bitrate.layer_id = MSM_VIDC_ALL_LAYER_ID; - dprintk(VIDC_HIGH, "%s: %d\n", __func__, bitrate.bit_rate); + s_vpr_h(inst->sid, "%s: %d\n", __func__, bitrate.bit_rate); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_CONFIG_VENC_TARGET_BITRATE, &bitrate, sizeof(bitrate)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -2648,7 +2631,7 @@ int msm_venc_set_layer_bitrate(struct msm_vidc_inst *inst) struct hfi_enable enable; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -2659,14 +2642,14 @@ int msm_venc_set_layer_bitrate(struct msm_vidc_inst *inst) V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_LAYER); if (!max_layer->val || !layer->val) { - dprintk(VIDC_HIGH, + s_vpr_h(inst->sid, "%s: Hierp layer not set. Ignore layer bitrate\n", __func__); goto error; } if (max_layer->val < layer->val) { - dprintk(VIDC_HIGH, + s_vpr_h(inst->sid, "%s: Hierp layer greater than max isn't allowed\n", __func__); goto error; @@ -2688,16 +2671,14 @@ int msm_venc_set_layer_bitrate(struct msm_vidc_inst *inst) /* Set layer bitrates only when highest layer br ratio is 100. */ if (layer_br_ratios[layer->val-1]->val != MAX_BIT_RATE_RATIO || layer_br_ratios[0]->val == 0) { - dprintk(VIDC_HIGH, - "%s: Improper layer bitrate ratio\n", + s_vpr_h(inst->sid, "%s: Improper layer bitrate ratio\n", __func__); goto error; } for (i = layer->val - 1; i > 0; --i) { if (layer_br_ratios[i]->val == 0) { - dprintk(VIDC_HIGH, - "%s: Layer ratio must be non-zero\n", + s_vpr_h(inst->sid, "%s: Layer ratio must be non-zero\n", __func__); goto error; } @@ -2705,12 +2686,12 @@ int msm_venc_set_layer_bitrate(struct msm_vidc_inst *inst) } enable.enable = 1; - dprintk(VIDC_HIGH, "%s: %d\n", __func__, enable.enable); + s_vpr_h(inst->sid, "%s: %d\n", __func__, enable.enable); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_VENC_BITRATE_TYPE, &enable, sizeof(enable)); if (rc) { - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); goto error; } @@ -2719,15 +2700,14 @@ int msm_venc_set_layer_bitrate(struct msm_vidc_inst *inst) layer_br.bit_rate = bitrate->val * layer_br_ratios[i]->val / 100; layer_br.layer_id = i; - dprintk(VIDC_HIGH, - "%s: Bitrate for Layer[%u]: [%u]\n", + s_vpr_h(inst->sid, "%s: Bitrate for Layer[%u]: [%u]\n", __func__, layer_br.layer_id, layer_br.bit_rate); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_CONFIG_VENC_TARGET_BITRATE, &layer_br, sizeof(layer_br)); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: set property failed for layer: %u\n", __func__, layer_br.layer_id); goto error; @@ -2752,7 +2732,7 @@ int msm_venc_set_frame_qp(struct msm_vidc_inst *inst) struct hfi_quantization qp; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -2784,7 +2764,7 @@ int msm_venc_set_frame_qp(struct msm_vidc_inst *inst) return 0; } else { if (!(inst->client_set_ctrls & CLIENT_SET_I_QP)) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: Client value is not valid\n", __func__); return -EINVAL; } @@ -2800,12 +2780,12 @@ int msm_venc_set_frame_qp(struct msm_vidc_inst *inst) qp.qp_packed = i_qp->val | p_qp->val << 8 | b_qp->val << 16; - dprintk(VIDC_HIGH, "%s: layers %#x frames %#x qp_packed %#x\n", + s_vpr_h(inst->sid, "%s: layers %#x frames %#x qp_packed %#x\n", __func__, qp.layer_id, qp.enable, qp.qp_packed); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_CONFIG_VENC_FRAME_QP, &qp, sizeof(qp)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -2818,15 +2798,15 @@ int msm_venc_set_qp_range(struct msm_vidc_inst *inst) struct hfi_quantization_range qp_range; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; if (!(inst->client_set_ctrls & CLIENT_SET_MIN_QP) && !(inst->client_set_ctrls & CLIENT_SET_MAX_QP)) { - dprintk(VIDC_HIGH, - "%s: Client didn't set QP range.\n", __func__); + s_vpr_h(inst->sid, + "%s: Client didn't set QP range\n", __func__); return 0; } @@ -2839,15 +2819,14 @@ int msm_venc_set_qp_range(struct msm_vidc_inst *inst) ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDEO_HEVC_MAX_QP); qp_range.max_qp.qp_packed = ctrl->val; - dprintk(VIDC_HIGH, - "%s: layers %#x qp_min %#x qp_max %#x\n", + s_vpr_h(inst->sid, "%s: layers %#x qp_min %#x qp_max %#x\n", __func__, qp_range.min_qp.layer_id, qp_range.min_qp.qp_packed, qp_range.max_qp.qp_packed); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_VENC_SESSION_QP_RANGE, &qp_range, sizeof(qp_range)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -2859,15 +2838,16 @@ static void set_all_intra_preconditions(struct msm_vidc_inst *inst) /* Disable multi slice */ ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE); if (ctrl->val) { - dprintk(VIDC_HIGH, "Disable multi slice for all intra\n"); - update_ctrl(ctrl, V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE); + d_vpr_h("Disable multi slice for all intra\n"); + update_ctrl(ctrl, V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE, + inst->sid); } /* Disable LTR */ ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_VIDEO_LTRCOUNT); if (ctrl->val) { - dprintk(VIDC_HIGH, "Disable LTR for all intra\n"); - update_ctrl(ctrl, 0); + s_vpr_h(inst->sid, "Disable LTR for all intra\n"); + update_ctrl(ctrl, 0, inst->sid); } /* Disable Layer encoding */ @@ -2875,18 +2855,18 @@ static void set_all_intra_preconditions(struct msm_vidc_inst *inst) ctrl_t = get_ctrl(inst, V4L2_CID_MPEG_VIDC_VIDEO_HEVC_MAX_HIER_CODING_LAYER); if (ctrl->val || ctrl_t->val) { - dprintk(VIDC_HIGH, "Disable layer encoding for all intra\n"); - update_ctrl(ctrl, 0); - update_ctrl(ctrl_t, 0); + s_vpr_h(inst->sid, "Disable layer encoding for all intra\n"); + update_ctrl(ctrl, 0, inst->sid); + update_ctrl(ctrl_t, 0, inst->sid); } /* Disable IR */ ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_VIDEO_INTRA_REFRESH_RANDOM); ctrl_t = get_ctrl(inst, V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB); if (ctrl->val || ctrl_t->val) { - dprintk(VIDC_HIGH, "Disable IR for all intra\n"); - update_ctrl(ctrl, 0); - update_ctrl(ctrl_t, 0); + s_vpr_h(inst->sid, "Disable IR for all intra\n"); + update_ctrl(ctrl, 0, inst->sid); + update_ctrl(ctrl_t, 0, inst->sid); } return; @@ -2899,15 +2879,15 @@ static void set_heif_preconditions(struct msm_vidc_inst *inst) /* Reset PFrames */ ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDEO_GOP_SIZE); if (ctrl->val) { - dprintk(VIDC_HIGH, "Reset P-frame count for HEIF\n"); - update_ctrl(ctrl, 0); + d_vpr_h("Reset P-frame count for HEIF\n"); + update_ctrl(ctrl, 0, inst->sid); } /* Reset BFrames */ ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDEO_B_FRAMES); if (ctrl->val) { - dprintk(VIDC_HIGH, "Reset B-frame count for HEIF\n"); - update_ctrl(ctrl, 0); + s_vpr_h(inst->sid, "Reset B-frame count for HEIF\n"); + update_ctrl(ctrl, 0, inst->sid); } return; @@ -2922,7 +2902,7 @@ int msm_venc_set_image_properties(struct msm_vidc_inst *inst) struct hfi_heic_grid_enable grid_enable; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -2933,13 +2913,13 @@ int msm_venc_set_image_properties(struct msm_vidc_inst *inst) ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_COMPRESSION_QUALITY); frame_quality.frame_quality = ctrl->val; - dprintk(VIDC_HIGH, "%s: frame quality: %d\n", __func__, + s_vpr_h(inst->sid, "%s: frame quality: %d\n", __func__, frame_quality.frame_quality); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_CONFIG_HEIC_FRAME_QUALITY, &frame_quality, sizeof(frame_quality)); if (rc) - dprintk(VIDC_ERR, "%s: set frame quality failed\n", __func__); + s_vpr_e(inst->sid, "%s: set frame quality failed\n", __func__); ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_IMG_GRID_SIZE); @@ -2949,13 +2929,13 @@ int msm_venc_set_image_properties(struct msm_vidc_inst *inst) else grid_enable.grid_enable = true; - dprintk(VIDC_HIGH, "%s: grid enable: %d\n", __func__, + s_vpr_h(inst->sid, "%s: grid enable: %d\n", __func__, grid_enable.grid_enable); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_CONFIG_HEIC_GRID_ENABLE, &grid_enable, sizeof(grid_enable)); if (rc) - dprintk(VIDC_ERR, "%s: set grid enable failed\n", __func__); + s_vpr_e(inst->sid, "%s: set grid enable failed\n", __func__); set_all_intra_preconditions(inst); set_heif_preconditions(inst); @@ -2971,7 +2951,7 @@ int msm_venc_set_entropy_mode(struct msm_vidc_inst *inst) struct hfi_h264_entropy_control entropy; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -2982,15 +2962,15 @@ int msm_venc_set_entropy_mode(struct msm_vidc_inst *inst) ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE); entropy.entropy_mode = msm_comm_v4l2_to_hfi( V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE, - ctrl->val); + ctrl->val, inst->sid); entropy.cabac_model = HFI_H264_CABAC_MODEL_2; - dprintk(VIDC_HIGH, "%s: %d\n", __func__, entropy.entropy_mode); + s_vpr_h(inst->sid, "%s: %d\n", __func__, entropy.entropy_mode); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_VENC_H264_ENTROPY_CONTROL, &entropy, sizeof(entropy)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -3010,7 +2990,7 @@ int msm_venc_set_slice_control_mode(struct msm_vidc_inst *inst) u32 codec; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } @@ -3082,8 +3062,9 @@ int msm_venc_set_slice_control_mode(struct msm_vidc_inst *inst) } if (slice_mode == HFI_MULTI_SLICE_OFF) { - update_ctrl(ctrl, V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE); - update_ctrl(ctrl_t, 0); + update_ctrl(ctrl, V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE, + inst->sid); + update_ctrl(ctrl_t, 0, inst->sid); } set_and_exit: @@ -3091,14 +3072,14 @@ set_and_exit: multi_slice_control.slice_size = slice_val; hdev = inst->core->device; - dprintk(VIDC_HIGH, "%s: %d %d\n", __func__, + s_vpr_h(inst->sid, "%s: %d %d\n", __func__, multi_slice_control.multi_slice, multi_slice_control.slice_size); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_VENC_MULTI_SLICE_CONTROL, &multi_slice_control, sizeof(multi_slice_control)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -3112,7 +3093,7 @@ int msm_venc_set_intra_refresh_mode(struct msm_vidc_inst *inst) struct v4l2_format *f; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -3147,13 +3128,13 @@ int msm_venc_set_intra_refresh_mode(struct msm_vidc_inst *inst) intra_refresh.mbs = 0; } - dprintk(VIDC_HIGH, "%s: %d %d\n", __func__, + s_vpr_h(inst->sid, "%s: %d %d\n", __func__, intra_refresh.mode, intra_refresh.mbs); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_VENC_INTRA_REFRESH, &intra_refresh, sizeof(intra_refresh)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -3166,7 +3147,7 @@ int msm_venc_set_bitrate_savings_mode(struct msm_vidc_inst *inst) struct hfi_enable enable; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -3174,17 +3155,17 @@ int msm_venc_set_bitrate_savings_mode(struct msm_vidc_inst *inst) ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_VENC_BITRATE_SAVINGS); enable.enable = !!ctrl->val; if (!ctrl->val && inst->rc_type != V4L2_MPEG_VIDEO_BITRATE_MODE_VBR) { - dprintk(VIDC_HIGH, + s_vpr_h(inst->sid, "Can't disable bitrate savings for non-VBR_CFR\n"); enable.enable = 1; } - dprintk(VIDC_HIGH, "%s: %d\n", __func__, enable.enable); + s_vpr_h(inst->sid, "%s: %d\n", __func__, enable.enable); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_VENC_BITRATE_SAVINGS, &enable, sizeof(enable)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -3200,7 +3181,7 @@ int msm_venc_set_loop_filter_mode(struct msm_vidc_inst *inst) u32 codec; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -3214,18 +3195,18 @@ int msm_venc_set_loop_filter_mode(struct msm_vidc_inst *inst) ctrl_b = get_ctrl(inst, V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA); h264_db_control.mode = msm_comm_v4l2_to_hfi( V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE, - ctrl->val); + ctrl->val, inst->sid); h264_db_control.slice_alpha_offset = ctrl_a->val; h264_db_control.slice_beta_offset = ctrl_b->val; - dprintk(VIDC_HIGH, "%s: %d %d %d\n", __func__, + s_vpr_h(inst->sid, "%s: %d %d %d\n", __func__, h264_db_control.mode, h264_db_control.slice_alpha_offset, h264_db_control.slice_beta_offset); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_VENC_H264_DEBLOCK_CONTROL, &h264_db_control, sizeof(h264_db_control)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -3239,7 +3220,7 @@ int msm_venc_set_sequence_header_mode(struct msm_vidc_inst *inst) u32 codec; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -3254,12 +3235,12 @@ int msm_venc_set_sequence_header_mode(struct msm_vidc_inst *inst) else enable.enable = false; - dprintk(VIDC_HIGH, "%s: %d\n", __func__, enable.enable); + s_vpr_h(inst->sid, "%s: %d\n", __func__, enable.enable); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_CONFIG_VENC_SYNC_FRAME_SEQUENCE_HEADER, &enable, sizeof(enable)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -3273,7 +3254,7 @@ int msm_venc_set_au_delimiter_mode(struct msm_vidc_inst *inst) u32 codec; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -3285,12 +3266,12 @@ int msm_venc_set_au_delimiter_mode(struct msm_vidc_inst *inst) ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_VIDEO_AU_DELIMITER); enable.enable = !!ctrl->val; - dprintk(VIDC_HIGH, "%s: %d\n", __func__, enable.enable); + s_vpr_h(inst->sid, "%s: %d\n", __func__, enable.enable); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_VENC_GENERATE_AUDNAL, &enable, sizeof(enable)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -3301,7 +3282,7 @@ int msm_venc_enable_hybrid_hp(struct msm_vidc_inst *inst) struct v4l2_ctrl *layer = NULL; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } @@ -3344,7 +3325,7 @@ int msm_venc_set_base_layer_priority_id(struct msm_vidc_inst *inst) u32 baselayerid; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -3352,7 +3333,7 @@ int msm_venc_set_base_layer_priority_id(struct msm_vidc_inst *inst) max_layer = get_ctrl(inst, V4L2_CID_MPEG_VIDC_VIDEO_HEVC_MAX_HIER_CODING_LAYER); if (max_layer->val <= 0) { - dprintk(VIDC_HIGH, "%s: Layer id can only be set with Hierp\n", + s_vpr_h(inst->sid, "%s: Layer id can only be set with Hierp\n", __func__); return 0; } @@ -3360,12 +3341,12 @@ int msm_venc_set_base_layer_priority_id(struct msm_vidc_inst *inst) ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_VIDEO_BASELAYER_ID); baselayerid = ctrl->val; - dprintk(VIDC_HIGH, "%s: %d\n", __func__, baselayerid); + s_vpr_h(inst->sid, "%s: %d\n", __func__, baselayerid); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_CONFIG_VENC_BASELAYER_PRIORITYID, &baselayerid, sizeof(baselayerid)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -3379,7 +3360,7 @@ int msm_venc_set_hp_max_layer(struct msm_vidc_inst *inst) u32 codec; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -3393,7 +3374,7 @@ int msm_venc_set_hp_max_layer(struct msm_vidc_inst *inst) rc = msm_venc_enable_hybrid_hp(inst); if (rc) { - dprintk(VIDC_ERR, "%s: get hybrid hp decision failed\n", + s_vpr_e(inst->sid, "%s: get hybrid hp decision failed\n", __func__); return rc; } @@ -3406,21 +3387,20 @@ int msm_venc_set_hp_max_layer(struct msm_vidc_inst *inst) hp_layer = ctrl->val - 1; if (inst->hybrid_hp) { - dprintk(VIDC_HIGH, "%s: Hybrid hierp layer: %d\n", + s_vpr_h(inst->sid, "%s: Hybrid hierp layer: %d\n", __func__, hp_layer); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_VENC_HIER_P_HYBRID_MODE, &hp_layer, sizeof(hp_layer)); } else { - dprintk(VIDC_HIGH, "%s: Hierp max layer: %d\n", + s_vpr_h(inst->sid, "%s: Hierp max layer: %d\n", __func__, hp_layer); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_VENC_HIER_P_MAX_NUM_ENH_LAYER, &hp_layer, sizeof(hp_layer)); } if (rc) - dprintk(VIDC_ERR, - "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -3434,7 +3414,7 @@ int msm_venc_set_hp_layer(struct msm_vidc_inst *inst) u32 codec; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -3444,7 +3424,7 @@ int msm_venc_set_hp_layer(struct msm_vidc_inst *inst) return 0; if (inst->hybrid_hp) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: Setting layer isn't allowed with hybrid hp\n", __func__); return 0; @@ -3454,9 +3434,10 @@ int msm_venc_set_hp_layer(struct msm_vidc_inst *inst) V4L2_CID_MPEG_VIDC_VIDEO_HEVC_MAX_HIER_CODING_LAYER); ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_LAYER); - + s_vpr_h(inst->sid, "%s: heir_layer: %d, max_hier_layer: %d\n", + __func__, ctrl->val, max_layer->val); if (max_layer->val < ctrl->val) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: HP layer count greater than max isn't allowed\n", __func__); return 0; @@ -3469,14 +3450,13 @@ int msm_venc_set_hp_layer(struct msm_vidc_inst *inst) if (ctrl->val) hp_layer = ctrl->val - 1; - dprintk(VIDC_HIGH, "%s: Hierp enhancement layer: %d\n", + s_vpr_h(inst->sid, "%s: Hierp enhancement layer: %d\n", __func__, hp_layer); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_CONFIG_VENC_HIER_P_ENH_LAYER, &hp_layer, sizeof(hp_layer)); if (rc) - dprintk(VIDC_ERR, - "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -3489,7 +3469,7 @@ int msm_venc_set_vpx_error_resilience(struct msm_vidc_inst *inst) struct hfi_enable enable; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -3500,12 +3480,12 @@ int msm_venc_set_vpx_error_resilience(struct msm_vidc_inst *inst) ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_VIDEO_VPX_ERROR_RESILIENCE); enable.enable = !!ctrl->val; - dprintk(VIDC_HIGH, "%s: %d\n", __func__, enable.enable); + s_vpr_h(inst->sid, "%s: %d\n", __func__, enable.enable); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_VENC_VPX_ERROR_RESILIENCE_MODE, &enable, sizeof(enable)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -3522,7 +3502,7 @@ int msm_venc_set_video_signal_info(struct msm_vidc_inst *inst) u32 codec; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -3546,7 +3526,7 @@ int msm_venc_set_video_signal_info(struct msm_vidc_inst *inst) signal_info.transfer_characteristics = ctrl_tr->val; signal_info.matrix_coeffs = ctrl_mc->val; - dprintk(VIDC_HIGH, "%s: %d %d %d %d\n", __func__, + s_vpr_h(inst->sid, "%s: %d %d %d %d\n", __func__, signal_info.color_primaries, signal_info.video_full_range, signal_info.transfer_characteristics, signal_info.matrix_coeffs); @@ -3554,7 +3534,7 @@ int msm_venc_set_video_signal_info(struct msm_vidc_inst *inst) HFI_PROPERTY_PARAM_VENC_VIDEO_SIGNAL_INFO, &signal_info, sizeof(signal_info)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -3567,7 +3547,6 @@ int msm_venc_set_rotation(struct msm_vidc_inst *inst) struct hfi_vpe_rotation_type vpe_rotation; hdev = inst->core->device; - rotation = get_ctrl(inst, V4L2_CID_ROTATE); vpe_rotation.rotation = HFI_ROTATE_NONE; @@ -3580,14 +3559,14 @@ int msm_venc_set_rotation(struct msm_vidc_inst *inst) vpe_rotation.flip = v4l2_to_hfi_flip(inst); - dprintk(VIDC_HIGH, "Set rotation = %d, flip = %d\n", + s_vpr_h(inst->sid, "Set rotation = %d, flip = %d\n", vpe_rotation.rotation, vpe_rotation.flip); rc = call_hfi_op(hdev, session_set_property, (void *)inst->session, HFI_PROPERTY_PARAM_VPE_ROTATION, &vpe_rotation, sizeof(vpe_rotation)); if (rc) { - dprintk(VIDC_ERR, "Set rotation/flip failed\n"); + s_vpr_e(inst->sid, "Set rotation/flip failed\n"); return rc; } @@ -3630,15 +3609,16 @@ int msm_venc_check_dynamic_flip_constraints(struct msm_vidc_inst *inst) ((blur->val & 0xFFFF) != input_height || (blur->val & 0x7FFF0000) >> 16 != input_width)) blur_enable = true; - + s_vpr_h(inst->sid, "Blur = %u, height = %u, width = %u\n", + blur->val, input_height, input_width); if (blur_enable) { /* Reject dynamic flip with external blur enabled */ - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Unsupported dynamic flip with external blur\n"); rc = -EINVAL; } else if (scalar_enable && !inst->static_rotation_flip_enabled) { /* Reject dynamic flip with scalar enabled */ - dprintk(VIDC_ERR, "Unsupported dynamic flip with scalar\n"); + s_vpr_e(inst->sid, "Unsupported dynamic flip with scalar\n"); rc = -EINVAL; } @@ -3655,28 +3635,26 @@ int msm_venc_set_dynamic_flip(struct msm_vidc_inst *inst) rc = msm_venc_check_dynamic_flip_constraints(inst); if (rc) { - dprintk(VIDC_ERR, - "%s: Dynamic flip unsupported\n", __func__); + d_vpr_e("%s: Dynamic flip unsupported\n", __func__); return rc; } /* Require IDR frame first */ - dprintk(VIDC_HIGH, "Set dynamic IDR frame\n"); + s_vpr_h(inst->sid, "Set dynamic IDR frame\n"); rc = msm_venc_set_request_keyframe(inst); if (rc) { - dprintk(VIDC_ERR, - "%s: Dynamic IDR failed\n", __func__); + s_vpr_e(inst->sid, "%s: Dynamic IDR failed\n", __func__); return rc; } dynamic_flip = v4l2_to_hfi_flip(inst); - dprintk(VIDC_HIGH, "Dynamic flip = %d\n", dynamic_flip); + s_vpr_h(inst->sid, "Dynamic flip = %d\n", dynamic_flip); rc = call_hfi_op(hdev, session_set_property, (void *)inst->session, HFI_PROPERTY_CONFIG_VPE_FLIP, &dynamic_flip, sizeof(dynamic_flip)); if (rc) { - dprintk(VIDC_ERR, "Set dynamic flip failed\n"); + s_vpr_e(inst->sid, "Set dynamic flip failed\n"); return rc; } @@ -3693,7 +3671,7 @@ int msm_venc_set_video_csc(struct msm_vidc_inst *inst) u32 color_primaries, custom_matrix; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -3714,7 +3692,7 @@ int msm_venc_set_video_csc(struct msm_vidc_inst *inst) custom_matrix = ctrl_cm->val; rc = msm_venc_set_csc(inst, color_primaries, custom_matrix); if (rc) - dprintk(VIDC_ERR, "%s: msm_venc_set_csc failed\n", __func__); + s_vpr_e(inst->sid, "%s: msm_venc_set_csc failed\n", __func__); return rc; } @@ -3727,20 +3705,20 @@ int msm_venc_set_8x8_transform(struct msm_vidc_inst *inst) struct hfi_enable enable; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; if (get_v4l2_codec(inst) != V4L2_PIX_FMT_H264) { - dprintk(VIDC_HIGH, "%s: skip as codec is not H264\n", + s_vpr_h(inst->sid, "%s: skip as codec is not H264\n", __func__); return 0; } if (inst->profile != HFI_H264_PROFILE_HIGH && inst->profile != HFI_H264_PROFILE_CONSTRAINED_HIGH) { - dprintk(VIDC_HIGH, "%s: skip due to %#x\n", + s_vpr_h(inst->sid, "%s: skip due to %#x\n", __func__, inst->profile); return 0; } @@ -3748,12 +3726,12 @@ int msm_venc_set_8x8_transform(struct msm_vidc_inst *inst) ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM); enable.enable = !!ctrl->val; - dprintk(VIDC_HIGH, "%s: %d\n", __func__, enable.enable); + s_vpr_h(inst->sid, "%s: %d\n", __func__, enable.enable); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_VENC_H264_8X8_TRANSFORM, &enable, sizeof(enable)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -3768,7 +3746,7 @@ int msm_venc_set_vui_timing_info(struct msm_vidc_inst *inst) u32 codec; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -3796,13 +3774,13 @@ int msm_venc_set_vui_timing_info(struct msm_vidc_inst *inst) timing_info.fixed_frame_rate = cfr; timing_info.time_scale = NSEC_PER_SEC; - dprintk(VIDC_HIGH, "%s: %d %d\n", __func__, timing_info.enable, + s_vpr_h(inst->sid, "%s: %d %d\n", __func__, timing_info.enable, timing_info.fixed_frame_rate); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_VENC_VUI_TIMING_INFO, &timing_info, sizeof(timing_info)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -3816,7 +3794,7 @@ int msm_venc_set_nal_stream_format(struct msm_vidc_inst *inst) u32 codec; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -3834,7 +3812,7 @@ int msm_venc_set_nal_stream_format(struct msm_vidc_inst *inst) */ if (is_secure_session(inst) && ctrl->val != V4L2_MPEG_VIDEO_HEVC_SIZE_0) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: Invalid stream format setting for secure session\n", __func__); return -EINVAL; @@ -3850,7 +3828,7 @@ int msm_venc_set_nal_stream_format(struct msm_vidc_inst *inst) HFI_NAL_FORMAT_FOUR_BYTE_LENGTH; break; default: - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: Invalid stream format setting. Setting default\n", __func__); stream_format.nal_stream_format_select = @@ -3858,13 +3836,13 @@ int msm_venc_set_nal_stream_format(struct msm_vidc_inst *inst) break; } - dprintk(VIDC_HIGH, "%s: %#x\n", __func__, + s_vpr_h(inst->sid, "%s: %#x\n", __func__, stream_format.nal_stream_format_select); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_NAL_STREAM_FORMAT_SELECT, &stream_format, sizeof(stream_format)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -3879,7 +3857,7 @@ int msm_venc_set_ltr_mode(struct msm_vidc_inst *inst) u32 codec; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -3901,7 +3879,7 @@ int msm_venc_set_ltr_mode(struct msm_vidc_inst *inst) } if (ctrl->val > inst->capability.cap[CAP_LTR_COUNT].max) { - dprintk(VIDC_ERR, "%s: invalid ltr count %d, max %d\n", + s_vpr_e(inst->sid, "%s: invalid ltr count %d, max %d\n", __func__, ctrl->val, inst->capability.cap[CAP_LTR_COUNT].max); return -EINVAL; @@ -3909,12 +3887,12 @@ int msm_venc_set_ltr_mode(struct msm_vidc_inst *inst) ltr.ltr_count = ctrl->val; ltr.ltr_mode = HFI_LTR_MODE_MANUAL; ltr.trust_mode = 1; - dprintk(VIDC_HIGH, "%s: %d %d\n", __func__, + s_vpr_h(inst->sid, "%s: %d %d\n", __func__, ltr.ltr_mode, ltr.ltr_count); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_VENC_LTRMODE, <r, sizeof(ltr)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); disable_ltr: /* @@ -3922,8 +3900,8 @@ disable_ltr: * client sets unsupported codec/rate control. */ if (!is_ltr) { - update_ctrl(ctrl, 0); - dprintk(VIDC_HIGH, "LTR is forcefully disabled!\n"); + update_ctrl(ctrl, 0, inst->sid); + s_vpr_h(inst->sid, "LTR is forcefully disabled!\n"); } return rc; } @@ -3937,7 +3915,7 @@ int msm_venc_set_ltr_useframe(struct msm_vidc_inst *inst) u32 codec; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -3954,12 +3932,12 @@ int msm_venc_set_ltr_useframe(struct msm_vidc_inst *inst) use_ltr.ref_ltr = ctrl->val; use_ltr.use_constrnt = true; use_ltr.frames = 0; - dprintk(VIDC_HIGH, "%s: %d\n", __func__, use_ltr.ref_ltr); + s_vpr_h(inst->sid, "%s: %d\n", __func__, use_ltr.ref_ltr); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_CONFIG_VENC_USELTRFRAME, &use_ltr, sizeof(use_ltr)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -3973,7 +3951,7 @@ int msm_venc_set_ltr_markframe(struct msm_vidc_inst *inst) u32 codec; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -3989,12 +3967,12 @@ int msm_venc_set_ltr_markframe(struct msm_vidc_inst *inst) ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_VIDEO_MARKLTRFRAME); mark_ltr.mark_frame = ctrl->val; - dprintk(VIDC_HIGH, "%s: %d\n", __func__, mark_ltr.mark_frame); + s_vpr_h(inst->sid, "%s: %d\n", __func__, mark_ltr.mark_frame); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_CONFIG_VENC_MARKLTRFRAME, &mark_ltr, sizeof(mark_ltr)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -4006,13 +3984,13 @@ int msm_venc_set_dyn_qp(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) struct hfi_quantization qp; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; if (inst->rc_type != RATE_CONTROL_OFF) { - dprintk(VIDC_ERR, "%s: Dyn qp is set only when RC is OFF\n", + s_vpr_e(inst->sid, "%s: Dyn qp is set only when RC is OFF\n", __func__); return -EINVAL; } @@ -4025,12 +4003,12 @@ int msm_venc_set_dyn_qp(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) if (get_v4l2_codec(inst) == V4L2_PIX_FMT_VP8) qp.enable &= ~QP_ENABLE_B; - dprintk(VIDC_HIGH, "%s: %#x\n", __func__, + s_vpr_h(inst->sid, "%s: %#x\n", __func__, ctrl->val); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_CONFIG_VENC_FRAME_QP, &qp, sizeof(qp)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -4044,7 +4022,7 @@ int msm_venc_set_aspect_ratio(struct msm_vidc_inst *inst) u32 codec; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -4063,12 +4041,12 @@ int msm_venc_set_aspect_ratio(struct msm_vidc_inst *inst) return 0; sar.aspect_height = ctrl->val; - dprintk(VIDC_HIGH, "%s: %d %d\n", __func__, + s_vpr_h(inst->sid, "%s: %d %d\n", __func__, sar.aspect_width, sar.aspect_height); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_VENC_ASPECT_RATIO, &sar, sizeof(sar)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -4082,7 +4060,7 @@ int msm_venc_set_blur_resolution(struct msm_vidc_inst *inst) struct v4l2_format *f; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -4101,7 +4079,7 @@ int msm_venc_set_blur_resolution(struct msm_vidc_inst *inst) */ if (ctrl->val == 0x2) { if (inst->state == MSM_VIDC_START_DONE) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Dynamic disable all blur not supported\n"); return -EINVAL; } @@ -4112,23 +4090,23 @@ int msm_venc_set_blur_resolution(struct msm_vidc_inst *inst) */ frame_sz.width = f->fmt.pix_mp.width; frame_sz.height = f->fmt.pix_mp.height; - dprintk(VIDC_HIGH, "Disable both auto and external blur\n"); + s_vpr_h(inst->sid, "Disable both auto and external blur\n"); } else if (ctrl->val != 0){ if (check_blur_restrictions(inst)) { /* reject external blur */ - dprintk(VIDC_ERR, - "External blur is unsupported with rotation/flip/scalar\n"); + s_vpr_e(inst->sid, + "External blur is unsupported with rotation/flip/scalar\n"); return -EINVAL; } } - dprintk(VIDC_HIGH, "%s: type %u, height %u, width %u\n", __func__, + s_vpr_h(inst->sid, "%s: type %u, height %u, width %u\n", __func__, frame_sz.buffer_type, frame_sz.height, frame_sz.width); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_CONFIG_VENC_BLUR_FRAME_SIZE, &frame_sz, sizeof(frame_sz)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -4140,7 +4118,7 @@ int msm_venc_set_hdr_info(struct msm_vidc_inst *inst) struct hfi_device *hdev; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; @@ -4153,12 +4131,12 @@ int msm_venc_set_hdr_info(struct msm_vidc_inst *inst) return 0; /* No conversion to HFI needed as both structures are same */ - dprintk(VIDC_HIGH, "%s: setting hdr info\n", __func__); + s_vpr_h(inst->sid, "%s: setting hdr info\n", __func__); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_VENC_HDR10_PQ_SEI, &inst->hdr10_sei_params, sizeof(inst->hdr10_sei_params)); if (rc) - dprintk(VIDC_ERR, "%s: set property failed\n", __func__); + s_vpr_e(inst->sid, "%s: set property failed\n", __func__); return rc; } @@ -4221,7 +4199,7 @@ int msm_venc_set_lossless(struct msm_vidc_inst *inst) if (inst->rc_type != RATE_CONTROL_LOSSLESS) return 0; - dprintk(VIDC_HIGH, "%s: enable lossless encoding\n", __func__); + s_vpr_h(inst->sid, "%s: enable lossless encoding\n", __func__); enable.enable = 1; rc = call_hfi_op(hdev, session_set_property, inst->session, @@ -4229,7 +4207,7 @@ int msm_venc_set_lossless(struct msm_vidc_inst *inst) &enable, sizeof(enable)); if (rc) - dprintk(VIDC_ERR, "Failed to set lossless mode\n"); + s_vpr_e(inst->sid, "Failed to set lossless mode\n"); return rc; } @@ -4244,7 +4222,7 @@ int handle_all_intra_restrictions(struct msm_vidc_inst *inst) struct hfi_intra_period intra_period; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } @@ -4261,17 +4239,17 @@ int handle_all_intra_restrictions(struct msm_vidc_inst *inst) else return 0; - dprintk(VIDC_HIGH, "All Intra(IDRs) Encoding\n"); + s_vpr_h(inst->sid, "All Intra(IDRs) Encoding\n"); /* check codec and profile */ f = &inst->fmts[OUTPUT_PORT].v4l2_fmt; - codec = get_hal_codec(f->fmt.pix_mp.pixelformat); + codec = get_hal_codec(f->fmt.pix_mp.pixelformat, inst->sid); if (codec != HAL_VIDEO_CODEC_HEVC && codec != HAL_VIDEO_CODEC_H264) { - dprintk(VIDC_ERR, "Unsupported codec for all intra\n"); + s_vpr_e(inst->sid, "Unsupported codec for all intra\n"); return -ENOTSUPP; } if (codec == HAL_VIDEO_CODEC_HEVC && inst->profile == HFI_HEVC_PROFILE_MAIN10) { - dprintk(VIDC_ERR, "Unsupported HEVC profile for all intra\n"); + s_vpr_e(inst->sid, "Unsupported HEVC profile for all intra\n"); return -ENOTSUPP; } @@ -4279,11 +4257,13 @@ int handle_all_intra_restrictions(struct msm_vidc_inst *inst) capability = &inst->capability; n_fps = inst->clk_data.frame_rate >> 16; fps_max = capability->cap[CAP_ALLINTRA_MAX_FPS].max; + s_vpr_h(inst->sid, "%s: rc_type %u, fps %u, fps_max %u\n", + inst->rc_type, n_fps, fps_max); if ((inst->rc_type != V4L2_MPEG_VIDEO_BITRATE_MODE_VBR && inst->rc_type != RATE_CONTROL_OFF && inst->rc_type != RATE_CONTROL_LOSSLESS) || n_fps > fps_max) { - dprintk(VIDC_ERR, "Unsupported bitrate mode or frame rate\n"); + s_vpr_e(inst->sid, "Unsupported bitrate mode or frame rate\n"); return -ENOTSUPP; } @@ -4474,9 +4454,9 @@ int msm_venc_set_properties(struct msm_vidc_inst *inst) exit: if (rc) - dprintk(VIDC_ERR, "%s: failed with %d\n", __func__, rc); + s_vpr_e(inst->sid, "%s: failed with %d\n", __func__, rc); else - dprintk(VIDC_HIGH, "%s: set properties successful\n", __func__); + s_vpr_h(inst->sid, "%s: set properties successful\n", __func__); return rc; } diff --git a/msm/vidc/msm_vidc.c b/msm/vidc/msm_vidc.c index 1974251de698..aa4128ff365d 100644 --- a/msm/vidc/msm_vidc.c +++ b/msm/vidc/msm_vidc.c @@ -131,13 +131,14 @@ int msm_vidc_query_ctrl(void *instance, struct v4l2_queryctrl *q_ctrl) struct v4l2_ctrl *ctrl; if (!inst || !q_ctrl) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK %pK\n", + __func__, inst, q_ctrl); return -EINVAL; } ctrl = v4l2_ctrl_find(&inst->ctrl_handler, q_ctrl->id); if (!ctrl) { - dprintk(VIDC_ERR, "%s: get_ctrl failed for id %d\n", + s_vpr_e(inst->sid, "%s: get_ctrl failed for id %d\n", __func__, q_ctrl->id); return -EINVAL; } @@ -153,7 +154,7 @@ int msm_vidc_query_ctrl(void *instance, struct v4l2_queryctrl *q_ctrl) else q_ctrl->flags = 0; - dprintk(VIDC_HIGH, "query ctrl: %s: min %d, max %d, flags %#x\n", + s_vpr_h(inst->sid, "query ctrl: %s: min %d, max %d, flags %#x\n", ctrl->name, q_ctrl->minimum, q_ctrl->maximum, q_ctrl->flags); return rc; } @@ -172,10 +173,9 @@ int msm_vidc_s_fmt(void *instance, struct v4l2_format *f) if (inst->session_type == MSM_VIDC_ENCODER) rc = msm_venc_s_fmt(instance, f); - dprintk(VIDC_HIGH, - "s_fmt: %x : type %d wxh %dx%d pixelfmt %#x num_planes %d size[0] %d size[1] %d in_reconfig %d\n", - hash32_ptr(inst->session), f->type, - f->fmt.pix_mp.width, f->fmt.pix_mp.height, + s_vpr_h(inst->sid, + "s_fmt: type %d wxh %dx%d pixelfmt %#x num_planes %d size[0] %d size[1] %d in_reconfig %d\n", + f->type, f->fmt.pix_mp.width, f->fmt.pix_mp.height, f->fmt.pix_mp.pixelformat, f->fmt.pix_mp.num_planes, f->fmt.pix_mp.plane_fmt[0].sizeimage, f->fmt.pix_mp.plane_fmt[1].sizeimage, inst->in_reconfig); @@ -196,10 +196,9 @@ int msm_vidc_g_fmt(void *instance, struct v4l2_format *f) if (inst->session_type == MSM_VIDC_ENCODER) rc = msm_venc_g_fmt(instance, f); - dprintk(VIDC_HIGH, - "g_fmt: %x : type %d wxh %dx%d pixelfmt %#x num_planes %d size[0] %d size[1] %d in_reconfig %d\n", - hash32_ptr(inst->session), f->type, - f->fmt.pix_mp.width, f->fmt.pix_mp.height, + s_vpr_h(inst->sid, + "g_fmt: type %d wxh %dx%d pixelfmt %#x num_planes %d size[0] %d size[1] %d in_reconfig %d\n", + f->type, f->fmt.pix_mp.width, f->fmt.pix_mp.height, f->fmt.pix_mp.pixelformat, f->fmt.pix_mp.num_planes, f->fmt.pix_mp.plane_fmt[0].sizeimage, f->fmt.pix_mp.plane_fmt[1].sizeimage, inst->in_reconfig); @@ -248,9 +247,8 @@ int msm_vidc_reqbufs(void *instance, struct v4l2_requestbuffers *b) return -EINVAL; q = msm_comm_get_vb2q(inst, b->type); if (!q) { - dprintk(VIDC_ERR, - "Failed to find buffer queue for type = %d\n", - b->type); + s_vpr_e(inst->sid, + "Failed to find buffer queue. type %d\n", b->type); return -EINVAL; } @@ -259,7 +257,7 @@ int msm_vidc_reqbufs(void *instance, struct v4l2_requestbuffers *b) mutex_unlock(&q->lock); if (rc) - dprintk(VIDC_ERR, "Failed to get reqbufs, %d\n", rc); + s_vpr_e(inst->sid, "Failed to get reqbufs, %d\n", rc); return rc; } EXPORT_SYMBOL(msm_vidc_reqbufs); @@ -286,7 +284,7 @@ int msm_vidc_release_buffer(void *instance, int type, unsigned int index) struct msm_vidc_buffer *mbuf, *dummy; if (!inst) { - dprintk(VIDC_ERR, "%s: invalid inst\n", __func__); + d_vpr_e("%s: invalid inst\n", __func__); return -EINVAL; } @@ -295,9 +293,9 @@ int msm_vidc_release_buffer(void *instance, int type, unsigned int index) inst->state < MSM_VIDC_RELEASE_RESOURCES_DONE) { rc = msm_comm_try_state(inst, MSM_VIDC_RELEASE_RESOURCES_DONE); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: Failed to move inst: %pK to rel res done\n", - __func__, inst); + __func__, inst); } } @@ -336,21 +334,20 @@ int msm_vidc_qbuf(void *instance, struct v4l2_buffer *b) u32 cr = 0; if (!inst || !inst->core || !b || !valid_v4l2_buffer(b, inst)) { - dprintk(VIDC_ERR, "%s: invalid params, inst %pK\n", - __func__, inst); + d_vpr_e("%s: invalid params %pK %pK\n", __func__, inst, b); return -EINVAL; } if (!IS_ALIGNED(b->m.planes[0].length, SZ_4K)) { - dprintk(VIDC_ERR, "qbuf: %x: buffer size not 4K aligned - %u\n", - hash32_ptr(inst->session), b->m.planes[0].length); + s_vpr_e(inst->sid, "qbuf: buffer size not 4K aligned - %u\n", + b->m.planes[0].length); return -EINVAL; } if ((inst->out_flush && b->type == OUTPUT_MPLANE) || inst->in_flush) { - dprintk(VIDC_ERR, - "%s: %x: in flush, discarding qbuf, type %u, index %u\n", - __func__, hash32_ptr(inst->session), b->type, b->index); + s_vpr_e(inst->sid, + "%s: in flush, discarding qbuf, type %u, index %u\n", + __func__, b->type, b->index); return -EINVAL; } @@ -370,19 +367,18 @@ int msm_vidc_qbuf(void *instance, struct v4l2_buffer *b) client_data = msm_comm_store_client_data(inst, b->m.planes[0].reserved[3]); if (!client_data) { - dprintk(VIDC_ERR, - "%s: %x: failed to store client data\n", - __func__, hash32_ptr(inst->session)); + s_vpr_e(inst->sid, + "%s: failed to store client data\n", __func__); return -EINVAL; } msm_comm_store_input_tag(&inst->etb_data, b->index, - client_data->id, 0); + client_data->id, 0, inst->sid); } q = msm_comm_get_vb2q(inst, b->type); if (!q) { - dprintk(VIDC_ERR, - "Failed to find buffer queue for type = %d\n", b->type); + s_vpr_e(inst->sid, + "Failed to find buffer queue. type %d\n", b->type); return -EINVAL; } @@ -390,7 +386,7 @@ int msm_vidc_qbuf(void *instance, struct v4l2_buffer *b) rc = vb2_qbuf(&q->vb2_bufq, b); mutex_unlock(&q->lock); if (rc) - dprintk(VIDC_ERR, "Failed to qbuf, %d\n", rc); + s_vpr_e(inst->sid, "Failed to qbuf, %d\n", rc); return rc; } @@ -406,15 +402,15 @@ int msm_vidc_dqbuf(void *instance, struct v4l2_buffer *b) bool remove; if (!inst || !b || !valid_v4l2_buffer(b, inst)) { - dprintk(VIDC_ERR, "%s: invalid params, inst %pK\n", - __func__, inst); + d_vpr_e("%s: invalid params, %pK %pK\n", + __func__, inst, b); return -EINVAL; } q = msm_comm_get_vb2q(inst, b->type); if (!q) { - dprintk(VIDC_ERR, - "Failed to find buffer queue for type = %d\n", b->type); + s_vpr_e(inst->sid, "Failed to find buffer queue. type %d\n", + b->type); return -EINVAL; } @@ -424,7 +420,7 @@ int msm_vidc_dqbuf(void *instance, struct v4l2_buffer *b) if (rc == -EAGAIN) { return rc; } else if (rc) { - dprintk(VIDC_ERR, "Failed to dqbuf, %d\n", rc); + s_vpr_e(inst->sid, "Failed to dqbuf, %d\n", rc); return rc; } @@ -443,9 +439,9 @@ int msm_vidc_dqbuf(void *instance, struct v4l2_buffer *b) if (b->type == OUTPUT_MPLANE && !inst->in_flush && !inst->out_flush && inst->clk_data.buffer_counter) { rc = msm_comm_fetch_input_tag(&inst->fbd_data, b->index, - &input_tag, &input_tag2); + &input_tag, &input_tag2, inst->sid); if (rc) { - dprintk(VIDC_ERR, "Failed to fetch input tag"); + s_vpr_e(inst->sid, "Failed to fetch input tag"); return -EINVAL; } /** @@ -477,16 +473,15 @@ int msm_vidc_streamon(void *instance, enum v4l2_buf_type i) q = msm_comm_get_vb2q(inst, i); if (!q) { - dprintk(VIDC_ERR, - "Failed to find buffer queue for type = %d\n", i); + d_vpr_e("Failed to find buffer queue. type %d\n", i); return -EINVAL; } - dprintk(VIDC_HIGH, "Calling streamon\n"); + s_vpr_h(inst->sid, "Calling streamon\n"); mutex_lock(&q->lock); rc = vb2_streamon(&q->vb2_bufq, i); mutex_unlock(&q->lock); if (rc) { - dprintk(VIDC_ERR, "streamon failed on port: %d\n", i); + s_vpr_e(inst->sid, "streamon failed on port: %d\n", i); msm_comm_kill_session(inst); } return rc; @@ -504,27 +499,26 @@ int msm_vidc_streamoff(void *instance, enum v4l2_buf_type i) q = msm_comm_get_vb2q(inst, i); if (!q) { - dprintk(VIDC_ERR, - "Failed to find buffer queue for type = %d\n", i); + s_vpr_e(inst->sid, "Failed to find buffer queue. type %d\n", i); return -EINVAL; } if (!inst->in_reconfig) { - dprintk(VIDC_HIGH, "%s: inst %pK release resources\n", + s_vpr_h(inst->sid, "%s: inst %pK release resources\n", __func__, inst); rc = msm_comm_try_state(inst, MSM_VIDC_RELEASE_RESOURCES_DONE); if (rc) - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: inst %pK move to rel res done failed\n", __func__, inst); } - dprintk(VIDC_HIGH, "Calling streamoff\n"); + s_vpr_h(inst->sid, "Calling streamoff\n"); mutex_lock(&q->lock); rc = vb2_streamoff(&q->vb2_bufq, i); mutex_unlock(&q->lock); if (rc) - dprintk(VIDC_ERR, "streamoff failed on port: %d\n", i); + s_vpr_e(inst->sid, "streamoff failed on port: %d\n", i); return rc; } EXPORT_SYMBOL(msm_vidc_streamoff); @@ -535,7 +529,7 @@ int msm_vidc_enum_framesizes(void *instance, struct v4l2_frmsizeenum *fsize) struct msm_vidc_capability *capability = NULL; if (!inst || !fsize) { - dprintk(VIDC_ERR, "%s: invalid parameter: %pK %pK\n", + d_vpr_e("%s: invalid parameter: %pK %pK\n", __func__, inst, fsize); return -EINVAL; } @@ -578,35 +572,33 @@ static void msm_vidc_cleanup_buffer(struct vb2_buffer *vb) struct msm_vidc_inst *inst = NULL; if (!vb) { - dprintk(VIDC_ERR, "%s : Invalid vb pointer %pK", - __func__, vb); + d_vpr_e("%s: Invalid vb pointer", __func__); return; } inst = vb2_get_drv_priv(vb->vb2_queue); if (!inst) { - dprintk(VIDC_ERR, "%s : Invalid inst pointer", - __func__); + d_vpr_e("%s: Invalid inst pointer", __func__); return; } q = msm_comm_get_vb2q(inst, vb->type); if (!q) { - dprintk(VIDC_ERR, - "%s : Failed to find buffer queue for type = %d\n", + s_vpr_e(inst->sid, + "%s: Failed to find buffer queue. type %d\n", __func__, vb->type); return; } if (q->vb2_bufq.streaming) { - dprintk(VIDC_HIGH, "%d PORT is streaming\n", + s_vpr_h(inst->sid, "%d PORT is streaming\n", vb->type); return; } rc = msm_vidc_release_buffer(inst, vb->type, vb->index); if (rc) - dprintk(VIDC_ERR, "%s : Failed to release buffers : %d\n", + s_vpr_e(inst->sid, "%s: Failed to release buffers: %d\n", __func__, rc); } @@ -622,14 +614,13 @@ static int msm_vidc_queue_setup(struct vb2_queue *q, if (!q || !num_buffers || !num_planes || !sizes || !q->drv_priv) { - dprintk(VIDC_ERR, "Invalid input, q = %pK, %pK, %pK\n", + d_vpr_e("Invalid input, q = %pK, %pK, %pK\n", q, num_buffers, num_planes); return -EINVAL; } inst = q->drv_priv; - if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, "%s invalid parameters\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } @@ -637,7 +628,7 @@ static int msm_vidc_queue_setup(struct vb2_queue *q, case INPUT_MPLANE: { fmt = &inst->fmts[INPUT_PORT]; if (*num_buffers < fmt->count_min_host) { - dprintk(VIDC_HIGH, + s_vpr_h(inst->sid, "Client passed num buffers %d less than the min_host count %d\n", *num_buffers, fmt->count_min_host); } @@ -658,7 +649,7 @@ static int msm_vidc_queue_setup(struct vb2_queue *q, if (inst->session_type != MSM_VIDC_DECODER && inst->state > MSM_VIDC_LOAD_RESOURCES_DONE) { if (*num_buffers < fmt->count_min_host) { - dprintk(VIDC_HIGH, + s_vpr_h(inst->sid, "Client passed num buffers %d less than the min_host count %d\n", *num_buffers, fmt->count_min_host); @@ -678,15 +669,14 @@ static int msm_vidc_queue_setup(struct vb2_queue *q, } break; default: - dprintk(VIDC_ERR, "Invalid q type = %d\n", q->type); + s_vpr_e(inst->sid, "Invalid q type = %d\n", q->type); rc = -EINVAL; break; } - dprintk(VIDC_HIGH, - "queue_setup: %x : type %d num_buffers %d num_planes %d sizes[0] %d sizes[1] %d\n", - hash32_ptr(inst->session), q->type, *num_buffers, - *num_planes, sizes[0], sizes[1]); + s_vpr_h(inst->sid, + "queue_setup:type %d num_buffers %d num_planes %d sizes[0] %d sizes[1] %d\n", + q->type, *num_buffers, *num_planes, sizes[0], sizes[1]); return rc; } @@ -698,8 +688,7 @@ static inline int msm_vidc_verify_buffer_counts(struct msm_vidc_inst *inst) if (inst->session_type == MSM_VIDC_DECODER && (inst->state < MSM_VIDC_LOAD_RESOURCES_DONE || inst->state >= MSM_VIDC_RELEASE_RESOURCES_DONE)) { - dprintk(VIDC_HIGH, - "No need to verify buffer counts : %pK\n", inst); + s_vpr_h(inst->sid, "No need to verify buffer counts\n"); return 0; } @@ -707,23 +696,20 @@ static inline int msm_vidc_verify_buffer_counts(struct msm_vidc_inst *inst) struct hal_buffer_requirements *req = &inst->buff_req.buffer[i]; if (req && (req->buffer_type == HAL_BUFFER_OUTPUT)) { - dprintk(VIDC_HIGH, "Verifying Buffer : %d\n", + s_vpr_h(inst->sid, "Verifying Buffer : %d\n", req->buffer_type); if (req->buffer_count_actual < req->buffer_count_min_host || req->buffer_count_min_host < req->buffer_count_min) { - dprintk(VIDC_ERR, - "Invalid data : Counts mismatch\n"); - dprintk(VIDC_ERR, - "Min Count = %d ", + s_vpr_e(inst->sid, + "Invalid data : Counts mismatch\n"); + s_vpr_e(inst->sid, "Min Count = %d ", req->buffer_count_min); - dprintk(VIDC_ERR, - "Min Host Count = %d ", + s_vpr_e(inst->sid, "Min Host Count = %d ", req->buffer_count_min_host); - dprintk(VIDC_ERR, - "Min Actual Count = %d\n", + s_vpr_e(inst->sid, "Min Actual Count = %d\n", req->buffer_count_actual); rc = -EINVAL; break; @@ -753,7 +739,7 @@ bool is_vidc_cvp_allowed(struct msm_vidc_inst *inst) struct v4l2_ctrl *superframe_enable; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); goto exit; } core = inst->core; @@ -782,10 +768,10 @@ bool is_vidc_cvp_allowed(struct msm_vidc_inst *inst) !inst->clk_data.is_legacy_cbr && !is_secure_session(inst) && !superframe_enable->val) { - dprintk(VIDC_HIGH, "%s: cvp allowed\n", __func__); + s_vpr_h(inst->sid, "%s: cvp allowed\n", __func__); allowed = true; } else { - dprintk(VIDC_HIGH, + s_vpr_h(inst->sid, "%s: cvp not allowed, cvp_external %d cvp_disable %d extradata %#x rc_type %d legacy_cbr %d secure %d superframe %d\n", __func__, core->resources.cvp_external, cvp_disable->val, inst->prop.extradata_ctrls, @@ -802,26 +788,26 @@ static int msm_vidc_prepare_preprocess(struct msm_vidc_inst *inst) int rc = 0; if (!inst) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } if (!msm_vidc_cvp_usage) { - dprintk(VIDC_HIGH, "%s: cvp usage disabled\n", __func__); + s_vpr_h(inst->sid, "%s: cvp usage disabled\n", __func__); return 0; } if (!is_vidc_cvp_allowed(inst)) { - dprintk(VIDC_HIGH, "%s: cvp not allowed\n", __func__); + s_vpr_h(inst->sid, "%s: cvp not allowed\n", __func__); return 0; } rc = msm_vidc_cvp_prepare_preprocess(inst); if (rc) { - dprintk(VIDC_ERR, "%s: no cvp preprocessing\n", __func__); + s_vpr_e(inst->sid, "%s: no cvp preprocessing\n", __func__); goto exit; } - dprintk(VIDC_HIGH, "%s: kernel to kernel cvp enabled\n", __func__); + s_vpr_h(inst->sid, "%s: kernel to kernel cvp enabled\n", __func__); inst->prop.extradata_ctrls |= EXTRADATA_ENC_INPUT_KK_CVP; exit: @@ -836,7 +822,7 @@ static bool msm_vidc_set_cvp_metadata(struct msm_vidc_inst *inst) { u32 value = 0x0; if (!inst) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params\n", __func__); return false; } @@ -844,12 +830,11 @@ static bool msm_vidc_set_cvp_metadata(struct msm_vidc_inst *inst) { (inst->prop.extradata_ctrls & EXTRADATA_ENC_INPUT_KK_CVP)) value = 0x1; - dprintk(VIDC_HIGH, "%s: CVP extradata %d\n", __func__, value); + s_vpr_h(inst->sid, "%s: CVP extradata %d\n", __func__, value); rc = msm_comm_set_extradata(inst, HFI_PROPERTY_PARAM_VENC_CVP_METADATA_EXTRADATA, value); if (rc) { - dprintk(VIDC_ERR, - "%s: set CVP extradata failed\n", __func__); + s_vpr_e(inst->sid, "%s: set CVP extradata failed\n", __func__); return false; } return true; @@ -862,21 +847,19 @@ static inline int start_streaming(struct msm_vidc_inst *inst) struct hfi_buffer_size_minimum b; struct v4l2_format *f; - dprintk(VIDC_HIGH, "%s: %x : inst %pK\n", __func__, - hash32_ptr(inst->session), inst); + s_vpr_h(inst->sid, "%s: inst %pK\n", __func__, inst); hdev = inst->core->device; rc = msm_vidc_set_properties(inst); if (rc) { - dprintk(VIDC_ERR, "%s: %x: set props failed\n", - __func__, hash32_ptr(inst->session)); + s_vpr_e(inst->sid, "%s: set props failed\n", __func__); goto fail_start; } if (is_encode_session(inst)) { rc = msm_vidc_prepare_preprocess(inst); if (rc) { - dprintk(VIDC_ERR, "%s: no preprocessing\n", __func__); + s_vpr_e(inst->sid, "%s: no preprocessing\n", __func__); /* ignore error */ rc = 0; } @@ -892,38 +875,34 @@ static inline int start_streaming(struct msm_vidc_inst *inst) /* Check if current session is under HW capability */ rc = msm_vidc_check_session_supported(inst); if (rc) { - dprintk(VIDC_ERR, - "This session is not supported %pK\n", inst); + s_vpr_e(inst->sid, "This session is not supported\n"); goto fail_start; } rc = msm_vidc_check_scaling_supported(inst); if (rc) { - dprintk(VIDC_ERR, - "This session scaling is not supported %pK\n", inst); + s_vpr_e(inst->sid, "scaling is not supported\n"); goto fail_start; } /* Decide work mode for current session */ rc = call_core_op(inst->core, decide_work_mode, inst); if (rc) { - dprintk(VIDC_ERR, - "Failed to decide work mode for session %pK\n", inst); + s_vpr_e(inst->sid, "Failed to decide work mode\n"); goto fail_start; } /* Decide work route for current session */ rc = call_core_op(inst->core, decide_work_route, inst); if (rc) { - dprintk(VIDC_ERR, - "Failed to decide work route for session %pK\n", inst); + s_vpr_e(inst->sid, "Failed to decide work route\n"); goto fail_start; } /* Assign Core and LP mode for current session */ rc = call_core_op(inst->core, decide_core_and_power_mode, inst); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "This session can't be submitted to HW %pK\n", inst); goto fail_start; } @@ -939,28 +918,25 @@ static inline int start_streaming(struct msm_vidc_inst *inst) /* Verify if buffer counts are correct */ rc = msm_vidc_verify_buffer_counts(inst); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "This session has mis-match buffer counts%pK\n", inst); goto fail_start; } rc = msm_comm_set_scratch_buffers(inst); if (rc) { - dprintk(VIDC_ERR, - "Failed to set scratch buffers: %d\n", rc); + s_vpr_e(inst->sid, "Failed to set scratch buffers: %d\n", rc); goto fail_start; } rc = msm_comm_set_persist_buffers(inst); if (rc) { - dprintk(VIDC_ERR, - "Failed to set persist buffers: %d\n", rc); + s_vpr_e(inst->sid, "Failed to set persist buffers: %d\n", rc); goto fail_start; } rc = msm_comm_set_recon_buffers(inst); if (rc) { - dprintk(VIDC_ERR, - "Failed to set recon buffers: %d\n", rc); + s_vpr_e(inst->sid, "Failed to set recon buffers: %d\n", rc); goto fail_start; } @@ -968,7 +944,7 @@ static inline int start_streaming(struct msm_vidc_inst *inst) HAL_VIDEO_DECODER_SECONDARY) { rc = msm_comm_set_dpb_only_buffers(inst); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Failed to set output buffers: %d\n", rc); goto fail_start; } @@ -983,9 +959,8 @@ static inline int start_streaming(struct msm_vidc_inst *inst) */ if (inst->batch.enable) inst->batch.enable = is_batching_allowed(inst); - dprintk(VIDC_HIGH|VIDC_PERF, "%s: batching %s for inst %pK (%#x)\n", - __func__, inst->batch.enable ? "enabled" : "disabled", - inst, hash32_ptr(inst->session)); + s_vpr_hp(inst->sid, "%s: batching %s for inst %pK\n", + __func__, inst->batch.enable ? "enabled" : "disabled", inst); msm_dcvs_try_enable(inst); @@ -1007,7 +982,7 @@ static inline int start_streaming(struct msm_vidc_inst *inst) rc = msm_comm_try_state(inst, MSM_VIDC_START_DONE); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Failed to move inst: %pK to start done state\n", inst); goto fail_start; } @@ -1018,7 +993,7 @@ static inline int start_streaming(struct msm_vidc_inst *inst) HAL_VIDEO_DECODER_SECONDARY) { rc = msm_comm_queue_dpb_only_buffers(inst); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Failed to queue output buffers: %d\n", rc); goto fail_start; } @@ -1026,8 +1001,8 @@ static inline int start_streaming(struct msm_vidc_inst *inst) fail_start: if (rc) - dprintk(VIDC_ERR, "%s: inst %pK session %x failed to start\n", - __func__, inst, hash32_ptr(inst->session)); + s_vpr_e(inst->sid, "%s: inst %pK failed to start\n", + __func__, inst); return rc; } @@ -1038,16 +1013,16 @@ static int msm_vidc_start_streaming(struct vb2_queue *q, unsigned int count) struct hfi_device *hdev; if (!q || !q->drv_priv) { - dprintk(VIDC_ERR, "Invalid input, q = %pK\n", q); + d_vpr_e("Invalid input, q = %pK\n", q); return -EINVAL; } inst = q->drv_priv; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, "%s invalid parameters\n", __func__); + d_vpr_e("%s: invalid parameters\n", __func__); return -EINVAL; } hdev = inst->core->device; - dprintk(VIDC_HIGH, "Streamon called on: %d capability for inst: %pK\n", + s_vpr_h(inst->sid, "Streamon called on: %d capability for inst: %pK\n", q->type, inst); switch (q->type) { case INPUT_MPLANE: @@ -1059,30 +1034,28 @@ static int msm_vidc_start_streaming(struct vb2_queue *q, unsigned int count) rc = start_streaming(inst); break; default: - dprintk(VIDC_ERR, "Queue type is not supported: %d\n", q->type); + s_vpr_e(inst->sid, + "Queue type is not supported: %d\n", q->type); rc = -EINVAL; goto stream_start_failed; } if (rc) { - dprintk(VIDC_ERR, - "Streamon failed on: %d capability for inst: %pK\n", + s_vpr_e(inst->sid, "Streamon failed: %d, inst: %pK\n", q->type, inst); goto stream_start_failed; } rc = msm_comm_qbufs(inst); if (rc) { - dprintk(VIDC_ERR, - "Failed to commit buffers queued before STREAM_ON to hardware: %d\n", - rc); + s_vpr_e(inst->sid, + "Failed to commit buffers queued before STREAM_ON: %d\n", + rc); goto stream_start_failed; } rc = msm_vidc_send_pending_eos_buffers(inst); if (rc) { - dprintk(VIDC_ERR, - "Failed : Send pending EOS buffs for Inst = %pK, %d\n", - inst, rc); + s_vpr_e(inst->sid, "Failed : Send pending EOS: %d\n", rc); goto stream_start_failed; } @@ -1103,8 +1076,7 @@ stream_start_failed: list_for_each_entry(vb, &q->queued_list, queued_entry) { if (msm_comm_compare_vb2_planes(inst, temp, vb)) { - print_vb2_buffer(VIDC_ERR, "return vb", - inst, vb); + print_vb2_buffer("return vb", inst, vb); vb2_buffer_done(vb, VB2_BUF_STATE_QUEUED); break; @@ -1124,7 +1096,7 @@ static int msm_vidc_unprepare_preprocess(struct msm_vidc_inst *inst) int rc = 0; if (!inst) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } @@ -1133,9 +1105,7 @@ static int msm_vidc_unprepare_preprocess(struct msm_vidc_inst *inst) rc = msm_vidc_cvp_unprepare_preprocess(inst); if (rc) - dprintk(VIDC_ERR, - "%s: cvp unprepare preprocess failed with rc %d\n", - __func__, rc); + s_vpr_e(inst->sid, "%s: failed rc %d\n", __func__, rc); return rc; } @@ -1144,19 +1114,21 @@ static inline int stop_streaming(struct msm_vidc_inst *inst) { int rc = 0; - dprintk(VIDC_HIGH, "%s: %x : inst %pK\n", __func__, - hash32_ptr(inst->session), inst); + if (!inst) { + d_vpr_e("%s: invalid params\n", __func__); + return -EINVAL; + } + s_vpr_h(inst->sid, "%s: inst %pK\n", __func__, inst); rc = msm_comm_try_state(inst, MSM_VIDC_RELEASE_RESOURCES_DONE); if (rc) - dprintk(VIDC_ERR, - "Failed to move inst: %pK to state %d\n", + s_vpr_e(inst->sid, "Failed to move inst: %pK to state %d\n", inst, MSM_VIDC_RELEASE_RESOURCES_DONE); if (is_encode_session(inst)) { rc = msm_vidc_unprepare_preprocess(inst); if (rc) - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: failed to unprepare preprocess\n", __func__); inst->all_intra = false; @@ -1173,12 +1145,12 @@ static void msm_vidc_stop_streaming(struct vb2_queue *q) int rc = 0; if (!q || !q->drv_priv) { - dprintk(VIDC_ERR, "Invalid input, q = %pK\n", q); + d_vpr_e("Invalid input, q = %pK\n", q); return; } inst = q->drv_priv; - dprintk(VIDC_HIGH, "Streamoff called on: %d capability\n", q->type); + s_vpr_h(inst->sid, "Streamoff called on: %d capability\n", q->type); switch (q->type) { case INPUT_MPLANE: if (!inst->bufq[OUTPUT_PORT].vb2_bufq.streaming) @@ -1189,8 +1161,7 @@ static void msm_vidc_stop_streaming(struct vb2_queue *q) rc = stop_streaming(inst); break; default: - dprintk(VIDC_ERR, - "Q-type is not supported: %d\n", q->type); + s_vpr_e(inst->sid, "Q-type is not supported: %d\n", q->type); rc = -EINVAL; break; } @@ -1198,7 +1169,7 @@ static void msm_vidc_stop_streaming(struct vb2_queue *q) msm_comm_scale_clocks_and_bus(inst, 1); if (rc) - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Failed STOP Streaming inst = %pK on cap = %d\n", inst, q->type); } @@ -1210,7 +1181,8 @@ static int msm_vidc_queue_buf(struct msm_vidc_inst *inst, struct msm_vidc_buffer *mbuf; if (!inst || !vb2) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK, %pK\n", + __func__, inst, vb2); return -EINVAL; } @@ -1223,16 +1195,16 @@ static int msm_vidc_queue_buf(struct msm_vidc_inst *inst, */ if (PTR_ERR(mbuf) == -EEXIST) return 0; - dprintk(VIDC_ERR, "%s: failed to get vidc-buf\n", __func__); + s_vpr_e(inst->sid, "%s: failed to get vidc-buf\n", __func__); return -EINVAL; } if (!kref_get_mbuf(inst, mbuf)) { - dprintk(VIDC_ERR, "%s: mbuf not found\n", __func__); + s_vpr_e(inst->sid, "%s: mbuf not found\n", __func__); return -EINVAL; } rc = msm_comm_qbuf(inst, mbuf); if (rc) - dprintk(VIDC_ERR, "%s: failed qbuf\n", __func__); + s_vpr_e(inst->sid, "%s: failed qbuf\n", __func__); kref_put_mbuf(mbuf); return rc; @@ -1245,17 +1217,18 @@ static int msm_vidc_queue_buf_decode_batch(struct msm_vidc_inst *inst, struct msm_vidc_buffer *mbuf; if (!inst || !vb2) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK, %pK\n", + __func__, inst, vb2); return -EINVAL; } mbuf = msm_comm_get_vidc_buffer(inst, vb2); if (IS_ERR_OR_NULL(mbuf)) { - dprintk(VIDC_ERR, "%s: failed to get vidc-buf\n", __func__); + s_vpr_e(inst->sid, "%s: failed to get vidc-buf\n", __func__); return -EINVAL; } if (!kref_get_mbuf(inst, mbuf)) { - dprintk(VIDC_ERR, "%s: mbuf not found\n", __func__); + s_vpr_e(inst->sid, "%s: mbuf not found\n", __func__); return -EINVAL; } /* @@ -1264,7 +1237,7 @@ static int msm_vidc_queue_buf_decode_batch(struct msm_vidc_inst *inst, */ rc = msm_comm_qbuf_decode_batch(inst, mbuf); if (rc) - dprintk(VIDC_ERR, "%s: failed qbuf\n", __func__); + s_vpr_e(inst->sid, "%s: failed qbuf\n", __func__); kref_put_mbuf(mbuf); return rc; @@ -1276,7 +1249,8 @@ static int msm_vidc_queue_buf_batch(struct msm_vidc_inst *inst, int rc; if (!inst || !vb2) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK, %pK\n", + __func__, inst, vb2); return -EINVAL; } @@ -1296,7 +1270,7 @@ static void msm_vidc_buf_queue(struct vb2_buffer *vb2) inst = vb2_get_drv_priv(vb2->vb2_queue); if (!inst) { - dprintk(VIDC_ERR, "%s: invalid inst\n", __func__); + d_vpr_e("%s: invalid inst\n", __func__); return; } @@ -1306,7 +1280,7 @@ static void msm_vidc_buf_queue(struct vb2_buffer *vb2) rc = msm_vidc_queue_buf(inst, vb2); if (rc) { - print_vb2_buffer(VIDC_ERR, "failed vb2-qbuf", inst, vb2); + print_vb2_buffer("failed vb2-qbuf", inst, vb2); msm_comm_generate_session_error(inst); } } @@ -1329,7 +1303,7 @@ static inline int vb2_bufq_init(struct msm_vidc_inst *inst, } else if (type == INPUT_MPLANE) { q = &inst->bufq[INPUT_PORT].vb2_bufq; } else { - dprintk(VIDC_ERR, "buf_type = %d not recognised\n", type); + s_vpr_e(inst->sid, "buf_type = %d not recognised\n", type); return -EINVAL; } @@ -1404,21 +1378,20 @@ int msm_vidc_private(void *vidc_inst, unsigned int cmd, int rc = 0; struct msm_vidc_inst *inst = (struct msm_vidc_inst *)vidc_inst; + if (!inst || !arg) { + d_vpr_e("%s: invalid args\n", __func__); + return -EINVAL; + } if (cmd != VIDIOC_VIDEO_CMD) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: invalid private cmd %#x\n", __func__, cmd); return -ENOIOCTLCMD; } - if (!inst || !arg) { - dprintk(VIDC_ERR, "%s: invalid args\n", __func__); - return -EINVAL; - } - if (inst->session_type == MSM_VIDC_CVP) { rc = msm_vidc_cvp(inst, arg); } else { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: private cmd %#x not supported for session_type %d\n", __func__, cmd, inst->session_type); rc = -EINVAL; @@ -1447,22 +1420,22 @@ static int msm_vidc_op_s_ctrl(struct v4l2_ctrl *ctrl) const char *ctrl_name = NULL; if (!ctrl) { - dprintk(VIDC_ERR, "%s invalid parameters for ctrl\n", __func__); + d_vpr_e("%s: invalid parameters for ctrl\n", __func__); return -EINVAL; } inst = container_of(ctrl->handler, struct msm_vidc_inst, ctrl_handler); if (!inst) { - dprintk(VIDC_ERR, "%s invalid parameters for inst\n", __func__); + d_vpr_e("%s: invalid parameters for inst\n", __func__); return -EINVAL; } rc = msm_vidc_try_set_ctrl(inst, ctrl); if (rc) { - dprintk(VIDC_ERR, "Failed setting %x\n", ctrl->id); + s_vpr_e(inst->sid, "Failed setting %x\n", ctrl->id); ctrl_name = v4l2_ctrl_get_name(ctrl->id); - dprintk(VIDC_ERR, "Failed setting control: Inst = %pK (%s)\n", + s_vpr_e(inst->sid, "Failed setting control: Inst = %pK (%s)\n", inst, ctrl_name ? ctrl_name : "Invalid ctrl"); } @@ -1478,38 +1451,37 @@ static int try_get_ctrl_for_instance(struct msm_vidc_inst *inst, case V4L2_CID_MPEG_VIDEO_H264_PROFILE: ctrl->val = msm_comm_hfi_to_v4l2( V4L2_CID_MPEG_VIDEO_H264_PROFILE, - inst->profile); + inst->profile, inst->sid); break; case V4L2_CID_MPEG_VIDEO_HEVC_PROFILE: ctrl->val = msm_comm_hfi_to_v4l2( V4L2_CID_MPEG_VIDEO_HEVC_PROFILE, - inst->profile); + inst->profile, inst->sid); break; case V4L2_CID_MPEG_VIDEO_H264_LEVEL: ctrl->val = msm_comm_hfi_to_v4l2( V4L2_CID_MPEG_VIDEO_H264_LEVEL, - inst->level); + inst->level, inst->sid); break; case V4L2_CID_MPEG_VIDC_VIDEO_VP8_PROFILE_LEVEL: ctrl->val = msm_comm_hfi_to_v4l2( V4L2_CID_MPEG_VIDC_VIDEO_VP8_PROFILE_LEVEL, - inst->level); + inst->level, inst->sid); break; case V4L2_CID_MPEG_VIDEO_HEVC_LEVEL: ctrl->val = msm_comm_hfi_to_v4l2( V4L2_CID_MPEG_VIDEO_HEVC_LEVEL, - inst->level); + inst->level, inst->sid); break; case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE: ctrl->val = inst->fmts[OUTPUT_PORT].count_min_host; - dprintk(VIDC_HIGH, "g_min: %x : hal_buffer %d min buffers %d\n", - hash32_ptr(inst->session), HAL_BUFFER_OUTPUT, - ctrl->val); + s_vpr_h(inst->sid, "g_min: hal_buffer %d min buffers %d\n", + HAL_BUFFER_OUTPUT, ctrl->val); break; case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT: ctrl->val = inst->fmts[INPUT_PORT].count_min_host; - dprintk(VIDC_HIGH, "g_min: %x : hal_buffer %d min buffers %d\n", - hash32_ptr(inst->session), HAL_BUFFER_INPUT, ctrl->val); + s_vpr_h(inst->sid, "g_min: hal_buffer %d min buffers %d\n", + HAL_BUFFER_INPUT, ctrl->val); break; case V4L2_CID_MPEG_VIDC_VIDEO_EXTRADATA: ctrl->val = inst->prop.extradata_ctrls; @@ -1540,26 +1512,26 @@ void *msm_vidc_open(int core_id, int session_type) if (core_id >= MSM_VIDC_CORES_MAX || session_type >= MSM_VIDC_MAX_DEVICES) { - dprintk(VIDC_ERR, "Invalid input, core_id = %d, session = %d\n", + d_vpr_e("Invalid input, core_id = %d, session = %d\n", core_id, session_type); goto err_invalid_core; } core = get_vidc_core(core_id); if (!core) { - dprintk(VIDC_ERR, - "Failed to find core for core_id = %d\n", core_id); + d_vpr_e("Failed to find core for core_id = %d\n", core_id); goto err_invalid_core; } inst = kzalloc(sizeof(*inst), GFP_KERNEL); if (!inst) { - dprintk(VIDC_ERR, "Failed to allocate memory\n"); + d_vpr_e("Failed to allocate memory\n"); rc = -ENOMEM; goto err_invalid_core; } + inst->sid = hash32_ptr(inst); pr_info(VIDC_DBG_TAG "Opening video instance: %pK, %d\n", - "high", inst, session_type); + "high", inst->sid, inst, session_type); mutex_init(&inst->sync_lock); mutex_init(&inst->bufq[OUTPUT_PORT].lock); mutex_init(&inst->bufq[INPUT_PORT].lock); @@ -1614,19 +1586,19 @@ void *msm_vidc_open(int core_id, int session_type) rc = msm_cvp_ctrl_init(inst, &msm_vidc_ctrl_ops); } if (rc) { - dprintk(VIDC_ERR, "Failed control initialization\n"); + s_vpr_e(inst->sid, "Failed control initialization\n"); goto fail_bufq_capture; } rc = vb2_bufq_init(inst, OUTPUT_MPLANE, session_type); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Failed to initialize vb2 queue on capture port\n"); goto fail_bufq_capture; } rc = vb2_bufq_init(inst, INPUT_MPLANE, session_type); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Failed to initialize vb2 queue on capture port\n"); goto fail_bufq_output; } @@ -1639,13 +1611,13 @@ void *msm_vidc_open(int core_id, int session_type) rc = msm_comm_try_state(inst, MSM_VIDC_CORE_INIT_DONE); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Failed to move video instance to init state\n"); goto fail_init; } if (msm_comm_check_for_inst_overload(core)) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Instance count reached Max limit, rejecting session"); goto fail_init; } @@ -1658,7 +1630,7 @@ void *msm_vidc_open(int core_id, int session_type) if (inst->session_type == MSM_VIDC_CVP) { rc = msm_comm_try_state(inst, MSM_VIDC_OPEN_DONE); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Failed to move video instance to open done state\n"); goto fail_init; } @@ -1712,7 +1684,7 @@ static void msm_vidc_cleanup_instance(struct msm_vidc_inst *inst) int c = 0; if (!inst) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params\n", __func__); return; } @@ -1726,8 +1698,7 @@ static void msm_vidc_cleanup_instance(struct msm_vidc_inst *inst) struct vb2_buffer, queued_entry); if (vb->state == VB2_BUF_STATE_ACTIVE) { vb->planes[0].bytesused = 0; - print_vb2_buffer(VIDC_ERR, "undequeud vb2", - inst, vb); + print_vb2_buffer("undequeud vb2", inst, vb); vb2_buffer_done(vb, VB2_BUF_STATE_ERROR); } } @@ -1749,20 +1720,16 @@ static void msm_vidc_cleanup_instance(struct msm_vidc_inst *inst) msm_comm_free_input_cr_table(inst); if (msm_comm_release_scratch_buffers(inst, false)) - dprintk(VIDC_ERR, - "Failed to release scratch buffers\n"); + s_vpr_e(inst->sid, "Failed to release scratch buffers\n"); if (msm_comm_release_recon_buffers(inst)) - dprintk(VIDC_ERR, - "Failed to release recon buffers\n"); + s_vpr_e(inst->sid, "Failed to release recon buffers\n"); if (msm_comm_release_persist_buffers(inst)) - dprintk(VIDC_ERR, - "Failed to release persist buffers\n"); + s_vpr_e(inst->sid, "Failed to release persist buffers\n"); if (msm_comm_release_input_tag(inst)) - dprintk(VIDC_ERR, - "Failed to release input_tag buffers\n"); + s_vpr_e(inst->sid, "Failed to release input_tag buffers\n"); msm_comm_release_client_data(inst, true); @@ -1771,17 +1738,14 @@ static void msm_vidc_cleanup_instance(struct msm_vidc_inst *inst) msm_comm_release_eos_buffers(inst); if (msm_comm_release_dpb_only_buffers(inst, true)) - dprintk(VIDC_ERR, - "Failed to release output buffers\n"); + s_vpr_e(inst->sid, "Failed to release output buffers\n"); if (inst->extradata_handle) msm_comm_smem_free(inst, inst->extradata_handle); mutex_lock(&inst->pending_getpropq.lock); if (!list_empty(&inst->pending_getpropq.list)) { - dprintk(VIDC_ERR, - "pending_getpropq not empty for instance %pK\n", - inst); + s_vpr_e(inst->sid, "pending_getpropq not empty\n"); list_for_each_entry_safe(temp_prop, dummy_prop, &inst->pending_getpropq.list, list) { kfree(temp_prop->data); @@ -1798,7 +1762,7 @@ int msm_vidc_destroy(struct msm_vidc_inst *inst) int i = 0; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } @@ -1839,7 +1803,7 @@ int msm_vidc_destroy(struct msm_vidc_inst *inst) msm_vidc_debugfs_deinit_inst(inst); pr_info(VIDC_DBG_TAG "Closed video instance: %pK\n", - "high", inst); + "high", inst->sid, inst); kfree(inst); return 0; } @@ -1858,7 +1822,7 @@ int msm_vidc_close(void *instance) int rc = 0; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } @@ -1868,9 +1832,7 @@ int msm_vidc_close(void *instance) */ rc = msm_comm_try_state(inst, MSM_VIDC_RELEASE_RESOURCES_DONE); if (rc) - dprintk(VIDC_ERR, - "Failed to move inst %pK to rel resource done state\n", - inst); + s_vpr_e(inst->sid, "Failed: move to rel resource done state\n"); /* * deinit instance after REL_RES_DONE to ensure hardware @@ -1887,7 +1849,7 @@ int msm_vidc_close(void *instance) rc = msm_comm_try_state(inst, MSM_VIDC_CORE_UNINIT); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Failed to move inst %pK to uninit state\n", inst); rc = msm_comm_force_cleanup(inst); } diff --git a/msm/vidc/msm_vidc_buffer_calculations.c b/msm/vidc/msm_vidc_buffer_calculations.c index 5fa0a05415e1..72d252395274 100644 --- a/msm/vidc/msm_vidc_buffer_calculations.c +++ b/msm/vidc/msm_vidc_buffer_calculations.c @@ -383,7 +383,7 @@ int msm_vidc_get_decoder_internal_buffer_sizes(struct msm_vidc_inst *inst) struct v4l2_format *f; if (!inst) { - dprintk(VIDC_ERR, "Instance is null!"); + d_vpr_e("%s: Instance is null!", __func__); return -EINVAL; } @@ -405,8 +405,8 @@ int msm_vidc_get_decoder_internal_buffer_sizes(struct msm_vidc_inst *inst) dec_calculators = &mpeg2d_calculators; break; default: - dprintk(VIDC_ERR, - "Invalid pix format. Internal buffer cal not defined : %x ", + s_vpr_e(inst->sid, + "Invalid pix format. Internal buffer cal not defined : %x\n", f->fmt.pix_mp.pixelformat); return -EINVAL; } @@ -503,7 +503,7 @@ int msm_vidc_get_encoder_internal_buffer_sizes(struct msm_vidc_inst *inst) struct v4l2_format *f; if (!inst) { - dprintk(VIDC_ERR, "Instance is null!"); + d_vpr_e("%s: Instance is null!", __func__); return -EINVAL; } @@ -519,7 +519,7 @@ int msm_vidc_get_encoder_internal_buffer_sizes(struct msm_vidc_inst *inst) enc_calculators = &vp8e_calculators; break; default: - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Invalid pix format. Internal buffer cal not defined : %x ", f->fmt.pix_mp.pixelformat); return -EINVAL; @@ -531,8 +531,7 @@ int msm_vidc_get_encoder_internal_buffer_sizes(struct msm_vidc_inst *inst) bframe = get_ctrl(inst, V4L2_CID_MPEG_VIDEO_B_FRAMES); num_bframes = bframe->val; if (num_bframes < 0) { - dprintk(VIDC_ERR, - "%s: get num bframe failed\n", __func__); + s_vpr_e(inst->sid, "%s: get num bframe failed\n", __func__); return -EINVAL; } @@ -583,7 +582,7 @@ int msm_vidc_get_encoder_internal_buffer_sizes(struct msm_vidc_inst *inst) int msm_vidc_calculate_internal_buffer_sizes(struct msm_vidc_inst *inst) { if (!inst) { - dprintk(VIDC_ERR, "Instance is null!"); + d_vpr_e("%s: Instance is null!", __func__); return -EINVAL; } @@ -617,7 +616,7 @@ int msm_vidc_calculate_input_buffer_count(struct msm_vidc_inst *inst) int extra_buff_count = 0; if (!inst) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } fmt = &inst->fmts[INPUT_PORT]; @@ -641,9 +640,9 @@ int msm_vidc_calculate_input_buffer_count(struct msm_vidc_inst *inst) fmt->count_min_host = fmt->count_actual = fmt->count_min + extra_buff_count; - dprintk(VIDC_HIGH, "%s: %x : input min %d min_host %d actual %d\n", - __func__, hash32_ptr(inst->session), - fmt->count_min, fmt->count_min_host, fmt->count_actual); + s_vpr_h(inst->sid, "%s: input min %d min_host %d actual %d\n", + __func__, fmt->count_min, + fmt->count_min_host, fmt->count_actual); return 0; } @@ -655,7 +654,7 @@ int msm_vidc_calculate_output_buffer_count(struct msm_vidc_inst *inst) u32 codec, output_min_count; if (!inst) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } fmt = &inst->fmts[OUTPUT_PORT]; @@ -697,9 +696,9 @@ int msm_vidc_calculate_output_buffer_count(struct msm_vidc_inst *inst) fmt->count_min_host = fmt->count_actual = fmt->count_min + extra_buff_count; - dprintk(VIDC_HIGH, "%s: %x : output min %d min_host %d actual %d\n", - __func__, hash32_ptr(inst->session), - fmt->count_min, fmt->count_min_host, fmt->count_actual); + s_vpr_h(inst->sid, "%s: output min %d min_host %d actual %d\n", + __func__, fmt->count_min, fmt->count_min_host, + fmt->count_actual); return 0; } @@ -722,7 +721,7 @@ int msm_vidc_get_extra_buff_count(struct msm_vidc_inst *inst, enum hal_buffer buffer_type) { if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s Invalid args\n", __func__); + d_vpr_e("%s: Invalid args\n", __func__); return 0; } @@ -744,7 +743,7 @@ static int msm_vidc_get_extra_input_buff_count(struct msm_vidc_inst *inst) struct v4l2_format *f; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } @@ -820,7 +819,7 @@ static int msm_vidc_get_extra_output_buff_count(struct msm_vidc_inst *inst) struct v4l2_format *f; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } @@ -914,10 +913,10 @@ u32 msm_vidc_calculate_dec_input_frame_size(struct msm_vidc_inst *inst) if (inst->buffer_size_limit && (inst->buffer_size_limit < frame_size)) { frame_size = inst->buffer_size_limit; - dprintk(VIDC_HIGH, "input buffer size limited to %d\n", + s_vpr_h(inst->sid, "input buffer size limited to %d\n", frame_size); } else { - dprintk(VIDC_HIGH, "set input buffer size to %d\n", + s_vpr_h(inst->sid, "set input buffer size to %d\n", frame_size); } @@ -930,7 +929,8 @@ u32 msm_vidc_calculate_dec_output_frame_size(struct msm_vidc_inst *inst) struct v4l2_format *f; f = &inst->fmts[OUTPUT_PORT].v4l2_fmt; - hfi_fmt = msm_comm_convert_color_fmt(f->fmt.pix_mp.pixelformat); + hfi_fmt = msm_comm_convert_color_fmt(f->fmt.pix_mp.pixelformat, + inst->sid); return VENUS_BUFFER_SIZE(hfi_fmt, f->fmt.pix_mp.width, f->fmt.pix_mp.height); } @@ -949,7 +949,8 @@ u32 msm_vidc_calculate_enc_input_frame_size(struct msm_vidc_inst *inst) struct v4l2_format *f; f = &inst->fmts[INPUT_PORT].v4l2_fmt; - hfi_fmt = msm_comm_convert_color_fmt(f->fmt.pix_mp.pixelformat); + hfi_fmt = msm_comm_convert_color_fmt(f->fmt.pix_mp.pixelformat, + inst->sid); return VENUS_BUFFER_SIZE(hfi_fmt, f->fmt.pix_mp.width, f->fmt.pix_mp.height); } diff --git a/msm/vidc/msm_vidc_bus.h b/msm/vidc/msm_vidc_bus.h index ea25ba1c25e0..07a5371df699 100644 --- a/msm/vidc/msm_vidc_bus.h +++ b/msm/vidc/msm_vidc_bus.h @@ -224,7 +224,7 @@ int calc_bw_iris2(struct vidc_bus_vote_data *vidc_data); struct lut const *__lut(int width, int height, int fps); fp_t __compression_ratio(struct lut const *entry, int bpp); -void __dump(struct dump dump[], int len); +void __dump(struct dump dump[], int len, u32 sid); static inline bool __ubwc(enum hal_uncompressed_format f) { @@ -237,7 +237,7 @@ static inline bool __ubwc(enum hal_uncompressed_format f) } } -static inline int __bpp(enum hal_uncompressed_format f) +static inline int __bpp(enum hal_uncompressed_format f, u32 sid) { switch (f) { case HAL_COLOR_FORMAT_NV12: @@ -248,8 +248,7 @@ static inline int __bpp(enum hal_uncompressed_format f) case HAL_COLOR_FORMAT_P010: return 10; default: - dprintk(VIDC_ERR, - "Unsupported colorformat (%x)", f); + s_vpr_e(sid, "Unsupported colorformat (%x)", f); return INT_MAX; } } diff --git a/msm/vidc/msm_vidc_bus_iris1.c b/msm/vidc/msm_vidc_bus_iris1.c index a141b3dfbc85..91c1f6f2ec69 100644 --- a/msm/vidc/msm_vidc_bus_iris1.c +++ b/msm/vidc/msm_vidc_bus_iris1.c @@ -31,7 +31,7 @@ fp_t __compression_ratio(struct lut const *entry, int bpp) return FP_ZERO; /* impossible */ } -void __dump(struct dump dump[], int len) +void __dump(struct dump dump[], int len, u32 sid) { int c = 0; @@ -64,7 +64,7 @@ void __dump(struct dump dump[], int len) } } - dprintk(VIDC_BUS, "%s", formatted_line); + s_vpr_b(sid, "%s", formatted_line); } } @@ -128,7 +128,8 @@ static unsigned long __calculate_decoder(struct vidc_bus_vote_data *d) lcu_size = d->lcu_size; - dpb_bpp = d->num_formats >= 1 ? __bpp(d->color_formats[0]) : INT_MAX; + dpb_bpp = d->num_formats >= 1 ? + __bpp(d->color_formats[0], d->sid) : INT_MAX; unified_dpb_opb = d->num_formats == 1; @@ -315,7 +316,7 @@ static unsigned long __calculate_decoder(struct vidc_bus_vote_data *d) {"llc line buffer write", DUMP_FP_FMT, llc.line_buffer_write}, }; - __dump(dump, ARRAY_SIZE(dump)); + __dump(dump, ARRAY_SIZE(dump), d->sid); } d->calc_bw_ddr = kbps(fp_round(ddr.total)); @@ -403,7 +404,8 @@ static unsigned long __calculate_encoder(struct vidc_bus_vote_data *d) original_color_format = d->num_formats >= 1 ? d->color_formats[0] : HAL_UNUSED_COLOR; - dpb_bpp = d->num_formats >= 1 ? __bpp(d->color_formats[0]) : INT_MAX; + dpb_bpp = d->num_formats >= 1 ? + __bpp(d->color_formats[0], d->sid) : INT_MAX; original_compression_enabled = __ubwc(original_color_format); @@ -603,7 +605,7 @@ static unsigned long __calculate_encoder(struct vidc_bus_vote_data *d) {"llc ref read crcb", DUMP_FP_FMT, llc.ref_read_crcb}, {"llc line buffer", DUMP_FP_FMT, llc.line_buffer}, }; - __dump(dump, ARRAY_SIZE(dump)); + __dump(dump, ARRAY_SIZE(dump), d->sid); } d->calc_bw_ddr = kbps(fp_round(ddr.total)); @@ -630,7 +632,7 @@ static unsigned long __calculate(struct vidc_bus_vote_data *d) value = __calculate_cvp(d); break; default: - dprintk(VIDC_ERR, "Unknown Domain"); + s_vpr_e(d->sid, "Unknown Domain %#x", d->domain); } return value; diff --git a/msm/vidc/msm_vidc_bus_iris2.c b/msm/vidc/msm_vidc_bus_iris2.c index d18b4a258865..0da868b57612 100644 --- a/msm/vidc/msm_vidc_bus_iris2.c +++ b/msm/vidc/msm_vidc_bus_iris2.c @@ -66,7 +66,7 @@ static unsigned long __calculate_decoder(struct vidc_bus_vote_data *d) lcu_size = d->lcu_size; - dpb_bpp = __bpp(d->color_formats[0]); + dpb_bpp = __bpp(d->color_formats[0], d->sid); unified_dpb_opb = d->num_formats == 1; @@ -245,7 +245,7 @@ static unsigned long __calculate_decoder(struct vidc_bus_vote_data *d) {"llc line buffer write", DUMP_FP_FMT, llc.line_buffer_write}, }; - __dump(dump, ARRAY_SIZE(dump)); + __dump(dump, ARRAY_SIZE(dump), d->sid); } d->calc_bw_ddr = kbps(fp_round(ddr.total)); @@ -329,7 +329,7 @@ static unsigned long __calculate_encoder(struct vidc_bus_vote_data *d) DIV_ROUND_UP(height, lcu_size); tnbr_per_lcu = 16; - dpb_bpp = __bpp(d->color_formats[0]); + dpb_bpp = __bpp(d->color_formats[0], d->sid); y_bw_no_ubwc_8bpp = fp_div(FP_INT(width * height * fps), FP_INT(1000 * 1000)); @@ -507,7 +507,7 @@ static unsigned long __calculate_encoder(struct vidc_bus_vote_data *d) {"llc ref read crcb", DUMP_FP_FMT, llc.ref_read_crcb}, {"llc line buffer", DUMP_FP_FMT, llc.line_buffer}, }; - __dump(dump, ARRAY_SIZE(dump)); + __dump(dump, ARRAY_SIZE(dump), d->sid); } d->calc_bw_ddr = kbps(fp_round(ddr.total)); @@ -534,7 +534,7 @@ static unsigned long __calculate(struct vidc_bus_vote_data *d) value = __calculate_cvp(d); break; default: - dprintk(VIDC_ERR, "Unknown Domain"); + s_vpr_e(d->sid, "Unknown Domain %#x", d->domain); } return value; diff --git a/msm/vidc/msm_vidc_clocks.c b/msm/vidc/msm_vidc_clocks.c index fc262a771ceb..b30a21285186 100644 --- a/msm/vidc/msm_vidc_clocks.c +++ b/msm/vidc/msm_vidc_clocks.c @@ -242,15 +242,15 @@ static int fill_dynamic_stats(struct msm_vidc_inst *inst, vote_data->complexity_factor = max_cf; vote_data->input_cr = min_input_cr; - dprintk(VIDC_PERF, + s_vpr_p(inst->sid, "Input CR = %d Recon CR = %d Complexity Factor = %d\n", - vote_data->input_cr, vote_data->compression_ratio, - vote_data->complexity_factor); + vote_data->input_cr, vote_data->compression_ratio, + vote_data->complexity_factor); return 0; } -int msm_comm_set_buses(struct msm_vidc_core *core) +int msm_comm_set_buses(struct msm_vidc_core *core, u32 sid) { int rc = 0; struct msm_vidc_inst *inst = NULL; @@ -258,7 +258,7 @@ int msm_comm_set_buses(struct msm_vidc_core *core) unsigned long total_bw_ddr = 0, total_bw_llcc = 0; if (!core || !core->device) { - dprintk(VIDC_ERR, "%s Invalid args: %pK\n", __func__, core); + s_vpr_e(sid, "%s: Invalid args: %pK\n", __func__, core); return -EINVAL; } hdev = core->device; @@ -282,8 +282,7 @@ int msm_comm_set_buses(struct msm_vidc_core *core) if ((!filled_len || !device_addr) && (inst->session_type != MSM_VIDC_CVP)) { - dprintk(VIDC_LOW, "%s: no input for session %x\n", - __func__, hash32_ptr(inst->session)); + s_vpr_l(sid, "%s: no input\n", __func__); continue; } @@ -297,7 +296,7 @@ int msm_comm_set_buses(struct msm_vidc_core *core) mutex_unlock(&core->lock); rc = call_hfi_op(hdev, vote_bus, hdev->hfi_device_data, - total_bw_ddr, total_bw_llcc); + total_bw_ddr, total_bw_llcc, sid); return rc; } @@ -316,7 +315,7 @@ int msm_comm_vote_bus(struct msm_vidc_inst *inst) int codec = 0; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s Invalid args: %pK\n", __func__, inst); + d_vpr_e("%s: Invalid args: %pK\n", __func__, inst); return -EINVAL; } core = inst->core; @@ -339,12 +338,12 @@ int msm_comm_vote_bus(struct msm_vidc_inst *inst) if ((!filled_len || !device_addr) && (inst->session_type != MSM_VIDC_CVP)) { - dprintk(VIDC_LOW, "%s: no input for session %x\n", - __func__, hash32_ptr(inst->session)); + s_vpr_l(inst->sid, "%s: no input\n", __func__); return 0; } - vote_data->domain = get_hal_domain(inst->session_type); + vote_data->sid = inst->sid; + vote_data->domain = get_hal_domain(inst->session_type, inst->sid); vote_data->power_mode = 0; if (inst->clk_data.buffer_counter < DCVS_FTB_WINDOW && inst->session_type != MSM_VIDC_CVP) @@ -369,12 +368,12 @@ int msm_comm_vote_bus(struct msm_vidc_inst *inst) codec = V4L2_PIX_FMT_CVP; break; default: - dprintk(VIDC_ERR, "%s: invalid session_type %#x\n", + s_vpr_e(inst->sid, "%s: invalid session_type %#x\n", __func__, inst->session_type); break; } - vote_data->codec = get_hal_codec(codec); + vote_data->codec = get_hal_codec(codec, inst->sid); vote_data->input_width = inp_f->fmt.pix_mp.width; vote_data->input_height = inp_f->fmt.pix_mp.height; vote_data->output_width = out_f->fmt.pix_mp.width; @@ -426,7 +425,7 @@ int msm_comm_vote_bus(struct msm_vidc_inst *inst) call_core_op(core, calc_bw, vote_data); } - rc = msm_comm_set_buses(core); + rc = msm_comm_set_buses(core, inst->sid); return rc; } @@ -440,12 +439,12 @@ static int msm_dcvs_scale_clocks(struct msm_vidc_inst *inst, struct clock_data *dcvs; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, "%s Invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } if (!inst->clk_data.dcvs_mode || inst->batch.enable) { - dprintk(VIDC_LOW, "Skip DCVS (dcvs %d, batching %d)\n", + s_vpr_l(inst->sid, "Skip DCVS (dcvs %d, batching %d)\n", inst->clk_data.dcvs_mode, inst->batch.enable); inst->clk_data.dcvs_flags = 0; return 0; @@ -491,23 +490,22 @@ static int msm_dcvs_scale_clocks(struct msm_vidc_inst *inst, dcvs->dcvs_flags |= MSM_VIDC_DCVS_DECR; } - dprintk(VIDC_PERF, - "DCVS: %x: bufs_with_fw %d Th[%d %d %d] Flag %#x\n", - hash32_ptr(inst->session), bufs_with_fw, - dcvs->min_threshold, dcvs->nom_threshold, dcvs->max_threshold, + s_vpr_p(inst->sid, "DCVS: bufs_with_fw %d Th[%d %d %d] Flag %#x\n", + bufs_with_fw, dcvs->min_threshold, + dcvs->nom_threshold, dcvs->max_threshold, dcvs->dcvs_flags); return rc; } -static unsigned long msm_vidc_max_freq(struct msm_vidc_core *core) +static unsigned long msm_vidc_max_freq(struct msm_vidc_core *core, u32 sid) { struct allowed_clock_rates_table *allowed_clks_tbl = NULL; unsigned long freq = 0; allowed_clks_tbl = core->resources.allowed_clks_tbl; freq = allowed_clks_tbl[0].clock_rate; - dprintk(VIDC_PERF, "Max rate = %lu\n", freq); + s_vpr_p(sid, "Max rate = %lu\n", freq); return freq; } @@ -542,7 +540,7 @@ void msm_comm_update_input_cr(struct msm_vidc_inst *inst, if (!found) { temp = kzalloc(sizeof(*temp), GFP_KERNEL); if (!temp) { - dprintk(VIDC_ERR, "%s: malloc failure.\n", __func__); + s_vpr_e(inst->sid, "%s: malloc failure.\n", __func__); goto exit; } temp->index = index; @@ -606,14 +604,14 @@ static unsigned long msm_vidc_calc_freq_ar50(struct msm_vidc_inst *inst, vsp_cycles += ((fps * filled_len * 8) * 10) / 7; } else { - dprintk(VIDC_ERR, "Unknown session type = %s\n", __func__); - return msm_vidc_max_freq(inst->core); + s_vpr_e(inst->sid, "%s: Unknown session type\n", __func__); + return msm_vidc_max_freq(inst->core, inst->sid); } freq = max(vpp_cycles, vsp_cycles); freq = max(freq, fw_cycles); - dprintk(VIDC_LOW, "Update DCVS Load\n"); + s_vpr_l(inst->sid, "Update DCVS Load\n"); allowed_clks_tbl = core->resources.allowed_clks_tbl; for (i = core->resources.allowed_clks_tbl_size - 1; i >= 0; i--) { rate = allowed_clks_tbl[i].clock_rate; @@ -624,7 +622,7 @@ static unsigned long msm_vidc_calc_freq_ar50(struct msm_vidc_inst *inst, if (i < 0) i = 0; - dprintk(VIDC_PERF, "%s Inst %pK : Filled Len = %d Freq = %llu\n", + s_vpr_p(inst->sid, "%s: Inst %pK : Filled Len = %d Freq = %llu\n", __func__, inst, filled_len, freq); return (unsigned long) freq; @@ -695,8 +693,8 @@ static unsigned long msm_vidc_calc_freq_iris1(struct msm_vidc_inst *inst, vsp_cycles += ((fps * filled_len * 8) * 10) / 5; } else { - dprintk(VIDC_ERR, "Unknown session type = %s\n", __func__); - return msm_vidc_max_freq(inst->core); + s_vpr_e(inst->sid, "%s: Unknown session type\n", __func__); + return msm_vidc_max_freq(inst->core, inst->sid); } freq = max(vpp_cycles, vsp_cycles); @@ -712,10 +710,8 @@ static unsigned long msm_vidc_calc_freq_iris1(struct msm_vidc_inst *inst, if (i < 0) i = 0; - dprintk(VIDC_PERF, - "%s: inst %pK: %x : filled len %d required freq %llu\n", - __func__, inst, hash32_ptr(inst->session), - filled_len, freq); + s_vpr_p(inst->sid, "%s: inst %pK: filled len %d required freq %llu\n", + __func__, inst, filled_len, freq); return (unsigned long) freq; } @@ -792,8 +788,8 @@ static unsigned long msm_vidc_calc_freq_iris2(struct msm_vidc_inst *inst, /* vsp perf is about 0.5 bits/cycle */ vsp_cycles += ((fps * filled_len * 8) * 10) / 5; } else { - dprintk(VIDC_ERR, "Unknown session type = %s\n", __func__); - return msm_vidc_max_freq(inst->core); + s_vpr_e(inst->sid, "%s: Unknown session type\n", __func__); + return msm_vidc_max_freq(inst->core, inst->sid); } freq = max(vpp_cycles, vsp_cycles); @@ -809,15 +805,13 @@ static unsigned long msm_vidc_calc_freq_iris2(struct msm_vidc_inst *inst, if (i < 0) i = 0; - dprintk(VIDC_PERF, - "%s: inst %pK: %x : filled len %d required freq %llu\n", - __func__, inst, hash32_ptr(inst->session), - filled_len, freq); + s_vpr_p(inst->sid, "%s: inst %pK: filled len %d required freq %llu\n", + __func__, inst, filled_len, freq); return (unsigned long) freq; } -int msm_vidc_set_clocks(struct msm_vidc_core *core) +int msm_vidc_set_clocks(struct msm_vidc_core *core, u32 sid) { struct hfi_device *hdev; unsigned long freq_core_1 = 0, freq_core_2 = 0, rate = 0; @@ -832,8 +826,7 @@ int msm_vidc_set_clocks(struct msm_vidc_core *core) hdev = core->device; allowed_clks_tbl = core->resources.allowed_clks_tbl; if (!allowed_clks_tbl) { - dprintk(VIDC_ERR, - "%s Invalid parameters\n", __func__); + s_vpr_e(sid, "%s: Invalid parameters\n", __func__); return -EINVAL; } @@ -855,8 +848,7 @@ int msm_vidc_set_clocks(struct msm_vidc_core *core) mutex_unlock(&inst->registeredbufs.lock); if (!filled_len || !device_addr) { - dprintk(VIDC_LOW, "%s no input for session %x\n", - __func__, hash32_ptr(inst->session)); + s_vpr_l(sid, "%s: no input\n", __func__); continue; } @@ -872,8 +864,7 @@ int msm_vidc_set_clocks(struct msm_vidc_core *core) freq_core_max = max_t(unsigned long, freq_core_1, freq_core_2); if (msm_vidc_clock_voting) { - dprintk(VIDC_PERF, - "msm_vidc_clock_voting %d\n", + s_vpr_p(sid, "msm_vidc_clock_voting %d\n", msm_vidc_clock_voting); freq_core_max = msm_vidc_clock_voting; decrement = false; @@ -913,12 +904,12 @@ int msm_vidc_set_clocks(struct msm_vidc_core *core) core->curr_freq = rate; mutex_unlock(&core->lock); - dprintk(VIDC_PERF, + s_vpr_p(sid, "%s: clock rate %lu requested %lu increment %d decrement %d\n", __func__, core->curr_freq, core->min_freq, increment, decrement); rc = call_hfi_op(hdev, scale_clocks, - hdev->hfi_device_data, core->curr_freq); + hdev->hfi_device_data, core->curr_freq, sid); return rc; } @@ -932,8 +923,7 @@ int msm_comm_scale_clocks(struct msm_vidc_inst *inst) bool is_turbo = false; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s Invalid args: Inst = %pK\n", - __func__, inst); + d_vpr_e("%s: Invalid args: Inst = %pK\n", __func__, inst); return -EINVAL; } @@ -953,14 +943,14 @@ int msm_comm_scale_clocks(struct msm_vidc_inst *inst) mutex_unlock(&inst->registeredbufs.lock); if (!filled_len || !device_addr) { - dprintk(VIDC_LOW, "%s no input for session %x\n", - __func__, hash32_ptr(inst->session)); + s_vpr_l(inst->sid, "%s: no input\n", __func__); return 0; } if (inst->clk_data.buffer_counter < DCVS_FTB_WINDOW || is_turbo || msm_vidc_clock_voting) { - inst->clk_data.min_freq = msm_vidc_max_freq(inst->core); + inst->clk_data.min_freq = + msm_vidc_max_freq(inst->core, inst->sid); inst->clk_data.dcvs_flags = 0; } else { freq = call_core_op(inst->core, calc_freq, inst, filled_len); @@ -968,8 +958,7 @@ int msm_comm_scale_clocks(struct msm_vidc_inst *inst) /* update dcvs flags */ msm_dcvs_scale_clocks(inst, freq); } - - msm_vidc_set_clocks(inst->core); + msm_vidc_set_clocks(inst->core, inst->sid); return 0; } @@ -980,20 +969,20 @@ int msm_comm_scale_clocks_and_bus(struct msm_vidc_inst *inst, bool do_bw_calc) struct hfi_device *hdev; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, "%s Invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } core = inst->core; hdev = core->device; if (msm_comm_scale_clocks(inst)) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Failed to scale clocks. May impact performance\n"); } if (do_bw_calc) { if (msm_comm_vote_bus(inst)) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Failed to scale DDR bus. May impact perf\n"); } } @@ -1003,7 +992,7 @@ int msm_comm_scale_clocks_and_bus(struct msm_vidc_inst *inst, bool do_bw_calc) int msm_dcvs_try_enable(struct msm_vidc_inst *inst) { if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: Invalid args: %p\n", __func__, inst); + d_vpr_e("%s: Invalid args: %p\n", __func__, inst); return -EINVAL; } @@ -1016,7 +1005,7 @@ int msm_dcvs_try_enable(struct msm_vidc_inst *inst) is_turbo_session(inst) || inst->rc_type == V4L2_MPEG_VIDEO_BITRATE_MODE_CQ); - dprintk(VIDC_HIGH|VIDC_PERF, "DCVS %s: %pK\n", + s_vpr_hp(inst->sid, "DCVS %s: %pK\n", inst->clk_data.dcvs_mode ? "enabled" : "disabled", inst); return 0; @@ -1028,13 +1017,13 @@ int msm_comm_init_clocks_and_bus_data(struct msm_vidc_inst *inst) int fourcc, count; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s Invalid args: Inst = %pK\n", + d_vpr_e("%s: Invalid args: Inst = %pK\n", __func__, inst); return -EINVAL; } if (inst->session_type == MSM_VIDC_CVP) { - dprintk(VIDC_LOW, "%s: cvp session\n", __func__); + s_vpr_l(inst->sid, "%s: cvp session\n", __func__); return 0; } @@ -1053,7 +1042,7 @@ int msm_comm_init_clocks_and_bus_data(struct msm_vidc_inst *inst) } if (!inst->clk_data.entry) { - dprintk(VIDC_ERR, "%s No match found\n", __func__); + s_vpr_e(inst->sid, "%s: No match found\n", __func__); rc = -EINVAL; } @@ -1070,13 +1059,12 @@ void msm_clock_data_reset(struct msm_vidc_inst *inst) struct clock_data *dcvs; struct msm_vidc_format *fmt; - dprintk(VIDC_HIGH, "Init DCVS Load\n"); - if (!inst || !inst->core || !inst->clk_data.entry) { - dprintk(VIDC_ERR, "%s Invalid args: Inst = %pK\n", + d_vpr_e("%s: Invalid args: Inst = %pK\n", __func__, inst); return; } + s_vpr_h(inst->sid, "Init DCVS Load\n"); core = inst->core; dcvs = &inst->clk_data; @@ -1092,7 +1080,7 @@ void msm_clock_data_reset(struct msm_vidc_inst *inst) } else if (inst->session_type == MSM_VIDC_DECODER) { fmt = &inst->fmts[OUTPUT_PORT]; } else { - dprintk(VIDC_ERR, "%s: invalid session type %#x\n", + s_vpr_e(inst->sid, "%s: invalid session type %#x\n", __func__, inst->session_type); return; } @@ -1124,7 +1112,7 @@ void msm_clock_data_reset(struct msm_vidc_inst *inst) rc = msm_comm_scale_clocks_and_bus(inst, 1); if (rc) - dprintk(VIDC_ERR, "%s Failed to scale Clocks and Bus\n", + s_vpr_e(inst->sid, "%s: Failed to scale Clocks and Bus\n", __func__); } @@ -1137,8 +1125,7 @@ int msm_vidc_decide_work_route_iris1(struct msm_vidc_inst *inst) u32 codec; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, - "%s Invalid args: Inst = %pK\n", + d_vpr_e("%s: Invalid args: Inst = %pK\n", __func__, inst); return -EINVAL; } @@ -1188,7 +1175,7 @@ int msm_vidc_decide_work_route_iris1(struct msm_vidc_inst *inst) V4L2_MPEG_VIDEO_BITRATE_MODE_CBR_VFR && mbps <= CBR_VFR_MB_LIMIT)) { pdata.video_work_route = 1; - dprintk(VIDC_HIGH, "Configured work route = 1"); + s_vpr_h(inst->sid, "Configured work route = 1"); } } else { return -EINVAL; @@ -1201,8 +1188,7 @@ decision_done: (void *)inst->session, HFI_PROPERTY_PARAM_WORK_ROUTE, (void *)&pdata, sizeof(pdata)); if (rc) - dprintk(VIDC_ERR, - " Failed to configure work route %pK\n", inst); + s_vpr_e(inst->sid, "Failed to configure work route\n"); return rc; } @@ -1216,8 +1202,7 @@ int msm_vidc_decide_work_route_iris2(struct msm_vidc_inst *inst) u32 codec; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, - "%s Invalid args: Inst = %pK\n", + d_vpr_e("%s: Invalid args: Inst = %pK\n", __func__, inst); return -EINVAL; } @@ -1249,15 +1234,14 @@ int msm_vidc_decide_work_route_iris2(struct msm_vidc_inst *inst) return -EINVAL; } - dprintk(VIDC_HIGH, "Configurng work route = %u", + s_vpr_h(inst->sid, "Configurng work route = %u", pdata.video_work_route); rc = call_hfi_op(hdev, session_set_property, (void *)inst->session, HFI_PROPERTY_PARAM_WORK_ROUTE, (void *)&pdata, sizeof(pdata)); if (rc) - dprintk(VIDC_ERR, - " Failed to configure work route %pK\n", inst); + s_vpr_e(inst->sid, "Failed to configure work route\n"); else inst->clk_data.work_route = pdata.video_work_route; @@ -1273,8 +1257,7 @@ static int msm_vidc_decide_work_mode_ar50(struct msm_vidc_inst *inst) struct v4l2_format *f; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, - "%s Invalid args: Inst = %pK\n", + d_vpr_e("%s: Invalid args: Inst = %pK\n", __func__, inst); return -EINVAL; } @@ -1312,8 +1295,7 @@ decision_done: (void *)inst->session, HFI_PROPERTY_PARAM_WORK_MODE, (void *)&pdata, sizeof(pdata)); if (rc) - dprintk(VIDC_ERR, - " Failed to configure Work Mode %pK\n", inst); + s_vpr_e(inst->sid, "Failed to configure Work Mode\n"); /* For WORK_MODE_1, set Low Latency mode by default to HW. */ @@ -1342,8 +1324,7 @@ int msm_vidc_decide_work_mode_iris1(struct msm_vidc_inst *inst) u32 codec; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, - "%s Invalid args: Inst = %pK\n", + d_vpr_e("%s: Invalid args: Inst = %pK\n", __func__, inst); return -EINVAL; } @@ -1352,7 +1333,7 @@ int msm_vidc_decide_work_mode_iris1(struct msm_vidc_inst *inst) if (inst->clk_data.low_latency_mode) { pdata.video_work_mode = HFI_WORKMODE_1; - dprintk(VIDC_HIGH, "Configured work mode = 1"); + s_vpr_h(inst->sid, "Configured work mode = 1"); goto decision_done; } @@ -1396,8 +1377,8 @@ decision_done: (void *)inst->session, HFI_PROPERTY_PARAM_WORK_MODE, (void *)&pdata, sizeof(pdata)); if (rc) - dprintk(VIDC_ERR, - " Failed to configure Work Mode %pK\n", inst); + s_vpr_e(inst->sid, "Failed to configure Work Mode %u\n", + pdata.video_work_mode); /* For WORK_MODE_1, set Low Latency mode by default to HW. */ @@ -1425,8 +1406,7 @@ int msm_vidc_decide_work_mode_iris2(struct msm_vidc_inst *inst) struct v4l2_format *inp_f; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, - "%s Invalid args: Inst = %pK\n", + d_vpr_e("%s: Invalid args: Inst = %pK\n", __func__, inst); return -EINVAL; } @@ -1464,7 +1444,7 @@ int msm_vidc_decide_work_mode_iris2(struct msm_vidc_inst *inst) return -EINVAL; } - dprintk(VIDC_HIGH, "Configuring work mode = %u low latency = %u", + s_vpr_h(inst->sid, "Configuring work mode = %u low latency = %u", pdata.video_work_mode, latency.enable); @@ -1474,8 +1454,7 @@ int msm_vidc_decide_work_mode_iris2(struct msm_vidc_inst *inst) HFI_PROPERTY_PARAM_VENC_LOW_LATENCY_MODE, (void *)&latency, sizeof(latency)); if (rc) - dprintk(VIDC_ERR, - " Failed to configure low latency %pK\n", inst); + s_vpr_e(inst->sid, "Failed to configure low latency\n"); else inst->clk_data.low_latency_mode = latency.enable; } @@ -1484,8 +1463,7 @@ int msm_vidc_decide_work_mode_iris2(struct msm_vidc_inst *inst) (void *)inst->session, HFI_PROPERTY_PARAM_WORK_MODE, (void *)&pdata, sizeof(pdata)); if (rc) - dprintk(VIDC_ERR, - " Failed to configure Work Mode %pK\n", inst); + s_vpr_e(inst->sid, "Failed to configure Work Mode\n"); else inst->clk_data.work_mode = pdata.video_work_mode; @@ -1503,9 +1481,9 @@ static inline int msm_vidc_power_save_mode_enable(struct msm_vidc_inst *inst, hdev = inst->core->device; if (inst->session_type != MSM_VIDC_ENCODER) { - dprintk(VIDC_LOW, - "%s : Not an encoder session. Nothing to do\n", - __func__); + s_vpr_l(inst->sid, + "%s: Not an encoder session. Nothing to do\n", + __func__); return 0; } @@ -1517,8 +1495,7 @@ static inline int msm_vidc_power_save_mode_enable(struct msm_vidc_inst *inst, (void *)inst->session, prop_id, pdata, sizeof(hfi_perf_mode)); if (rc) { - dprintk(VIDC_ERR, - "%s: Failed to set power save mode for inst: %pK\n", + s_vpr_e(inst->sid, "%s: Failed to set power save mode\n", __func__, inst); return rc; } @@ -1526,18 +1503,18 @@ static inline int msm_vidc_power_save_mode_enable(struct msm_vidc_inst *inst, inst->flags | VIDC_LOW_POWER : inst->flags & ~VIDC_LOW_POWER; - dprintk(VIDC_HIGH, + s_vpr_h(inst->sid, "Power Save Mode for inst: %pK Enable = %d\n", inst, enable); return rc; } static int msm_vidc_move_core_to_power_save_mode(struct msm_vidc_core *core, - u32 core_id) + u32 core_id, u32 sid) { struct msm_vidc_inst *inst = NULL; - dprintk(VIDC_HIGH, "Core %d : Moving all inst to LP mode\n", core_id); + s_vpr_h(sid, "Core %d : Moving all inst to LP mode\n", core_id); mutex_lock(&core->lock); list_for_each_entry(inst, &core->instances, list) { if (inst->clk_data.core_id == core_id && @@ -1599,14 +1576,13 @@ int msm_vidc_decide_core_and_power_mode_iris1(struct msm_vidc_inst *inst) struct msm_vidc_core *core; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, - "%s Invalid args: Inst = %pK\n", + d_vpr_e("%s: Invalid args: Inst = %pK\n", __func__, inst); return -EINVAL; } core = inst->core; - max_freq = msm_vidc_max_freq(inst->core); + max_freq = msm_vidc_max_freq(inst->core, inst->sid); inst->clk_data.core_id = 0; core_load = get_core_load(core, VIDC_CORE_ID_1, false, true); @@ -1627,15 +1603,15 @@ int msm_vidc_decide_core_and_power_mode_iris1(struct msm_vidc_inst *inst) max_hq_mbpf = core->resources.max_hq_mbs_per_frame; max_hq_mbps = core->resources.max_hq_mbs_per_sec; - dprintk(VIDC_HIGH, "Core RT Load = %d LP Load = %d\n", + s_vpr_h(inst->sid, "Core RT Load = %d LP Load = %d\n", core_load, core_lp_load); - dprintk(VIDC_HIGH, "Max Load = %lu\n", max_freq); - dprintk(VIDC_HIGH, "Current Load = %d Current LP Load = %d\n", + s_vpr_h(inst->sid, "Max Load = %lu\n", max_freq); + s_vpr_h(inst->sid, "Current Load = %d Current LP Load = %d\n", cur_inst_load, cur_inst_lp_load); if (inst->rc_type == V4L2_MPEG_VIDEO_BITRATE_MODE_CQ && (core_load > max_freq || core_lp_load > max_freq)) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "CQ session - Core cannot support this load\n"); return -EINVAL; } @@ -1647,16 +1623,17 @@ int msm_vidc_decide_core_and_power_mode_iris1(struct msm_vidc_inst *inst) } else if (cur_inst_lp_load + core_load <= max_freq) { msm_vidc_power_save_mode_enable(inst, true); } else if (cur_inst_lp_load + core_lp_load <= max_freq) { - dprintk(VIDC_HIGH, "Moved all inst's to LP"); - msm_vidc_move_core_to_power_save_mode(core, VIDC_CORE_ID_1); + s_vpr_h(inst->sid, "Moved all inst's to LP"); + msm_vidc_move_core_to_power_save_mode(core, + VIDC_CORE_ID_1, inst->sid); } else { - dprintk(VIDC_ERR, "Core cannot support this load\n"); + s_vpr_e(inst->sid, "Core cannot support this load\n"); return -EINVAL; } inst->clk_data.core_id = VIDC_CORE_ID_1; rc = msm_comm_scale_clocks_and_bus(inst, 1); - msm_print_core_status(core, VIDC_CORE_ID_1); + msm_print_core_status(core, VIDC_CORE_ID_1, inst->sid); return rc; } @@ -1666,7 +1643,7 @@ int msm_vidc_decide_core_and_power_mode_iris2(struct msm_vidc_inst *inst) bool enable = true; inst->clk_data.core_id = VIDC_CORE_ID_1; - msm_print_core_status(inst->core, VIDC_CORE_ID_1); + msm_print_core_status(inst->core, VIDC_CORE_ID_1, inst->sid); /* Power saving always disabled for CQ and LOSSLESS RC modes. */ mbpf = msm_vidc_get_mbs_per_frame(inst); @@ -1696,22 +1673,21 @@ void msm_vidc_init_core_clk_ops(struct msm_vidc_core *core) core->core_ops = &core_ops_iris2; } -void msm_print_core_status(struct msm_vidc_core *core, u32 core_id) +void msm_print_core_status(struct msm_vidc_core *core, u32 core_id, u32 sid) { struct msm_vidc_inst *inst = NULL; struct v4l2_format *out_f; struct v4l2_format *inp_f; - dprintk(VIDC_PERF, "Instances running on core %u", core_id); + s_vpr_p(sid, "Instances running on core %u", core_id); mutex_lock(&core->lock); list_for_each_entry(inst, &core->instances, list) { - if ((inst->clk_data.core_id != core_id) && (inst->clk_data.core_id != VIDC_CORE_ID_3)) continue; out_f = &inst->fmts[OUTPUT_PORT].v4l2_fmt; inp_f = &inst->fmts[INPUT_PORT].v4l2_fmt; - dprintk(VIDC_PERF, + s_vpr_p(sid, "inst %pK (%4ux%4u) to (%4ux%4u) %3u %s %s %u %s %s %lu\n", inst, inp_f->fmt.pix_mp.width, diff --git a/msm/vidc/msm_vidc_clocks.h b/msm/vidc/msm_vidc_clocks.h index c9b463637e77..7a2be7e613b1 100644 --- a/msm/vidc/msm_vidc_clocks.h +++ b/msm/vidc/msm_vidc_clocks.h @@ -8,7 +8,7 @@ #include "msm_vidc_internal.h" void msm_clock_data_reset(struct msm_vidc_inst *inst); -int msm_vidc_set_clocks(struct msm_vidc_core *core); +int msm_vidc_set_clocks(struct msm_vidc_core *core, u32 sid); int msm_comm_vote_bus(struct msm_vidc_inst *inst); int msm_dcvs_try_enable(struct msm_vidc_inst *inst); bool res_is_less_than(u32 width, u32 height, u32 ref_width, u32 ref_height); @@ -27,7 +27,7 @@ int msm_vidc_decide_work_route_iris2(struct msm_vidc_inst *inst); int msm_vidc_decide_work_mode_iris2(struct msm_vidc_inst *inst); int msm_vidc_decide_core_and_power_mode_iris1(struct msm_vidc_inst *inst); int msm_vidc_decide_core_and_power_mode_iris2(struct msm_vidc_inst *inst); -void msm_print_core_status(struct msm_vidc_core *core, u32 core_id); +void msm_print_core_status(struct msm_vidc_core *core, u32 core_id, u32 sid); void msm_comm_free_input_cr_table(struct msm_vidc_inst *inst); void msm_comm_update_input_cr(struct msm_vidc_inst *inst, u32 index, u32 cr); diff --git a/msm/vidc/msm_vidc_common.c b/msm/vidc/msm_vidc_common.c index 4a3e6e56d341..d1f57b0e8700 100644 --- a/msm/vidc/msm_vidc_common.c +++ b/msm/vidc/msm_vidc_common.c @@ -43,7 +43,7 @@ int msm_comm_g_ctrl_for_id(struct msm_vidc_inst *inst, int id) return ctrl->val; } -int msm_comm_hfi_to_v4l2(int id, int value) +int msm_comm_hfi_to_v4l2(int id, int value, u32 sid) { switch (id) { /* H264 */ @@ -245,11 +245,11 @@ int msm_comm_hfi_to_v4l2(int id, int value) } unknown_value: - dprintk(VIDC_ERR, "Unknown control (%x, %d)\n", id, value); + s_vpr_e(sid, "Unknown control (%x, %d)\n", id, value); return -EINVAL; } -static int h264_level_v4l2_to_hfi(int value) +static int h264_level_v4l2_to_hfi(int value, u32 sid) { switch (value) { case V4L2_MPEG_VIDEO_H264_LEVEL_1_0: @@ -299,11 +299,11 @@ static int h264_level_v4l2_to_hfi(int value) } unknown_value: - dprintk(VIDC_ERR, "Unknown level (%d)\n", value); + s_vpr_e(sid, "Unknown level (%d)\n", value); return -EINVAL; } -static int hevc_level_v4l2_to_hfi(int value) +static int hevc_level_v4l2_to_hfi(int value, u32 sid) { switch (value) { case V4L2_MPEG_VIDEO_HEVC_LEVEL_1: @@ -339,11 +339,11 @@ static int hevc_level_v4l2_to_hfi(int value) } unknown_value: - dprintk(VIDC_ERR, "Unknown level (%d)\n", value); + s_vpr_e(sid, "Unknown level (%d)\n", value); return -EINVAL; } -static int vp9_level_v4l2_to_hfi(int value) +static int vp9_level_v4l2_to_hfi(int value, u32 sid) { switch (value) { case V4L2_MPEG_VIDC_VIDEO_VP9_LEVEL_1: @@ -377,11 +377,11 @@ static int vp9_level_v4l2_to_hfi(int value) } unknown_value: - dprintk(VIDC_ERR, "Unknown level (%d)\n", value); + s_vpr_e(sid, "Unknown level (%d)\n", value); return -EINVAL; - } -int msm_comm_v4l2_to_hfi(int id, int value) + +int msm_comm_v4l2_to_hfi(int id, int value, u32 sid) { switch (id) { /* H264 */ @@ -405,7 +405,7 @@ int msm_comm_v4l2_to_hfi(int id, int value) return HFI_H264_PROFILE_HIGH; } case V4L2_CID_MPEG_VIDEO_H264_LEVEL: - return h264_level_v4l2_to_hfi(value); + return h264_level_v4l2_to_hfi(value, sid); case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE: switch (value) { case V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CAVLC: @@ -447,7 +447,7 @@ int msm_comm_v4l2_to_hfi(int id, int value) return HFI_VP9_PROFILE_P0; } case V4L2_CID_MPEG_VIDC_VIDEO_VP9_LEVEL: - return vp9_level_v4l2_to_hfi(value); + return vp9_level_v4l2_to_hfi(value, sid); case V4L2_CID_MPEG_VIDEO_HEVC_PROFILE: switch (value) { case V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN: @@ -460,7 +460,7 @@ int msm_comm_v4l2_to_hfi(int id, int value) return HFI_HEVC_PROFILE_MAIN; } case V4L2_CID_MPEG_VIDEO_HEVC_LEVEL: - return hevc_level_v4l2_to_hfi(value); + return hevc_level_v4l2_to_hfi(value, sid); case V4L2_CID_MPEG_VIDEO_HEVC_TIER: switch (value) { case V4L2_MPEG_VIDEO_HEVC_TIER_MAIN: @@ -503,52 +503,52 @@ int msm_comm_v4l2_to_hfi(int id, int value) return HFI_H264_DB_MODE_ALL_BOUNDARY; } } - dprintk(VIDC_ERR, "Unknown control (%x, %d)\n", id, value); + s_vpr_e(sid, "Unknown control (%x, %d)\n", id, value); return -EINVAL; } -int msm_comm_get_v4l2_profile(int fourcc, int profile) +int msm_comm_get_v4l2_profile(int fourcc, int profile, u32 sid) { switch (fourcc) { case V4L2_PIX_FMT_H264: return msm_comm_hfi_to_v4l2( V4L2_CID_MPEG_VIDEO_H264_PROFILE, - profile); + profile, sid); case V4L2_PIX_FMT_HEVC: return msm_comm_hfi_to_v4l2( V4L2_CID_MPEG_VIDEO_HEVC_PROFILE, - profile); + profile, sid); case V4L2_PIX_FMT_VP8: case V4L2_PIX_FMT_VP9: case V4L2_PIX_FMT_MPEG2: return 0; default: - dprintk(VIDC_ERR, "Unknown codec id %x\n", fourcc); + s_vpr_e(sid, "Unknown codec id %x\n", fourcc); return 0; } } -int msm_comm_get_v4l2_level(int fourcc, int level) +int msm_comm_get_v4l2_level(int fourcc, int level, u32 sid) { switch (fourcc) { case V4L2_PIX_FMT_H264: return msm_comm_hfi_to_v4l2( V4L2_CID_MPEG_VIDEO_H264_LEVEL, - level); + level, sid); case V4L2_PIX_FMT_HEVC: level &= ~(0xF << 28); return msm_comm_hfi_to_v4l2( V4L2_CID_MPEG_VIDEO_HEVC_LEVEL, - level); + level, sid); case V4L2_PIX_FMT_VP8: return msm_comm_hfi_to_v4l2( V4L2_CID_MPEG_VIDC_VIDEO_VP8_PROFILE_LEVEL, - level); + level, sid); case V4L2_PIX_FMT_VP9: case V4L2_PIX_FMT_MPEG2: return 0; default: - dprintk(VIDC_ERR, "Unknown codec id %x\n", fourcc); + s_vpr_e(sid, "Unknown codec id %x\n", fourcc); return 0; } } @@ -562,21 +562,21 @@ int msm_comm_ctrl_init(struct msm_vidc_inst *inst, int ret_val = 0; if (!inst || !drv_ctrls || !ctrl_ops || !num_ctrls) { - dprintk(VIDC_ERR, "%s - invalid input\n", __func__); + d_vpr_e("%s: invalid input\n", __func__); return -EINVAL; } inst->ctrls = kcalloc(num_ctrls, sizeof(struct v4l2_ctrl *), GFP_KERNEL); if (!inst->ctrls) { - dprintk(VIDC_ERR, "%s - failed to allocate ctrl\n", __func__); + s_vpr_e(inst->sid, "%s: failed to allocate ctrl\n", __func__); return -ENOMEM; } ret_val = v4l2_ctrl_handler_init(&inst->ctrl_handler, num_ctrls); if (ret_val) { - dprintk(VIDC_ERR, "CTRL ERR: Control handler init failed, %d\n", + s_vpr_e(inst->sid, "Control handler init failed, %d\n", inst->ctrl_handler.error); return ret_val; } @@ -622,14 +622,14 @@ int msm_comm_ctrl_init(struct msm_vidc_inst *inst, } if (!ctrl) { - dprintk(VIDC_ERR, "%s - invalid ctrl %s\n", __func__, + s_vpr_e(inst->sid, "%s: invalid ctrl %s\n", __func__, drv_ctrls[idx].name); return -EINVAL; } ret_val = inst->ctrl_handler.error; if (ret_val) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Error adding ctrl (%s) to ctrl handle, %d\n", drv_ctrls[idx].name, inst->ctrl_handler.error); return ret_val; @@ -646,7 +646,7 @@ int msm_comm_ctrl_init(struct msm_vidc_inst *inst, int msm_comm_ctrl_deinit(struct msm_vidc_inst *inst) { if (!inst) { - dprintk(VIDC_ERR, "%s invalid parameters\n", __func__); + d_vpr_e("%s: invalid parameters\n", __func__); return -EINVAL; } @@ -660,13 +660,12 @@ int msm_comm_set_stream_output_mode(struct msm_vidc_inst *inst, enum multi_stream mode) { if (!inst) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } if (!is_decode_session(inst)) { - dprintk(VIDC_HIGH, "%s: not a decode session %x\n", - __func__, hash32_ptr(inst->session)); + s_vpr_h(inst->sid, "%s: not a decode session\n", __func__); return -EINVAL; } @@ -681,8 +680,7 @@ int msm_comm_set_stream_output_mode(struct msm_vidc_inst *inst, enum multi_stream msm_comm_get_stream_output_mode(struct msm_vidc_inst *inst) { if (!inst) { - dprintk(VIDC_ERR, "%s: invalid params, return default mode\n", - __func__); + d_vpr_e("%s: invalid params\n", __func__); return HAL_VIDEO_DECODER_PRIMARY; } @@ -702,7 +700,7 @@ bool is_single_session(struct msm_vidc_inst *inst, u32 ignore_flags) struct msm_vidc_inst *temp; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return false; } core = inst->core; @@ -732,7 +730,7 @@ int msm_comm_get_num_perf_sessions(struct msm_vidc_inst *inst) struct msm_vidc_inst *temp; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); goto exit; } core = inst->core; @@ -832,7 +830,7 @@ int msm_comm_get_device_load(struct msm_vidc_core *core, int num_mbs_per_sec = 0; if (!core) { - dprintk(VIDC_ERR, "Invalid args: %pK\n", core); + d_vpr_e("Invalid args: %pK\n", core); return -EINVAL; } @@ -848,7 +846,7 @@ int msm_comm_get_device_load(struct msm_vidc_core *core, return num_mbs_per_sec; } -enum hal_domain get_hal_domain(int session_type) +enum hal_domain get_hal_domain(int session_type, u32 sid) { enum hal_domain domain; @@ -863,7 +861,7 @@ enum hal_domain get_hal_domain(int session_type) domain = HAL_VIDEO_DOMAIN_CVP; break; default: - dprintk(VIDC_ERR, "Wrong domain %d\n", session_type); + s_vpr_e(sid, "Wrong domain %d\n", session_type); domain = HAL_UNUSED_DOMAIN; break; } @@ -871,7 +869,7 @@ enum hal_domain get_hal_domain(int session_type) return domain; } -enum hal_video_codec get_hal_codec(int fourcc) +enum hal_video_codec get_hal_codec(int fourcc, u32 sid) { enum hal_video_codec codec; @@ -905,7 +903,7 @@ enum hal_video_codec get_hal_codec(int fourcc) codec = HAL_VIDEO_CODEC_CVP; break; default: - dprintk(VIDC_ERR, "Wrong codec: %#x\n", fourcc); + s_vpr_e(sid, "Wrong codec: %#x\n", fourcc); codec = HAL_UNUSED_CODEC; break; } @@ -944,7 +942,7 @@ enum hal_uncompressed_format msm_comm_get_hal_uncompressed(int fourcc) return format; } -u32 msm_comm_get_hfi_uncompressed(int fourcc) +u32 msm_comm_get_hfi_uncompressed(int fourcc, u32 sid) { u32 format; @@ -969,7 +967,7 @@ u32 msm_comm_get_hfi_uncompressed(int fourcc) break; default: format = HFI_COLOR_FORMAT_NV12_UBWC; - dprintk(VIDC_ERR, "Invalid format, defaulting to UBWC"); + s_vpr_e(sid, "Invalid format, defaulting to UBWC"); break; } @@ -981,7 +979,7 @@ struct msm_vidc_core *get_vidc_core(int core_id) int found = 0; if (core_id > MSM_VIDC_CORES_MAX) { - dprintk(VIDC_ERR, "Core id = %d is greater than max = %d\n", + d_vpr_e("Core id = %d is greater than max = %d\n", core_id, MSM_VIDC_CORES_MAX); return NULL; } @@ -999,13 +997,13 @@ struct msm_vidc_core *get_vidc_core(int core_id) } const struct msm_vidc_format_desc *msm_comm_get_pixel_fmt_index( - const struct msm_vidc_format_desc fmt[], int size, int index) + const struct msm_vidc_format_desc fmt[], int size, int index, u32 sid) { int i, k = 0; if (!fmt || index < 0) { - dprintk(VIDC_ERR, "Invalid inputs, fmt = %pK, index = %d\n", - fmt, index); + s_vpr_e(sid, "Invalid inputs, fmt = %pK, index = %d\n", + fmt, index); return NULL; } for (i = 0; i < size; i++) { @@ -1014,18 +1012,18 @@ const struct msm_vidc_format_desc *msm_comm_get_pixel_fmt_index( k++; } if (i == size) { - dprintk(VIDC_HIGH, "Format not found\n"); + s_vpr_h(sid, "Format not found\n"); return NULL; } return &fmt[i]; } struct msm_vidc_format_desc *msm_comm_get_pixel_fmt_fourcc( - struct msm_vidc_format_desc fmt[], int size, int fourcc) + struct msm_vidc_format_desc fmt[], int size, int fourcc, u32 sid) { int i; if (!fmt) { - dprintk(VIDC_ERR, "Invalid inputs, fmt = %pK\n", fmt); + s_vpr_e(sid, "Invalid inputs, fmt = %pK\n", fmt); return NULL; } for (i = 0; i < size; i++) { @@ -1033,19 +1031,19 @@ struct msm_vidc_format_desc *msm_comm_get_pixel_fmt_fourcc( break; } if (i == size) { - dprintk(VIDC_HIGH, "Format not found\n"); + s_vpr_h(sid, "Format not found\n"); return NULL; } return &fmt[i]; } struct msm_vidc_format_constraint *msm_comm_get_pixel_fmt_constraints( - struct msm_vidc_format_constraint fmt[], int size, int fourcc) + struct msm_vidc_format_constraint fmt[], int size, int fourcc, u32 sid) { int i; if (!fmt) { - dprintk(VIDC_ERR, "Invalid inputs, fmt = %pK\n", fmt); + s_vpr_e(sid, "Invalid inputs, fmt = %pK\n", fmt); return NULL; } for (i = 0; i < size; i++) { @@ -1053,7 +1051,7 @@ struct msm_vidc_format_constraint *msm_comm_get_pixel_fmt_constraints( break; } if (i == size) { - dprintk(VIDC_HIGH, "Format constraint not found.\n"); + s_vpr_h(sid, "Format constraint not found.\n"); return NULL; } return &fmt[i]; @@ -1073,10 +1071,10 @@ static void update_capability(struct msm_vidc_codec_capability *in, struct msm_vidc_capability *capability) { if (!in || !capability) { - dprintk(VIDC_ERR, "%s Invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK %pK\n", + __func__, in, capability); return; } - if (in->capability_type < CAP_MAX) { capability->cap[in->capability_type].capability_type = in->capability_type; @@ -1086,7 +1084,7 @@ static void update_capability(struct msm_vidc_codec_capability *in, capability->cap[in->capability_type].default_value = in->default_value; } else { - dprintk(VIDC_ERR, "%s: invalid capability_type %d\n", + d_vpr_e("%s: invalid capability_type %d\n", __func__, in->capability_type); } } @@ -1098,13 +1096,13 @@ static int msm_vidc_capabilities(struct msm_vidc_core *core) int i, j, num_platform_caps; if (!core || !core->capabilities) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, core); return -EINVAL; } platform_caps = core->resources.codec_caps; num_platform_caps = core->resources.codec_caps_count; - dprintk(VIDC_HIGH, "%s: num caps %d\n", __func__, num_platform_caps); + d_vpr_h("%s: num caps %d\n", __func__, num_platform_caps); /* loop over each platform capability */ for (i = 0; i < num_platform_caps; i++) { /* select matching core codec and update it */ @@ -1129,20 +1127,19 @@ static void handle_sys_init_done(enum hal_command_response cmd, void *data) struct msm_vidc_core *core; if (!IS_HAL_SYS_CMD(cmd)) { - dprintk(VIDC_ERR, "%s - invalid cmd\n", __func__); + d_vpr_e("%s: invalid cmd\n", __func__); return; } if (!response) { - dprintk(VIDC_ERR, - "Failed to get valid response for sys init\n"); + d_vpr_e("Failed to get valid response for sys init\n"); return; } core = get_vidc_core(response->device_id); if (!core) { - dprintk(VIDC_ERR, "Wrong device_id received\n"); + d_vpr_e("Wrong device_id received\n"); return; } - dprintk(VIDC_HIGH, "%s: core %pK\n", __func__, core); + d_vpr_l("handled: SYS_INIT_DONE\n"); complete(&(core->completions[SYS_MSG_INDEX(cmd)])); } @@ -1163,12 +1160,12 @@ void put_inst(struct msm_vidc_inst *inst) } struct msm_vidc_inst *get_inst(struct msm_vidc_core *core, - void *session_id) + void *inst_id) { struct msm_vidc_inst *inst = NULL; bool matches = false; - if (!core || !session_id) + if (!core || !inst_id) return NULL; mutex_lock(&core->lock); @@ -1179,7 +1176,7 @@ struct msm_vidc_inst *get_inst(struct msm_vidc_core *core, * sessions */ list_for_each_entry(inst, &core->instances, list) { - if (inst == session_id) { + if (inst == inst_id) { /* * Even if the instance is valid, we really shouldn't * be receiving or handling callbacks when we've deleted @@ -1213,14 +1210,13 @@ static void handle_session_release_buf_done(enum hal_command_response cmd, u32 address; if (!response) { - dprintk(VIDC_ERR, "Invalid release_buf_done response\n"); + d_vpr_e("Invalid release_buf_done response\n"); return; } - inst = get_inst(get_vidc_core(response->device_id), - response->session_id); + response->inst_id); if (!inst) { - dprintk(VIDC_ERR, "Got a response for an inactive session\n"); + d_vpr_e("Got a response for an inactive session\n"); return; } @@ -1231,7 +1227,7 @@ static void handle_session_release_buf_done(enum hal_command_response cmd, list_for_each_safe(ptr, next, &inst->scratchbufs.list) { buf = list_entry(ptr, struct internal_buf, list); if (address == buf->smem.device_addr) { - dprintk(VIDC_HIGH, "releasing scratch: %x\n", + s_vpr_h(inst->sid, "releasing scratch: %x\n", buf->smem.device_addr); buf_found = true; } @@ -1242,7 +1238,7 @@ static void handle_session_release_buf_done(enum hal_command_response cmd, list_for_each_safe(ptr, next, &inst->persistbufs.list) { buf = list_entry(ptr, struct internal_buf, list); if (address == buf->smem.device_addr) { - dprintk(VIDC_HIGH, "releasing persist: %x\n", + s_vpr_h(inst->sid, "releasing persist: %x\n", buf->smem.device_addr); buf_found = true; } @@ -1250,13 +1246,14 @@ static void handle_session_release_buf_done(enum hal_command_response cmd, mutex_unlock(&inst->persistbufs.lock); if (!buf_found) - dprintk(VIDC_ERR, "invalid buffer received from firmware"); + s_vpr_e(inst->sid, "invalid buffer received from firmware"); if (IS_HAL_SESSION_CMD(cmd)) complete(&inst->completions[SESSION_MSG_INDEX(cmd)]); else - dprintk(VIDC_ERR, "Invalid inst cmd response: %d\n", cmd); + s_vpr_e(inst->sid, "Invalid inst cmd response: %d\n", cmd); put_inst(inst); + s_vpr_l(inst->sid, "handled: SESSION_RELEASE_BUFFER_DONE\n"); } static void handle_sys_release_res_done( @@ -1266,15 +1263,15 @@ static void handle_sys_release_res_done( struct msm_vidc_core *core; if (!response) { - dprintk(VIDC_ERR, - "Failed to get valid response for sys init\n"); + d_vpr_e("Failed to get valid response for sys init\n"); return; } core = get_vidc_core(response->device_id); if (!core) { - dprintk(VIDC_ERR, "Wrong device_id received\n"); + d_vpr_e("Wrong device_id received\n"); return; } + d_vpr_l("handled: SYS_RELEASE_RESOURCE_DONE\n"); complete(&core->completions[ SYS_MSG_INDEX(HAL_SYS_RELEASE_RESOURCE_DONE)]); } @@ -1282,17 +1279,17 @@ static void handle_sys_release_res_done( void change_inst_state(struct msm_vidc_inst *inst, enum instance_state state) { if (!inst) { - dprintk(VIDC_ERR, "Invalid parameter %s\n", __func__); + d_vpr_e("Invalid parameter %s\n", __func__); return; } mutex_lock(&inst->lock); if (inst->state == MSM_VIDC_CORE_INVALID) { - dprintk(VIDC_HIGH, + s_vpr_h(inst->sid, "Inst: %pK is in bad state can't change state to %d\n", inst, state); goto exit; } - dprintk(VIDC_HIGH, "Moved inst: %pK from state: %d to state: %d\n", + s_vpr_h(inst->sid, "Moved inst: %pK from state: %d to state: %d\n", inst, inst->state, state); inst->state = state; exit: @@ -1303,13 +1300,13 @@ static int signal_session_msg_receipt(enum hal_command_response cmd, struct msm_vidc_inst *inst) { if (!inst) { - dprintk(VIDC_ERR, "Invalid(%pK) instance id\n", inst); + d_vpr_e("Invalid(%pK) instance id\n", inst); return -EINVAL; } if (IS_HAL_SESSION_CMD(cmd)) { complete(&inst->completions[SESSION_MSG_INDEX(cmd)]); } else { - dprintk(VIDC_ERR, "Invalid inst cmd response: %d\n", cmd); + s_vpr_e(inst->sid, "Invalid inst cmd response: %d\n", cmd); return -EINVAL; } return 0; @@ -1321,8 +1318,12 @@ static int wait_for_sess_signal_receipt(struct msm_vidc_inst *inst, int rc = 0; struct hfi_device *hdev; + if (!inst) { + d_vpr_e("Invalid(%pK) instance id\n", inst); + return -EINVAL; + } if (!IS_HAL_SESSION_CMD(cmd)) { - dprintk(VIDC_ERR, "Invalid inst cmd response: %d\n", cmd); + s_vpr_e(inst->sid, "Invalid inst cmd response: %d\n", cmd); return -EINVAL; } hdev = (struct hfi_device *)(inst->core->device); @@ -1331,7 +1332,7 @@ static int wait_for_sess_signal_receipt(struct msm_vidc_inst *inst, msecs_to_jiffies( inst->core->resources.msm_vidc_hw_rsp_timeout)); if (!rc) { - dprintk(VIDC_ERR, "Wait interrupted or timed out: %d\n", + s_vpr_e(inst->sid, "Wait interrupted or timed out: %d\n", SESSION_MSG_INDEX(cmd)); msm_comm_kill_session(inst); rc = -EIO; @@ -1348,12 +1349,16 @@ static int wait_for_state(struct msm_vidc_inst *inst, { int rc = 0; + if (!inst) { + d_vpr_e("Invalid parameter %s\n", __func__); + return -EINVAL; + } if (IS_ALREADY_IN_STATE(flipped_state, desired_state)) { - dprintk(VIDC_HIGH, "inst: %pK is already in state: %d\n", + s_vpr_h(inst->sid, "inst: %pK is already in state: %d\n", inst, inst->state); goto err_same_state; } - dprintk(VIDC_HIGH, "Waiting for hal_cmd: %d\n", hal_cmd); + s_vpr_h(inst->sid, "Waiting for hal_cmd: %d\n", hal_cmd); rc = wait_for_sess_signal_receipt(inst, hal_cmd); if (!rc) change_inst_state(inst, desired_state); @@ -1374,20 +1379,19 @@ static void msm_comm_generate_max_clients_error(struct msm_vidc_inst *inst) struct msm_vidc_cb_cmd_done response = {0}; if (!inst) { - dprintk(VIDC_ERR, "%s: invalid input parameters\n", __func__); + d_vpr_e("%s: invalid input parameters\n", __func__); return; } - dprintk(VIDC_ERR, "%s: Too many clients\n", __func__); - response.session_id = inst; + s_vpr_e(inst->sid, "%s: Too many clients\n", __func__); + response.inst_id = inst; response.status = VIDC_ERR_MAX_CLIENTS; handle_session_error(cmd, (void *)&response); } -static void print_cap(const char *type, +static void print_cap(u32 sid, const char *type, struct hal_capability_supported *cap) { - dprintk(VIDC_HIGH, - "%-24s: %-10d %-10d %-10d %-10d\n", + s_vpr_h(sid, "%-24s: %-10d %-10d %-10d %-10d\n", type, cap->min, cap->max, cap->step_size, cap->default_value); } @@ -1399,7 +1403,7 @@ static int msm_vidc_comm_update_ctrl(struct msm_vidc_inst *inst, ctrl = v4l2_ctrl_find(&inst->ctrl_handler, id); if (!ctrl) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: Conrol id %d not found\n", __func__, id); return -EINVAL; } @@ -1407,7 +1411,7 @@ static int msm_vidc_comm_update_ctrl(struct msm_vidc_inst *inst, rc = v4l2_ctrl_modify_range(ctrl, cap->min, cap->max, cap->step_size, cap->default_value); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: failed: control name %s, min %d, max %d, step %d, default_value %d\n", __func__, ctrl->name, cap->min, cap->max, cap->step_size, cap->default_value); @@ -1419,12 +1423,11 @@ static int msm_vidc_comm_update_ctrl(struct msm_vidc_inst *inst, */ rc = v4l2_ctrl_s_ctrl(ctrl, cap->default_value); if (rc) { - dprintk(VIDC_ERR, - "%s: failed s_ctrl: %s with value %d\n", + s_vpr_e(inst->sid, "%s: failed s_ctrl: %s with value %d\n", __func__, ctrl->name, cap->default_value); goto error; } - dprintk(VIDC_HIGH, + s_vpr_h(inst->sid, "Updated control: %s: min %lld, max %lld, step %lld, default value = %lld\n", ctrl->name, ctrl->minimum, ctrl->maximum, ctrl->step, ctrl->default_value); @@ -1439,8 +1442,9 @@ static void msm_vidc_comm_update_ctrl_limits(struct msm_vidc_inst *inst) if (inst->session_type == MSM_VIDC_ENCODER) { f = &inst->fmts[OUTPUT_PORT].v4l2_fmt; - if (get_hal_codec(f->fmt.pix_mp.pixelformat) == - HAL_VIDEO_CODEC_TME) + if (get_hal_codec(f->fmt.pix_mp.pixelformat, + inst->sid) == + HAL_VIDEO_CODEC_TME) return; msm_vidc_comm_update_ctrl(inst, V4L2_CID_MPEG_VIDEO_BITRATE, &inst->capability.cap[CAP_BITRATE]); @@ -1462,29 +1466,25 @@ static void handle_session_init_done(enum hal_command_response cmd, void *data) u32 i, codec; if (!response) { - dprintk(VIDC_ERR, - "Failed to get valid response for session init\n"); + d_vpr_e("Failed to get valid response for session init\n"); return; } inst = get_inst(get_vidc_core(response->device_id), - response->session_id); - + response->inst_id); if (!inst) { - dprintk(VIDC_ERR, "Got a response for an inactive session\n"); + d_vpr_e("Got a response for an inactive session\n"); return; } if (response->status) { - dprintk(VIDC_ERR, - "Session init response from FW : %#x\n", + s_vpr_e(inst->sid, "Session init response from FW: %#x\n", response->status); goto error; } if (inst->session_type == MSM_VIDC_CVP) { - dprintk(VIDC_HIGH, "%s: cvp session %#x\n", - __func__, hash32_ptr(inst->session)); + s_vpr_h(inst->sid, "%s: cvp session\n", __func__); signal_session_msg_receipt(cmd, inst); put_inst(inst); return; @@ -1495,73 +1495,81 @@ static void handle_session_init_done(enum hal_command_response cmd, void *data) for (i = 0; i < core->resources.codecs_count; i++) { if (core->capabilities[i].codec == - get_hal_codec(codec) && + get_hal_codec(codec, inst->sid) && core->capabilities[i].domain == - get_hal_domain(inst->session_type)) { + get_hal_domain(inst->session_type, inst->sid)) { capability = &core->capabilities[i]; break; } } if (!capability) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: capabilities not found for domain %#x codec %#x\n", - __func__, get_hal_domain(inst->session_type), - get_hal_codec(codec)); + __func__, get_hal_domain(inst->session_type, inst->sid), + get_hal_codec(codec, inst->sid)); goto error; } - dprintk(VIDC_HIGH, - "%s: capabilities for domain %#x codec %#x\n", + s_vpr_h(inst->sid, "%s: capabilities for domain %#x codec %#x\n", __func__, capability->domain, capability->codec); memcpy(&inst->capability, capability, sizeof(struct msm_vidc_capability)); - dprintk(VIDC_HIGH, + s_vpr_h(inst->sid, "Capability type : min max step_size default_value\n"); - print_cap("width", &inst->capability.cap[CAP_FRAME_WIDTH]); - print_cap("height", &inst->capability.cap[CAP_FRAME_HEIGHT]); - print_cap("mbs_per_frame", &inst->capability.cap[CAP_MBS_PER_FRAME]); - print_cap("mbs_per_sec", &inst->capability.cap[CAP_MBS_PER_SECOND]); - print_cap("frame_rate", &inst->capability.cap[CAP_FRAMERATE]); - print_cap("bitrate", &inst->capability.cap[CAP_BITRATE]); - print_cap("scale_x", &inst->capability.cap[CAP_SCALE_X]); - print_cap("scale_y", &inst->capability.cap[CAP_SCALE_Y]); - print_cap("hier_p", &inst->capability.cap[CAP_HIER_P_NUM_ENH_LAYERS]); - print_cap("ltr_count", &inst->capability.cap[CAP_LTR_COUNT]); - print_cap("bframe", &inst->capability.cap[CAP_BFRAME]); - print_cap("mbs_per_sec_low_power", + print_cap(inst->sid, "width", &inst->capability.cap[CAP_FRAME_WIDTH]); + print_cap(inst->sid, "height", &inst->capability.cap[CAP_FRAME_HEIGHT]); + print_cap(inst->sid, "mbs_per_frame", + &inst->capability.cap[CAP_MBS_PER_FRAME]); + print_cap(inst->sid, "mbs_per_sec", + &inst->capability.cap[CAP_MBS_PER_SECOND]); + print_cap(inst->sid, "frame_rate", + &inst->capability.cap[CAP_FRAMERATE]); + print_cap(inst->sid, "bitrate", &inst->capability.cap[CAP_BITRATE]); + print_cap(inst->sid, "scale_x", &inst->capability.cap[CAP_SCALE_X]); + print_cap(inst->sid, "scale_y", &inst->capability.cap[CAP_SCALE_Y]); + print_cap(inst->sid, "hier_p", + &inst->capability.cap[CAP_HIER_P_NUM_ENH_LAYERS]); + print_cap(inst->sid, "ltr_count", &inst->capability.cap[CAP_LTR_COUNT]); + print_cap(inst->sid, "bframe", &inst->capability.cap[CAP_BFRAME]); + print_cap(inst->sid, "mbs_per_sec_low_power", &inst->capability.cap[CAP_MBS_PER_SECOND_POWER_SAVE]); - print_cap("i_qp", &inst->capability.cap[CAP_I_FRAME_QP]); - print_cap("p_qp", &inst->capability.cap[CAP_P_FRAME_QP]); - print_cap("b_qp", &inst->capability.cap[CAP_B_FRAME_QP]); - print_cap("slice_bytes", &inst->capability.cap[CAP_SLICE_BYTE]); - print_cap("slice_mbs", &inst->capability.cap[CAP_SLICE_MB]); - print_cap("max_videocores", &inst->capability.cap[CAP_MAX_VIDEOCORES]); + print_cap(inst->sid, "i_qp", &inst->capability.cap[CAP_I_FRAME_QP]); + print_cap(inst->sid, "p_qp", &inst->capability.cap[CAP_P_FRAME_QP]); + print_cap(inst->sid, "b_qp", &inst->capability.cap[CAP_B_FRAME_QP]); + print_cap(inst->sid, "slice_bytes", + &inst->capability.cap[CAP_SLICE_BYTE]); + print_cap(inst->sid, "slice_mbs", &inst->capability.cap[CAP_SLICE_MB]); + print_cap(inst->sid, "max_videocores", + &inst->capability.cap[CAP_MAX_VIDEOCORES]); /* Secure usecase specific */ - print_cap("secure_width", + print_cap(inst->sid, "secure_width", &inst->capability.cap[CAP_SECURE_FRAME_WIDTH]); - print_cap("secure_height", + print_cap(inst->sid, "secure_height", &inst->capability.cap[CAP_SECURE_FRAME_HEIGHT]); - print_cap("secure_mbs_per_frame", + print_cap(inst->sid, "secure_mbs_per_frame", &inst->capability.cap[CAP_SECURE_MBS_PER_FRAME]); - print_cap("secure_bitrate", &inst->capability.cap[CAP_SECURE_BITRATE]); + print_cap(inst->sid, "secure_bitrate", + &inst->capability.cap[CAP_SECURE_BITRATE]); /* Batch Mode Decode */ - print_cap("batch_mbs_per_frame", + print_cap(inst->sid, "batch_mbs_per_frame", &inst->capability.cap[CAP_BATCH_MAX_MB_PER_FRAME]); - print_cap("batch_frame_rate", &inst->capability.cap[CAP_BATCH_MAX_FPS]); + print_cap(inst->sid, "batch_frame_rate", + &inst->capability.cap[CAP_BATCH_MAX_FPS]); /* Lossless encoding usecase specific */ - print_cap("lossless_width", + print_cap(inst->sid, "lossless_width", &inst->capability.cap[CAP_LOSSLESS_FRAME_WIDTH]); - print_cap("lossless_height", + print_cap(inst->sid, "lossless_height", &inst->capability.cap[CAP_LOSSLESS_FRAME_HEIGHT]); - print_cap("lossless_mbs_per_frame", + print_cap(inst->sid, "lossless_mbs_per_frame", &inst->capability.cap[CAP_LOSSLESS_MBS_PER_FRAME]); /* All intra encoding usecase specific */ - print_cap("all_intra_frame_rate", + print_cap(inst->sid, "all_intra_frame_rate", &inst->capability.cap[CAP_ALLINTRA_MAX_FPS]); msm_vidc_comm_update_ctrl_limits(inst); + s_vpr_l(inst->sid, "handled: SESSION_INIT_DONE\n"); signal_session_msg_receipt(cmd, inst); put_inst(inst); return; @@ -1605,14 +1613,14 @@ static void handle_event_change(enum hal_command_response cmd, void *data) u32 codec; if (!event_notify) { - dprintk(VIDC_ERR, "Got an empty event from hfi\n"); + d_vpr_e("Got an empty event from hfi\n"); return; } inst = get_inst(get_vidc_core(event_notify->device_id), - event_notify->session_id); + event_notify->inst_id); if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, "Got a response for an inactive session\n"); + d_vpr_e("Got a response for an inactive session\n"); goto err_bad_event; } hdev = inst->core->device; @@ -1628,11 +1636,10 @@ static void handle_event_change(enum hal_command_response cmd, void *data) */ bool event_fields_changed = false; - dprintk(VIDC_HIGH, "V4L2_EVENT_SEQ_CHANGED_SUFFICIENT\n"); - dprintk(VIDC_HIGH, - "event_notify->height = %d event_notify->width = %d\n", - event_notify->height, - event_notify->width); + s_vpr_h(inst->sid, "seq: V4L2_EVENT_SEQ_CHANGED_SUFFICIENT\n"); + s_vpr_h(inst->sid, + "seq: event_notify->height = %d event_notify->width = %d\n", + event_notify->height, event_notify->width); if (codec == V4L2_PIX_FMT_HEVC || codec == V4L2_PIX_FMT_VP9) event_fields_changed |= (inst->bit_depth != event_notify->bit_depth); @@ -1653,12 +1660,12 @@ static void handle_event_change(enum hal_command_response cmd, void *data) if (event_fields_changed) { event = V4L2_EVENT_SEQ_CHANGED_INSUFFICIENT; } else { - dprintk(VIDC_HIGH, - "No parameter change continue session\n"); + s_vpr_h(inst->sid, + "seq: No parameter change continue session\n"); rc = call_hfi_op(hdev, session_continue, (void *)inst->session); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "failed to send session_continue\n"); } goto err_bad_event; @@ -1673,9 +1680,9 @@ static void handle_event_change(enum hal_command_response cmd, void *data) struct msm_vidc_buffer *mbuf; u32 planes[VIDEO_MAX_PLANES] = {0}; - dprintk(VIDC_LOW, - "%s: inst: %pK data_buffer: %x extradata_buffer: %x\n", - __func__, inst, event_notify->packet_buffer, + s_vpr_l(inst->sid, + "rbr: data_buffer: %x extradata_buffer: %x\n", + event_notify->packet_buffer, event_notify->extra_data_buffer); planes[0] = event_notify->packet_buffer; @@ -1683,7 +1690,7 @@ static void handle_event_change(enum hal_command_response cmd, void *data) mbuf = msm_comm_get_buffer_using_device_planes(inst, OUTPUT_MPLANE, planes); if (!mbuf || !kref_get_mbuf(inst, mbuf)) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: data_addr %x, extradata_addr %x not found\n", __func__, planes[0], planes[1]); } else { @@ -1744,26 +1751,23 @@ static void handle_event_change(enum hal_command_response cmd, void *data) ptr[7] = event_notify->crop_data.height; ptr[8] = event_notify->crop_data.width; ptr[9] = msm_comm_get_v4l2_profile(codec, - event_notify->profile); + event_notify->profile, inst->sid); ptr[10] = msm_comm_get_v4l2_level(codec, - event_notify->level); + event_notify->level, inst->sid); - dprintk(VIDC_HIGH, - "Event payload: height = %u width = %u profile = %u level = %u\n", - event_notify->height, event_notify->width, - ptr[9], ptr[10]); + s_vpr_h(inst->sid, + "seq: height = %u width = %u profile = %u level = %u\n", + event_notify->height, event_notify->width, ptr[9], ptr[10]); - dprintk(VIDC_HIGH, - "Event payload: bit_depth = %u pic_struct = %u colour_space = %u\n", + s_vpr_h(inst->sid, + "seq: bit_depth = %u pic_struct = %u colour_space = %u\n", event_notify->bit_depth, event_notify->pic_struct, - event_notify->colour_space); + event_notify->colour_space); - dprintk(VIDC_HIGH, - "Event payload: CROP top = %u left = %u Height = %u Width = %u\n", - event_notify->crop_data.top, - event_notify->crop_data.left, - event_notify->crop_data.height, - event_notify->crop_data.width); + s_vpr_h(inst->sid, + "seq: CROP top = %u left = %u Height = %u Width = %u\n", + event_notify->crop_data.top, event_notify->crop_data.left, + event_notify->crop_data.height, event_notify->crop_data.width); mutex_lock(&inst->lock); inst->in_reconfig = true; @@ -1778,22 +1782,21 @@ static void handle_event_change(enum hal_command_response cmd, void *data) mutex_unlock(&inst->lock); if (event == V4L2_EVENT_SEQ_CHANGED_INSUFFICIENT) { - dprintk(VIDC_HIGH, "V4L2_EVENT_SEQ_CHANGED_INSUFFICIENT\n"); + s_vpr_h(inst->sid, + "seq: V4L2_EVENT_SEQ_CHANGED_INSUFFICIENT\n"); /* decide batching as configuration changed */ if (inst->batch.enable) inst->batch.enable = is_batching_allowed(inst); - dprintk(VIDC_HIGH|VIDC_PERF, "%s: %x : batching %s\n", - __func__, hash32_ptr(inst->session), + s_vpr_hp(inst->sid, "seq : batching %s\n", __func__, inst->batch.enable ? "enabled" : "disabled"); msm_dcvs_try_enable(inst); extra_buff_count = msm_vidc_get_extra_buff_count(inst, HAL_BUFFER_OUTPUT); fmt->count_min = event_notify->capture_buf_count; fmt->count_min_host = fmt->count_min + extra_buff_count; - dprintk(VIDC_HIGH, - "%s: %x : hal buffer[%d] count: min %d min_host %d\n", - __func__, hash32_ptr(inst->session), + s_vpr_h(inst->sid, + "seq: hal buffer[%d] count: min %d min_host %d\n", HAL_BUFFER_OUTPUT, fmt->count_min, fmt->count_min_host); } @@ -1809,6 +1812,7 @@ static void handle_event_change(enum hal_command_response cmd, void *data) msm_vidc_queue_v4l2_event(inst, V4L2_EVENT_MSM_VIDC_HW_OVERLOAD); } + s_vpr_l(inst->sid, "handled: SESSION_EVENT_CHANGE\n"); err_bad_event: put_inst(inst); @@ -1821,28 +1825,27 @@ static void handle_session_prop_info(enum hal_command_response cmd, void *data) struct msm_vidc_inst *inst; if (!response) { - dprintk(VIDC_ERR, - "Failed to get valid response for prop info\n"); + d_vpr_e("Failed to get valid response for prop info\n"); return; } inst = get_inst(get_vidc_core(response->device_id), - response->session_id); + response->inst_id); if (!inst) { - dprintk(VIDC_ERR, "Got a response for an inactive session\n"); + d_vpr_e("Got a response for an inactive session\n"); return; } getprop = kzalloc(sizeof(*getprop), GFP_KERNEL); if (!getprop) { - dprintk(VIDC_ERR, "%s: getprop kzalloc failed\n", __func__); + s_vpr_e(inst->sid, "%s: getprop kzalloc failed\n", __func__); goto err_prop_info; } getprop->data = kmemdup((void *) (&response->data.property), sizeof(union hal_get_property), GFP_KERNEL); if (!getprop->data) { - dprintk(VIDC_ERR, "%s: kmemdup failed\n", __func__); + s_vpr_e(inst->sid, "%s: kmemdup failed\n", __func__); kfree(getprop); goto err_prop_info; } @@ -1850,8 +1853,9 @@ static void handle_session_prop_info(enum hal_command_response cmd, void *data) mutex_lock(&inst->pending_getpropq.lock); list_add_tail(&getprop->list, &inst->pending_getpropq.list); mutex_unlock(&inst->pending_getpropq.lock); - + s_vpr_l(inst->sid, "handled: SESSION_PROPERTY_INFO\n"); signal_session_msg_receipt(cmd, inst); + err_prop_info: put_inst(inst); } @@ -1862,26 +1866,25 @@ static void handle_load_resource_done(enum hal_command_response cmd, void *data) struct msm_vidc_inst *inst; if (!response) { - dprintk(VIDC_ERR, - "Failed to get valid response for load resource\n"); + d_vpr_e("Failed to get valid response for load resource\n"); return; } inst = get_inst(get_vidc_core(response->device_id), - response->session_id); + response->inst_id); if (!inst) { - dprintk(VIDC_ERR, "Got a response for an inactive session\n"); + d_vpr_e("Got a response for an inactive session\n"); return; } if (response->status) { - dprintk(VIDC_ERR, - "Load resource response from FW : %#x\n", + s_vpr_e(inst->sid, "Load resource response from FW : %#x\n", response->status); msm_comm_generate_session_error(inst); } put_inst(inst); + s_vpr_l(inst->sid, "handled: SESSION_LOAD_RESOURCE_DONE\n"); } static void handle_start_done(enum hal_command_response cmd, void *data) @@ -1890,16 +1893,17 @@ static void handle_start_done(enum hal_command_response cmd, void *data) struct msm_vidc_inst *inst; if (!response) { - dprintk(VIDC_ERR, "Failed to get valid response for start\n"); + d_vpr_e("Failed to get valid response for start\n"); return; } inst = get_inst(get_vidc_core(response->device_id), - response->session_id); + response->inst_id); if (!inst) { - dprintk(VIDC_ERR, "Got a response for an inactive session\n"); + d_vpr_e("Got a response for an inactive session\n"); return; } + s_vpr_l(inst->sid, "handled: SESSION_START_DONE\n"); signal_session_msg_receipt(cmd, inst); put_inst(inst); @@ -1911,17 +1915,18 @@ static void handle_stop_done(enum hal_command_response cmd, void *data) struct msm_vidc_inst *inst; if (!response) { - dprintk(VIDC_ERR, "Failed to get valid response for stop\n"); + d_vpr_e("Failed to get valid response for stop\n"); return; } inst = get_inst(get_vidc_core(response->device_id), - response->session_id); + response->inst_id); if (!inst) { - dprintk(VIDC_ERR, "Got a response for an inactive session\n"); + d_vpr_e("Got a response for an inactive session\n"); return; } + s_vpr_l(inst->sid, "handled: SESSION_STOP_DONE\n"); signal_session_msg_receipt(cmd, inst); put_inst(inst); } @@ -1932,18 +1937,18 @@ static void handle_release_res_done(enum hal_command_response cmd, void *data) struct msm_vidc_inst *inst; if (!response) { - dprintk(VIDC_ERR, - "Failed to get valid response for release resource\n"); + d_vpr_e("Failed to get valid response for release resource\n"); return; } inst = get_inst(get_vidc_core(response->device_id), - response->session_id); + response->inst_id); if (!inst) { - dprintk(VIDC_ERR, "Got a response for an inactive session\n"); + d_vpr_e("Got a response for an inactive session\n"); return; } + s_vpr_l(inst->sid, "handled: SESSION_RELEASE_RESOURCE_DONE\n"); signal_session_msg_receipt(cmd, inst); put_inst(inst); } @@ -1958,15 +1963,14 @@ void msm_comm_validate_output_buffers(struct msm_vidc_inst *inst) mutex_lock(&inst->outputbufs.lock); if (list_empty(&inst->outputbufs.list)) { - dprintk(VIDC_HIGH, "%s: no OUTPUT buffers allocated\n", + s_vpr_h(inst->sid, "%s: no OUTPUT buffers allocated\n", __func__); mutex_unlock(&inst->outputbufs.lock); return; } list_for_each_entry(binfo, &inst->outputbufs.list, list) { if (binfo->buffer_ownership != DRIVER) { - dprintk(VIDC_HIGH, - "This buffer is with FW %x\n", + s_vpr_h(inst->sid, "This buffer is with FW %x\n", binfo->smem.device_addr); continue; } @@ -1976,8 +1980,7 @@ void msm_comm_validate_output_buffers(struct msm_vidc_inst *inst) /* Only minimum number of DPBs are allocated */ if (buffers_owned_by_driver != fmt->count_min) { - dprintk(VIDC_ERR, - "OUTPUT Buffer count mismatch %d of %d\n", + s_vpr_e(inst->sid, "OUTPUT Buffer count mismatch %d of %d\n", buffers_owned_by_driver, fmt->count_min); msm_vidc_handle_hw_error(inst->core); @@ -1992,7 +1995,7 @@ int msm_comm_queue_dpb_only_buffers(struct msm_vidc_inst *inst) int rc = 0; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, "%s invalid parameters\n", __func__); + d_vpr_e("%s: invalid parameters\n", __func__); return -EINVAL; } @@ -2034,14 +2037,14 @@ static void handle_session_flush(enum hal_command_response cmd, void *data) int rc; if (!response) { - dprintk(VIDC_ERR, "Failed to get valid response for flush\n"); + d_vpr_e("Failed to get valid response for flush\n"); return; } inst = get_inst(get_vidc_core(response->device_id), - response->session_id); + response->inst_id); if (!inst) { - dprintk(VIDC_ERR, "Got a response for an inactive session\n"); + d_vpr_e("Got a response for an inactive session\n"); return; } @@ -2056,9 +2059,8 @@ static void handle_session_flush(enum hal_command_response cmd, void *data) if (!inst->in_reconfig) { rc = msm_comm_queue_dpb_only_buffers(inst); if (rc) { - dprintk(VIDC_ERR, - "Failed to queue output buffers: %d\n", - rc); + s_vpr_e(inst->sid, + "Failed to queue output buffers\n"); } } } @@ -2082,7 +2084,7 @@ static void handle_session_flush(enum hal_command_response cmd, void *data) ptr[0] |= V4L2_CMD_FLUSH_OUTPUT; break; default: - dprintk(VIDC_ERR, "Invalid flush type received!"); + s_vpr_e(inst->sid, "Invalid flush type received!"); goto exit; } @@ -2092,13 +2094,14 @@ static void handle_session_flush(enum hal_command_response cmd, void *data) inst->clk_data.buffer_counter = 0; } - dprintk(VIDC_HIGH, + s_vpr_h(inst->sid, "Notify flush complete, flush_type: %x\n", flush_type); v4l2_event_queue_fh(&inst->event_handler, &flush_event); exit: mutex_unlock(&inst->flush_lock); put_inst(inst); + s_vpr_l(inst->sid, "handled: SESSION_FLUSH_DONE\n"); } static void handle_session_error(enum hal_command_response cmd, void *data) @@ -2109,24 +2112,22 @@ static void handle_session_error(enum hal_command_response cmd, void *data) int event = V4L2_EVENT_MSM_VIDC_SYS_ERROR; if (!response) { - dprintk(VIDC_ERR, - "Failed to get valid response for session error\n"); + d_vpr_e("Failed to get valid response for session error\n"); return; } inst = get_inst(get_vidc_core(response->device_id), - response->session_id); + response->inst_id); if (!inst) { - dprintk(VIDC_ERR, "Got a response for an inactive session\n"); + d_vpr_e("Got a response for an inactive session\n"); return; } hdev = inst->core->device; - dprintk(VIDC_ERR, "Session error received for inst %pK session %x\n", - inst, hash32_ptr(inst->session)); + s_vpr_e(inst->sid, "Session error received for inst %pK\n", inst); if (response->status == VIDC_ERR_MAX_CLIENTS) { - dprintk(VIDC_ERR, "Too many clients, rejecting %pK", inst); + s_vpr_e(inst->sid, "Too many clients, rejecting %pK", inst); event = V4L2_EVENT_MSM_VIDC_MAX_CLIENTS; /* @@ -2138,10 +2139,10 @@ static void handle_session_error(enum hal_command_response cmd, void *data) msm_comm_session_clean(inst); } else if (response->status == VIDC_ERR_NOT_SUPPORTED) { - dprintk(VIDC_ERR, "Unsupported bitstream in %pK", inst); + s_vpr_e(inst->sid, "Unsupported bitstream in %pK", inst); event = V4L2_EVENT_MSM_VIDC_HW_UNSUPPORTED; } else { - dprintk(VIDC_ERR, "Unknown session error (%d) for %pK\n", + s_vpr_e(inst->sid, "Unknown session error (%d) for %pK\n", response->status, inst); event = V4L2_EVENT_MSM_VIDC_SYS_ERROR; } @@ -2150,6 +2151,7 @@ static void handle_session_error(enum hal_command_response cmd, void *data) change_inst_state(inst, MSM_VIDC_CORE_INVALID); msm_vidc_queue_v4l2_event(inst, event); put_inst(inst); + s_vpr_l(inst->sid, "handled: SESSION_ERROR\n"); } static void msm_comm_clean_notify_client(struct msm_vidc_core *core) @@ -2157,19 +2159,19 @@ static void msm_comm_clean_notify_client(struct msm_vidc_core *core) struct msm_vidc_inst *inst = NULL; if (!core) { - dprintk(VIDC_ERR, "%s: Invalid params\n", __func__); + d_vpr_e("%s: invalid params\n", __func__); return; } - dprintk(VIDC_ERR, "%s: Core %pK\n", __func__, core); + d_vpr_e("%s: Core %pK\n", __func__, core); mutex_lock(&core->lock); list_for_each_entry(inst, &core->instances, list) { mutex_lock(&inst->lock); inst->state = MSM_VIDC_CORE_INVALID; mutex_unlock(&inst->lock); - dprintk(VIDC_ERR, - "%s Send sys error for inst %pK\n", __func__, inst); + s_vpr_e(inst->sid, + "%s: Send sys error for inst %pK\n", __func__, inst); msm_vidc_queue_v4l2_event(inst, V4L2_EVENT_MSM_VIDC_SYS_ERROR); } @@ -2186,33 +2188,30 @@ static void handle_sys_error(enum hal_command_response cmd, void *data) subsystem_crashed("venus"); if (!response) { - dprintk(VIDC_ERR, - "Failed to get valid response for sys error\n"); + d_vpr_e("Failed to get valid response for sys error\n"); return; } core = get_vidc_core(response->device_id); if (!core) { - dprintk(VIDC_ERR, - "Got SYS_ERR but unable to identify core\n"); + d_vpr_e("Got SYS_ERR but unable to identify core\n"); return; } hdev = core->device; mutex_lock(&core->lock); if (core->state == VIDC_CORE_UNINIT) { - dprintk(VIDC_ERR, - "%s: Core %pK already moved to state %d\n", + d_vpr_e("%s: Core %pK already moved to state %d\n", __func__, core, core->state); mutex_unlock(&core->lock); return; } - dprintk(VIDC_ERR, "SYS_ERROR received for core %pK\n", core); + d_vpr_e("SYS_ERROR received for core %pK\n", core); msm_vidc_noc_error_info(core); call_hfi_op(hdev, flush_debug_queue, hdev->hfi_device_data); list_for_each_entry(inst, &core->instances, list) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: Send sys error for inst %pK\n", __func__, inst); change_inst_state(inst, MSM_VIDC_CORE_INVALID); msm_vidc_queue_v4l2_event(inst, V4L2_EVENT_MSM_VIDC_SYS_ERROR); @@ -2223,21 +2222,21 @@ static void handle_sys_error(enum hal_command_response cmd, void *data) /* handle the hw error before core released to get full debug info */ msm_vidc_handle_hw_error(core); if (response->status == VIDC_ERR_NOC_ERROR) { - dprintk(VIDC_ERR, "Got NOC error"); + d_vpr_e("Got NOC error"); MSM_VIDC_ERROR(true); } - dprintk(VIDC_ERR, "Calling core_release\n"); + d_vpr_e("Calling core_release\n"); rc = call_hfi_op(hdev, core_release, hdev->hfi_device_data); if (rc) { - dprintk(VIDC_ERR, "core_release failed\n"); + d_vpr_e("core_release failed\n"); mutex_unlock(&core->lock); return; } core->state = VIDC_CORE_UNINIT; mutex_unlock(&core->lock); - dprintk(VIDC_ERR, "SYS_ERROR handled.\n"); + d_vpr_l("handled: SYS_ERROR\n"); } void msm_comm_session_clean(struct msm_vidc_inst *inst) @@ -2246,23 +2245,22 @@ void msm_comm_session_clean(struct msm_vidc_inst *inst) struct hfi_device *hdev = NULL; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, "%s invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return; } if (!inst->session) { - dprintk(VIDC_HIGH, "%s: inst %pK session already cleaned\n", + s_vpr_h(inst->sid, "%s: inst %pK session already cleaned\n", __func__, inst); return; } hdev = inst->core->device; mutex_lock(&inst->lock); - dprintk(VIDC_HIGH, "%s: inst %pK\n", __func__, inst); + s_vpr_h(inst->sid, "%s: inst %pK\n", __func__, inst); rc = call_hfi_op(hdev, session_clean, (void *)inst->session); if (rc) { - dprintk(VIDC_ERR, - "Session clean failed :%pK\n", inst); + s_vpr_e(inst->sid, "Session clean failed :%pK\n", inst); } inst->session = NULL; mutex_unlock(&inst->lock); @@ -2274,18 +2272,18 @@ static void handle_session_close(enum hal_command_response cmd, void *data) struct msm_vidc_inst *inst; if (!response) { - dprintk(VIDC_ERR, - "Failed to get valid response for session close\n"); + d_vpr_e("Failed to get valid response for session close\n"); return; } inst = get_inst(get_vidc_core(response->device_id), - response->session_id); + response->inst_id); if (!inst) { - dprintk(VIDC_ERR, "Got a response for an inactive session\n"); + d_vpr_e("Got a response for an inactive session\n"); return; } + s_vpr_l(inst->sid, "handled: SESSION_END_DONE\n"); signal_session_msg_receipt(cmd, inst); show_stats(inst); put_inst(inst); @@ -2304,7 +2302,7 @@ struct vb2_buffer *msm_comm_get_vb_using_vidc_buffer( } else if (mbuf->vvb.vb2_buf.type == INPUT_MPLANE) { port = INPUT_PORT; } else { - dprintk(VIDC_ERR, "%s: invalid type %d\n", + s_vpr_e(inst->sid, "%s: invalid type %d\n", __func__, mbuf->vvb.vb2_buf.type); return NULL; } @@ -2313,7 +2311,7 @@ struct vb2_buffer *msm_comm_get_vb_using_vidc_buffer( found = false; q = &inst->bufq[port].vb2_bufq; if (!q->streaming) { - dprintk(VIDC_ERR, "port %d is not streaming", port); + s_vpr_e(inst->sid, "port %d is not streaming", port); goto unlock; } list_for_each_entry(vb, &q->queued_list, queued_entry) { @@ -2342,7 +2340,7 @@ int msm_comm_vb2_buffer_done(struct msm_vidc_inst *inst, u32 i, port; if (!inst || !mbuf) { - dprintk(VIDC_ERR, "%s: invalid params %pK %pK\n", + d_vpr_e("%s: invalid params %pK %pK\n", __func__, inst, mbuf); return -EINVAL; } @@ -2376,7 +2374,7 @@ int msm_comm_vb2_buffer_done(struct msm_vidc_inst *inst, } vb2_buffer_done(vb2, VB2_BUF_STATE_DONE); } else { - dprintk(VIDC_ERR, "%s: port %d is not streaming\n", + s_vpr_e(inst->sid, "%s: port %d is not streaming\n", __func__, port); } mutex_unlock(&inst->bufq[port].lock); @@ -2416,21 +2414,20 @@ static void handle_ebd(enum hal_command_response cmd, void *data) struct v4l2_ctrl *ctrl; if (!response) { - dprintk(VIDC_ERR, "Invalid response from vidc_hal\n"); + d_vpr_e("Invalid response from vidc_hal\n"); return; } - inst = get_inst(get_vidc_core(response->device_id), - response->session_id); + response->inst_id); if (!inst) { - dprintk(VIDC_ERR, "Got a response for an inactive session\n"); + d_vpr_e("Got a response for an inactive session\n"); return; } empty_buf_done = (struct vidc_hal_ebd *)&response->input_done; /* If this is internal EOS buffer, handle it in driver */ if (is_eos_buffer(inst, empty_buf_done->packet_buffer)) { - dprintk(VIDC_HIGH, "Received EOS buffer 0x%x\n", + s_vpr_h(inst->sid, "Received EOS buffer 0x%x\n", empty_buf_done->packet_buffer); goto exit; } @@ -2441,7 +2438,7 @@ static void handle_ebd(enum hal_command_response cmd, void *data) mbuf = msm_comm_get_buffer_using_device_planes(inst, INPUT_MPLANE, planes); if (!mbuf || !kref_get_mbuf(inst, mbuf)) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: data_addr %x, extradata_addr %x not found\n", __func__, planes[0], planes[1]); goto exit; @@ -2451,10 +2448,9 @@ static void handle_ebd(enum hal_command_response cmd, void *data) ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_SUPERFRAME); if (ctrl->val && empty_buf_done->offset + empty_buf_done->filled_len < vb->planes[0].length) { - dprintk(VIDC_HIGH, - "%s: %x : addr (%#x): offset (%d) + filled_len (%d) < length (%d)\n", - __func__, hash32_ptr(inst->session), - empty_buf_done->packet_buffer, + s_vpr_h(inst->sid, + "%s: addr (%#x): offset (%d) + filled_len (%d) < length (%d)\n", + __func__, empty_buf_done->packet_buffer, empty_buf_done->offset, empty_buf_done->filled_len, vb->planes[0].length); @@ -2465,18 +2461,18 @@ static void handle_ebd(enum hal_command_response cmd, void *data) mbuf->flags &= ~MSM_VIDC_FLAG_QUEUED; vb->planes[0].bytesused = response->input_done.filled_len; if (vb->planes[0].bytesused > vb->planes[0].length) - dprintk(VIDC_LOW, "bytesused overflow length\n"); + s_vpr_l(inst->sid, "bytesused overflow length\n"); vb->planes[0].data_offset = response->input_done.offset; if (vb->planes[0].data_offset > vb->planes[0].length) - dprintk(VIDC_LOW, "data_offset overflow length\n"); + s_vpr_l(inst->sid, "data_offset overflow length\n"); if (empty_buf_done->status == VIDC_ERR_NOT_SUPPORTED) { - dprintk(VIDC_LOW, "Failed : Unsupported input stream\n"); + s_vpr_l(inst->sid, "Failed : Unsupported input stream\n"); mbuf->vvb.flags |= V4L2_BUF_INPUT_UNSUPPORTED; } if (empty_buf_done->status == VIDC_ERR_BITSTREAM_ERR) { - dprintk(VIDC_LOW, "Failed : Corrupted input stream\n"); + s_vpr_l(inst->sid, "Failed : Corrupted input stream\n"); mbuf->vvb.flags |= V4L2_BUF_FLAG_DATA_CORRUPT; } @@ -2502,6 +2498,7 @@ static void handle_ebd(enum hal_command_response cmd, void *data) kref_put_mbuf(mbuf); exit: put_inst(inst); + s_vpr_l(inst->sid, "handled: SESSION_ETB_DONE\n"); } static int handle_multi_stream_buffers(struct msm_vidc_inst *inst, @@ -2516,7 +2513,7 @@ static int handle_multi_stream_buffers(struct msm_vidc_inst *inst, smem = &binfo->smem; if (smem && dev_addr == smem->device_addr) { if (binfo->buffer_ownership == DRIVER) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "FW returned same buffer: %x\n", dev_addr); break; @@ -2529,7 +2526,7 @@ static int handle_multi_stream_buffers(struct msm_vidc_inst *inst, mutex_unlock(&inst->outputbufs.lock); if (!found) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Failed to find output buffer in queued list: %x\n", dev_addr); } @@ -2559,14 +2556,14 @@ static void handle_fbd(enum hal_command_response cmd, void *data) struct v4l2_format *f; if (!response) { - dprintk(VIDC_ERR, "Invalid response from vidc_hal\n"); + d_vpr_e("Invalid response from vidc_hal\n"); return; } inst = get_inst(get_vidc_core(response->device_id), - response->session_id); + response->inst_id); if (!inst) { - dprintk(VIDC_ERR, "Got a response for an inactive session\n"); + d_vpr_e("Got a response for an inactive session\n"); return; } @@ -2579,7 +2576,7 @@ static void handle_fbd(enum hal_command_response cmd, void *data) mbuf = msm_comm_get_buffer_using_device_planes(inst, OUTPUT_MPLANE, planes); if (!mbuf || !kref_get_mbuf(inst, mbuf)) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: data_addr %x, extradata_addr %x not found\n", __func__, planes[0], planes[1]); goto exit; @@ -2587,7 +2584,7 @@ static void handle_fbd(enum hal_command_response cmd, void *data) } else { if (handle_multi_stream_buffers(inst, fill_buf_done->packet_buffer1)) - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Failed : Output buffer not found %pa\n", &fill_buf_done->packet_buffer1); goto exit; @@ -2597,8 +2594,8 @@ static void handle_fbd(enum hal_command_response cmd, void *data) if (fill_buf_done->buffer_type == HAL_BUFFER_OUTPUT2 && fill_buf_done->flags1 & HAL_BUFFERFLAG_READONLY) { - dprintk(VIDC_ERR, - "%s: Read only buffer not allowed for OPB\n", __func__); + s_vpr_e(inst->sid, "%s: Read only buffer not allowed for OPB\n", + __func__); goto exit; } @@ -2606,16 +2603,14 @@ static void handle_fbd(enum hal_command_response cmd, void *data) fill_buf_done->filled_len1 = 0; vb->planes[0].bytesused = fill_buf_done->filled_len1; if (vb->planes[0].bytesused > vb->planes[0].length) - dprintk(VIDC_LOW, - "fbd:Overflow bytesused = %d; length = %d\n", + s_vpr_l(inst->sid, "fbd:Overflow bytesused = %d; length = %d\n", vb->planes[0].bytesused, vb->planes[0].length); vb->planes[0].data_offset = fill_buf_done->offset1; if (vb->planes[0].data_offset > vb->planes[0].length) - dprintk(VIDC_LOW, + s_vpr_l(inst->sid, "fbd:Overflow data_offset = %d; length = %d\n", - vb->planes[0].data_offset, - vb->planes[0].length); + vb->planes[0].data_offset, vb->planes[0].length); time_usec = fill_buf_done->timestamp_hi; time_usec = (time_usec << 32) | fill_buf_done->timestamp_lo; @@ -2623,7 +2618,7 @@ static void handle_fbd(enum hal_command_response cmd, void *data) vb->timestamp = (time_usec * NSEC_PER_USEC); msm_comm_store_input_tag(&inst->fbd_data, vb->index, - fill_buf_done->input_tag, fill_buf_done->input_tag2); + fill_buf_done->input_tag, fill_buf_done->input_tag2, inst->sid); if (inst->session_type == MSM_VIDC_ENCODER) { if (inst->max_filled_len < fill_buf_done->filled_len1) @@ -2680,11 +2675,11 @@ static void handle_fbd(enum hal_command_response cmd, void *data) exit: put_inst(inst); + s_vpr_l(inst->sid, "handled: SESSION_FTB_DONE\n"); } void handle_cmd_response(enum hal_command_response cmd, void *data) { - dprintk(VIDC_LOW, "Command response = %d\n", cmd); switch (cmd) { case HAL_SYS_INIT_DONE: handle_sys_init_done(cmd, data); @@ -2743,7 +2738,7 @@ void handle_cmd_response(enum hal_command_response cmd, void *data) handle_session_unregister_buffer_done(cmd, data); break; default: - dprintk(VIDC_LOW, "response unhandled: %d\n", cmd); + d_vpr_l("response unhandled: %d\n", cmd); break; } } @@ -2786,8 +2781,7 @@ static bool is_thermal_permissible(struct msm_vidc_core *core) return true; if (msm_vidc_thermal_mitigation_disabled) { - dprintk(VIDC_HIGH, - "Thermal mitigation not enabled. debugfs %d\n", + d_vpr_h("Thermal mitigation not enabled. debugfs %d\n", msm_vidc_thermal_mitigation_disabled); return true; } @@ -2796,12 +2790,11 @@ static bool is_thermal_permissible(struct msm_vidc_core *core) freq = core->curr_freq; is_turbo = is_core_turbo(core, freq); - dprintk(VIDC_HIGH, - "Core freq %ld Thermal level %d Turbo mode %d\n", + d_vpr_h("Core freq %ld Thermal level %d Turbo mode %d\n", freq, tl, is_turbo); if (is_turbo && tl >= VIDC_THERMAL_LOW) { - dprintk(VIDC_ERR, + d_vpr_e( "Video session not allowed. Turbo mode %d Thermal level %d\n", is_turbo, tl); return false; @@ -2840,18 +2833,17 @@ static int msm_comm_session_abort(struct msm_vidc_inst *inst) struct hfi_device *hdev; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, "%s invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } hdev = inst->core->device; abort_completion = SESSION_MSG_INDEX(HAL_SESSION_ABORT_DONE); - dprintk(VIDC_ERR, "%s: inst %pK session %x\n", __func__, - inst, hash32_ptr(inst->session)); + s_vpr_e(inst->sid, "%s: inst %pK\n", __func__, inst); rc = call_hfi_op(hdev, session_abort, (void *)inst->session); if (rc) { - dprintk(VIDC_ERR, - "%s session_abort failed rc: %d\n", __func__, rc); + s_vpr_e(inst->sid, + "%s: session_abort failed rc: %d\n", __func__, rc); goto exit; } rc = wait_for_completion_timeout( @@ -2859,8 +2851,7 @@ static int msm_comm_session_abort(struct msm_vidc_inst *inst) msecs_to_jiffies( inst->core->resources.msm_vidc_hw_rsp_timeout)); if (!rc) { - dprintk(VIDC_ERR, "%s: inst %pK session %x abort timed out\n", - __func__, inst, hash32_ptr(inst->session)); + s_vpr_e(inst->sid, "%s: session abort timed out\n", __func__); msm_comm_generate_sys_error(inst); rc = -EBUSY; } else { @@ -2876,7 +2867,7 @@ static void handle_thermal_event(struct msm_vidc_core *core) struct msm_vidc_inst *inst; if (!core || !core->device) { - dprintk(VIDC_ERR, "%s Invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, core); return; } mutex_lock(&core->lock); @@ -2887,18 +2878,17 @@ static void handle_thermal_event(struct msm_vidc_core *core) mutex_unlock(&core->lock); if (inst->state >= MSM_VIDC_OPEN_DONE && inst->state < MSM_VIDC_CLOSE_DONE) { - dprintk(VIDC_ERR, "%s: abort inst %pK\n", + s_vpr_e(inst->sid, "%s: abort inst %pK\n", __func__, inst); rc = msm_comm_session_abort(inst); if (rc) { - dprintk(VIDC_ERR, - "%s session_abort failed rc: %d\n", + s_vpr_e(inst->sid, + "%s: session_abort failed rc: %d\n", __func__, rc); goto err_sess_abort; } change_inst_state(inst, MSM_VIDC_CORE_INVALID); - dprintk(VIDC_ERR, - "%s Send sys error for inst %pK\n", + s_vpr_e(inst->sid, "%s: Send sys error for inst %pK\n", __func__, inst); msm_vidc_queue_v4l2_event(inst, V4L2_EVENT_MSM_VIDC_SYS_ERROR); @@ -2920,29 +2910,29 @@ void msm_comm_handle_thermal_event(void) list_for_each_entry(core, &vidc_driver->cores, list) { if (!is_thermal_permissible(core)) { - dprintk(VIDC_ERR, - "Thermal level critical, stop all active sessions!\n"); + d_vpr_e( + "Thermal level critical, stop active sessions\n"); handle_thermal_event(core); } } } -int msm_comm_check_core_init(struct msm_vidc_core *core) +int msm_comm_check_core_init(struct msm_vidc_core *core, u32 sid) { int rc = 0; mutex_lock(&core->lock); if (core->state >= VIDC_CORE_INIT_DONE) { - dprintk(VIDC_HIGH, "Video core: %d is already in state: %d\n", + s_vpr_h(sid, "Video core: %d is already in state: %d\n", core->id, core->state); goto exit; } - dprintk(VIDC_HIGH, "Waiting for SYS_INIT_DONE\n"); + s_vpr_h(sid, "Waiting for SYS_INIT_DONE\n"); rc = wait_for_completion_timeout( &core->completions[SYS_MSG_INDEX(HAL_SYS_INIT_DONE)], msecs_to_jiffies(core->resources.msm_vidc_hw_rsp_timeout)); if (!rc) { - dprintk(VIDC_ERR, "%s: Wait interrupted or timed out: %d\n", + s_vpr_e(sid, "%s: Wait interrupted or timed out: %d\n", __func__, SYS_MSG_INDEX(HAL_SYS_INIT_DONE)); rc = -EIO; goto exit; @@ -2950,7 +2940,7 @@ int msm_comm_check_core_init(struct msm_vidc_core *core) core->state = VIDC_CORE_INIT_DONE; rc = 0; } - dprintk(VIDC_HIGH, "SYS_INIT_DONE!!!\n"); + s_vpr_h(sid, "SYS_INIT_DONE!!!\n"); exit: mutex_unlock(&core->lock); return rc; @@ -2960,9 +2950,9 @@ static int msm_comm_init_core_done(struct msm_vidc_inst *inst) { int rc = 0; - rc = msm_comm_check_core_init(inst->core); + rc = msm_comm_check_core_init(inst->core, inst->sid); if (rc) { - dprintk(VIDC_ERR, "%s - failed to initialize core\n", __func__); + d_vpr_e("%s: failed to initialize core\n", __func__); msm_comm_generate_sys_error(inst); return rc; } @@ -2983,14 +2973,14 @@ static int msm_comm_init_core(struct msm_vidc_inst *inst) hdev = core->device; mutex_lock(&core->lock); if (core->state >= VIDC_CORE_INIT) { - dprintk(VIDC_HIGH, "Video core: %d is already in state: %d\n", + s_vpr_h(inst->sid, "Video core: %d is already in state: %d\n", core->id, core->state); goto core_already_inited; } - dprintk(VIDC_HIGH, "%s: core %pK\n", __func__, core); + s_vpr_h(inst->sid, "%s: core %pK\n", __func__, core); rc = call_hfi_op(hdev, core_init, hdev->hfi_device_data); if (rc) { - dprintk(VIDC_ERR, "Failed to init core, id = %d\n", + s_vpr_e(inst->sid, "Failed to init core, id = %d\n", core->id); goto fail_core_init; } @@ -3004,11 +2994,11 @@ static int msm_comm_init_core(struct msm_vidc_inst *inst) core->resources.max_secure_inst_count ? core->resources.max_secure_inst_count : core->resources.max_inst_count; - dprintk(VIDC_HIGH, "%s: codecs count %d, max inst count %d\n", + s_vpr_h(inst->sid, "%s: codecs count %d, max inst count %d\n", __func__, core->resources.codecs_count, core->resources.max_inst_count); if (!core->resources.codecs || !core->resources.codecs_count) { - dprintk(VIDC_ERR, "%s: invalid codecs\n", __func__); + s_vpr_e(inst->sid, "%s: invalid codecs\n", __func__); rc = -EINVAL; goto fail_core_init; } @@ -3016,14 +3006,14 @@ static int msm_comm_init_core(struct msm_vidc_inst *inst) core->capabilities = kcalloc(core->resources.codecs_count, sizeof(struct msm_vidc_capability), GFP_KERNEL); if (!core->capabilities) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: failed to allocate capabilities\n", __func__); rc = -ENOMEM; goto fail_core_init; } } else { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: capabilities memory is expected to be freed\n", __func__); } @@ -3035,13 +3025,13 @@ static int msm_comm_init_core(struct msm_vidc_inst *inst) } rc = msm_vidc_capabilities(core); if (rc) { - dprintk(VIDC_ERR, - "%s: default capabilities failed\n", __func__); + s_vpr_e(inst->sid, + "%s: default capabilities failed\n", __func__); kfree(core->capabilities); core->capabilities = NULL; goto fail_core_init; } - dprintk(VIDC_HIGH, "%s: done\n", __func__); + s_vpr_h(inst->sid, "%s: done\n", __func__); core_already_inited: change_inst_state(inst, MSM_VIDC_CORE_INIT); mutex_unlock(&core->lock); @@ -3061,7 +3051,7 @@ static int msm_vidc_deinit_core(struct msm_vidc_inst *inst) struct hfi_device *hdev; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, "%s invalid parameters\n", __func__); + d_vpr_e("%s: invalid parameters\n", __func__); return -EINVAL; } @@ -3070,7 +3060,7 @@ static int msm_vidc_deinit_core(struct msm_vidc_inst *inst) mutex_lock(&core->lock); if (core->state == VIDC_CORE_UNINIT) { - dprintk(VIDC_HIGH, "Video core: %d is already in state: %d\n", + s_vpr_h(inst->sid, "Video core: %d is already in state: %d\n", core->id, core->state); goto core_already_uninited; } @@ -3093,7 +3083,7 @@ static int msm_vidc_deinit_core(struct msm_vidc_inst *inst) msecs_to_jiffies(core->state == VIDC_CORE_INIT_DONE ? core->resources.msm_vidc_firmware_unload_delay : 0)); - dprintk(VIDC_HIGH, "firmware unload delayed by %u ms\n", + s_vpr_h(inst->sid, "firmware unload delayed by %u ms\n", core->state == VIDC_CORE_INIT_DONE ? core->resources.msm_vidc_firmware_unload_delay : 0); } @@ -3115,11 +3105,15 @@ static int msm_comm_session_init_done(int flipped_state, { int rc; - dprintk(VIDC_HIGH, "inst %pK: waiting for session init done\n", inst); + if (!inst) { + d_vpr_e("Invalid parameter %s\n", __func__); + return -EINVAL; + } + s_vpr_h(inst->sid, "waiting for session init done\n"); rc = wait_for_state(inst, flipped_state, MSM_VIDC_OPEN_DONE, HAL_SESSION_INIT_DONE); if (rc) { - dprintk(VIDC_ERR, "Session init failed for inst %pK\n", inst); + s_vpr_e(inst->sid, "Session init failed for inst %pK\n", inst); msm_comm_generate_sys_error(inst); return rc; } @@ -3136,13 +3130,13 @@ static int msm_comm_session_init(int flipped_state, struct v4l2_format *f; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, "%s invalid parameters\n", __func__); + d_vpr_e("%s: invalid parameters\n", __func__); return -EINVAL; } hdev = inst->core->device; if (IS_ALREADY_IN_STATE(flipped_state, MSM_VIDC_OPEN)) { - dprintk(VIDC_HIGH, "inst: %pK is already in state: %d\n", + s_vpr_h(inst->sid, "inst: %pK is already in state: %d\n", inst, inst->state); goto exit; } @@ -3155,24 +3149,25 @@ static int msm_comm_session_init(int flipped_state, } else if (inst->session_type == MSM_VIDC_CVP) { fourcc = V4L2_PIX_FMT_CVP; } else { - dprintk(VIDC_ERR, "Invalid session\n"); + s_vpr_e(inst->sid, "Invalid session\n"); return -EINVAL; } rc = msm_comm_init_clocks_and_bus_data(inst); if (rc) { - dprintk(VIDC_ERR, "Failed to initialize clocks and bus data\n"); + s_vpr_e(inst->sid, + "Failed to initialize clocks and bus data\n"); goto exit; } - dprintk(VIDC_HIGH, "%s: inst %pK\n", __func__, inst); + s_vpr_h(inst->sid, "%s: inst %pK\n", __func__, inst); rc = call_hfi_op(hdev, session_init, hdev->hfi_device_data, - inst, get_hal_domain(inst->session_type), - get_hal_codec(fourcc), - &inst->session); + inst, get_hal_domain(inst->session_type, inst->sid), + get_hal_codec(fourcc, inst->sid), + &inst->session, inst->sid); if (rc || !inst->session) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Failed to call session init for: %pK, %pK, %d, %d\n", inst->core->device, inst, inst->session_type, fourcc); @@ -3182,7 +3177,7 @@ static int msm_comm_session_init(int flipped_state, rc = msm_vidc_calculate_buffer_counts(inst); if (rc) { - dprintk(VIDC_ERR, "Failed to initialize buff counts\n"); + s_vpr_e(inst->sid, "Failed to initialize buff counts\n"); goto exit; } change_inst_state(inst, MSM_VIDC_OPEN); @@ -3198,8 +3193,8 @@ static void msm_vidc_print_running_insts(struct msm_vidc_core *core) struct v4l2_format *out_f; struct v4l2_format *inp_f; - dprintk(VIDC_ERR, "Running instances:\n"); - dprintk(VIDC_ERR, "%4s|%4s|%4s|%4s|%4s|%4s\n", + d_vpr_e("Running instances:\n"); + d_vpr_e("%4s|%4s|%4s|%4s|%4s|%4s\n", "type", "w", "h", "fps", "opr", "prop"); mutex_lock(&core->lock); @@ -3224,7 +3219,7 @@ static void msm_vidc_print_running_insts(struct msm_vidc_core *core) else op_rate = temp->clk_data.frame_rate >> 16; - dprintk(VIDC_ERR, "%4d|%4d|%4d|%4d|%4d|%4s\n", + s_vpr_e(temp->sid, "%4d|%4d|%4d|%4d|%4d|%4s\n", temp->session_type, max(out_f->fmt.pix_mp.width, inp_f->fmt.pix_mp.width), @@ -3247,17 +3242,17 @@ static int msm_vidc_load_resources(int flipped_state, enum load_calc_quirks quirks = LOAD_ADMISSION_CONTROL; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, "%s invalid parameters\n", __func__); + d_vpr_e("%s: invalid parameters\n", __func__); return -EINVAL; } if (inst->state == MSM_VIDC_CORE_INVALID) { - dprintk(VIDC_ERR, - "%s: inst %pK is in invalid state\n", __func__, inst); + s_vpr_e(inst->sid, "%s: inst %pK is in invalid state\n", + __func__, inst); return -EINVAL; } if (IS_ALREADY_IN_STATE(flipped_state, MSM_VIDC_LOAD_RESOURCES)) { - dprintk(VIDC_HIGH, "inst: %pK is already in state: %d\n", - inst, inst->state); + s_vpr_h(inst->sid, "inst: %pK is already in state: %d\n", + inst, inst->state); goto exit; } core = inst->core; @@ -3270,7 +3265,7 @@ static int msm_vidc_load_resources(int flipped_state, inst->capability.cap[CAP_MBS_PER_FRAME].max; if (num_mbs_per_sec > max_load_adj) { - dprintk(VIDC_ERR, "HW is overloaded, needed: %d max: %d\n", + s_vpr_e(inst->sid, "HW is overloaded, needed: %d max: %d\n", num_mbs_per_sec, max_load_adj); msm_vidc_print_running_insts(core); msm_comm_kill_session(inst); @@ -3278,11 +3273,10 @@ static int msm_vidc_load_resources(int flipped_state, } hdev = core->device; - dprintk(VIDC_HIGH, "%s: inst %pK\n", __func__, inst); + s_vpr_h(inst->sid, "%s: inst %pK\n", __func__, inst); rc = call_hfi_op(hdev, session_load_res, (void *) inst->session); if (rc) { - dprintk(VIDC_ERR, - "Failed to send load resources\n"); + s_vpr_e(inst->sid, "Failed to send load resources\n"); goto exit; } change_inst_state(inst, MSM_VIDC_LOAD_RESOURCES); @@ -3296,26 +3290,24 @@ static int msm_vidc_start(int flipped_state, struct msm_vidc_inst *inst) struct hfi_device *hdev; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, "%s invalid parameters\n", __func__); + d_vpr_e("%s: invalid parameters\n", __func__); return -EINVAL; } if (inst->state == MSM_VIDC_CORE_INVALID) { - dprintk(VIDC_ERR, - "%s: inst %pK is in invalid\n", __func__, inst); + s_vpr_e(inst->sid, "%s: inst %pK is in invalid\n", + __func__, inst); return -EINVAL; } if (IS_ALREADY_IN_STATE(flipped_state, MSM_VIDC_START)) { - dprintk(VIDC_HIGH, - "inst: %pK is already in state: %d\n", + s_vpr_h(inst->sid, "inst: %pK is already in state: %d\n", inst, inst->state); goto exit; } hdev = inst->core->device; - dprintk(VIDC_HIGH, "%s: inst %pK\n", __func__, inst); + s_vpr_h(inst->sid, "%s: inst %pK\n", __func__, inst); rc = call_hfi_op(hdev, session_start, (void *) inst->session); if (rc) { - dprintk(VIDC_ERR, - "Failed to send start\n"); + s_vpr_e(inst->sid, "Failed to send start\n"); goto exit; } change_inst_state(inst, MSM_VIDC_START); @@ -3329,25 +3321,24 @@ static int msm_vidc_stop(int flipped_state, struct msm_vidc_inst *inst) struct hfi_device *hdev; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, "%s invalid parameters\n", __func__); + d_vpr_e("%s: invalid parameters\n", __func__); return -EINVAL; } if (inst->state == MSM_VIDC_CORE_INVALID) { - dprintk(VIDC_ERR, - "%s: inst %pK is in invalid state\n", __func__, inst); + s_vpr_e(inst->sid, "%s: inst %pK is in invalid state\n", + __func__, inst); return -EINVAL; } if (IS_ALREADY_IN_STATE(flipped_state, MSM_VIDC_STOP)) { - dprintk(VIDC_HIGH, - "inst: %pK is already in state: %d\n", + s_vpr_h(inst->sid, "inst: %pK is already in state: %d\n", inst, inst->state); goto exit; } hdev = inst->core->device; - dprintk(VIDC_HIGH, "%s: inst %pK\n", __func__, inst); + s_vpr_h(inst->sid, "%s: inst %pK\n", __func__, inst); rc = call_hfi_op(hdev, session_stop, (void *) inst->session); if (rc) { - dprintk(VIDC_ERR, "%s: inst %pK session_stop failed\n", + s_vpr_e(inst->sid, "%s: inst %pK session_stop failed\n", __func__, inst); goto exit; } @@ -3362,26 +3353,24 @@ static int msm_vidc_release_res(int flipped_state, struct msm_vidc_inst *inst) struct hfi_device *hdev; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, "%s invalid parameters\n", __func__); + d_vpr_e("%s: invalid parameters\n", __func__); return -EINVAL; } if (inst->state == MSM_VIDC_CORE_INVALID) { - dprintk(VIDC_ERR, - "%s: inst %pK is in invalid state\n", __func__, inst); + s_vpr_e(inst->sid, "%s: inst %pK is in invalid state\n", + __func__, inst); return -EINVAL; } if (IS_ALREADY_IN_STATE(flipped_state, MSM_VIDC_RELEASE_RESOURCES)) { - dprintk(VIDC_HIGH, - "inst: %pK is already in state: %d\n", + s_vpr_h(inst->sid, "inst: %pK is already in state: %d\n", inst, inst->state); goto exit; } hdev = inst->core->device; - dprintk(VIDC_HIGH, "%s: inst %pK\n", __func__, inst); + s_vpr_h(inst->sid, "%s: inst %pK\n", __func__, inst); rc = call_hfi_op(hdev, session_release_res, (void *) inst->session); if (rc) { - dprintk(VIDC_ERR, - "Failed to send release resources\n"); + s_vpr_e(inst->sid, "Failed to send release resources\n"); goto exit; } change_inst_state(inst, MSM_VIDC_RELEASE_RESOURCES); @@ -3396,21 +3385,19 @@ static int msm_comm_session_close(int flipped_state, struct hfi_device *hdev; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, "%s invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } if (IS_ALREADY_IN_STATE(flipped_state, MSM_VIDC_CLOSE)) { - dprintk(VIDC_HIGH, - "inst: %pK is already in state: %d\n", - inst, inst->state); + s_vpr_h(inst->sid, "inst: %pK is already in state: %d\n", + inst, inst->state); goto exit; } hdev = inst->core->device; - dprintk(VIDC_HIGH, "%s: inst %pK\n", __func__, inst); + s_vpr_h(inst->sid, "%s: inst %pK\n", __func__, inst); rc = call_hfi_op(hdev, session_end, (void *) inst->session); if (rc) { - dprintk(VIDC_ERR, - "Failed to send close\n"); + s_vpr_e(inst->sid, "Failed to send close\n"); goto exit; } change_inst_state(inst, MSM_VIDC_CLOSE); @@ -3426,21 +3413,20 @@ int msm_comm_suspend(int core_id) core = get_vidc_core(core_id); if (!core) { - dprintk(VIDC_ERR, - "%s: Failed to find core for core_id = %d\n", + d_vpr_e("%s: Failed to find core for core_id = %d\n", __func__, core_id); return -EINVAL; } hdev = (struct hfi_device *)core->device; if (!hdev) { - dprintk(VIDC_ERR, "%s Invalid device handle\n", __func__); + d_vpr_e("%s: Invalid device handle\n", __func__); return -EINVAL; } rc = call_hfi_op(hdev, suspend, hdev->hfi_device_data); if (rc) - dprintk(VIDC_ERR, "Failed to suspend\n"); + d_vpr_e("Failed to suspend\n"); return rc; } @@ -3470,13 +3456,13 @@ int msm_comm_reset_bufreqs(struct msm_vidc_inst *inst, enum hal_buffer buf_type) struct hal_buffer_requirements *bufreqs; if (!inst) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } bufreqs = get_buff_req_buffer(inst, buf_type); if (!bufreqs) { - dprintk(VIDC_ERR, "%s: invalid buf type %d\n", + s_vpr_e(inst->sid, "%s: invalid buf type %d\n", __func__, buf_type); return -EINVAL; } @@ -3497,11 +3483,11 @@ struct hal_buffer_requirements *get_buff_req_buffer( if (inst->buff_req.buffer[i].buffer_type == buffer_type) return &inst->buff_req.buffer[i]; } - dprintk(VIDC_ERR, "Failed to get buff req for : %x", buffer_type); + s_vpr_e(inst->sid, "Failed to get buff req for : %x", buffer_type); return NULL; } -u32 msm_comm_convert_color_fmt(u32 v4l2_fmt) +u32 msm_comm_convert_color_fmt(u32 v4l2_fmt, u32 sid) { switch (v4l2_fmt) { case V4L2_PIX_FMT_NV12: @@ -3517,14 +3503,14 @@ u32 msm_comm_convert_color_fmt(u32 v4l2_fmt) case V4L2_PIX_FMT_NV12_TP10_UBWC: return COLOR_FMT_NV12_BPP10_UBWC; default: - dprintk(VIDC_ERR, + s_vpr_e(sid, "Invalid v4l2 color fmt FMT : %x, Set default(NV12)", v4l2_fmt); return COLOR_FMT_NV12; } } -static u32 get_hfi_buffer(int hal_buffer) +static u32 get_hfi_buffer(int hal_buffer, u32 sid) { u32 buffer; @@ -3563,8 +3549,7 @@ static u32 get_hfi_buffer(int hal_buffer) buffer = HFI_BUFFER_INTERNAL_PERSIST_1; break; default: - dprintk(VIDC_ERR, "Invalid buffer: %#x\n", - hal_buffer); + s_vpr_e(sid, "Invalid buffer: %#x\n", hal_buffer); buffer = 0; break; } @@ -3589,16 +3574,16 @@ static int set_dpb_only_buffers(struct msm_vidc_inst *inst, /* For DPB buffers, Always use min count */ num_buffers = fmt->count_min; - hfi_fmt = msm_comm_convert_color_fmt(inst->clk_data.dpb_fourcc); + hfi_fmt = msm_comm_convert_color_fmt(inst->clk_data.dpb_fourcc, + inst->sid); f = &inst->fmts[OUTPUT_PORT].v4l2_fmt; buffer_size = VENUS_BUFFER_SIZE(hfi_fmt, f->fmt.pix_mp.width, f->fmt.pix_mp.height); - dprintk(VIDC_HIGH, - "output: num = %d, size = %d\n", + s_vpr_h(inst->sid, "output: num = %d, size = %d\n", num_buffers, buffer_size); - b.buffer_type = get_hfi_buffer(buffer_type); + b.buffer_type = get_hfi_buffer(buffer_type, inst->sid); if (!b.buffer_type) return -EINVAL; b.buffer_size = buffer_size; @@ -3608,17 +3593,16 @@ static int set_dpb_only_buffers(struct msm_vidc_inst *inst, if (f->fmt.pix_mp.num_planes == 1 || !f->fmt.pix_mp.plane_fmt[1].sizeimage) { - dprintk(VIDC_HIGH, + s_vpr_h(inst->sid, "This extradata buffer not required, buffer_type: %x\n", buffer_type); } else { - dprintk(VIDC_HIGH, - "extradata: num = 1, size = %d\n", + s_vpr_h(inst->sid, "extradata: num = 1, size = %d\n", f->fmt.pix_mp.plane_fmt[1].sizeimage); inst->dpb_extra_binfo = NULL; inst->dpb_extra_binfo = kzalloc(sizeof(*binfo), GFP_KERNEL); if (!inst->dpb_extra_binfo) { - dprintk(VIDC_ERR, "Out of memory\n"); + s_vpr_e(inst->sid, "%s: Out of memory\n", __func__); rc = -ENOMEM; goto fail_kzalloc; } @@ -3626,7 +3610,7 @@ static int set_dpb_only_buffers(struct msm_vidc_inst *inst, f->fmt.pix_mp.plane_fmt[1].sizeimage, 1, smem_flags, buffer_type, 0, &inst->dpb_extra_binfo->smem); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Failed to allocate output memory\n"); goto err_no_mem; } @@ -3639,7 +3623,7 @@ static int set_dpb_only_buffers(struct msm_vidc_inst *inst, for (i = 0; i < num_buffers; i++) { binfo = kzalloc(sizeof(*binfo), GFP_KERNEL); if (!binfo) { - dprintk(VIDC_ERR, "Out of memory\n"); + s_vpr_e(inst->sid, "Out of memory\n"); rc = -ENOMEM; goto fail_kzalloc; } @@ -3647,13 +3631,13 @@ static int set_dpb_only_buffers(struct msm_vidc_inst *inst, buffer_size, 1, smem_flags, buffer_type, 0, &binfo->smem); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Failed to allocate output memory\n"); goto err_no_mem; } binfo->buffer_type = buffer_type; binfo->buffer_ownership = DRIVER; - dprintk(VIDC_HIGH, "Output buffer address: %#x\n", + s_vpr_h(inst->sid, "Output buffer address: %#x\n", binfo->smem.device_addr); if (inst->buffer_mode_set[OUTPUT_PORT] == @@ -3672,8 +3656,8 @@ static int set_dpb_only_buffers(struct msm_vidc_inst *inst, rc = call_hfi_op(hdev, session_set_buffers, (void *) inst->session, &buffer_info); if (rc) { - dprintk(VIDC_ERR, - "%s : session_set_buffers failed\n", + s_vpr_e(inst->sid, + "%s: session_set_buffers failed\n", __func__); goto fail_set_buffers; } @@ -3720,7 +3704,8 @@ static int set_internal_buf_on_fw(struct msm_vidc_inst *inst, int rc = 0; if (!inst || !inst->core || !inst->core->device || !handle) { - dprintk(VIDC_ERR, "%s - invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK %pK\n", + __func__, inst, handle); return -EINVAL; } @@ -3730,16 +3715,15 @@ static int set_internal_buf_on_fw(struct msm_vidc_inst *inst, buffer_info.buffer_type = buffer_type; buffer_info.num_buffers = 1; buffer_info.align_device_addr = handle->device_addr; - dprintk(VIDC_HIGH, "%s %s buffer : %x\n", - reuse ? "Reusing" : "Allocated", - get_buffer_name(buffer_type), - buffer_info.align_device_addr); + s_vpr_h(inst->sid, "%s %s buffer : %x\n", + reuse ? "Reusing" : "Allocated", + get_buffer_name(buffer_type), + buffer_info.align_device_addr); rc = call_hfi_op(hdev, session_set_buffers, (void *) inst->session, &buffer_info); if (rc) { - dprintk(VIDC_ERR, - "vidc_hal_session_set_buffers failed\n"); + s_vpr_e(inst->sid, "vidc_hal_session_set_buffers failed\n"); return rc; } return 0; @@ -3753,7 +3737,8 @@ static bool reuse_internal_buffers(struct msm_vidc_inst *inst, bool reused = false; if (!inst || !buf_list) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK %pK\n", + __func__, inst, buf_list); return false; } @@ -3776,7 +3761,7 @@ static bool reuse_internal_buffers(struct msm_vidc_inst *inst, rc = set_internal_buf_on_fw(inst, buffer_type, &buf->smem, true); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: session_set_buffers failed\n", __func__); reused = false; @@ -3784,7 +3769,7 @@ static bool reuse_internal_buffers(struct msm_vidc_inst *inst, } } reused = true; - dprintk(VIDC_HIGH, + s_vpr_h(inst->sid, "Re-using internal buffer type : %d\n", buffer_type); } mutex_unlock(&buf_list->lock); @@ -3812,7 +3797,7 @@ static int allocate_and_set_internal_bufs(struct msm_vidc_inst *inst, for (i = 0; i < internal_bufreq->buffer_count_actual; i++) { binfo = kzalloc(sizeof(*binfo), GFP_KERNEL); if (!binfo) { - dprintk(VIDC_ERR, "Out of memory\n"); + s_vpr_e(inst->sid, "%s: Out of memory\n", __func__); rc = -ENOMEM; goto fail_kzalloc; } @@ -3820,7 +3805,7 @@ static int allocate_and_set_internal_bufs(struct msm_vidc_inst *inst, 1, smem_flags, internal_bufreq->buffer_type, 0, &binfo->smem); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Failed to allocate scratch memory\n"); goto err_no_mem; } @@ -3854,13 +3839,13 @@ static int set_internal_buffers(struct msm_vidc_inst *inst, internal_buf = get_buff_req_buffer(inst, buffer_type); if (!internal_buf) { - dprintk(VIDC_HIGH, + s_vpr_h(inst->sid, "This internal buffer not required, buffer_type: %x\n", buffer_type); return 0; } - dprintk(VIDC_HIGH, "Buffer type %s: num = %d, size = %d\n", + s_vpr_h(inst->sid, "Buffer type %s: num = %d, size = %d\n", get_buffer_name(buffer_type), internal_buf->buffer_count_actual, internal_buf->buffer_size); @@ -3881,25 +3866,23 @@ int msm_comm_try_state(struct msm_vidc_inst *inst, int state) int flipped_state; if (!inst) { - dprintk(VIDC_ERR, "%s: invalid params %pK", __func__, inst); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } - dprintk(VIDC_HIGH, - "Trying to move inst: %pK (%#x) from: %#x to %#x\n", - inst, hash32_ptr(inst->session), inst->state, state); + s_vpr_h(inst->sid, "Trying to move inst: %pK from: %#x to %#x\n", + inst, inst->state, state); mutex_lock(&inst->sync_lock); if (inst->state == MSM_VIDC_CORE_INVALID) { - dprintk(VIDC_ERR, "%s: inst %pK is in invalid\n", + s_vpr_e(inst->sid, "%s: inst %pK is in invalid\n", __func__, inst); rc = -EINVAL; goto exit; } flipped_state = get_flipped_state(inst->state, state); - dprintk(VIDC_HIGH, - "inst: %pK (%#x) flipped_state = %#x\n", - inst, hash32_ptr(inst->session), flipped_state); + s_vpr_h(inst->sid, "inst: %pK flipped_state = %#x\n", + inst, flipped_state); switch (flipped_state) { case MSM_VIDC_CORE_UNINIT_DONE: case MSM_VIDC_CORE_INIT: @@ -3941,7 +3924,7 @@ int msm_comm_try_state(struct msm_vidc_inst *inst, int state) HAL_SESSION_STOP_DONE); if (rc || state <= get_flipped_state(inst->state, state)) break; - dprintk(VIDC_HIGH, "Moving to Stop Done state\n"); + s_vpr_h(inst->sid, "Moving to Stop Done state\n"); case MSM_VIDC_RELEASE_RESOURCES: rc = msm_vidc_release_res(flipped_state, inst); if (rc || state <= get_flipped_state(inst->state, state)) @@ -3952,8 +3935,7 @@ int msm_comm_try_state(struct msm_vidc_inst *inst, int state) HAL_SESSION_RELEASE_RESOURCE_DONE); if (rc || state <= get_flipped_state(inst->state, state)) break; - dprintk(VIDC_HIGH, - "Moving to release resources done state\n"); + s_vpr_h(inst->sid, "Moving to release resources done state\n"); case MSM_VIDC_CLOSE: rc = msm_comm_session_close(flipped_state, inst); if (rc || state <= get_flipped_state(inst->state, state)) @@ -3966,12 +3948,12 @@ int msm_comm_try_state(struct msm_vidc_inst *inst, int state) msm_comm_session_clean(inst); case MSM_VIDC_CORE_UNINIT: case MSM_VIDC_CORE_INVALID: - dprintk(VIDC_HIGH, "Sending core uninit\n"); + s_vpr_h(inst->sid, "Sending core uninit\n"); rc = msm_vidc_deinit_core(inst); if (rc || state == get_flipped_state(inst->state, state)) break; default: - dprintk(VIDC_ERR, "State not recognized\n"); + s_vpr_e(inst->sid, "State not recognized\n"); rc = -EINVAL; break; } @@ -3980,9 +3962,8 @@ exit: mutex_unlock(&inst->sync_lock); if (rc) { - dprintk(VIDC_ERR, - "Failed to move from state: %d to %d\n", - inst->state, state); + s_vpr_e(inst->sid, "Failed to move from state: %d to %d\n", + inst->state, state); msm_comm_kill_session(inst); } else { trace_msm_vidc_common_state_change((void *)inst, @@ -3999,7 +3980,7 @@ int msm_vidc_send_pending_eos_buffers(struct msm_vidc_inst *inst) int rc = 0; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, "%s: Invalid arguments\n", __func__); + d_vpr_e("%s: Invalid arguments\n", __func__); return -EINVAL; } @@ -4015,7 +3996,7 @@ int msm_vidc_send_pending_eos_buffers(struct msm_vidc_inst *inst) data.timestamp = 0; data.extradata_addr = 0; data.extradata_size = 0; - dprintk(VIDC_HIGH, "Queueing EOS buffer 0x%x\n", + s_vpr_h(inst->sid, "Queueing EOS buffer 0x%x\n", data.device_addr); hdev = inst->core->device; @@ -4036,7 +4017,8 @@ int msm_vidc_comm_cmd(void *instance, union msm_v4l2_cmd *cmd) int which_cmd = 0, flags = 0, rc = 0; if (!inst || !inst->core || !cmd) { - dprintk(VIDC_ERR, "%s invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK %pK\n", + __func__, inst, cmd); return -EINVAL; } core = inst->core; @@ -4055,8 +4037,7 @@ int msm_vidc_comm_cmd(void *instance, union msm_v4l2_cmd *cmd) case V4L2_CMD_FLUSH: rc = msm_comm_flush(inst, flags); if (rc) { - dprintk(VIDC_ERR, - "Failed to flush buffers: %d\n", rc); + s_vpr_e(inst->sid, "Failed to flush buffers: %d\n", rc); } break; case V4L2_CMD_SESSION_CONTINUE: @@ -4071,14 +4052,14 @@ int msm_vidc_comm_cmd(void *instance, union msm_v4l2_cmd *cmd) u32 smem_flags = SMEM_UNCACHED; if (inst->state != MSM_VIDC_START_DONE) { - dprintk(VIDC_HIGH, + s_vpr_h(inst->sid, "Inst = %pK is not ready for EOS\n", inst); break; } binfo = kzalloc(sizeof(*binfo), GFP_KERNEL); if (!binfo) { - dprintk(VIDC_ERR, "%s: Out of memory\n", __func__); + s_vpr_e(inst->sid, "%s: Out of memory\n", __func__); rc = -ENOMEM; break; } @@ -4091,7 +4072,7 @@ int msm_vidc_comm_cmd(void *instance, union msm_v4l2_cmd *cmd) HAL_BUFFER_INPUT, 0, &binfo->smem); if (rc) { kfree(binfo); - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Failed to allocate output memory\n"); rc = -ENOMEM; break; @@ -4103,7 +4084,7 @@ int msm_vidc_comm_cmd(void *instance, union msm_v4l2_cmd *cmd) rc = msm_vidc_send_pending_eos_buffers(inst); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Failed pending_eos_buffers sending\n"); list_del(&binfo->list); kfree(binfo); @@ -4112,7 +4093,7 @@ int msm_vidc_comm_cmd(void *instance, union msm_v4l2_cmd *cmd) break; } default: - dprintk(VIDC_ERR, "Unknown Command %d\n", which_cmd); + s_vpr_e(inst->sid, "Unknown Command %d\n", which_cmd); rc = -ENOTSUPP; break; } @@ -4125,7 +4106,8 @@ static int msm_comm_preprocess(struct msm_vidc_inst *inst, int rc = 0; if (!inst || !mbuf) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK %pK\n", + __func__, inst, mbuf); return -EINVAL; } @@ -4139,7 +4121,7 @@ static int msm_comm_preprocess(struct msm_vidc_inst *inst, rc = msm_vidc_cvp_preprocess(inst, mbuf); if (rc) { - dprintk(VIDC_ERR, "%s: cvp preprocess failed\n", + s_vpr_e(inst->sid, "%s: cvp preprocess failed\n", __func__); return rc; } @@ -4157,7 +4139,7 @@ static void populate_frame_data(struct vidc_frame_data *data, u32 itag = 0, itag2 = 0; if (!inst || !mbuf || !data) { - dprintk(VIDC_ERR, "%s: invalid params %pK %pK %pK\n", + d_vpr_e("%s: invalid params %pK %pK %pK\n", __func__, inst, mbuf, data); return; } @@ -4189,7 +4171,7 @@ static void populate_frame_data(struct vidc_frame_data *data, data->flags |= HAL_BUFFERFLAG_CVPMETADATA_SKIP; msm_comm_fetch_input_tag(&inst->etb_data, vb->index, - &itag, &itag2); + &itag, &itag2, inst->sid); data->input_tag = itag; f = &inst->fmts[INPUT_PORT].v4l2_fmt; @@ -4229,7 +4211,7 @@ int msm_comm_num_queued_bufs(struct msm_vidc_inst *inst, u32 type) struct msm_vidc_buffer *mbuf; if (!inst) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params\n", __func__); return 0; } @@ -4252,7 +4234,7 @@ static int num_pending_qbufs(struct msm_vidc_inst *inst, u32 type) struct msm_vidc_buffer *mbuf; if (!inst) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params\n", __func__); return 0; } @@ -4279,7 +4261,7 @@ static int msm_comm_qbuf_to_hfi(struct msm_vidc_inst *inst, struct vidc_frame_data frame_data = {0}; if (!inst || !inst->core || !inst->core->device || !mbuf) { - dprintk(VIDC_ERR, "%s: Invalid arguments\n", __func__); + d_vpr_e("%s: Invalid arguments\n", __func__); return -EINVAL; } hdev = inst->core->device; @@ -4295,12 +4277,12 @@ static int msm_comm_qbuf_to_hfi(struct msm_vidc_inst *inst, e = MSM_VIDC_DEBUGFS_EVENT_FTB; rc = call_hfi_op(hdev, session_ftb, inst->session, &frame_data); } else { - dprintk(VIDC_ERR, "%s: invalid qbuf type %d:\n", __func__, + s_vpr_e(inst->sid, "%s: invalid qbuf type %d:\n", __func__, mbuf->vvb.vb2_buf.type); rc = -EINVAL; } if (rc) { - dprintk(VIDC_ERR, "%s: Failed to qbuf: %d\n", __func__, rc); + s_vpr_e(inst->sid, "%s: Failed to qbuf: %d\n", __func__, rc); goto err_bad_input; } mbuf->flags |= MSM_VIDC_FLAG_QUEUED; @@ -4320,24 +4302,23 @@ void msm_vidc_batch_handler(struct work_struct *work) struct msm_vidc_inst *inst; inst = container_of(work, struct msm_vidc_inst, batch_work.work); - inst = get_inst(get_vidc_core(MSM_VIDC_CORE_VENUS), inst); if (!inst) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params\n", __func__); return; } if (inst->state == MSM_VIDC_CORE_INVALID) { - dprintk(VIDC_ERR, "%s: invalid state\n", __func__); + s_vpr_e(inst->sid, "%s: invalid state\n", __func__); goto exit; } - dprintk(VIDC_HIGH, "%s: %x: queue pending batch buffers\n", - __func__, hash32_ptr(inst->session)); + s_vpr_h(inst->sid, "%s: queue pending batch buffers\n", + __func__); rc = msm_comm_qbufs_batch(inst, NULL); if (rc) - dprintk(VIDC_ERR, "%s: batch qbufs failed\n", __func__); + s_vpr_e(inst->sid, "%s: batch qbufs failed\n", __func__); exit: put_inst(inst); @@ -4356,7 +4337,7 @@ static int msm_comm_qbuf_superframe_to_hfi(struct msm_vidc_inst *inst, bool skip_allowed = false; if (!inst || !inst->core || !inst->core->device || !mbuf) { - dprintk(VIDC_ERR, "%s: Invalid arguments\n", __func__); + d_vpr_e("%s: Invalid arguments\n", __func__); return -EINVAL; } hdev = inst->core->device; @@ -4368,23 +4349,24 @@ static int msm_comm_qbuf_superframe_to_hfi(struct msm_vidc_inst *inst, ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_SUPERFRAME); superframe_count = ctrl->val; if (superframe_count > VIDC_SUPERFRAME_MAX) { - dprintk(VIDC_ERR, "%s: wrong superframe count %d, max %d\n", + s_vpr_e(inst->sid, "%s: wrong superframe count %d, max %d\n", __func__, superframe_count, VIDC_SUPERFRAME_MAX); return -EINVAL; } ts_delta_us = 1000000 / (inst->clk_data.frame_rate >> 16); f = &inst->fmts[INPUT_PORT].v4l2_fmt; - hfi_fmt = msm_comm_convert_color_fmt(f->fmt.pix_mp.pixelformat); + hfi_fmt = msm_comm_convert_color_fmt(f->fmt.pix_mp.pixelformat, + inst->sid); frame_size = VENUS_BUFFER_SIZE(hfi_fmt, f->fmt.pix_mp.width, f->fmt.pix_mp.height); if (frame_size * superframe_count != mbuf->vvb.vb2_buf.planes[0].length) { - dprintk(VIDC_ERR, - "%s: %#x : invalid superframe length, pxlfmt %#x wxh %dx%d framesize %d count %d length %d\n", - __func__, hash32_ptr(inst->session), - f->fmt.pix_mp.pixelformat, f->fmt.pix_mp.width, - f->fmt.pix_mp.height, frame_size, superframe_count, + s_vpr_e(inst->sid, + "%s: invalid superframe length, pxlfmt %#x wxh %dx%d framesize %d count %d length %d\n", + __func__, f->fmt.pix_mp.pixelformat, + f->fmt.pix_mp.width, f->fmt.pix_mp.height, + frame_size, superframe_count, mbuf->vvb.vb2_buf.planes[0].length); return -EINVAL; } @@ -4401,7 +4383,7 @@ static int msm_comm_qbuf_superframe_to_hfi(struct msm_vidc_inst *inst, frames[0].flags &= ~HAL_BUFFERFLAG_EOS; frames[0].flags &= ~HAL_BUFFERFLAG_CVPMETADATA_SKIP; if (frames[0].flags) - dprintk(VIDC_ERR, "%s: invalid flags %#x\n", + s_vpr_e(inst->sid, "%s: invalid flags %#x\n", __func__, frames[0].flags); frames[0].flags = 0; @@ -4437,7 +4419,7 @@ static int msm_comm_qbuf_superframe_to_hfi(struct msm_vidc_inst *inst, rc = call_hfi_op(hdev, session_process_batch, inst->session, num_etbs, frames, 0, NULL); if (rc) { - dprintk(VIDC_ERR, "%s: Failed to qbuf: %d\n", __func__, rc); + s_vpr_e(inst->sid, "%s: Failed to qbuf: %d\n", __func__, rc); return rc; } /* update mbuf flags */ @@ -4454,23 +4436,24 @@ static int msm_comm_qbuf_in_rbr(struct msm_vidc_inst *inst, int rc = 0; if (!inst || !mbuf) { - dprintk(VIDC_ERR, "%s: Invalid arguments\n", __func__); + d_vpr_e("%s: Invalid arguments\n", __func__); return -EINVAL; } if (inst->state == MSM_VIDC_CORE_INVALID) { - dprintk(VIDC_ERR, "%s: inst is in bad state\n", __func__); + s_vpr_e(inst->sid, "%s: inst is in bad state\n", __func__); return -EINVAL; } rc = msm_comm_scale_clocks_and_bus(inst, 0); if (rc) - dprintk(VIDC_ERR, "%s: scale clock failed\n", __func__); + s_vpr_e(inst->sid, "%s: scale clock failed\n", __func__); print_vidc_buffer(VIDC_HIGH|VIDC_PERF, "qbuf in rbr", inst, mbuf); rc = msm_comm_qbuf_to_hfi(inst, mbuf); if (rc) - dprintk(VIDC_ERR, "%s: Failed qbuf to hfi: %d\n", __func__, rc); + s_vpr_e(inst->sid, + "%s: Failed qbuf to hfi: %d\n", __func__, rc); return rc; } @@ -4482,12 +4465,12 @@ int msm_comm_qbuf(struct msm_vidc_inst *inst, struct msm_vidc_buffer *mbuf) int do_bw_calc = 0; if (!inst || !mbuf) { - dprintk(VIDC_ERR, "%s: Invalid arguments\n", __func__); + d_vpr_e("%s: Invalid arguments\n", __func__); return -EINVAL; } if (inst->state == MSM_VIDC_CORE_INVALID) { - dprintk(VIDC_ERR, "%s: inst is in bad state\n", __func__); + s_vpr_e(inst->sid, "%s: inst is in bad state\n", __func__); return -EINVAL; } @@ -4504,7 +4487,7 @@ int msm_comm_qbuf(struct msm_vidc_inst *inst, struct msm_vidc_buffer *mbuf) do_bw_calc = mbuf->vvb.vb2_buf.type == INPUT_MPLANE; rc = msm_comm_scale_clocks_and_bus(inst, do_bw_calc); if (rc) - dprintk(VIDC_ERR, "%s: scale clock & bw failed\n", __func__); + s_vpr_e(inst->sid, "%s: scale clock & bw failed\n", __func__); print_vidc_buffer(VIDC_HIGH|VIDC_PERF, "qbuf", inst, mbuf); ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_SUPERFRAME); @@ -4513,7 +4496,8 @@ int msm_comm_qbuf(struct msm_vidc_inst *inst, struct msm_vidc_buffer *mbuf) else rc = msm_comm_qbuf_to_hfi(inst, mbuf); if (rc) - dprintk(VIDC_ERR, "%s: Failed qbuf to hfi: %d\n", __func__, rc); + s_vpr_e(inst->sid, "%s: Failed qbuf to hfi: %d\n", + __func__, rc); return rc; } @@ -4525,12 +4509,12 @@ int msm_comm_qbufs(struct msm_vidc_inst *inst) bool found; if (!inst) { - dprintk(VIDC_ERR, "%s: Invalid arguments\n", __func__); + d_vpr_e("%s: Invalid arguments\n", __func__); return -EINVAL; } if (inst->state != MSM_VIDC_START_DONE) { - dprintk(VIDC_HIGH, "%s: inst not in start state: %d\n", + s_vpr_h(inst->sid, "%s: inst not in start state: %d\n", __func__, inst->state); return 0; } @@ -4547,21 +4531,21 @@ int msm_comm_qbufs(struct msm_vidc_inst *inst) } mutex_unlock(&inst->registeredbufs.lock); if (!found) { - dprintk(VIDC_HIGH, + s_vpr_h(inst->sid, "%s: no more deferred qbufs\n", __func__); break; } /* do not call msm_comm_qbuf() under registerbufs lock */ if (!kref_get_mbuf(inst, mbuf)) { - dprintk(VIDC_ERR, "%s: mbuf not found\n", __func__); + s_vpr_e(inst->sid, "%s: mbuf not found\n", __func__); rc = -EINVAL; break; } rc = msm_comm_qbuf(inst, mbuf); kref_put_mbuf(mbuf); if (rc) { - dprintk(VIDC_ERR, "%s: failed qbuf\n", __func__); + s_vpr_e(inst->sid, "%s: failed qbuf\n", __func__); break; } } while (found); @@ -4579,7 +4563,7 @@ int msm_comm_qbufs_batch(struct msm_vidc_inst *inst, do_bw_calc = mbuf ? mbuf->vvb.vb2_buf.type == INPUT_MPLANE : 0; rc = msm_comm_scale_clocks_and_bus(inst, do_bw_calc); if (rc) - dprintk(VIDC_ERR, "%s: scale clock & bw failed\n", __func__); + s_vpr_e(inst->sid, "%s: scale clock & bw failed\n", __func__); mutex_lock(&inst->registeredbufs.lock); list_for_each_entry(buf, &inst->registeredbufs.list, list) { @@ -4596,7 +4580,7 @@ int msm_comm_qbufs_batch(struct msm_vidc_inst *inst, print_vidc_buffer(VIDC_HIGH|VIDC_PERF, "batch-qbuf", inst, buf); rc = msm_comm_qbuf_to_hfi(inst, buf); if (rc) { - dprintk(VIDC_ERR, "%s: Failed batch qbuf to hfi: %d\n", + s_vpr_e(inst->sid, "%s: Failed batch qbuf to hfi: %d\n", __func__, rc); break; } @@ -4624,12 +4608,12 @@ int msm_comm_qbuf_decode_batch(struct msm_vidc_inst *inst, u32 count = 0; if (!inst || !inst->core || !mbuf) { - dprintk(VIDC_ERR, "%s: Invalid arguments\n", __func__); + d_vpr_e("%s: Invalid arguments\n", __func__); return -EINVAL; } if (inst->state == MSM_VIDC_CORE_INVALID) { - dprintk(VIDC_ERR, "%s: inst is in bad state\n", __func__); + s_vpr_e(inst->sid, "%s: inst is in bad state\n", __func__); return -EINVAL; } @@ -4662,7 +4646,8 @@ int msm_comm_qbuf_decode_batch(struct msm_vidc_inst *inst, rc = msm_comm_qbufs_batch(inst, mbuf); if (rc) - dprintk(VIDC_ERR, "%s: Failed qbuf to hfi: %d\n", + s_vpr_e(inst->sid, + "%s: Failed qbuf to hfi: %d\n", __func__, rc); return rc; @@ -4674,7 +4659,7 @@ int schedule_batch_work(struct msm_vidc_inst *inst) struct msm_vidc_platform_resources *res; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: Invalid arguments\n", __func__); + d_vpr_e("%s: Invalid arguments\n", __func__); return -EINVAL; } core = inst->core; @@ -4690,7 +4675,7 @@ int schedule_batch_work(struct msm_vidc_inst *inst) int cancel_batch_work(struct msm_vidc_inst *inst) { if (!inst) { - dprintk(VIDC_ERR, "%s: Invalid arguments\n", __func__); + d_vpr_e("%s: Invalid arguments\n", __func__); return -EINVAL; } cancel_delayed_work(&inst->batch_work); @@ -4720,8 +4705,9 @@ int msm_comm_try_get_bufreqs(struct msm_vidc_inst *inst) if (inst->buffer_size_calculators) { rc = inst->buffer_size_calculators(inst); if (rc) - dprintk(VIDC_ERR, - "Failed calculating internal buffer sizes: %d", rc); + s_vpr_e(inst->sid, + "Failed calculating internal buffer sizes: %d", + rc); } /* @@ -4731,7 +4717,7 @@ int msm_comm_try_get_bufreqs(struct msm_vidc_inst *inst) if (rc) { rc = msm_comm_try_get_buff_req(inst, &hprop); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Failed getting buffer requirements: %d", rc); return rc; } @@ -4770,15 +4756,15 @@ int msm_comm_try_get_bufreqs(struct msm_vidc_inst *inst) } } - dprintk(VIDC_HIGH, "Buffer requirements :\n"); - dprintk(VIDC_HIGH, "%15s %8s %8s %8s %8s %8s\n", + s_vpr_h(inst->sid, "Buffer requirements :\n"); + s_vpr_h(inst->sid, "%15s %8s %8s %8s %8s %8s\n", "buffer type", "count", "mincount_host", "mincount_fw", "size", "alignment"); for (i = 0; i < HAL_BUFFER_MAX; i++) { struct hal_buffer_requirements req = inst->buff_req.buffer[i]; if (req.buffer_type != HAL_BUFFER_NONE) { - dprintk(VIDC_HIGH, "%15s %8d %8d %8d %8d %8d\n", + s_vpr_h(inst->sid, "%15s %8d %8d %8d %8d %8d\n", get_buffer_name(req.buffer_type), req.buffer_count_actual, req.buffer_count_min_host, @@ -4797,7 +4783,7 @@ int msm_comm_try_get_buff_req(struct msm_vidc_inst *inst, struct getprop_buf *buf; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, "%s invalid parameters\n", __func__); + d_vpr_e("%s: invalid parameters\n", __func__); return -EINVAL; } @@ -4812,9 +4798,9 @@ int msm_comm_try_get_buff_req(struct msm_vidc_inst *inst, * is enough check to have. */ - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "In Wrong state to call Buf Req: Inst %pK or Core %pK\n", - inst, inst->core); + inst, inst->core); rc = -EAGAIN; mutex_unlock(&inst->sync_lock); goto exit; @@ -4823,7 +4809,7 @@ int msm_comm_try_get_buff_req(struct msm_vidc_inst *inst, rc = call_hfi_op(hdev, session_get_buf_req, inst->session); if (rc) { - dprintk(VIDC_ERR, "Can't query hardware for property: %d\n", + s_vpr_e(inst->sid, "Can't query hardware for property: %d\n", rc); goto exit; } @@ -4833,7 +4819,7 @@ int msm_comm_try_get_buff_req(struct msm_vidc_inst *inst, msecs_to_jiffies( inst->core->resources.msm_vidc_hw_rsp_timeout)); if (!rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: Wait interrupted or timed out [%pK]: %d\n", __func__, inst, SESSION_MSG_INDEX(HAL_SESSION_PROPERTY_INFO)); @@ -4854,7 +4840,7 @@ int msm_comm_try_get_buff_req(struct msm_vidc_inst *inst, list_del(&buf->list); kfree(buf); } else { - dprintk(VIDC_ERR, "%s getprop list empty\n", __func__); + s_vpr_e(inst->sid, "%s: getprop list empty\n", __func__); rc = -EINVAL; } mutex_unlock(&inst->pending_getpropq.lock); @@ -4873,13 +4859,12 @@ int msm_comm_release_dpb_only_buffers(struct msm_vidc_inst *inst, struct hfi_device *hdev; if (!inst) { - dprintk(VIDC_ERR, - "Invalid instance pointer = %pK\n", inst); + d_vpr_e("Invalid instance pointer = %pK\n", inst); return -EINVAL; } mutex_lock(&inst->outputbufs.lock); if (list_empty(&inst->outputbufs.list)) { - dprintk(VIDC_HIGH, "%s - No OUTPUT buffers allocated\n", + s_vpr_h(inst->sid, "%s: No OUTPUT buffers allocated\n", __func__); mutex_unlock(&inst->outputbufs.lock); return 0; @@ -4888,13 +4873,12 @@ int msm_comm_release_dpb_only_buffers(struct msm_vidc_inst *inst, core = inst->core; if (!core) { - dprintk(VIDC_ERR, - "Invalid core pointer = %pK\n", core); + s_vpr_e(inst->sid, "Invalid core pointer\n"); return -EINVAL; } hdev = core->device; if (!hdev) { - dprintk(VIDC_ERR, "Invalid device pointer = %pK\n", hdev); + s_vpr_e(inst->sid, "Invalid device pointer\n"); return -EINVAL; } mutex_lock(&inst->outputbufs.lock); @@ -4902,7 +4886,7 @@ int msm_comm_release_dpb_only_buffers(struct msm_vidc_inst *inst, handle = &buf->smem; if ((buf->buffer_ownership == FIRMWARE) && !force_release) { - dprintk(VIDC_HIGH, "DPB is with f/w. Can't free it\n"); + s_vpr_h(inst->sid, "DPB is with f/w. Can't free it\n"); /* * mark this buffer to avoid sending it to video h/w * again, this buffer belongs to old resolution and @@ -4922,7 +4906,7 @@ int msm_comm_release_dpb_only_buffers(struct msm_vidc_inst *inst, rc = call_hfi_op(hdev, session_release_buffers, (void *)inst->session, &buffer_info); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Rel output buf fail:%x, %d\n", buffer_info.align_device_addr, buffer_info.buffer_size); @@ -4952,7 +4936,7 @@ static enum hal_buffer scratch_buf_sufficient(struct msm_vidc_inst *inst, int count = 0; if (!inst) { - dprintk(VIDC_ERR, "%s - invalid param\n", __func__); + d_vpr_e("%s: invalid params\n", __func__); goto not_sufficient; } @@ -4973,7 +4957,7 @@ static enum hal_buffer scratch_buf_sufficient(struct msm_vidc_inst *inst, if (count != bufreq->buffer_count_actual) goto not_sufficient; - dprintk(VIDC_HIGH, + s_vpr_h(inst->sid, "Existing scratch buffer is sufficient for buffer type %#x\n", buffer_type); @@ -4995,19 +4979,17 @@ int msm_comm_release_scratch_buffers(struct msm_vidc_inst *inst, enum hal_buffer sufficiency = HAL_BUFFER_NONE; if (!inst) { - dprintk(VIDC_ERR, - "Invalid instance pointer = %pK\n", inst); + d_vpr_e("Invalid instance pointer = %pK\n", inst); return -EINVAL; } core = inst->core; if (!core) { - dprintk(VIDC_ERR, - "Invalid core pointer = %pK\n", core); + s_vpr_e(inst->sid, "Invalid core pointer = %pK\n", core); return -EINVAL; } hdev = core->device; if (!hdev) { - dprintk(VIDC_ERR, "Invalid device pointer = %pK\n", hdev); + s_vpr_e(inst->sid, "Invalid device pointer = %pK\n", hdev); return -EINVAL; } @@ -5037,13 +5019,12 @@ int msm_comm_release_scratch_buffers(struct msm_vidc_inst *inst, rc = wait_for_sess_signal_receipt(inst, HAL_SESSION_RELEASE_BUFFER_DONE); if (rc) - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: wait for signal failed, rc %d\n", __func__, rc); mutex_lock(&inst->scratchbufs.lock); } else { - dprintk(VIDC_ERR, - "Rel scrtch buf fail:%x, %d\n", + s_vpr_e(inst->sid, "Rel scrtch buf fail:%x, %d\n", buffer_info.align_device_addr, buffer_info.buffer_size); } @@ -5066,8 +5047,7 @@ void msm_comm_release_eos_buffers(struct msm_vidc_inst *inst) struct eos_buf *buf, *next; if (!inst) { - dprintk(VIDC_ERR, - "Invalid instance pointer = %pK\n", inst); + d_vpr_e("Invalid instance pointer = %pK\n", inst); return; } @@ -5087,8 +5067,7 @@ int msm_comm_release_recon_buffers(struct msm_vidc_inst *inst) struct recon_buf *buf, *next; if (!inst) { - dprintk(VIDC_ERR, - "Invalid instance pointer = %pK\n", inst); + d_vpr_e("Invalid instance pointer = %pK\n", inst); return -EINVAL; } @@ -5114,19 +5093,17 @@ int msm_comm_release_persist_buffers(struct msm_vidc_inst *inst) struct hfi_device *hdev; if (!inst) { - dprintk(VIDC_ERR, - "Invalid instance pointer = %pK\n", inst); + d_vpr_e("Invalid instance pointer = %pK\n", inst); return -EINVAL; } core = inst->core; if (!core) { - dprintk(VIDC_ERR, - "Invalid core pointer = %pK\n", core); + s_vpr_e(inst->sid, "Invalid core pointer = %pK\n", core); return -EINVAL; } hdev = core->device; if (!hdev) { - dprintk(VIDC_ERR, "Invalid device pointer = %pK\n", hdev); + s_vpr_e(inst->sid, "Invalid device pointer = %pK\n", hdev); return -EINVAL; } @@ -5146,13 +5123,12 @@ int msm_comm_release_persist_buffers(struct msm_vidc_inst *inst) rc = wait_for_sess_signal_receipt(inst, HAL_SESSION_RELEASE_BUFFER_DONE); if (rc) - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: wait for signal failed, rc %d\n", __func__, rc); mutex_lock(&inst->persistbufs.lock); } else { - dprintk(VIDC_ERR, - "Rel prst buf fail:%x, %d\n", + s_vpr_e(inst->sid, "Rel prst buf fail:%x, %d\n", buffer_info.align_device_addr, buffer_info.buffer_size); } @@ -5173,26 +5149,25 @@ int msm_comm_set_buffer_count(struct msm_vidc_inst *inst, struct hfi_buffer_count_actual buf_count; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, "%s invalid parameters\n", __func__); + d_vpr_e("%s: invalid parameters\n", __func__); return -EINVAL; } hdev = inst->core->device; - buf_count.buffer_type = get_hfi_buffer(type); + buf_count.buffer_type = get_hfi_buffer(type, inst->sid); buf_count.buffer_count_actual = act_count; buf_count.buffer_count_min_host = host_count; /* set total superframe buffers count */ ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_SUPERFRAME); if (ctrl->val) buf_count.buffer_count_actual = act_count * ctrl->val; - dprintk(VIDC_HIGH, "%s: %x : hal_buffer %d min_host %d actual %d\n", - __func__, hash32_ptr(inst->session), type, - host_count, act_count); + s_vpr_h(inst->sid, "%s: hal_buffer %d min_host %d actual %d\n", + __func__, type, host_count, act_count); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_BUFFER_COUNT_ACTUAL, &buf_count, sizeof(buf_count)); if (rc) - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Failed to set actual buffer count %d for buffer type %d\n", act_count, type); return rc; @@ -5204,7 +5179,7 @@ int msm_comm_set_dpb_only_buffers(struct msm_vidc_inst *inst) bool force_release = true; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, "%s invalid parameters\n", __func__); + d_vpr_e("%s: invalid parameters\n", __func__); return -EINVAL; } @@ -5212,7 +5187,7 @@ int msm_comm_set_dpb_only_buffers(struct msm_vidc_inst *inst) force_release = false; if (msm_comm_release_dpb_only_buffers(inst, force_release)) - dprintk(VIDC_ERR, "Failed to release output buffers\n"); + s_vpr_e(inst->sid, "Failed to release output buffers\n"); rc = set_dpb_only_buffers(inst, HAL_BUFFER_OUTPUT); if (rc) @@ -5228,12 +5203,12 @@ int msm_comm_set_scratch_buffers(struct msm_vidc_inst *inst) int rc = 0; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, "%s invalid parameters\n", __func__); + d_vpr_e("%s: invalid parameters\n", __func__); return -EINVAL; } if (msm_comm_release_scratch_buffers(inst, true)) - dprintk(VIDC_ERR, "Failed to release scratch buffers\n"); + s_vpr_e(inst->sid, "Failed to release scratch buffers\n"); rc = set_internal_buffers(inst, HAL_BUFFER_INTERNAL_SCRATCH, &inst->scratchbufs); @@ -5264,13 +5239,13 @@ int msm_comm_set_recon_buffers(struct msm_vidc_inst *inst) struct msm_vidc_list *buf_list = &inst->refbufs; if (!inst) { - dprintk(VIDC_ERR, "%s invalid parameters\n", __func__); + d_vpr_e("%s: invalid parameters\n", __func__); return -EINVAL; } if (inst->session_type != MSM_VIDC_ENCODER && inst->session_type != MSM_VIDC_DECODER) { - dprintk(VIDC_HIGH, "Recon buffs not req for cvp\n"); + s_vpr_h(inst->sid, "Recon buffs not req for cvp\n"); return 0; } @@ -5281,7 +5256,7 @@ int msm_comm_set_recon_buffers(struct msm_vidc_inst *inst) for (i = 0; i < bufcount; i++) { binfo = kzalloc(sizeof(*binfo), GFP_KERNEL); if (!binfo) { - dprintk(VIDC_ERR, "Out of memory\n"); + s_vpr_e(inst->sid, "%s: Out of memory\n", __func__); rc = -ENOMEM; goto fail_kzalloc; } @@ -5301,7 +5276,7 @@ int msm_comm_set_persist_buffers(struct msm_vidc_inst *inst) int rc = 0; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, "%s invalid parameters\n", __func__); + d_vpr_e("%s: invalid parameters\n", __func__); return -EINVAL; } @@ -5339,13 +5314,12 @@ static void msm_comm_flush_in_invalid_state(struct msm_vidc_inst *inst) struct vb2_buffer, queued_entry); if (vb->state == VB2_BUF_STATE_ACTIVE) { vb->planes[0].bytesused = 0; - print_vb2_buffer(VIDC_ERR, "flush in invalid", - inst, vb); + print_vb2_buffer("flush in invalid", inst, vb); vb2_buffer_done(vb, VB2_BUF_STATE_DONE); } else { - dprintk(VIDC_ERR, - "%s VB is in state %d not in ACTIVE state\n" - , __func__, vb->state); + s_vpr_e(inst->sid, + "%s: VB is in state %d not in ACTIVE state\n", + __func__, vb->state); } } mutex_unlock(&inst->bufq[port].lock); @@ -5364,13 +5338,12 @@ int msm_comm_flush(struct msm_vidc_inst *inst, u32 flags) struct hfi_device *hdev; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, - "Invalid params, inst %pK\n", inst); + d_vpr_e("invalid params %pK\n", inst); return -EINVAL; } if (inst->state < MSM_VIDC_OPEN_DONE) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Invalid state to call flush, inst %pK, state %#x\n", inst, inst->state); return -EINVAL; @@ -5383,15 +5356,14 @@ int msm_comm_flush(struct msm_vidc_inst *inst, u32 flags) op_flush = !!(flags & V4L2_CMD_FLUSH_CAPTURE); if (ip_flush && !op_flush) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Input only flush not supported, making it flush all\n"); op_flush = true; goto exit; } if ((inst->in_flush && ip_flush) || (inst->out_flush && op_flush)) { - dprintk(VIDC_ERR, "%s: %x : Already in flush\n", - __func__, hash32_ptr(inst->session)); + s_vpr_e(inst->sid, "%s: Already in flush\n", __func__); goto exit; } @@ -5399,9 +5371,8 @@ int msm_comm_flush(struct msm_vidc_inst *inst, u32 flags) cancel_batch_work(inst); if (inst->state == MSM_VIDC_CORE_INVALID) { - dprintk(VIDC_ERR, - "Core %pK and inst %pK are in bad state\n", - core, inst); + s_vpr_e(inst->sid, "Core %pK and inst %pK are in bad state\n", + core, inst); msm_comm_flush_in_invalid_state(inst); goto exit; } @@ -5454,17 +5425,17 @@ int msm_comm_flush(struct msm_vidc_inst *inst, u32 flags) hdev = inst->core->device; if (ip_flush) { - dprintk(VIDC_HIGH, "Send flush on all ports to firmware\n"); + s_vpr_h(inst->sid, "Send flush on all ports to firmware\n"); rc = call_hfi_op(hdev, session_flush, inst->session, HAL_FLUSH_ALL); } else { - dprintk(VIDC_HIGH, "Send flush on output port to firmware\n"); + s_vpr_h(inst->sid, "Send flush on output port to firmware\n"); rc = call_hfi_op(hdev, session_flush, inst->session, HAL_FLUSH_OUTPUT); } mutex_unlock(&inst->flush_lock); if (rc) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Sending flush to firmware failed, flush out all buffers\n"); msm_comm_flush_in_invalid_state(inst); /* disable in_flush & out_flush */ @@ -5481,7 +5452,7 @@ int msm_vidc_noc_error_info(struct msm_vidc_core *core) struct hfi_device *hdev; if (!core || !core->device) { - dprintk(VIDC_ERR, "%s: Invalid parameters: %pK\n", + d_vpr_e("%s: Invalid parameters: %pK\n", __func__, core); return -EINVAL; } @@ -5502,7 +5473,7 @@ int msm_vidc_trigger_ssr(struct msm_vidc_core *core, enum hal_ssr_trigger_type type) { if (!core) { - dprintk(VIDC_ERR, "%s: Invalid parameters\n", __func__); + d_vpr_e("%s: Invalid parameters\n", __func__); return -EINVAL; } core->ssr_type = type; @@ -5518,15 +5489,14 @@ void msm_vidc_ssr_handler(struct work_struct *work) core = container_of(work, struct msm_vidc_core, ssr_work); if (!core || !core->device) { - dprintk(VIDC_ERR, "%s: Invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, core); return; } hdev = core->device; mutex_lock(&core->lock); if (core->state == VIDC_CORE_INIT_DONE) { - dprintk(VIDC_ERR, "%s: ssr type %d\n", __func__, - core->ssr_type); + d_vpr_e("%s: ssr type %d\n", __func__, core->ssr_type); /* * In current implementation user-initiated SSR triggers * a fatal error from hardware. However, there is no way @@ -5537,13 +5507,11 @@ void msm_vidc_ssr_handler(struct work_struct *work) rc = call_hfi_op(hdev, core_trigger_ssr, hdev->hfi_device_data, core->ssr_type); if (rc) { - dprintk(VIDC_ERR, "%s: trigger_ssr failed\n", - __func__); + d_vpr_e("%s: trigger_ssr failed\n", __func__); core->trigger_ssr = false; } } else { - dprintk(VIDC_ERR, "%s: video core %pK not initialized\n", - __func__, core); + d_vpr_e("%s: video core not initialized\n", __func__); } mutex_unlock(&core->lock); } @@ -5555,13 +5523,13 @@ static int msm_vidc_check_mbpf_supported(struct msm_vidc_inst *inst) struct msm_vidc_inst *temp; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } core = inst->core; if (!core->resources.max_mbpf) { - dprintk(VIDC_HIGH, "%s: max mbpf not available\n", + s_vpr_h(inst->sid, "%s: max mbpf not available\n", __func__); return 0; } @@ -5603,10 +5571,9 @@ static int msm_vidc_check_mbps_supported(struct msm_vidc_inst *inst) num_mbs_per_sec += msm_comm_get_device_load(inst->core, MSM_VIDC_ENCODER, quirks); if (num_mbs_per_sec > max_load_adj) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "H/W is overloaded. needed: %d max: %d\n", - num_mbs_per_sec, - max_load_adj); + num_mbs_per_sec, max_load_adj); msm_vidc_print_running_insts(inst->core); return -EBUSY; } @@ -5625,7 +5592,7 @@ int msm_vidc_check_scaling_supported(struct msm_vidc_inst *inst) if (is_image_session(inst)) { ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_IMG_GRID_SIZE); if (ctrl->val > 0) { - dprintk(VIDC_HIGH, "Skip scaling check for HEIC\n"); + s_vpr_h(inst->sid, "Skip scaling check for HEIC\n"); return 0; } } @@ -5638,11 +5605,9 @@ int msm_vidc_check_scaling_supported(struct msm_vidc_inst *inst) output_width = f->fmt.pix_mp.width; if (!input_height || !input_width || !output_height || !output_width) { - dprintk(VIDC_ERR, - "Invalid : Input height = %d width = %d", + s_vpr_e(inst->sid, "Invalid : Input height = %d width = %d", input_height, input_width); - dprintk(VIDC_ERR, - " output height = %d width = %d\n", + s_vpr_e(inst->sid, " output height = %d width = %d\n", output_height, output_width); return -ENOTSUPP; } @@ -5654,14 +5619,14 @@ int msm_vidc_check_scaling_supported(struct msm_vidc_inst *inst) if (input_width * input_height != output_width * output_height) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: scaling is not supported (%dx%d != %dx%d)\n", __func__, input_width, input_height, output_width, output_height); return -ENOTSUPP; } - dprintk(VIDC_HIGH, "%s: supported WxH = %dx%d\n", + s_vpr_h(inst->sid, "%s: supported WxH = %dx%d\n", __func__, input_width, input_height); return 0; } @@ -5673,14 +5638,14 @@ int msm_vidc_check_scaling_supported(struct msm_vidc_inst *inst) if (input_height > output_height) { if (input_height > x_min * output_height) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Unsupported height min height %d vs %d\n", input_height / x_min, output_height); return -ENOTSUPP; } } else { if (output_height > x_max * input_height) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Unsupported height max height %d vs %d\n", x_max * input_height, output_height); return -ENOTSUPP; @@ -5688,14 +5653,14 @@ int msm_vidc_check_scaling_supported(struct msm_vidc_inst *inst) } if (input_width > output_width) { if (input_width > y_min * output_width) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Unsupported width min width %d vs %d\n", input_width / y_min, output_width); return -ENOTSUPP; } } else { if (output_width > y_max * input_width) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Unsupported width max width %d vs %d\n", y_max * input_width, output_width); return -ENOTSUPP; @@ -5715,18 +5680,19 @@ int msm_vidc_check_session_supported(struct msm_vidc_inst *inst) u32 mbpf_max; struct v4l2_format *f; struct v4l2_ctrl *ctrl = NULL; + u32 sid; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, "%s: Invalid parameter\n", __func__); + d_vpr_e("%s: Invalid parameter\n", __func__); return -EINVAL; } capability = &inst->capability; hdev = inst->core->device; core = inst->core; + sid = inst->sid; rc = msm_vidc_check_mbps_supported(inst); if (rc) { - dprintk(VIDC_ERR, - "%s: Hardware is overloaded\n", __func__); + s_vpr_e(sid, "%s: Hardware is overloaded\n", __func__); return rc; } @@ -5735,7 +5701,7 @@ int msm_vidc_check_session_supported(struct msm_vidc_inst *inst) return rc; if (!is_thermal_permissible(core)) { - dprintk(VIDC_ERR, + s_vpr_e(sid, "Thermal level critical, stop all active sessions!\n"); return -ENOTSUPP; } @@ -5772,8 +5738,7 @@ int msm_vidc_check_session_supported(struct msm_vidc_inst *inst) if (is_image_session(inst)) { if (is_secure_session(inst)) { - dprintk(VIDC_ERR, - "Secure image encode isn't supported!\n"); + s_vpr_e(sid, "Secure image encode isn't supported!\n"); return -ENOTSUPP; } @@ -5815,10 +5780,9 @@ int msm_vidc_check_session_supported(struct msm_vidc_inst *inst) if (inst->session_type == MSM_VIDC_ENCODER && (input_width % 2 != 0 || input_height % 2 != 0 || output_width % 2 != 0 || output_height % 2 != 0)) { - dprintk(VIDC_ERR, + s_vpr_e(sid, "Height and Width should be even numbers for NV12\n"); - dprintk(VIDC_ERR, - "Input WxH = (%u)x(%u), Output WxH = (%u)x(%u)\n", + s_vpr_e(sid, "Input WxH = (%u)x(%u), Output WxH = (%u)x(%u)\n", input_width, input_height, output_width, output_height); rc = -ENOTSUPP; @@ -5830,14 +5794,14 @@ int msm_vidc_check_session_supported(struct msm_vidc_inst *inst) if (!rc) { if (output_width < width_min || output_height < height_min) { - dprintk(VIDC_ERR, - "Unsupported WxH = (%u)x(%u), min supported is - (%u)x(%u)\n", + s_vpr_e(sid, + "Unsupported WxH (%u)x(%u), min supported is (%u)x(%u)\n", output_width, output_height, width_min, height_min); rc = -ENOTSUPP; } if (!rc && output_width > width_max) { - dprintk(VIDC_ERR, + s_vpr_e(sid, "Unsupported width = %u supported max width = %u\n", output_width, width_max); rc = -ENOTSUPP; @@ -5845,10 +5809,10 @@ int msm_vidc_check_session_supported(struct msm_vidc_inst *inst) if (!rc && output_height * output_width > width_max * height_max) { - dprintk(VIDC_ERR, - "Unsupported WxH = (%u)x(%u), max supported is - (%u)x(%u)\n", - output_width, output_height, - width_max, height_max); + s_vpr_e(sid, + "Unsupported WxH = (%u)x(%u), max supported is (%u)x(%u)\n", + output_width, output_height, + width_max, height_max); rc = -ENOTSUPP; } /* Image size max capability has equal width and height, @@ -5857,7 +5821,7 @@ int msm_vidc_check_session_supported(struct msm_vidc_inst *inst) if (!rc && !is_image_session(inst) && NUM_MBS_PER_FRAME(input_width, input_height) > mbpf_max) { - dprintk(VIDC_ERR, "Unsupported mbpf %d, max %d\n", + s_vpr_e(sid, "Unsupported mbpf %d, max %d\n", NUM_MBS_PER_FRAME(input_width, input_height), mbpf_max); rc = -ENOTSUPP; @@ -5868,16 +5832,16 @@ int msm_vidc_check_session_supported(struct msm_vidc_inst *inst) output_height > INTERLACE_HEIGHT_MAX || (NUM_MBS_PER_FRAME(output_height, output_width) > INTERLACE_MB_PER_FRAME_MAX))) { - dprintk(VIDC_ERR, - "Unsupported interlace WxH = (%u)x(%u), max supported is - (%u)x(%u)\n", + s_vpr_e(sid, + "Unsupported interlace WxH = (%u)x(%u), max supported is (%u)x(%u)\n", output_width, output_height, - INTERLACE_WIDTH_MAX, INTERLACE_HEIGHT_MAX); + INTERLACE_WIDTH_MAX, + INTERLACE_HEIGHT_MAX); rc = -ENOTSUPP; } } if (rc) { - dprintk(VIDC_ERR, - "%s: Resolution unsupported\n", __func__); + s_vpr_e(sid, "%s: Resolution unsupported\n", __func__); } return rc; } @@ -5888,11 +5852,11 @@ void msm_comm_generate_session_error(struct msm_vidc_inst *inst) struct msm_vidc_cb_cmd_done response = {0}; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid input parameters\n", __func__); + d_vpr_e("%s: invalid input parameters\n", __func__); return; } - dprintk(VIDC_ERR, "%s: inst %pK\n", __func__, inst); - response.session_id = inst; + s_vpr_e(inst->sid, "%s: inst %pK\n", __func__, inst); + response.inst_id = inst; response.status = VIDC_ERR_FAIL; handle_session_error(cmd, (void *)&response); } @@ -5904,10 +5868,10 @@ void msm_comm_generate_sys_error(struct msm_vidc_inst *inst) struct msm_vidc_cb_cmd_done response = {0}; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid input parameters\n", __func__); + d_vpr_e("%s: invalid input parameters\n", __func__); return; } - dprintk(VIDC_ERR, "%s: inst %pK\n", __func__, inst); + s_vpr_e(inst->sid, "%s: inst %pK\n", __func__, inst); core = inst->core; response.device_id = (u32) core->id; handle_sys_error(cmd, (void *) &response); @@ -5919,16 +5883,16 @@ int msm_comm_kill_session(struct msm_vidc_inst *inst) int rc = 0; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, "%s: invalid input parameters\n", __func__); + d_vpr_e("%s: invalid input parameters\n", __func__); return -EINVAL; } else if (!inst->session) { - dprintk(VIDC_ERR, "%s: no session to kill for inst %pK\n", + s_vpr_e(inst->sid, "%s: no session to kill for inst %pK\n", __func__, inst); return 0; } - dprintk(VIDC_ERR, "%s: inst %pK, session %x state %d\n", __func__, - inst, hash32_ptr(inst->session), inst->state); + s_vpr_e(inst->sid, "%s: inst %pK, state %d\n", __func__, + inst, inst->state); /* * We're internally forcibly killing the session, if fw is aware of * the session send session_abort to firmware to clean up and release @@ -5939,9 +5903,9 @@ int msm_comm_kill_session(struct msm_vidc_inst *inst) inst->state == MSM_VIDC_CORE_INVALID) { rc = msm_comm_session_abort(inst); if (rc) { - dprintk(VIDC_ERR, - "%s: inst %pK session %x abort failed\n", - __func__, inst, hash32_ptr(inst->session)); + s_vpr_e(inst->sid, + "%s: inst %pK session abort failed\n", + __func__, inst); change_inst_state(inst, MSM_VIDC_CORE_INVALID); } } @@ -5949,8 +5913,8 @@ int msm_comm_kill_session(struct msm_vidc_inst *inst) change_inst_state(inst, MSM_VIDC_CLOSE_DONE); msm_comm_session_clean(inst); - dprintk(VIDC_ERR, "%s: inst %pK session %x handled\n", __func__, - inst, hash32_ptr(inst->session)); + s_vpr_e(inst->sid, "%s: inst %pK handled\n", __func__, + inst); return rc; } @@ -5961,23 +5925,23 @@ int msm_comm_smem_alloc(struct msm_vidc_inst *inst, int rc = 0; if (!inst || !inst->core) { - dprintk(VIDC_ERR, "%s: invalid inst: %pK\n", __func__, inst); + d_vpr_e("%s: invalid inst: %pK\n", __func__, inst); return -EINVAL; } rc = msm_smem_alloc(size, align, flags, buffer_type, map_kernel, &(inst->core->resources), inst->session_type, - smem); + smem, inst->sid); return rc; } void msm_comm_smem_free(struct msm_vidc_inst *inst, struct msm_smem *mem) { if (!inst || !inst->core || !mem) { - dprintk(VIDC_ERR, - "%s: invalid params: %pK %pK\n", __func__, inst, mem); + d_vpr_e("%s: invalid params: %pK %pK\n", + __func__, inst, mem); return; } - msm_smem_free(mem); + msm_smem_free(mem, inst->sid); } void msm_vidc_fw_unload_handler(struct work_struct *work) @@ -5988,8 +5952,7 @@ void msm_vidc_fw_unload_handler(struct work_struct *work) core = container_of(work, struct msm_vidc_core, fw_unload_work.work); if (!core || !core->device) { - dprintk(VIDC_ERR, "%s - invalid work or core handle\n", - __func__); + d_vpr_e("%s: invalid work or core handle\n", __func__); return; } @@ -5999,12 +5962,11 @@ void msm_vidc_fw_unload_handler(struct work_struct *work) if (list_empty(&core->instances) && core->state != VIDC_CORE_UNINIT) { if (core->state > VIDC_CORE_INIT) { - dprintk(VIDC_HIGH, "Calling vidc_hal_core_release\n"); + d_vpr_h("Calling vidc_hal_core_release\n"); rc = call_hfi_op(hdev, core_release, hdev->hfi_device_data); if (rc) { - dprintk(VIDC_ERR, - "Failed to release core, id = %d\n", + d_vpr_e("Failed to release core, id = %d\n", core->id); mutex_unlock(&core->lock); return; @@ -6026,24 +5988,24 @@ int msm_comm_set_color_format(struct msm_vidc_inst *inst, struct hfi_device *hdev; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, "%s - invalid param\n", __func__); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } hdev = inst->core->device; - format = msm_comm_get_hfi_uncompressed(fourcc); - hfi_fmt.buffer_type = get_hfi_buffer(buffer_type); + format = msm_comm_get_hfi_uncompressed(fourcc, inst->sid); + hfi_fmt.buffer_type = get_hfi_buffer(buffer_type, inst->sid); hfi_fmt.format = format; - + s_vpr_h(inst->sid, "buffer_type %#x, format %#x\n", + hfi_fmt.buffer_type, hfi_fmt.format); rc = call_hfi_op(hdev, session_set_property, inst->session, HFI_PROPERTY_PARAM_UNCOMPRESSED_FORMAT_SELECT, &hfi_fmt, sizeof(hfi_fmt)); if (rc) - dprintk(VIDC_ERR, - "Failed to set input color format\n"); + s_vpr_e(inst->sid, "Failed to set input color format\n"); else - dprintk(VIDC_HIGH, "Setting uncompressed colorformat to %#x\n", + s_vpr_h(inst->sid, "Setting uncompressed colorformat to %#x\n", format); return rc; @@ -6059,8 +6021,7 @@ void msm_comm_print_inst_info(struct msm_vidc_inst *inst) struct v4l2_format *f; if (!inst) { - dprintk(VIDC_ERR, "%s - invalid param %pK\n", - __func__, inst); + d_vpr_e("%s: invalid params\n", __func__); return; } @@ -6068,7 +6029,7 @@ void msm_comm_print_inst_info(struct msm_vidc_inst *inst) port = is_decode ? INPUT_PORT : OUTPUT_PORT; is_secure = inst->flags & VIDC_SECURE; f = &inst->fmts[port].v4l2_fmt; - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s session, %s, Codec type: %s HxW: %d x %d fps: %d bitrate: %d bit-depth: %s\n", is_decode ? "Decode" : "Encode", is_secure ? "Secure" : "Non-Secure", @@ -6076,36 +6037,34 @@ void msm_comm_print_inst_info(struct msm_vidc_inst *inst) f->fmt.pix_mp.height, f->fmt.pix_mp.width, inst->clk_data.frame_rate >> 16, inst->prop.bitrate, !inst->bit_depth ? "8" : "10"); - - dprintk(VIDC_ERR, - "---Buffer details for inst: %pK of type: %d---\n", + s_vpr_e(inst->sid, "---Buffer details for inst: %pK of type: %d---\n", inst, inst->session_type); mutex_lock(&inst->registeredbufs.lock); - dprintk(VIDC_ERR, "registered buffer list:\n"); + s_vpr_e(inst->sid, "registered buffer list:\n"); list_for_each_entry(mbuf, &inst->registeredbufs.list, list) print_vidc_buffer(VIDC_ERR, "buf", inst, mbuf); mutex_unlock(&inst->registeredbufs.lock); mutex_lock(&inst->scratchbufs.lock); - dprintk(VIDC_ERR, "scratch buffer list:\n"); + s_vpr_e(inst->sid, "scratch buffer list:\n"); list_for_each_entry(buf, &inst->scratchbufs.list, list) - dprintk(VIDC_ERR, "type: %d addr: %x size: %u\n", + s_vpr_e(inst->sid, "type: %d addr: %x size: %u\n", buf->buffer_type, buf->smem.device_addr, buf->smem.size); mutex_unlock(&inst->scratchbufs.lock); mutex_lock(&inst->persistbufs.lock); - dprintk(VIDC_ERR, "persist buffer list:\n"); + s_vpr_e(inst->sid, "persist buffer list:\n"); list_for_each_entry(buf, &inst->persistbufs.list, list) - dprintk(VIDC_ERR, "type: %d addr: %x size: %u\n", + s_vpr_e(inst->sid, "type: %d addr: %x size: %u\n", buf->buffer_type, buf->smem.device_addr, buf->smem.size); mutex_unlock(&inst->persistbufs.lock); mutex_lock(&inst->outputbufs.lock); - dprintk(VIDC_ERR, "dpb buffer list:\n"); + s_vpr_e(inst->sid, "dpb buffer list:\n"); list_for_each_entry(buf, &inst->outputbufs.list, list) - dprintk(VIDC_ERR, "type: %d addr: %x size: %u\n", + s_vpr_e(inst->sid, "type: %d addr: %x size: %u\n", buf->buffer_type, buf->smem.device_addr, buf->smem.size); mutex_unlock(&inst->outputbufs.lock); @@ -6123,18 +6082,17 @@ int msm_comm_session_continue(void *instance) mutex_lock(&inst->lock); if (inst->state >= MSM_VIDC_RELEASE_RESOURCES_DONE || inst->state < MSM_VIDC_START_DONE) { - dprintk(VIDC_HIGH, - "Inst %pK : Not in valid state to call %s\n", + s_vpr_h(inst->sid, "Inst %pK : Not in valid state to call %s\n", inst, __func__); goto sess_continue_fail; } if (inst->session_type == MSM_VIDC_DECODER && inst->in_reconfig) { - dprintk(VIDC_HIGH, "send session_continue\n"); + s_vpr_h(inst->sid, "send session_continue\n"); rc = call_hfi_op(hdev, session_continue, (void *)inst->session); if (rc) { - dprintk(VIDC_ERR, - "failed to send session_continue\n"); + s_vpr_e(inst->sid, + "failed to send session_continue\n"); rc = -EINVAL; goto sess_continue_fail; } @@ -6144,18 +6102,17 @@ int msm_comm_session_continue(void *instance) HAL_VIDEO_DECODER_SECONDARY) { rc = msm_comm_queue_dpb_only_buffers(inst); if (rc) { - dprintk(VIDC_ERR, - "Failed to queue output buffers: %d\n", - rc); + s_vpr_e(inst->sid, + "Failed to queue output buffers\n"); goto sess_continue_fail; } } } else if (inst->session_type == MSM_VIDC_ENCODER) { - dprintk(VIDC_HIGH, - "session_continue not supported for encoder"); + s_vpr_h(inst->sid, + "session_continue not supported for encoder"); } else { - dprintk(VIDC_ERR, - "session_continue called in wrong state for decoder"); + s_vpr_e(inst->sid, + "session_continue called in wrong state for decoder"); } sess_continue_fail: @@ -6174,20 +6131,20 @@ void print_vidc_buffer(u32 tag, const char *str, struct msm_vidc_inst *inst, vb2 = &mbuf->vvb.vb2_buf; if (vb2->num_planes == 1) - dprintk(tag, - "%s: %s: %x : idx %2d fd %d off %d daddr %x size %d filled %d flags 0x%x ts %lld refcnt %d mflags 0x%x\n", + dprintk(tag, inst->sid, + "%s: %s: idx %2d fd %d off %d daddr %x size %d filled %d flags 0x%x ts %lld refcnt %d mflags 0x%x\n", str, vb2->type == INPUT_MPLANE ? - "OUTPUT" : "CAPTURE", hash32_ptr(inst->session), + "OUTPUT" : "CAPTURE", vb2->index, vb2->planes[0].m.fd, vb2->planes[0].data_offset, mbuf->smem[0].device_addr, vb2->planes[0].length, vb2->planes[0].bytesused, mbuf->vvb.flags, mbuf->vvb.vb2_buf.timestamp, mbuf->smem[0].refcount, mbuf->flags); else - dprintk(tag, - "%s: %s: %x : idx %2d fd %d off %d daddr %x size %d filled %d flags 0x%x ts %lld refcnt %d mflags 0x%x, extradata: fd %d off %d daddr %x size %d filled %d refcnt %d\n", + dprintk(tag, inst->sid, + "%s: %s: idx %2d fd %d off %d daddr %x size %d filled %d flags 0x%x ts %lld refcnt %d mflags 0x%x, extradata: fd %d off %d daddr %x size %d filled %d refcnt %d\n", str, vb2->type == INPUT_MPLANE ? - "OUTPUT" : "CAPTURE", hash32_ptr(inst->session), + "OUTPUT" : "CAPTURE", vb2->index, vb2->planes[0].m.fd, vb2->planes[0].data_offset, mbuf->smem[0].device_addr, vb2->planes[0].length, vb2->planes[0].bytesused, @@ -6198,29 +6155,23 @@ void print_vidc_buffer(u32 tag, const char *str, struct msm_vidc_inst *inst, vb2->planes[1].bytesused, mbuf->smem[1].refcount); } -void print_vb2_buffer(u32 tag, const char *str, struct msm_vidc_inst *inst, +void print_vb2_buffer(const char *str, struct msm_vidc_inst *inst, struct vb2_buffer *vb2) { - if (!(tag & msm_vidc_debug) || !inst || !vb2) - return; - if ((tag & VIDC_PERF) && - !(tag & VIDC_HIGH) && - (inst->session_type != MSM_VIDC_DECODER)) + if (!inst || !vb2) return; if (vb2->num_planes == 1) - dprintk(tag, - "%s: %s: %x : idx %2d fd %d off %d size %d filled %d\n", - str, vb2->type == INPUT_MPLANE ? - "OUTPUT" : "CAPTURE", hash32_ptr(inst->session), + s_vpr_e(inst->sid, + "%s: %s: idx %2d fd %d off %d size %d filled %d\n", + str, vb2->type == INPUT_MPLANE ? "OUTPUT" : "CAPTURE", vb2->index, vb2->planes[0].m.fd, vb2->planes[0].data_offset, vb2->planes[0].length, vb2->planes[0].bytesused); else - dprintk(tag, - "%s: %s: %x : idx %2d fd %d off %d size %d filled %d, extradata: fd %d off %d size %d filled %d\n", - str, vb2->type == INPUT_MPLANE ? - "OUTPUT" : "CAPTURE", hash32_ptr(inst->session), + s_vpr_e(inst->sid, + "%s: %s: idx %2d fd %d off %d size %d filled %d, extradata: fd %d off %d size %d filled %d\n", + str, vb2->type == INPUT_MPLANE ? "OUTPUT" : "CAPTURE", vb2->index, vb2->planes[0].m.fd, vb2->planes[0].data_offset, vb2->planes[0].length, vb2->planes[0].bytesused, vb2->planes[1].m.fd, @@ -6228,43 +6179,13 @@ void print_vb2_buffer(u32 tag, const char *str, struct msm_vidc_inst *inst, vb2->planes[1].bytesused); } -void print_v4l2_buffer(u32 tag, const char *str, struct msm_vidc_inst *inst, - struct v4l2_buffer *v4l2) -{ - if (!(tag & msm_vidc_debug) || !inst || !v4l2) - return; - - if (v4l2->length == 1) - dprintk(tag, - "%s: %s: %x : idx %2d fd %d off %d size %d filled %d\n", - str, v4l2->type == INPUT_MPLANE ? - "OUTPUT" : "CAPTURE", hash32_ptr(inst->session), - v4l2->index, v4l2->m.planes[0].m.fd, - v4l2->m.planes[0].data_offset, - v4l2->m.planes[0].length, - v4l2->m.planes[0].bytesused); - else - dprintk(tag, - "%s: %s: %x : idx %2d fd %d off %d size %d filled %d, extradata: fd %d off %d size %d filled %d\n", - str, v4l2->type == INPUT_MPLANE ? - "OUTPUT" : "CAPTURE", hash32_ptr(inst->session), - v4l2->index, v4l2->m.planes[0].m.fd, - v4l2->m.planes[0].data_offset, - v4l2->m.planes[0].length, - v4l2->m.planes[0].bytesused, - v4l2->m.planes[1].m.fd, - v4l2->m.planes[1].data_offset, - v4l2->m.planes[1].length, - v4l2->m.planes[1].bytesused); -} - bool msm_comm_compare_vb2_plane(struct msm_vidc_inst *inst, struct msm_vidc_buffer *mbuf, struct vb2_buffer *vb2, u32 i) { struct vb2_buffer *vb; if (!inst || !mbuf || !vb2) { - dprintk(VIDC_ERR, "%s: invalid params, %pK %pK %pK\n", + d_vpr_e("%s: invalid params, %pK %pK %pK\n", __func__, inst, mbuf, vb2); return false; } @@ -6285,7 +6206,7 @@ bool msm_comm_compare_vb2_planes(struct msm_vidc_inst *inst, struct vb2_buffer *vb; if (!inst || !mbuf || !vb2) { - dprintk(VIDC_ERR, "%s: invalid params, %pK %pK %pK\n", + d_vpr_e("%s: invalid params, %pK %pK %pK\n", __func__, inst, mbuf, vb2); return false; } @@ -6307,7 +6228,7 @@ bool msm_comm_compare_dma_plane(struct msm_vidc_inst *inst, struct msm_vidc_buffer *mbuf, unsigned long *dma_planes, u32 i) { if (!inst || !mbuf || !dma_planes) { - dprintk(VIDC_ERR, "%s: invalid params, %pK %pK %pK\n", + d_vpr_e("%s: invalid params, %pK %pK %pK\n", __func__, inst, mbuf, dma_planes); return false; } @@ -6325,7 +6246,7 @@ bool msm_comm_compare_dma_planes(struct msm_vidc_inst *inst, struct vb2_buffer *vb; if (!inst || !mbuf || !dma_planes) { - dprintk(VIDC_ERR, "%s: invalid params, %pK %pK %pK\n", + d_vpr_e("%s: invalid params, %pK %pK %pK\n", __func__, inst, mbuf, dma_planes); return false; } @@ -6340,11 +6261,11 @@ bool msm_comm_compare_dma_planes(struct msm_vidc_inst *inst, } -bool msm_comm_compare_device_plane(struct msm_vidc_buffer *mbuf, +bool msm_comm_compare_device_plane(u32 sid, struct msm_vidc_buffer *mbuf, u32 type, u32 *planes, u32 i) { if (!mbuf || !planes) { - dprintk(VIDC_ERR, "%s: invalid params, %pK %pK\n", + s_vpr_e(sid, "%s: invalid params, %pK %pK\n", __func__, mbuf, planes); return false; } @@ -6356,7 +6277,7 @@ bool msm_comm_compare_device_plane(struct msm_vidc_buffer *mbuf, return false; } -bool msm_comm_compare_device_planes(struct msm_vidc_buffer *mbuf, +bool msm_comm_compare_device_planes(u32 sid, struct msm_vidc_buffer *mbuf, u32 type, u32 *planes) { unsigned int i = 0; @@ -6365,7 +6286,7 @@ bool msm_comm_compare_device_planes(struct msm_vidc_buffer *mbuf, return false; for (i = 0; i < mbuf->vvb.vb2_buf.num_planes; i++) { - if (!msm_comm_compare_device_plane(mbuf, type, planes, i)) + if (!msm_comm_compare_device_plane(sid, mbuf, type, planes, i)) return false; } @@ -6381,14 +6302,15 @@ struct msm_vidc_buffer *msm_comm_get_buffer_using_device_planes( mutex_lock(&inst->registeredbufs.lock); found = false; list_for_each_entry(mbuf, &inst->registeredbufs.list, list) { - if (msm_comm_compare_device_planes(mbuf, type, planes)) { + if (msm_comm_compare_device_planes(inst->sid, mbuf, + type, planes)) { found = true; break; } } mutex_unlock(&inst->registeredbufs.lock); if (!found) { - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "%s: data_addr %x, extradata_addr %x not found\n", __func__, planes[0], planes[1]); mbuf = NULL; @@ -6404,7 +6326,7 @@ int msm_comm_flush_vidc_buffer(struct msm_vidc_inst *inst, u32 port; if (!inst || !mbuf) { - dprintk(VIDC_ERR, "%s: invalid params %pK %pK\n", + d_vpr_e("%s: invalid params %pK %pK\n", __func__, inst, mbuf); return -EINVAL; } @@ -6428,7 +6350,7 @@ int msm_comm_flush_vidc_buffer(struct msm_vidc_inst *inst, vb->planes[0].bytesused = 0; vb2_buffer_done(vb, VB2_BUF_STATE_DONE); } else { - dprintk(VIDC_ERR, "%s: port %d is not streaming\n", + s_vpr_e(inst->sid, "%s: port %d is not streaming\n", __func__, port); } mutex_unlock(&inst->bufq[port].lock); @@ -6445,7 +6367,7 @@ int msm_comm_qbuf_cache_operations(struct msm_vidc_inst *inst, bool skip; if (!inst || !mbuf) { - dprintk(VIDC_ERR, "%s: invalid params %pK %pK\n", + d_vpr_e("%s: invalid params %pK %pK\n", __func__, inst, mbuf); return -EINVAL; } @@ -6494,7 +6416,7 @@ int msm_comm_qbuf_cache_operations(struct msm_vidc_inst *inst, if (!skip) { rc = msm_smem_cache_operations(mbuf->smem[i].dma_buf, - cache_op, offset, size); + cache_op, offset, size, inst->sid); if (rc) print_vidc_buffer(VIDC_ERR, "qbuf cache ops failed", inst, mbuf); @@ -6513,7 +6435,7 @@ int msm_comm_dqbuf_cache_operations(struct msm_vidc_inst *inst, bool skip; if (!inst || !mbuf) { - dprintk(VIDC_ERR, "%s: invalid params %pK %pK\n", + d_vpr_e("%s: invalid params %pK %pK\n", __func__, inst, mbuf); return -EINVAL; } @@ -6557,7 +6479,7 @@ int msm_comm_dqbuf_cache_operations(struct msm_vidc_inst *inst, if (!skip) { rc = msm_smem_cache_operations(mbuf->smem[i].dma_buf, - cache_op, offset, size); + cache_op, offset, size, inst->sid); if (rc) print_vidc_buffer(VIDC_ERR, "dqbuf cache ops failed", inst, mbuf); @@ -6579,7 +6501,8 @@ struct msm_vidc_buffer *msm_comm_get_vidc_buffer(struct msm_vidc_inst *inst, unsigned int i; if (!inst || !vb2) { - dprintk(VIDC_ERR, "%s: invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK %pK\n", + __func__, inst, vb2); return NULL; } @@ -6589,10 +6512,11 @@ struct msm_vidc_buffer *msm_comm_get_vidc_buffer(struct msm_vidc_inst *inst, * to be same across the processes (duplicate fds). */ dma_planes[i] = (unsigned long)msm_smem_get_dma_buf( - vb2->planes[i].m.fd); + vb2->planes[i].m.fd, inst->sid); if (!dma_planes[i]) return NULL; - msm_smem_put_dma_buf((struct dma_buf *)dma_planes[i]); + msm_smem_put_dma_buf((struct dma_buf *)dma_planes[i], + inst->sid); } mutex_lock(&inst->registeredbufs.lock); @@ -6623,7 +6547,7 @@ struct msm_vidc_buffer *msm_comm_get_vidc_buffer(struct msm_vidc_inst *inst, /* this is new vb2_buffer */ mbuf = kzalloc(sizeof(struct msm_vidc_buffer), GFP_KERNEL); if (!mbuf) { - dprintk(VIDC_ERR, "%s: alloc msm_vidc_buffer failed\n", + s_vpr_e(inst->sid, "%s: alloc msm_vidc_buffer failed\n", __func__); rc = -ENOMEM; goto exit; @@ -6645,13 +6569,13 @@ struct msm_vidc_buffer *msm_comm_get_vidc_buffer(struct msm_vidc_inst *inst, mbuf->smem[i].size = vb->planes[i].length; rc = inst->smem_ops->smem_map_dma_buf(inst, &mbuf->smem[i]); if (rc) { - dprintk(VIDC_ERR, "%s: map failed.\n", __func__); + s_vpr_e(inst->sid, "%s: map failed.\n", __func__); goto exit; } /* increase refcount as we get both fbd and rbr */ rc = inst->smem_ops->smem_map_dma_buf(inst, &mbuf->smem[i]); if (rc) { - dprintk(VIDC_ERR, "%s: map failed..\n", __func__); + s_vpr_e(inst->sid, "%s: map failed..\n", __func__); goto exit; } } @@ -6708,7 +6632,7 @@ struct msm_vidc_buffer *msm_comm_get_vidc_buffer(struct msm_vidc_inst *inst, return mbuf; exit: - dprintk(VIDC_ERR, "%s: rc %d\n", __func__, rc); + s_vpr_e(inst->sid, "%s: %d\n", __func__, rc); msm_comm_unmap_vidc_buffer(inst, mbuf); if (!found) kref_put_mbuf(mbuf); @@ -6725,7 +6649,7 @@ void msm_comm_put_vidc_buffer(struct msm_vidc_inst *inst, unsigned int i = 0; if (!inst || !mbuf) { - dprintk(VIDC_ERR, "%s: invalid params %pK %pK\n", + d_vpr_e("%s: invalid params %pK %pK\n", __func__, inst, mbuf); return; } @@ -6835,7 +6759,7 @@ void handle_release_buffer_reference(struct msm_vidc_inst *inst, */ found = false; list_for_each_entry(temp, &inst->registeredbufs.list, list) { - if (msm_comm_compare_device_plane(temp, + if (msm_comm_compare_device_plane(inst->sid, temp, OUTPUT_MPLANE, planes, 0)) { mbuf = temp; found = true; @@ -6882,12 +6806,12 @@ int msm_comm_unmap_vidc_buffer(struct msm_vidc_inst *inst, unsigned int i; if (!inst || !mbuf) { - dprintk(VIDC_ERR, "%s: invalid params %pK %pK\n", + d_vpr_e("%s: invalid params %pK %pK\n", __func__, inst, mbuf); return -EINVAL; } if (mbuf->vvb.vb2_buf.num_planes > VIDEO_MAX_PLANES) { - dprintk(VIDC_ERR, "%s: invalid num_planes %d\n", __func__, + s_vpr_e(inst->sid, "%s: invalid num_planes %d\n", __func__, mbuf->vvb.vb2_buf.num_planes); return -EINVAL; } @@ -6951,8 +6875,7 @@ struct msm_vidc_client_data *msm_comm_store_client_data( struct msm_vidc_client_data *data = NULL, *temp = NULL; if (!inst) { - dprintk(VIDC_ERR, "%s: invalid params %pK %un", - __func__, inst, itag); + d_vpr_e("%s: invalid params\n", __func__); return NULL; } @@ -6966,7 +6889,7 @@ struct msm_vidc_client_data *msm_comm_store_client_data( if (!data) { data = kzalloc(sizeof(*data), GFP_KERNEL); if (!data) { - dprintk(VIDC_ERR, "No memory avilable - tag data"); + s_vpr_e(inst->sid, "%s: No memory avilable", __func__); goto exit; } INIT_LIST_HEAD(&data->list); @@ -6996,7 +6919,7 @@ void msm_comm_fetch_client_data(struct msm_vidc_inst *inst, bool remove, bool found_itag = false, found_itag2 = false; if (!inst || !otag || !otag2) { - dprintk(VIDC_ERR, "%s: invalid params %pK %x %x\n", + d_vpr_e("%s: invalid params %pK %x %x\n", __func__, inst, otag, otag2); return; } @@ -7026,8 +6949,8 @@ void msm_comm_fetch_client_data(struct msm_vidc_inst *inst, bool remove, mutex_unlock(&inst->client_data.lock); if (!found_itag || !found_itag2) { - dprintk(VIDC_ERR, "%s: %x: client data not found - %u, %u\n", - __func__, hash32_ptr(inst->session), itag, itag2); + s_vpr_e(inst->sid, "%s: client data not found - %u, %u\n", + __func__, itag, itag2); } } @@ -7036,8 +6959,7 @@ void msm_comm_release_client_data(struct msm_vidc_inst *inst, bool remove) struct msm_vidc_client_data *temp, *next; if (!inst) { - dprintk(VIDC_ERR, "%s: invalid params %pK\n", - __func__, inst); + d_vpr_e("%s: invalid params\n", __func__); return; } @@ -7053,14 +6975,13 @@ void msm_comm_release_client_data(struct msm_vidc_inst *inst, bool remove) } void msm_comm_store_input_tag(struct msm_vidc_list *data_list, - u32 index, u32 itag, u32 itag2) + u32 index, u32 itag, u32 itag2, u32 sid) { struct msm_vidc_buf_data *pdata = NULL; bool found = false; if (!data_list) { - dprintk(VIDC_ERR, "%s: invalid params %pK\n", - __func__, data_list); + s_vpr_e(sid, "%s: invalid params\n", __func__); return; } @@ -7077,7 +6998,7 @@ void msm_comm_store_input_tag(struct msm_vidc_list *data_list, if (!found) { pdata = kzalloc(sizeof(*pdata), GFP_KERNEL); if (!pdata) { - dprintk(VIDC_ERR, "%s: malloc failure.\n", __func__); + s_vpr_e(sid, "%s: malloc failure.\n", __func__); goto exit; } pdata->index = index; @@ -7091,13 +7012,13 @@ exit: } int msm_comm_fetch_input_tag(struct msm_vidc_list *data_list, - u32 index, u32 *itag, u32 *itag2) + u32 index, u32 *itag, u32 *itag2, u32 sid) { struct msm_vidc_buf_data *pdata = NULL; int rc = 0; if (!data_list || !itag || !itag2) { - dprintk(VIDC_ERR, "%s: invalid params %pK %pK %pK\n", + s_vpr_e(sid, "%s: invalid params %pK %pK %pK\n", __func__, data_list, itag, itag2); return -EINVAL; } @@ -7123,8 +7044,7 @@ int msm_comm_release_input_tag(struct msm_vidc_inst *inst) struct msm_vidc_buf_data *pdata, *next; if (!inst) { - dprintk(VIDC_ERR, "%s: invalid params %pK\n", - __func__, inst); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } @@ -7158,7 +7078,7 @@ int msm_comm_set_color_format_constraints(struct msm_vidc_inst *inst, u32 hfi_fmt; if (!inst || !inst->core || !inst->core->device) { - dprintk(VIDC_ERR, "%s - invalid param\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, inst); return -EINVAL; } @@ -7170,16 +7090,16 @@ int msm_comm_set_color_format_constraints(struct msm_vidc_inst *inst, pconstraint = kzalloc(size, GFP_KERNEL); if (!pconstraint) { - dprintk(VIDC_ERR, "No memory cannot alloc constrain\n"); + s_vpr_e(inst->sid, "No memory cannot alloc constrain\n"); rc = -ENOMEM; goto exit; } - hfi_fmt = msm_comm_convert_color_fmt(pix_constraint->fourcc); - pconstraint->buffer_type = get_hfi_buffer(buffer_type); + hfi_fmt = msm_comm_convert_color_fmt(pix_constraint->fourcc, inst->sid); + pconstraint->buffer_type = get_hfi_buffer(buffer_type, inst->sid); pconstraint->num_planes = pix_constraint->num_planes; //set Y plan constraints - dprintk(VIDC_HIGH, "Set Y plan constraints.\n"); + s_vpr_h(inst->sid, "Set Y plan constraints.\n"); pconstraint->rg_plane_format[0].stride_multiples = VENUS_Y_STRIDE(hfi_fmt, 1); pconstraint->rg_plane_format[0].max_stride = @@ -7190,7 +7110,7 @@ int msm_comm_set_color_format_constraints(struct msm_vidc_inst *inst, pix_constraint->y_buffer_alignment; //set UV plan constraints - dprintk(VIDC_HIGH, "Set UV plan constraints.\n"); + s_vpr_h(inst->sid, "Set UV plan constraints.\n"); pconstraint->rg_plane_format[1].stride_multiples = VENUS_UV_STRIDE(hfi_fmt, 1); pconstraint->rg_plane_format[1].max_stride = @@ -7207,10 +7127,10 @@ int msm_comm_set_color_format_constraints(struct msm_vidc_inst *inst, pconstraint, size); if (rc) - dprintk(VIDC_ERR, + s_vpr_e(inst->sid, "Failed to set input color format constraint\n"); else - dprintk(VIDC_HIGH, "Set color format constraint success\n"); + s_vpr_h(inst->sid, "Set color format constraint success\n"); exit: if (!pconstraint) @@ -7274,7 +7194,7 @@ bool msm_comm_check_for_inst_overload(struct msm_vidc_core *core) if (instance_count > core->resources.max_inst_count || secure_instance_count > core->resources.max_secure_inst_count) { overload = true; - dprintk(VIDC_ERR, + d_vpr_e( "%s: inst_count:%u max_inst:%u sec_inst_count:%u max_sec_inst:%u\n", __func__, instance_count, core->resources.max_inst_count, secure_instance_count, @@ -7291,7 +7211,7 @@ int msm_comm_check_window_bitrate(struct msm_vidc_inst *inst, int buf_cnt = 1, fps, window_start; if (!inst || !inst->core || !frame_data) { - dprintk(VIDC_ERR, "%s: Invalid arguments\n", __func__); + d_vpr_e("%s: Invalid arguments\n", __func__); return -EINVAL; } @@ -7327,7 +7247,7 @@ int msm_comm_check_window_bitrate(struct msm_vidc_inst *inst, if(!temp) { pdata = kzalloc(sizeof(*pdata), GFP_KERNEL); if (!pdata) { - dprintk(VIDC_ERR, "%s: malloc failure.\n", __func__); + s_vpr_e(inst->sid, "%s: malloc failure.\n", __func__); mutex_unlock(&inst->window_data.lock); return -ENOMEM; } @@ -7342,7 +7262,7 @@ int msm_comm_check_window_bitrate(struct msm_vidc_inst *inst, bitrate = DIV_ROUND_UP(((u64)bitrate * 8 * fps), window_size); if (bitrate > max_br) { - dprintk(VIDC_PERF, + s_vpr_p(inst->sid, "Unsupported bitrate %u max %u, window size %u [%u,%u]", bitrate, max_br, window_size, window_start, inst->count.etb); @@ -7356,8 +7276,7 @@ void msm_comm_clear_window_data(struct msm_vidc_inst *inst) struct msm_vidc_window_data *pdata; if (!inst) { - dprintk(VIDC_ERR, "%s: invalid params %pK\n", - __func__, inst); + d_vpr_e("%s: invalid params\n", __func__); return; } @@ -7373,8 +7292,7 @@ void msm_comm_release_window_data(struct msm_vidc_inst *inst) struct msm_vidc_window_data *pdata, *next; if (!inst) { - dprintk(VIDC_ERR, "%s: invalid params %pK\n", - __func__, inst); + d_vpr_e("%s: invalid params\n", __func__); return; } diff --git a/msm/vidc/msm_vidc_common.h b/msm/vidc/msm_vidc_common.h index 45172d170cf4..882b97a93eb3 100644 --- a/msm/vidc/msm_vidc_common.h +++ b/msm/vidc/msm_vidc_common.h @@ -69,12 +69,12 @@ static inline struct v4l2_ctrl *get_ctrl(struct msm_vidc_inst *inst, if (inst->ctrls[i]->id == id) return inst->ctrls[i]; } - dprintk(VIDC_ERR, "%s: control id (%#x) not found\n", __func__, id); + s_vpr_e(inst->sid, "%s: control id (%#x) not found\n", __func__, id); MSM_VIDC_ERROR(true); return inst->ctrls[0]; } -static inline void update_ctrl(struct v4l2_ctrl *ctrl, s32 val) +static inline void update_ctrl(struct v4l2_ctrl *ctrl, s32 val, u32 sid) { switch (ctrl->type) { case V4L2_CTRL_TYPE_INTEGER: @@ -83,7 +83,7 @@ static inline void update_ctrl(struct v4l2_ctrl *ctrl, s32 val) ctrl->elems * ctrl->elem_size); break; default: - dprintk(VIDC_ERR, "unhandled control type"); + s_vpr_e(sid, "unhandled control type"); } } @@ -172,15 +172,15 @@ enum hal_buffer get_hal_buffer_type(unsigned int type, unsigned int plane_num); void put_inst(struct msm_vidc_inst *inst); struct msm_vidc_inst *get_inst(struct msm_vidc_core *core, - void *session_id); + void *inst_id); void change_inst_state(struct msm_vidc_inst *inst, enum instance_state state); struct msm_vidc_core *get_vidc_core(int core_id); const struct msm_vidc_format_desc *msm_comm_get_pixel_fmt_index( - const struct msm_vidc_format_desc fmt[], int size, int index); + const struct msm_vidc_format_desc fmt[], int size, int index, u32 sid); struct msm_vidc_format_desc *msm_comm_get_pixel_fmt_fourcc( - struct msm_vidc_format_desc fmt[], int size, int fourcc); + struct msm_vidc_format_desc fmt[], int size, int fourcc, u32 sid); struct msm_vidc_format_constraint *msm_comm_get_pixel_fmt_constraints( - struct msm_vidc_format_constraint fmt[], int size, int fourcc); + struct msm_vidc_format_constraint fmt[], int size, int fourcc, u32 sid); int msm_comm_set_color_format_constraints(struct msm_vidc_inst *inst, enum hal_buffer buffer_type, struct msm_vidc_format_constraint *pix_constraint); @@ -232,9 +232,9 @@ int msm_comm_smem_alloc(struct msm_vidc_inst *inst, size_t size, u32 align, void msm_comm_smem_free(struct msm_vidc_inst *inst, struct msm_smem *smem); int msm_comm_smem_cache_operations(struct msm_vidc_inst *inst, struct msm_smem *mem, enum smem_cache_ops cache_ops); -enum hal_video_codec get_hal_codec(int fourcc); -enum hal_domain get_hal_domain(int session_type); -int msm_comm_check_core_init(struct msm_vidc_core *core); +enum hal_video_codec get_hal_codec(int fourcc, u32 sid); +enum hal_domain get_hal_domain(int session_type, u32 sid); +int msm_comm_check_core_init(struct msm_vidc_core *core, u32 sid); int msm_comm_get_inst_load(struct msm_vidc_inst *inst, enum load_calc_quirks quirks); int msm_comm_get_inst_load_per_core(struct msm_vidc_inst *inst, @@ -253,15 +253,15 @@ int msm_comm_ctrl_deinit(struct msm_vidc_inst *inst); void msm_comm_cleanup_internal_buffers(struct msm_vidc_inst *inst); bool msm_comm_turbo_session(struct msm_vidc_inst *inst); void msm_comm_print_inst_info(struct msm_vidc_inst *inst); -int msm_comm_v4l2_to_hfi(int id, int value); -int msm_comm_hfi_to_v4l2(int id, int value); -int msm_comm_get_v4l2_profile(int fourcc, int profile); -int msm_comm_get_v4l2_level(int fourcc, int level); +int msm_comm_v4l2_to_hfi(int id, int value, u32 sid); +int msm_comm_hfi_to_v4l2(int id, int value, u32 sid); +int msm_comm_get_v4l2_profile(int fourcc, int profile, u32 sid); +int msm_comm_get_v4l2_level(int fourcc, int level, u32 sid); int msm_comm_session_continue(void *instance); int msm_vidc_send_pending_eos_buffers(struct msm_vidc_inst *inst); enum hal_uncompressed_format msm_comm_get_hal_uncompressed(int fourcc); -u32 msm_comm_get_hfi_uncompressed(int fourcc); -u32 msm_comm_convert_color_fmt(u32 v4l2_fmt); +u32 msm_comm_get_hfi_uncompressed(int fourcc, u32 sid); +u32 msm_comm_convert_color_fmt(u32 v4l2_fmt, u32 sid); struct vb2_buffer *msm_comm_get_vb_using_vidc_buffer( struct msm_vidc_inst *inst, struct msm_vidc_buffer *mbuf); struct msm_vidc_buffer *msm_comm_get_buffer_using_device_planes( @@ -286,9 +286,9 @@ bool msm_comm_compare_vb2_plane(struct msm_vidc_inst *inst, struct msm_vidc_buffer *mbuf, struct vb2_buffer *vb2, u32 i); bool msm_comm_compare_vb2_planes(struct msm_vidc_inst *inst, struct msm_vidc_buffer *mbuf, struct vb2_buffer *vb2); -bool msm_comm_compare_device_plane(struct msm_vidc_buffer *mbuf, +bool msm_comm_compare_device_plane(u32 sid, struct msm_vidc_buffer *mbuf, u32 type, u32 *planes, u32 i); -bool msm_comm_compare_device_planes(struct msm_vidc_buffer *mbuf, +bool msm_comm_compare_device_planes(u32 sid, struct msm_vidc_buffer *mbuf, u32 type, u32 *planes); int msm_comm_qbuf_cache_operations(struct msm_vidc_inst *inst, struct msm_vidc_buffer *mbuf); @@ -296,16 +296,14 @@ int msm_comm_dqbuf_cache_operations(struct msm_vidc_inst *inst, struct msm_vidc_buffer *mbuf); void print_vidc_buffer(u32 tag, const char *str, struct msm_vidc_inst *inst, struct msm_vidc_buffer *mbuf); -void print_vb2_buffer(u32 tag, const char *str, struct msm_vidc_inst *inst, +void print_vb2_buffer(const char *str, struct msm_vidc_inst *inst, struct vb2_buffer *vb2); -void print_v4l2_buffer(u32 tag, const char *str, struct msm_vidc_inst *inst, - struct v4l2_buffer *v4l2); void kref_put_mbuf(struct msm_vidc_buffer *mbuf); bool kref_get_mbuf(struct msm_vidc_inst *inst, struct msm_vidc_buffer *mbuf); void msm_comm_store_input_tag(struct msm_vidc_list *data_list, - u32 index, u32 itag, u32 itag2); + u32 index, u32 itag, u32 itag2, u32 sid); int msm_comm_fetch_input_tag(struct msm_vidc_list *data_list, - u32 index, u32 *itag, u32 *itag2); + u32 index, u32 *itag, u32 *itag2, u32 sid); int msm_comm_release_input_tag(struct msm_vidc_inst *inst); struct msm_vidc_client_data *msm_comm_store_client_data( struct msm_vidc_inst *inst, u32 itag); diff --git a/msm/vidc/msm_vidc_debug.c b/msm/vidc/msm_vidc_debug.c index 7312b7dbb11f..14492f3610cc 100644 --- a/msm/vidc/msm_vidc_debug.c +++ b/msm/vidc/msm_vidc_debug.c @@ -58,13 +58,13 @@ static ssize_t core_info_read(struct file *file, char __user *buf, ssize_t len = 0; if (!core || !core->device) { - dprintk(VIDC_ERR, "Invalid params, core: %pK\n", core); + d_vpr_e("%s: invalid params %pK\n", __func__, core); return 0; } dbuf = kzalloc(MAX_DBG_BUF_SIZE, GFP_KERNEL); if (!dbuf) { - dprintk(VIDC_ERR, "%s: Allocation failed!\n", __func__); + d_vpr_e("%s: Allocation failed!\n", __func__); return -ENOMEM; } cur = dbuf; @@ -77,7 +77,7 @@ static ssize_t core_info_read(struct file *file, char __user *buf, cur += write_str(cur, end - cur, "Core state: %d\n", core->state); rc = call_hfi_op(hdev, get_fw_info, hdev->hfi_device_data, &fw_info); if (rc) { - dprintk(VIDC_ERR, "Failed to read FW info\n"); + d_vpr_e("Failed to read FW info\n"); goto err_fw_info; } @@ -130,14 +130,14 @@ static ssize_t trigger_ssr_write(struct file *filp, const char __user *buf, size = count; if (copy_from_user(kbuf, buf, size)) { - dprintk(VIDC_ERR, "%s User memory fault\n", __func__); + d_vpr_e("%s: User memory fault\n", __func__); rc = -EFAULT; goto exit; } rc = kstrtoul(kbuf, 0, &ssr_trigger_val); if (rc) { - dprintk(VIDC_ERR, "returning error err %d\n", rc); + d_vpr_e("returning error err %d\n", rc); rc = -EINVAL; } else { msm_vidc_trigger_ssr(core, ssr_trigger_val); @@ -161,28 +161,27 @@ static ssize_t debug_level_write(struct file *filp, const char __user *buf, /* filter partial writes and invalid commands */ if (*ppos != 0 || count >= sizeof(kbuf) || count == 0) { - dprintk(VIDC_ERR, "returning error - pos %d, count %d\n", - *ppos, count); + d_vpr_e("returning error - pos %d, count %d\n", *ppos, count); rc = -EINVAL; } rc = simple_write_to_buffer(kbuf, sizeof(kbuf) - 1, ppos, buf, count); if (rc < 0) { - dprintk(VIDC_ERR, "%s User memory fault\n", __func__); + d_vpr_e("%s: User memory fault\n", __func__); rc = -EFAULT; goto exit; } rc = kstrtoint(kbuf, 0, &msm_vidc_debug); if (rc) { - dprintk(VIDC_ERR, "returning error err %d\n", rc); + d_vpr_e("returning error err %d\n", rc); rc = -EINVAL; goto exit; } core->resources.msm_vidc_hw_rsp_timeout = ((msm_vidc_debug & 0xFF) > (VIDC_ERR | VIDC_HIGH)) ? 1500 : 1000; rc = count; - dprintk(VIDC_HIGH, "debug timeout updated to - %d\n", + d_vpr_h("debug timeout updated to - %d\n", core->resources.msm_vidc_hw_rsp_timeout); exit: @@ -220,7 +219,7 @@ struct dentry *msm_vidc_debugfs_init_drv(void) struct dentry *f = debugfs_create_##__type(__name, 0644, \ dir, __value); \ if (IS_ERR_OR_NULL(f)) { \ - dprintk(VIDC_ERR, "Failed creating debugfs file '%pd/%s'\n", \ + d_vpr_e("Failed creating debugfs file '%pd/%s'\n", \ dir, __name); \ f = NULL; \ } \ @@ -261,28 +260,28 @@ struct dentry *msm_vidc_debugfs_init_core(struct msm_vidc_core *core, char debugfs_name[MAX_DEBUGFS_NAME]; if (!core) { - dprintk(VIDC_ERR, "Invalid params, core: %pK\n", core); + d_vpr_e("%s: invalid params\n", __func__); goto failed_create_dir; } snprintf(debugfs_name, MAX_DEBUGFS_NAME, "core%d", core->id); dir = debugfs_create_dir(debugfs_name, parent); if (!dir) { - dprintk(VIDC_ERR, "Failed to create debugfs for msm_vidc\n"); + d_vpr_e("Failed to create debugfs for msm_vidc\n"); goto failed_create_dir; } if (!debugfs_create_file("info", 0444, dir, core, &core_info_fops)) { - dprintk(VIDC_ERR, "debugfs_create_file: fail\n"); + d_vpr_e("debugfs_create_file: fail\n"); goto failed_create_dir; } if (!debugfs_create_file("trigger_ssr", 0200, dir, core, &ssr_fops)) { - dprintk(VIDC_ERR, "debugfs_create_file: fail\n"); + d_vpr_e("debugfs_create_file: fail\n"); goto failed_create_dir; } if (!debugfs_create_file("debug_level", 0644, parent, core, &debug_level_fops)) { - dprintk(VIDC_ERR, "debugfs_create_file: fail\n"); + d_vpr_e("debugfs_create_file: fail\n"); goto failed_create_dir; } failed_create_dir: @@ -291,7 +290,7 @@ failed_create_dir: static int inst_info_open(struct inode *inode, struct file *file) { - dprintk(VIDC_LOW, "Open inode ptr: %pK\n", inode->i_private); + d_vpr_l("Open inode ptr: %pK\n", inode->i_private); file->private_data = inode->i_private; return 0; } @@ -303,7 +302,7 @@ static int publish_unreleased_reference(struct msm_vidc_inst *inst, char *cur = *dbuf; if (!inst) { - dprintk(VIDC_ERR, "%s: invalid param\n", __func__); + d_vpr_e("%s: invalid params\n", __func__); return -EINVAL; } @@ -350,7 +349,7 @@ static ssize_t inst_info_read(struct file *file, char __user *buf, struct v4l2_format *f; if (!idata || !idata->core || !idata->inst) { - dprintk(VIDC_ERR, "%s: Invalid params\n", __func__); + d_vpr_e("%s: invalid params %pK\n", __func__, idata); return 0; } @@ -367,13 +366,13 @@ static ssize_t inst_info_read(struct file *file, char __user *buf, mutex_unlock(&core->lock); if (!inst) { - dprintk(VIDC_ERR, "%s: Instance has become obsolete", __func__); + d_vpr_e("%s: Instance has become obsolete", __func__); return 0; } dbuf = kzalloc(MAX_DBG_BUF_SIZE, GFP_KERNEL); if (!dbuf) { - dprintk(VIDC_ERR, "%s: Allocation failed!\n", __func__); + s_vpr_e(inst->sid, "%s: Allocation failed!\n", __func__); len = -ENOMEM; goto failed_alloc; } @@ -453,7 +452,7 @@ failed_alloc: static int inst_info_release(struct inode *inode, struct file *file) { - dprintk(VIDC_LOW, "Release inode ptr: %pK\n", inode->i_private); + d_vpr_l("Release inode ptr: %pK\n", inode->i_private); file->private_data = NULL; return 0; } @@ -472,14 +471,14 @@ struct dentry *msm_vidc_debugfs_init_inst(struct msm_vidc_inst *inst, struct core_inst_pair *idata = NULL; if (!inst) { - dprintk(VIDC_ERR, "Invalid params, inst: %pK\n", inst); + d_vpr_e("%s: invalid params\n", __func__); goto exit; } snprintf(debugfs_name, MAX_DEBUGFS_NAME, "inst_%p", inst); idata = kzalloc(sizeof(struct core_inst_pair), GFP_KERNEL); if (!idata) { - dprintk(VIDC_ERR, "%s: Allocation failed!\n", __func__); + s_vpr_e(inst->sid, "%s: Allocation failed!\n", __func__); goto exit; } @@ -488,14 +487,14 @@ struct dentry *msm_vidc_debugfs_init_inst(struct msm_vidc_inst *inst, dir = debugfs_create_dir(debugfs_name, parent); if (!dir) { - dprintk(VIDC_ERR, "Failed to create debugfs for msm_vidc\n"); + s_vpr_e(inst->sid, "Failed to create debugfs for msm_vidc\n"); goto failed_create_dir; } info = debugfs_create_file("info", 0444, dir, idata, &inst_info_fops); if (!info) { - dprintk(VIDC_ERR, "debugfs_create_file: fail\n"); + s_vpr_e(inst->sid, "debugfs_create_file: fail\n"); goto failed_create_file; } @@ -521,7 +520,7 @@ void msm_vidc_debugfs_deinit_inst(struct msm_vidc_inst *inst) dentry = inst->debugfs_root; if (dentry->d_inode) { - dprintk(VIDC_LOW, "Destroy %pK\n", dentry->d_inode->i_private); + s_vpr_l(inst->sid, "Destroy %pK\n", dentry->d_inode->i_private); kfree(dentry->d_inode->i_private); dentry->d_inode->i_private = NULL; } @@ -553,10 +552,10 @@ void msm_vidc_debugfs_update(struct msm_vidc_inst *inst, inst->count.ftb, inst->count.fbd); if (inst->count.ebd && inst->count.ebd == inst->count.etb) { toc(inst, FRAME_PROCESSING); - dprintk(VIDC_PERF, "EBD: FW needs input buffers\n"); + s_vpr_p(inst->sid, "EBD: FW needs input buffers\n"); } if (inst->count.ftb == inst->count.fbd) - dprintk(VIDC_PERF, "EBD: FW needs output buffers\n"); + s_vpr_p(inst->sid, "EBD: FW needs output buffers\n"); break; case MSM_VIDC_DEBUGFS_EVENT_FTB: { inst->count.ftb++; @@ -578,13 +577,13 @@ void msm_vidc_debugfs_update(struct msm_vidc_inst *inst, if (inst->count.fbd && inst->count.fbd == inst->count.ftb) { toc(inst, FRAME_PROCESSING); - dprintk(VIDC_PERF, "FBD: FW needs output buffers\n"); + s_vpr_p(inst->sid, "FBD: FW needs output buffers\n"); } if (inst->count.etb == inst->count.ebd) - dprintk(VIDC_PERF, "FBD: FW needs input buffers\n"); + s_vpr_p(inst->sid, "FBD: FW needs input buffers\n"); break; default: - dprintk(VIDC_ERR, "Invalid state in debugfs: %d\n", e); + s_vpr_e(inst->sid, "Invalid state in debugfs: %d\n", e); break; } } diff --git a/msm/vidc/msm_vidc_debug.h b/msm/vidc/msm_vidc_debug.h index a28151c2c430..ddbc9d60b948 100644 --- a/msm/vidc/msm_vidc_debug.h +++ b/msm/vidc/msm_vidc_debug.h @@ -23,7 +23,8 @@ #define VIDC_DBG_SESSION_RATELIMIT_INTERVAL (1 * HZ) #define VIDC_DBG_SESSION_RATELIMIT_BURST 6 -#define VIDC_DBG_TAG VIDC_DBG_LABEL ": %4s: " +#define VIDC_DBG_TAG VIDC_DBG_LABEL ": %6s: %8x: " +#define DEFAULT_SID ((u32)-1) /* To enable messages OR these values and * echo the result to debugfs file. @@ -68,7 +69,7 @@ extern bool msm_vidc_syscache_disable; extern bool msm_vidc_lossless_encode; extern bool msm_vidc_cvp_usage; -#define dprintk(__level, __fmt, ...) \ +#define dprintk(__level, sid, __fmt, ...) \ do { \ if (msm_vidc_debug & __level) { \ if (msm_vidc_debug & VIDC_FTRACE) { \ @@ -77,6 +78,7 @@ extern bool msm_vidc_cvp_usage; MAX_TRACER_LOG_LENGTH, \ VIDC_DBG_TAG __fmt, \ get_debug_level_str(__level), \ + sid, \ ##__VA_ARGS__); \ trace_msm_vidc_printf(trace_logbuf, \ log_length); \ @@ -84,11 +86,34 @@ extern bool msm_vidc_cvp_usage; if (msm_vidc_debug & VIDC_PRINTK) { \ pr_info(VIDC_DBG_TAG __fmt, \ get_debug_level_str(__level), \ + sid, \ ##__VA_ARGS__); \ } \ } \ } while (0) +#define s_vpr_e(sid, __fmt, ...) dprintk(VIDC_ERR, sid, __fmt, ##__VA_ARGS__) +#define s_vpr_h(sid, __fmt, ...) dprintk(VIDC_HIGH, sid, __fmt, ##__VA_ARGS__) +#define s_vpr_l(sid, __fmt, ...) dprintk(VIDC_LOW, sid, __fmt, ##__VA_ARGS__) +#define s_vpr_p(sid, __fmt, ...) dprintk(VIDC_PERF, sid, __fmt, ##__VA_ARGS__) +#define s_vpr_t(sid, __fmt, ...) dprintk(VIDC_PKT, sid, __fmt, ##__VA_ARGS__) +#define s_vpr_b(sid, __fmt, ...) dprintk(VIDC_BUS, sid, __fmt, ##__VA_ARGS__) +#define s_vpr_hp(sid, __fmt, ...) \ + dprintk(VIDC_HIGH|VIDC_PERF, sid, __fmt, ##__VA_ARGS__) + +#define d_vpr_e(__fmt, ...) \ + dprintk(VIDC_ERR, DEFAULT_SID, __fmt, ##__VA_ARGS__) +#define d_vpr_h(__fmt, ...) \ + dprintk(VIDC_HIGH, DEFAULT_SID, __fmt, ##__VA_ARGS__) +#define d_vpr_l(__fmt, ...) \ + dprintk(VIDC_LOW, DEFAULT_SID, __fmt, ##__VA_ARGS__) +#define d_vpr_p(__fmt, ...) \ + dprintk(VIDC_PERF, DEFAULT_SID, __fmt, ##__VA_ARGS__) +#define d_vpr_t(__fmt, ...) \ + dprintk(VIDC_PKT, DEFAULT_SID, __fmt, ##__VA_ARGS__) +#define d_vpr_b(__fmt, ...) \ + dprintk(VIDC_BUS, DEFAULT_SID, __fmt, ##__VA_ARGS__) + #define dprintk_firmware(__level, __fmt, ...) \ do { \ if (__level & FW_FTRACE) { \ @@ -111,13 +136,13 @@ extern bool msm_vidc_cvp_usage; #define dprintk_ratelimit(__level, __fmt, arg...) \ do { \ if (msm_vidc_check_ratelimit()) { \ - dprintk(__level, __fmt, arg); \ + dprintk(__level, DEFAULT_SID, __fmt, arg); \ } \ } while (0) #define MSM_VIDC_ERROR(value) \ do { if (value) \ - dprintk(VIDC_ERR, "BugOn"); \ + d_vpr_e("BugOn"); \ BUG_ON(value); \ } while (0) @@ -136,20 +161,20 @@ static inline char *get_debug_level_str(int level) { switch (level) { case VIDC_ERR: - return "err"; + return "err "; case VIDC_HIGH|VIDC_PERF: case VIDC_HIGH: return "high"; case VIDC_LOW: - return "low"; + return "low "; case VIDC_PERF: return "perf"; case VIDC_PKT: - return "pkt"; + return "pkt "; case VIDC_BUS: - return "bus"; + return "bus "; default: - return "???"; + return "????"; } } @@ -192,15 +217,14 @@ static inline void show_stats(struct msm_vidc_inst *i) if (i->debug.pdata[x].name[0] && (msm_vidc_debug & VIDC_PERF)) { if (i->debug.samples) { - dprintk(VIDC_PERF, "%s averaged %d ms/sample\n", + s_vpr_p(i->sid, "%s averaged %d ms/sample\n", i->debug.pdata[x].name, i->debug.pdata[x].cumulative / i->debug.samples); } - dprintk(VIDC_PERF, "%s Samples: %d\n", - i->debug.pdata[x].name, - i->debug.samples); + s_vpr_p(i->sid, "%s Samples: %d\n", + i->debug.pdata[x].name, i->debug.samples); } } } diff --git a/msm/vidc/msm_vidc_internal.h b/msm/vidc/msm_vidc_internal.h index 822d9c392d67..610df5a0c1a3 100644 --- a/msm/vidc/msm_vidc_internal.h +++ b/msm/vidc/msm_vidc_internal.h @@ -419,6 +419,7 @@ struct clock_data { }; struct vidc_bus_vote_data { + u32 sid; enum hal_domain domain; enum hal_video_codec codec; enum hal_uncompressed_format color_formats[2]; @@ -509,6 +510,7 @@ struct msm_vidc_inst { struct msm_vidc_core *core; enum session_type session_type; void *session; + u32 sid; struct msm_cvp_external *cvp; struct session_prop prop; enum instance_state state; @@ -620,18 +622,19 @@ struct msm_vidc_cvp_buffer { void msm_comm_handle_thermal_event(void); int msm_smem_alloc(size_t size, u32 align, u32 flags, enum hal_buffer buffer_type, int map_kernel, - void *res, u32 session_type, struct msm_smem *smem); -int msm_smem_free(struct msm_smem *smem); + void *res, u32 session_type, struct msm_smem *smem, u32 sid); +int msm_smem_free(struct msm_smem *smem, u32 sid); struct context_bank_info *msm_smem_get_context_bank(u32 session_type, bool is_secure, struct msm_vidc_platform_resources *res, - enum hal_buffer buffer_type); + enum hal_buffer buffer_type, u32 sid); int msm_smem_map_dma_buf(struct msm_vidc_inst *inst, struct msm_smem *smem); int msm_smem_unmap_dma_buf(struct msm_vidc_inst *inst, struct msm_smem *smem); -struct dma_buf *msm_smem_get_dma_buf(int fd); -void msm_smem_put_dma_buf(void *dma_buf); +struct dma_buf *msm_smem_get_dma_buf(int fd, u32 sid); +void msm_smem_put_dma_buf(void *dma_buf, u32 sid); int msm_smem_cache_operations(struct dma_buf *dbuf, - enum smem_cache_ops cache_op, unsigned long offset, unsigned long size); + enum smem_cache_ops cache_op, unsigned long offset, + unsigned long size, u32 sid); void msm_vidc_fw_unload_handler(struct work_struct *work); void msm_vidc_ssr_handler(struct work_struct *work); /* diff --git a/msm/vidc/msm_vidc_platform.c b/msm/vidc/msm_vidc_platform.c index 0fb3af904f17..29ca3b195f73 100644 --- a/msm/vidc/msm_vidc_platform.c +++ b/msm/vidc/msm_vidc_platform.c @@ -1126,8 +1126,7 @@ static int msm_vidc_read_efuse( base = devm_ioremap(dev, (efuse_data[i]).start_address, (efuse_data[i]).size); if (!base) { - dprintk(VIDC_ERR, - "failed efuse ioremap: res->start %#x, size %d\n", + d_vpr_e("failed efuse: start %#x, size %d\n", (efuse_data[i]).start_address, (efuse_data[i]).size); return -EINVAL; @@ -1138,8 +1137,7 @@ static int msm_vidc_read_efuse( data->sku_version = (efuse & (efuse_data[i]).mask) >> (efuse_data[i]).shift; - dprintk(VIDC_HIGH, - "efuse 0x%x, platform version 0x%x\n", + d_vpr_h("efuse 0x%x, platform version 0x%x\n", efuse, data->sku_version); devm_iounmap(dev, base); @@ -1186,10 +1184,9 @@ void *vidc_get_drv_data(struct device *dev) } else if (!strcmp(match->compatible, "qcom,kona-vidc")) { ddr_type = of_fdt_get_ddrtype(); if (ddr_type == -ENOENT) { - dprintk(VIDC_ERR, - "Failed to get ddr type, use LPDDR5\n"); + d_vpr_e("Failed to get ddr type, use LPDDR5\n"); } - dprintk(VIDC_HIGH, "DDR Type %x\n", ddr_type); + d_vpr_h("DDR Type %x\n", ddr_type); if (driver_data->ubwc_config && (ddr_type == DDR_TYPE_LPDDR4 || diff --git a/msm/vidc/msm_vidc_res_parse.c b/msm/vidc/msm_vidc_res_parse.c index 067637053422..8ecadde92f6e 100644 --- a/msm/vidc/msm_vidc_res_parse.c +++ b/msm/vidc/msm_vidc_res_parse.c @@ -33,15 +33,13 @@ static size_t get_u32_array_num_elements(struct device_node *np, size_t num_elements = 0; if (!of_get_property(np, name, &len)) { - dprintk(VIDC_ERR, "Failed to read %s from device tree\n", - name); + d_vpr_e("Failed to read %s from device tree\n", name); goto fail_read; } num_elements = len / sizeof(u32); if (num_elements <= 0) { - dprintk(VIDC_ERR, "%s not specified in device tree\n", - name); + d_vpr_e("%s not specified in device tree\n", name); goto fail_read; } return num_elements; @@ -143,7 +141,7 @@ static int msm_vidc_load_reg_table(struct msm_vidc_platform_resources *res) * qcom,reg-presets is an optional property. It likely won't be * present if we don't have any register settings to program */ - dprintk(VIDC_HIGH, "qcom,reg-presets not found\n"); + d_vpr_h("reg-presets not found\n"); return 0; } @@ -153,29 +151,26 @@ static int msm_vidc_load_reg_table(struct msm_vidc_platform_resources *res) reg_set->count /= sizeof(*reg_set->reg_tbl) / sizeof(u32); if (!reg_set->count) { - dprintk(VIDC_HIGH, "no elements in reg set\n"); + d_vpr_h("no elements in reg set\n"); return rc; } reg_set->reg_tbl = devm_kzalloc(&pdev->dev, reg_set->count * sizeof(*(reg_set->reg_tbl)), GFP_KERNEL); if (!reg_set->reg_tbl) { - dprintk(VIDC_ERR, "%s Failed to alloc register table\n", - __func__); + d_vpr_e("%s: Failed to alloc register table\n", __func__); return -ENOMEM; } if (of_property_read_u32_array(pdev->dev.of_node, "qcom,reg-presets", (u32 *)reg_set->reg_tbl, reg_set->count * 2)) { - dprintk(VIDC_ERR, "Failed to read register table\n"); + d_vpr_e("Failed to read register table\n"); msm_vidc_free_reg_table(res); return -EINVAL; } for (i = 0; i < reg_set->count; i++) { - dprintk(VIDC_HIGH, - "reg = %x, value = %x\n", - reg_set->reg_tbl[i].reg, - reg_set->reg_tbl[i].value + d_vpr_h("reg = %x, value = %x\n", + reg_set->reg_tbl[i].reg, reg_set->reg_tbl[i].value ); } return rc; @@ -192,7 +187,7 @@ static int msm_vidc_load_qdss_table(struct msm_vidc_platform_resources *res) * qcom,qdss-presets is an optional property. It likely won't be * present if we don't have any register settings to program */ - dprintk(VIDC_HIGH, "qcom,qdss-presets not found\n"); + d_vpr_h("qdss-presets not found\n"); return rc; } @@ -202,7 +197,7 @@ static int msm_vidc_load_qdss_table(struct msm_vidc_platform_resources *res) qdss_addr_set->count /= sizeof(*qdss_addr_set->addr_tbl) / sizeof(u32); if (!qdss_addr_set->count) { - dprintk(VIDC_HIGH, "no elements in qdss reg set\n"); + d_vpr_h("no elements in qdss reg set\n"); return rc; } @@ -210,8 +205,7 @@ static int msm_vidc_load_qdss_table(struct msm_vidc_platform_resources *res) qdss_addr_set->count * sizeof(*qdss_addr_set->addr_tbl), GFP_KERNEL); if (!qdss_addr_set->addr_tbl) { - dprintk(VIDC_ERR, "%s Failed to alloc register table\n", - __func__); + d_vpr_e("%s: Failed to alloc register table\n", __func__); rc = -ENOMEM; goto err_qdss_addr_tbl; } @@ -219,14 +213,14 @@ static int msm_vidc_load_qdss_table(struct msm_vidc_platform_resources *res) rc = of_property_read_u32_array(pdev->dev.of_node, "qcom,qdss-presets", (u32 *)qdss_addr_set->addr_tbl, qdss_addr_set->count * 2); if (rc) { - dprintk(VIDC_ERR, "Failed to read qdss address table\n"); + d_vpr_e("Failed to read qdss address table\n"); msm_vidc_free_qdss_addr_table(res); rc = -EINVAL; goto err_qdss_addr_tbl; } for (i = 0; i < qdss_addr_set->count; i++) { - dprintk(VIDC_HIGH, "qdss addr = %x, value = %x\n", + d_vpr_h("qdss addr = %x, value = %x\n", qdss_addr_set->addr_tbl[i].start, qdss_addr_set->addr_tbl[i].size); } @@ -243,21 +237,20 @@ static int msm_vidc_load_subcache_info(struct msm_vidc_platform_resources *res) num_subcaches = of_property_count_strings(pdev->dev.of_node, "cache-slice-names"); if (num_subcaches <= 0) { - dprintk(VIDC_HIGH, "No subcaches found\n"); + d_vpr_h("No subcaches found\n"); goto err_load_subcache_table_fail; } subcaches->subcache_tbl = devm_kzalloc(&pdev->dev, sizeof(*subcaches->subcache_tbl) * num_subcaches, GFP_KERNEL); if (!subcaches->subcache_tbl) { - dprintk(VIDC_ERR, - "Failed to allocate memory for subcache tbl\n"); + d_vpr_e("Failed to allocate memory for subcache tbl\n"); rc = -ENOMEM; goto err_load_subcache_table_fail; } subcaches->count = num_subcaches; - dprintk(VIDC_HIGH, "Found %d subcaches\n", num_subcaches); + d_vpr_h("Found %d subcaches\n", num_subcaches); for (c = 0; c < num_subcaches; ++c) { struct subcache_info *vsc = &res->subcache_set.subcache_tbl[c]; @@ -303,26 +296,26 @@ int msm_vidc_load_u32_table(struct platform_device *pdev, u32 *ptbl = NULL; if (!of_find_property(of_node, table_name, NULL)) { - dprintk(VIDC_HIGH, "%s not found\n", table_name); + d_vpr_h("%s not found\n", table_name); return 0; } num_elemts = get_u32_array_num_elements(of_node, table_name); if (!num_elemts) { - dprintk(VIDC_ERR, "no elements in %s\n", table_name); + d_vpr_e("no elements in %s\n", table_name); return 0; } num_elemts /= struct_size / sizeof(u32); ptbl = devm_kzalloc(&pdev->dev, num_elemts * struct_size, GFP_KERNEL); if (!ptbl) { - dprintk(VIDC_ERR, "Failed to alloc table %s\n", table_name); + d_vpr_e("Failed to alloc table %s\n", table_name); return -ENOMEM; } if (of_property_read_u32_array(of_node, table_name, ptbl, num_elemts * struct_size / sizeof(u32))) { - dprintk(VIDC_ERR, "Failed to read %s\n", table_name); + d_vpr_e("Failed to read %s\n", table_name); return -EINVAL; } @@ -350,7 +343,7 @@ static int msm_vidc_load_allowed_clocks_table( if (!of_find_property(pdev->dev.of_node, "qcom,allowed-clock-rates", NULL)) { - dprintk(VIDC_HIGH, "qcom,allowed-clock-rates not found\n"); + d_vpr_h("allowed-clock-rates not found\n"); return 0; } @@ -360,8 +353,7 @@ static int msm_vidc_load_allowed_clocks_table( (u32 **)&res->allowed_clks_tbl, &res->allowed_clks_tbl_size); if (rc) { - dprintk(VIDC_ERR, - "%s: failed to read allowed clocks table\n", __func__); + d_vpr_e("%s: failed to read allowed clocks table\n", __func__); return rc; } @@ -391,7 +383,7 @@ static int msm_vidc_populate_bus(struct device *dev, temp_table = krealloc(buses->bus_tbl, sizeof(*temp_table) * (buses->count + 1), GFP_KERNEL); if (!temp_table) { - dprintk(VIDC_ERR, "%s: Failed to allocate memory", __func__); + d_vpr_e("%s: Failed to allocate memory", __func__); rc = -ENOMEM; goto err_bus; } @@ -403,7 +395,7 @@ static int msm_vidc_populate_bus(struct device *dev, rc = of_property_read_string(dev->of_node, "label", &temp_name); if (rc) { - dprintk(VIDC_ERR, "'label' not found in node\n"); + d_vpr_e("'label' not found in node\n"); goto err_bus; } /* need a non-const version of name, hence copying it over */ @@ -416,13 +408,13 @@ static int msm_vidc_populate_bus(struct device *dev, rc = of_property_read_u32(dev->of_node, "qcom,bus-master", &bus->master); if (rc) { - dprintk(VIDC_ERR, "'qcom,bus-master' not found in node\n"); + d_vpr_e("'bus-master' not found in node\n"); goto err_bus; } rc = of_property_read_u32(dev->of_node, "qcom,bus-slave", &bus->slave); if (rc) { - dprintk(VIDC_ERR, "'qcom,bus-slave' not found in node\n"); + d_vpr_e("'bus-slave' not found in node\n"); goto err_bus; } @@ -436,8 +428,7 @@ static int msm_vidc_populate_bus(struct device *dev, range, ARRAY_SIZE(range)); if (rc) { rc = 0; - dprintk(VIDC_HIGH, - "'qcom,range' not found defaulting to <0 INT_MAX>\n"); + d_vpr_h("'bus-range' not found defaulting to <0 INT_MAX>\n"); range[0] = 0; range[1] = INT_MAX; } @@ -447,7 +438,7 @@ static int msm_vidc_populate_bus(struct device *dev, buses->count++; bus->dev = dev; - dprintk(VIDC_HIGH, "Found bus %s [%d->%d] with mode %s\n", + d_vpr_h("Found bus %s [%d->%d] with mode %s\n", bus->name, bus->master, bus->slave, bus->mode); err_bus: return rc; @@ -467,7 +458,7 @@ static int msm_vidc_load_buffer_usage_table( * likely won't be present if the core doesn't support content * protection */ - dprintk(VIDC_HIGH, "buffer-type-tz-usage-table not found\n"); + d_vpr_h("buffer-type-tz-usage-table not found\n"); return 0; } @@ -476,7 +467,7 @@ static int msm_vidc_load_buffer_usage_table( buffer_usage_set->count /= sizeof(*buffer_usage_set->buffer_usage_tbl) / sizeof(u32); if (!buffer_usage_set->count) { - dprintk(VIDC_HIGH, "no elements in buffer usage set\n"); + d_vpr_h("no elements in buffer usage set\n"); return 0; } @@ -485,7 +476,7 @@ static int msm_vidc_load_buffer_usage_table( sizeof(*buffer_usage_set->buffer_usage_tbl), GFP_KERNEL); if (!buffer_usage_set->buffer_usage_tbl) { - dprintk(VIDC_ERR, "%s Failed to alloc buffer usage table\n", + d_vpr_e("%s: Failed to alloc buffer usage table\n", __func__); rc = -ENOMEM; goto err_load_buf_usage; @@ -497,7 +488,7 @@ static int msm_vidc_load_buffer_usage_table( buffer_usage_set->count * sizeof(*buffer_usage_set->buffer_usage_tbl) / sizeof(u32)); if (rc) { - dprintk(VIDC_ERR, "Failed to read buffer usage table\n"); + d_vpr_e("Failed to read buffer usage table\n"); goto err_load_buf_usage; } @@ -542,8 +533,7 @@ static int msm_vidc_load_regulator_table( if (!regulators->regulator_tbl) { rc = -ENOMEM; - dprintk(VIDC_ERR, - "Failed to alloc memory for regulator table\n"); + d_vpr_e("Failed to alloc memory for regulator table\n"); goto err_reg_tbl_alloc; } @@ -565,8 +555,8 @@ static int msm_vidc_load_regulator_table( regulator_node = of_parse_phandle(domains_parent_node, domains_property->name, 0); if (IS_ERR(regulator_node)) { - dprintk(VIDC_ERR, "%s is not a phandle\n", - domains_property->name); + d_vpr_e("%s is not a phandle\n", + domains_property->name); continue; } regulators->count++; @@ -577,8 +567,7 @@ static int msm_vidc_load_regulator_table( (supply - domains_property->name) + 1, GFP_KERNEL); if (!rinfo->name) { rc = -ENOMEM; - dprintk(VIDC_ERR, - "Failed to alloc memory for regulator name\n"); + d_vpr_e("Failed to alloc memory for regulator name\n"); goto err_reg_name_alloc; } strlcpy(rinfo->name, domains_property->name, @@ -587,13 +576,13 @@ static int msm_vidc_load_regulator_table( rinfo->has_hw_power_collapse = of_property_read_bool( regulator_node, "qcom,support-hw-trigger"); - dprintk(VIDC_HIGH, "Found regulator %s: h/w collapse = %s\n", + d_vpr_h("Found regulator %s: h/w collapse = %s\n", rinfo->name, rinfo->has_hw_power_collapse ? "yes" : "no"); } if (!regulators->count) - dprintk(VIDC_HIGH, "No regulators found"); + d_vpr_h("No regulators found"); return 0; @@ -614,7 +603,7 @@ static int msm_vidc_load_clock_table( num_clocks = of_property_count_strings(pdev->dev.of_node, "clock-names"); if (num_clocks <= 0) { - dprintk(VIDC_HIGH, "No clocks found\n"); + d_vpr_h("No clocks found\n"); clocks->count = 0; rc = 0; goto err_load_clk_table_fail; @@ -623,7 +612,7 @@ static int msm_vidc_load_clock_table( clock_props = devm_kzalloc(&pdev->dev, num_clocks * sizeof(*clock_props), GFP_KERNEL); if (!clock_props) { - dprintk(VIDC_ERR, "No memory to read clock properties\n"); + d_vpr_e("No memory to read clock properties\n"); rc = -ENOMEM; goto err_load_clk_table_fail; } @@ -632,20 +621,20 @@ static int msm_vidc_load_clock_table( "qcom,clock-configs", clock_props, num_clocks); if (rc) { - dprintk(VIDC_ERR, "Failed to read clock properties: %d\n", rc); + d_vpr_e("Failed to read clock properties: %d\n", rc); goto err_load_clk_prop_fail; } clocks->clock_tbl = devm_kzalloc(&pdev->dev, sizeof(*clocks->clock_tbl) * num_clocks, GFP_KERNEL); if (!clocks->clock_tbl) { - dprintk(VIDC_ERR, "Failed to allocate memory for clock tbl\n"); + d_vpr_e("Failed to allocate memory for clock tbl\n"); rc = -ENOMEM; goto err_load_clk_prop_fail; } clocks->count = num_clocks; - dprintk(VIDC_HIGH, "Found %d clocks\n", num_clocks); + d_vpr_h("Found %d clocks\n", num_clocks); for (c = 0; c < num_clocks; ++c) { struct clock_info *vc = &res->clock_set.clock_tbl[c]; @@ -664,7 +653,7 @@ static int msm_vidc_load_clock_table( else vc->has_mem_retention = false; - dprintk(VIDC_HIGH, "Found clock %s: scale-able = %s\n", vc->name, + d_vpr_h("Found clock %s: scale-able = %s\n", vc->name, vc->has_scaling ? "yes" : "no"); } @@ -686,7 +675,7 @@ static int msm_vidc_load_reset_table( num_clocks = of_property_count_strings(pdev->dev.of_node, "reset-names"); if (num_clocks <= 0) { - dprintk(VIDC_HIGH, "No reset clocks found\n"); + d_vpr_h("No reset clocks found\n"); rst->count = 0; return 0; } @@ -697,7 +686,7 @@ static int msm_vidc_load_reset_table( return -ENOMEM; rst->count = num_clocks; - dprintk(VIDC_HIGH, "Found %d reset clocks\n", num_clocks); + d_vpr_h("Found %d reset clocks\n", num_clocks); for (c = 0; c < num_clocks; ++c) { struct reset_info *rc = &res->reset_set.reset_tbl[c]; @@ -719,13 +708,12 @@ static int msm_decide_dt_node( rc = of_property_read_u32(pdev->dev.of_node, "sku-index", &sku_index); if (rc) { - dprintk(VIDC_HIGH, "'sku_index' not found in node\n"); + d_vpr_h("'sku_index' not found in node\n"); return 0; } if (sku_index != res->sku_version) { - dprintk(VIDC_HIGH, - "Failed to parser dt: sku_index %d res->sku_version - %d\n", + d_vpr_h("Failed to parse dt: sku_index %d sku_version %d\n", sku_index, res->sku_version); return -EINVAL; } @@ -755,7 +743,7 @@ int read_platform_resources_from_drv_data( int rc = 0; if (!core || !core->platform_data) { - dprintk(VIDC_ERR, "%s Invalid data\n", __func__); + d_vpr_e("%s: Invalid data\n", __func__); return -ENOENT; } platform_data = core->platform_data; @@ -772,7 +760,7 @@ int read_platform_resources_from_drv_data( res->fw_name = "venus"; - dprintk(VIDC_HIGH, "Firmware filename: %s\n", res->fw_name); + d_vpr_h("Firmware filename: %s\n", res->fw_name); res->max_load = find_key_value(platform_data, "qcom,max-hw-load"); @@ -863,25 +851,23 @@ static int msm_vidc_populate_cx_ipeak_context( if (IS_ERR(res->cx_ipeak_context)) { rc = PTR_ERR(res->cx_ipeak_context); if (rc == -EPROBE_DEFER) - dprintk(VIDC_HIGH, - "cx-ipeak register failed. Deferring probe!"); + d_vpr_h("cx-ipeak register failed. Deferring probe!"); else - dprintk(VIDC_ERR, - "cx-ipeak register failed. rc: %d", rc); + d_vpr_e("cx-ipeak register failed. rc: %d", rc); res->cx_ipeak_context = NULL; return rc; } if (res->cx_ipeak_context) - dprintk(VIDC_HIGH, "cx-ipeak register successful"); + d_vpr_h("cx-ipeak register successful"); else - dprintk(VIDC_HIGH, "cx-ipeak register not implemented"); + d_vpr_h("cx-ipeak register not implemented"); of_property_read_u32(pdev->dev.of_node, "qcom,clock-freq-threshold", &res->clk_freq_threshold); - dprintk(VIDC_HIGH, "cx ipeak threshold frequency = %u\n", + d_vpr_h("cx ipeak threshold frequency = %u\n", res->clk_freq_threshold); return rc; @@ -896,7 +882,7 @@ int read_platform_resources_from_dt( uint32_t firmware_base = 0; if (!pdev->dev.of_node) { - dprintk(VIDC_ERR, "DT node not found\n"); + d_vpr_e("DT node not found\n"); return -ENOENT; } @@ -918,63 +904,57 @@ int read_platform_resources_from_dt( rc = msm_vidc_load_subcache_info(res); if (rc) - dprintk(VIDC_ERR, "Failed to load subcache info: %d\n", rc); + d_vpr_e("Failed to load subcache info: %d\n", rc); rc = msm_vidc_load_qdss_table(res); if (rc) - dprintk(VIDC_ERR, "Failed to load qdss reg table: %d\n", rc); + d_vpr_e("Failed to load qdss reg table: %d\n", rc); rc = msm_vidc_load_reg_table(res); if (rc) { - dprintk(VIDC_ERR, "Failed to load reg table: %d\n", rc); + d_vpr_e("Failed to load reg table: %d\n", rc); goto err_load_reg_table; } rc = msm_vidc_load_buffer_usage_table(res); if (rc) { - dprintk(VIDC_ERR, - "Failed to load buffer usage table: %d\n", rc); + d_vpr_e("Failed to load buffer usage table: %d\n", rc); goto err_load_buffer_usage_table; } rc = msm_vidc_load_regulator_table(res); if (rc) { - dprintk(VIDC_ERR, "Failed to load list of regulators %d\n", rc); + d_vpr_e("Failed to load list of regulators %d\n", rc); goto err_load_regulator_table; } rc = msm_vidc_load_clock_table(res); if (rc) { - dprintk(VIDC_ERR, - "Failed to load clock table: %d\n", rc); + d_vpr_e("Failed to load clock table: %d\n", rc); goto err_load_clock_table; } rc = msm_vidc_load_allowed_clocks_table(res); if (rc) { - dprintk(VIDC_ERR, - "Failed to load allowed clocks table: %d\n", rc); + d_vpr_e("Failed to load allowed clocks table: %d\n", rc); goto err_load_allowed_clocks_table; } rc = msm_vidc_load_reset_table(res); if (rc) { - dprintk(VIDC_ERR, - "Failed to load reset table: %d\n", rc); + d_vpr_e("Failed to load reset table: %d\n", rc); goto err_load_reset_table; } rc = msm_vidc_populate_legacy_context_bank(res); if (rc) { - dprintk(VIDC_ERR, - "Failed to setup context banks %d\n", rc); + d_vpr_e("Failed to setup context banks %d\n", rc); goto err_setup_legacy_cb; } rc = msm_vidc_populate_cx_ipeak_context(res); if (rc) { - dprintk(VIDC_ERR, - "Failed to setup cx-ipeak %d\n", rc); + d_vpr_e("Failed to setup cx-ipeak %d\n", rc); goto err_register_cx_ipeak; } @@ -1004,15 +984,14 @@ static int msm_vidc_setup_context_bank(struct msm_vidc_platform_resources *res, struct bus_type *bus; if (!dev || !cb || !res) { - dprintk(VIDC_ERR, - "%s: Invalid Input params\n", __func__); + d_vpr_e("%s: Invalid Input params\n", __func__); return -EINVAL; } cb->dev = dev; bus = cb->dev->bus; if (IS_ERR_OR_NULL(bus)) { - dprintk(VIDC_ERR, "%s - failed to get bus type\n", __func__); + d_vpr_e("%s: failed to get bus type\n", __func__); rc = PTR_ERR(bus) ? PTR_ERR(bus) : -ENODEV; goto remove_cb; } @@ -1030,9 +1009,9 @@ static int msm_vidc_setup_context_bank(struct msm_vidc_platform_resources *res, dma_set_max_seg_size(dev, DMA_BIT_MASK(32)); dma_set_seg_boundary(dev, DMA_BIT_MASK(64)); - dprintk(VIDC_HIGH, "Attached %s and created mapping\n", dev_name(dev)); - dprintk(VIDC_HIGH, - "Context bank name:%s, buffer_type: %#x, is_secure: %d, address range start: %#x, size: %#x, dev: %pK, domain: %pK", + d_vpr_h("Attached %s and created mapping\n", dev_name(dev)); + d_vpr_h( + "Context bank: %s, buffer_type: %#x, is_secure: %d, address range start: %#x, size: %#x, dev: %pK, domain: %pK", cb->name, cb->buffer_type, cb->is_secure, cb->addr_range.start, cb->addr_range.size, cb->dev, cb->domain); @@ -1047,7 +1026,7 @@ int msm_vidc_smmu_fault_handler(struct iommu_domain *domain, struct msm_vidc_inst *inst; if (!domain || !core) { - dprintk(VIDC_ERR, "%s - invalid param %pK %pK\n", + d_vpr_e("%s: invalid params %pK %pK\n", __func__, domain, core); return -EINVAL; } @@ -1061,7 +1040,7 @@ int msm_vidc_smmu_fault_handler(struct iommu_domain *domain, } } - dprintk(VIDC_ERR, "%s - faulting address: %lx\n", __func__, iova); + d_vpr_e("%s: faulting address: %lx\n", __func__, iova); mutex_lock(&core->lock); list_for_each_entry(inst, &core->instances, list) { @@ -1086,14 +1065,14 @@ static int msm_vidc_populate_context_bank(struct device *dev, struct device_node *np = NULL; if (!dev || !core) { - dprintk(VIDC_ERR, "%s - invalid inputs\n", __func__); + d_vpr_e("%s: invalid inputs\n", __func__); return -EINVAL; } np = dev->of_node; cb = devm_kzalloc(dev, sizeof(*cb), GFP_KERNEL); if (!cb) { - dprintk(VIDC_ERR, "%s - Failed to allocate cb\n", __func__); + d_vpr_e("%s: Failed to allocate cb\n", __func__); return -ENOMEM; } @@ -1102,40 +1081,37 @@ static int msm_vidc_populate_context_bank(struct device *dev, rc = of_property_read_string(np, "label", &cb->name); if (rc) { - dprintk(VIDC_HIGH, - "Failed to read cb label from device tree\n"); + d_vpr_h("Failed to read cb label from device tree\n"); rc = 0; } - dprintk(VIDC_HIGH, "%s: context bank has name %s\n", __func__, cb->name); + d_vpr_h("%s: context bank has name %s\n", __func__, cb->name); rc = of_property_read_u32_array(np, "virtual-addr-pool", (u32 *)&cb->addr_range, 2); if (rc) { - dprintk(VIDC_ERR, - "Could not read addr pool for context bank : %s %d\n", + d_vpr_e("Could not read addr pool: context bank: %s %d\n", cb->name, rc); goto err_setup_cb; } cb->is_secure = of_property_read_bool(np, "qcom,secure-context-bank"); - dprintk(VIDC_HIGH, "context bank %s : secure = %d\n", + d_vpr_h("context bank %s: secure = %d\n", cb->name, cb->is_secure); /* setup buffer type for each sub device*/ rc = of_property_read_u32(np, "buffer-types", &cb->buffer_type); if (rc) { - dprintk(VIDC_ERR, "failed to load buffer_type info %d\n", rc); + d_vpr_e("failed to load buffer_type info %d\n", rc); rc = -ENOENT; goto err_setup_cb; } - dprintk(VIDC_HIGH, - "context bank %s address start = %x address size = %x buffer_type = %x\n", + d_vpr_h("context bank %s address start %x size %x buffer_type %x\n", cb->name, cb->addr_range.start, cb->addr_range.size, cb->buffer_type); rc = msm_vidc_setup_context_bank(&core->resources, cb, dev); if (rc) { - dprintk(VIDC_ERR, "Cannot setup context bank %d\n", rc); + d_vpr_e("Cannot setup context bank %d\n", rc); goto err_setup_cb; } @@ -1160,7 +1136,7 @@ static int msm_vidc_populate_legacy_context_bank( struct context_bank_info *cb; if (!res || !res->pdev) { - dprintk(VIDC_ERR, "%s - invalid inputs\n", __func__); + d_vpr_e("%s: invalid inputs\n", __func__); return -EINVAL; } pdev = res->pdev; @@ -1168,8 +1144,7 @@ static int msm_vidc_populate_legacy_context_bank( domains_parent_node = of_find_node_by_name(pdev->dev.of_node, "qcom,vidc-iommu-domains"); if (!domains_parent_node) { - dprintk(VIDC_HIGH, - "%s legacy iommu domains not present\n", __func__); + d_vpr_h("%s: legacy iommu domains not present\n", __func__); return 0; } @@ -1178,8 +1153,7 @@ static int msm_vidc_populate_legacy_context_bank( domains_child_node) { cb = devm_kzalloc(&pdev->dev, sizeof(*cb), GFP_KERNEL); if (!cb) { - dprintk(VIDC_ERR, - "%s - Failed to allocate cb\n", __func__); + d_vpr_e("%s: Failed to allocate cb\n", __func__); return -ENOMEM; } INIT_LIST_HEAD(&cb->list); @@ -1188,24 +1162,21 @@ static int msm_vidc_populate_legacy_context_bank( ctx_node = of_parse_phandle(domains_child_node, "qcom,vidc-domain-phandle", 0); if (!ctx_node) { - dprintk(VIDC_ERR, - "%s Unable to parse pHandle\n", __func__); + d_vpr_e("%s: Unable to parse pHandle\n", __func__); rc = -EBADHANDLE; goto err_setup_cb; } rc = of_property_read_string(ctx_node, "label", &(cb->name)); if (rc) { - dprintk(VIDC_ERR, - "%s Could not find label\n", __func__); + d_vpr_e("%s: Could not find label\n", __func__); goto err_setup_cb; } rc = of_property_read_u32_array(ctx_node, "qcom,virtual-addr-pool", (u32 *)&cb->addr_range, 2); if (rc) { - dprintk(VIDC_ERR, - "%s Could not read addr pool for group : %s (%d)\n", + d_vpr_e("%s: Could not read addr pool: %s (%d)\n", __func__, cb->name, rc); goto err_setup_cb; } @@ -1216,28 +1187,27 @@ static int msm_vidc_populate_legacy_context_bank( rc = of_property_read_u32(domains_child_node, "qcom,vidc-buffer-types", &cb->buffer_type); if (rc) { - dprintk(VIDC_ERR, - "%s Could not read buffer type (%d)\n", + d_vpr_e("%s: Could not read buffer type (%d)\n", __func__, rc); goto err_setup_cb; } cb->dev = msm_iommu_get_ctx(cb->name); if (IS_ERR_OR_NULL(cb->dev)) { - dprintk(VIDC_ERR, "%s could not get device for cb %s\n", - __func__, cb->name); + d_vpr_e("%s: could not get device for cb %s\n", + __func__, cb->name); rc = -ENOENT; goto err_setup_cb; } rc = msm_vidc_setup_context_bank(res, cb, cb->dev); if (rc) { - dprintk(VIDC_ERR, "Cannot setup context bank %d\n", rc); + d_vpr_e("Cannot setup context bank %d\n", rc); goto err_setup_cb; } - dprintk(VIDC_HIGH, - "%s: context bank %s secure %d addr start = %#x addr size = %#x buffer_type = %#x\n", - __func__, cb->name, cb->is_secure, cb->addr_range.start, + d_vpr_h( + "context bank %s secure %d addr start = %#x size = %#x buffer_type = %#x\n", + cb->name, cb->is_secure, cb->addr_range.start, cb->addr_range.size, cb->buffer_type); } return rc; @@ -1253,26 +1223,26 @@ int read_context_bank_resources_from_dt(struct platform_device *pdev) int rc = 0; if (!pdev) { - dprintk(VIDC_ERR, "Invalid platform device\n"); + d_vpr_e("Invalid platform device\n"); return -EINVAL; } else if (!pdev->dev.parent) { - dprintk(VIDC_ERR, "Failed to find a parent for %s\n", - dev_name(&pdev->dev)); + d_vpr_e("Failed to find a parent for %s\n", + dev_name(&pdev->dev)); return -ENODEV; } core = dev_get_drvdata(pdev->dev.parent); if (!core) { - dprintk(VIDC_ERR, "Failed to find cookie in parent device %s", + d_vpr_e("Failed to find cookie in parent device %s", dev_name(pdev->dev.parent)); return -EINVAL; } rc = msm_vidc_populate_context_bank(&pdev->dev, core); if (rc) - dprintk(VIDC_ERR, "Failed to probe context bank\n"); + d_vpr_e("Failed to probe context bank\n"); else - dprintk(VIDC_HIGH, "Successfully probed context bank\n"); + d_vpr_h("Successfully probed context bank\n"); return rc; } @@ -1282,18 +1252,18 @@ int read_bus_resources_from_dt(struct platform_device *pdev) struct msm_vidc_core *core; if (!pdev) { - dprintk(VIDC_ERR, "Invalid platform device\n"); + d_vpr_e("Invalid platform device\n"); return -EINVAL; } else if (!pdev->dev.parent) { - dprintk(VIDC_ERR, "Failed to find a parent for %s\n", - dev_name(&pdev->dev)); + d_vpr_e("Failed to find a parent for %s\n", + dev_name(&pdev->dev)); return -ENODEV; } core = dev_get_drvdata(pdev->dev.parent); if (!core) { - dprintk(VIDC_ERR, "Failed to find cookie in parent device %s", - dev_name(pdev->dev.parent)); + d_vpr_e("Failed to find cookie in parent device %s", + dev_name(pdev->dev.parent)); return -EINVAL; } @@ -1305,17 +1275,17 @@ int read_mem_cdsp_resources_from_dt(struct platform_device *pdev) struct msm_vidc_core *core; if (!pdev) { - dprintk(VIDC_ERR, "%s: invalid platform device\n", __func__); + d_vpr_e("%s: invalid platform device\n", __func__); return -EINVAL; } else if (!pdev->dev.parent) { - dprintk(VIDC_ERR, "Failed to find a parent for %s\n", + d_vpr_e("Failed to find a parent for %s\n", dev_name(&pdev->dev)); return -ENODEV; } core = dev_get_drvdata(pdev->dev.parent); if (!core) { - dprintk(VIDC_ERR, "Failed to find cookie in parent device %s", + d_vpr_e("Failed to find cookie in parent device %s", dev_name(pdev->dev.parent)); return -EINVAL; } diff --git a/msm/vidc/vidc_hfi.c b/msm/vidc/vidc_hfi.c index 11ea53019f63..111965e6e457 100644 --- a/msm/vidc/vidc_hfi.c +++ b/msm/vidc/vidc_hfi.c @@ -16,7 +16,7 @@ struct hfi_device *vidc_hfi_initialize(enum msm_vidc_hfi_type hfi_type, hdev = kzalloc(sizeof(struct hfi_device), GFP_KERNEL); if (!hdev) { - dprintk(VIDC_ERR, "%s: failed to allocate hdev\n", __func__); + d_vpr_e("%s: failed to allocate hdev\n", __func__); return NULL; } @@ -25,13 +25,13 @@ struct hfi_device *vidc_hfi_initialize(enum msm_vidc_hfi_type hfi_type, rc = venus_hfi_initialize(hdev, device_id, res, callback); break; default: - dprintk(VIDC_ERR, "Unsupported host-firmware interface\n"); + d_vpr_e("Unsupported host-firmware interface\n"); goto err_hfi_init; } if (rc) { if (rc != -EPROBE_DEFER) - dprintk(VIDC_ERR, "%s device init failed rc = %d", + d_vpr_e("%s: device init failed rc = %d", __func__, rc); goto err_hfi_init; } @@ -47,7 +47,7 @@ void vidc_hfi_deinitialize(enum msm_vidc_hfi_type hfi_type, struct hfi_device *hdev) { if (!hdev) { - dprintk(VIDC_ERR, "%s invalid device %pK", __func__, hdev); + d_vpr_e("%s: invalid device %pK", __func__, hdev); return; } @@ -56,7 +56,7 @@ void vidc_hfi_deinitialize(enum msm_vidc_hfi_type hfi_type, venus_hfi_delete_device(hdev->hfi_device_data); break; default: - dprintk(VIDC_ERR, "Unsupported host-firmware interface\n"); + d_vpr_e("Unsupported host-firmware interface\n"); } kfree(hdev); diff --git a/msm/vidc/vidc_hfi.h b/msm/vidc/vidc_hfi.h index 1d30ed804205..3d1f9ae383cc 100644 --- a/msm/vidc/vidc_hfi.h +++ b/msm/vidc/vidc_hfi.h @@ -370,31 +370,31 @@ struct hfi_uncompressed_plane_actual_constraints_info { struct hfi_cmd_sys_session_abort_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; }; struct hfi_cmd_session_load_resources_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; }; struct hfi_cmd_session_start_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; }; struct hfi_cmd_session_stop_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; }; struct hfi_cmd_session_empty_buffer_compressed_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 time_stamp_hi; u32 time_stamp_lo; u32 flags; @@ -412,7 +412,7 @@ struct hfi_cmd_session_empty_buffer_compressed_packet { struct hfi_cmd_session_empty_buffer_uncompressed_plane0_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 view_id; u32 time_stamp_hi; u32 time_stamp_lo; @@ -449,7 +449,7 @@ struct hfi_cmd_session_empty_buffer_uncompressed_plane2_packet { struct hfi_cmd_session_fill_buffer_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 stream_id; u32 offset; u32 alloc_len; @@ -463,26 +463,26 @@ struct hfi_cmd_session_fill_buffer_packet { struct hfi_cmd_session_flush_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 flush_type; }; struct hfi_cmd_session_suspend_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; }; struct hfi_cmd_session_resume_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; }; struct hfi_cmd_session_get_property_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 num_properties; u32 rg_property_data[1]; }; @@ -490,7 +490,7 @@ struct hfi_cmd_session_get_property_packet { struct hfi_cmd_session_release_buffer_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 buffer_type; u32 buffer_size; u32 extra_data_size; @@ -502,13 +502,13 @@ struct hfi_cmd_session_release_buffer_packet { struct hfi_cmd_session_release_resources_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; }; struct hfi_msg_sys_session_abort_done_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 error_type; }; @@ -522,42 +522,42 @@ struct hfi_msg_sys_property_info_packet { struct hfi_msg_session_load_resources_done_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 error_type; }; struct hfi_msg_session_start_done_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 error_type; }; struct hfi_msg_session_stop_done_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 error_type; }; struct hfi_msg_session_suspend_done_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 error_type; }; struct hfi_msg_session_resume_done_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 error_type; }; struct hfi_msg_session_flush_done_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 error_type; u32 flush_type; }; @@ -581,7 +581,7 @@ struct hfi_frame_cr_stats_type { struct hfi_msg_session_empty_buffer_done_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 error_type; u32 offset; u32 filled_len; @@ -597,7 +597,7 @@ struct hfi_msg_session_empty_buffer_done_packet { struct hfi_msg_session_fill_buffer_done_compressed_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 time_stamp_hi; u32 time_stamp_lo; u32 error_type; @@ -619,7 +619,7 @@ struct hfi_msg_session_fill_buffer_done_compressed_packet { struct hfi_msg_session_fbd_uncompressed_plane0_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 stream_id; u32 view_id; u32 error_type; @@ -666,7 +666,7 @@ struct hfi_msg_session_fill_buffer_done_uncompressed_plane2_packet { struct hfi_msg_session_property_info_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 num_properties; u32 rg_property_data[1]; }; @@ -674,14 +674,14 @@ struct hfi_msg_session_property_info_packet { struct hfi_msg_session_release_resources_done_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 error_type; }; struct hfi_msg_session_release_buffers_done_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 error_type; u32 num_buffers; u32 rg_buffer_info[1]; @@ -690,7 +690,7 @@ struct hfi_msg_session_release_buffers_done_packet { struct hfi_msg_session_register_buffers_done_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 client_data; u32 error_type; }; @@ -698,7 +698,7 @@ struct hfi_msg_session_register_buffers_done_packet { struct hfi_msg_session_unregister_buffers_done_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 client_data; u32 error_type; }; @@ -806,7 +806,7 @@ struct hfi_extradata_recovery_point_sei_payload { struct hfi_cmd_session_continue_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; }; enum session_flags { @@ -815,11 +815,12 @@ enum session_flags { struct hal_session { struct list_head list; - void *session_id; + void *inst_id; bool is_decoder; enum hal_video_codec codec; enum hal_domain domain; u32 flags; + u32 sid; }; struct hal_device_data { diff --git a/msm/vidc/vidc_hfi_api.h b/msm/vidc/vidc_hfi_api.h index 86ce8e48ea1b..e0e5b5d4eab0 100644 --- a/msm/vidc/vidc_hfi_api.h +++ b/msm/vidc/vidc_hfi_api.h @@ -577,7 +577,7 @@ struct vidc_hal_sys_init_done { struct msm_vidc_cb_cmd_done { u32 device_id; - void *session_id; + void *inst_id; enum vidc_status status; u32 size; union { @@ -609,7 +609,7 @@ struct hal_index_extradata_input_crop_payload { struct msm_vidc_cb_event { u32 device_id; - void *session_id; + void *inst_id; enum vidc_status status; u32 height; u32 width; @@ -628,7 +628,7 @@ struct msm_vidc_cb_event { struct msm_vidc_cb_data_done { u32 device_id; - void *session_id; + void *inst_id; enum vidc_status status; u32 size; union { @@ -689,9 +689,9 @@ struct hfi_device { int (*core_init)(void *device); int (*core_release)(void *device); int (*core_trigger_ssr)(void *device, enum hal_ssr_trigger_type); - int (*session_init)(void *device, void *session_id, + int (*session_init)(void *device, void *inst_id, enum hal_domain session_type, enum hal_video_codec codec_type, - void **new_session); + void **new_session, u32 sid); int (*session_end)(void *session); int (*session_abort)(void *session); int (*session_set_buffers)(void *sess, @@ -718,9 +718,9 @@ struct hfi_device { void *pdata, u32 size); int (*session_pause)(void *sess); int (*session_resume)(void *sess); - int (*scale_clocks)(void *dev, u32 freq); + int (*scale_clocks)(void *dev, u32 freq, u32 sid); int (*vote_bus)(void *dev, unsigned long bw_ddr, - unsigned long bw_llcc); + unsigned long bw_llcc, u32 sid); int (*get_fw_info)(void *dev, struct hal_fw_info *fw_info); int (*session_clean)(void *sess); int (*get_core_capabilities)(void *dev); @@ -739,9 +739,6 @@ struct hfi_device *vidc_hfi_initialize(enum msm_vidc_hfi_type hfi_type, hfi_cmd_response_callback callback); void vidc_hfi_deinitialize(enum msm_vidc_hfi_type hfi_type, struct hfi_device *hdev); -u32 vidc_get_hfi_domain(enum hal_domain hal_domain); -u32 vidc_get_hfi_codec(enum hal_video_codec hal_codec); -enum hal_domain vidc_get_hal_domain(u32 hfi_domain); -enum hal_video_codec vidc_get_hal_codec(u32 hfi_codec); - +u32 vidc_get_hfi_domain(enum hal_domain hal_domain, u32 sid); +u32 vidc_get_hfi_codec(enum hal_video_codec hal_codec, u32 sid); #endif /*__VIDC_HFI_API_H__ */ diff --git a/msm/vidc/vidc_hfi_helper.h b/msm/vidc/vidc_hfi_helper.h index 2b96d5645a5e..f345fdf475f6 100644 --- a/msm/vidc/vidc_hfi_helper.h +++ b/msm/vidc/vidc_hfi_helper.h @@ -834,7 +834,7 @@ struct vidc_hal_msg_pkt_hdr { struct vidc_hal_session_cmd_pkt { u32 size; u32 packet_type; - u32 session_id; + u32 sid; }; struct hfi_packet_header { @@ -885,7 +885,7 @@ struct hfi_cmd_sys_get_property_packet { struct hfi_cmd_sys_session_init_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 session_domain; u32 session_codec; }; @@ -893,7 +893,7 @@ struct hfi_cmd_sys_session_init_packet { struct hfi_cmd_sys_session_end_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; }; struct hfi_cmd_sys_set_buffers_packet { @@ -927,7 +927,7 @@ struct hfi_cmd_sys_set_ubwc_config_packet_type { struct hfi_cmd_session_set_property_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 num_properties; u32 rg_property_data[1]; }; @@ -935,7 +935,7 @@ struct hfi_cmd_session_set_property_packet { struct hfi_cmd_session_set_buffers_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 buffer_type; u32 buffer_size; u32 extra_data_size; @@ -953,7 +953,7 @@ struct hfi_buffer_mapping_type { struct hfi_cmd_session_register_buffers_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 client_data; u32 response_req; u32 num_buffers; @@ -963,7 +963,7 @@ struct hfi_cmd_session_register_buffers_packet { struct hfi_cmd_session_unregister_buffers_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 client_data; u32 response_req; u32 num_buffers; @@ -973,7 +973,7 @@ struct hfi_cmd_session_unregister_buffers_packet { struct hfi_cmd_session_sync_process_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 sync_id; u32 rg_data[1]; }; @@ -981,7 +981,7 @@ struct hfi_cmd_session_sync_process_packet { struct hfi_msg_event_notify_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 event_id; u32 event_data1; u32 event_data2; @@ -1018,7 +1018,7 @@ struct hfi_msg_sys_release_resource_done_packet { struct hfi_msg_sys_session_init_done_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 error_type; u32 num_properties; u32 rg_property_data[1]; @@ -1027,7 +1027,7 @@ struct hfi_msg_sys_session_init_done_packet { struct hfi_msg_sys_session_end_done_packet { u32 size; u32 packet_type; - u32 session_id; + u32 sid; u32 error_type; };