C++ VCD_MSG_LOW函数代码示例

static u32 vcd_resume_in_paused(struct vcd_clnt_ctxt *cctxt)
{
	struct vcd_dev_ctxt *dev_ctxt = cctxt->dev_ctxt;
	u32 rc = VCD_S_SUCCESS;

	VCD_MSG_LOW("vcd_resume_in_paused:");


	if (cctxt->sched_clnt_hdl) {
		rc = vcd_power_event(cctxt->dev_ctxt,
				     cctxt, VCD_EVT_PWR_CLNT_RESUME);

		if (VCD_FAILED(rc)) {
			VCD_MSG_ERROR("VCD_EVT_PWR_CLNT_RESUME failed");
		} else {
			rc = vcd_sched_suspend_resume_clnt(cctxt, true);
			if (VCD_FAILED(rc)) {
				VCD_MSG_ERROR
				    ("rc = 0x%x. Failed: "
				     "vcd_sched_suspend_resume_clnt",
				     rc);
			}

		}
		if (!VCD_FAILED(rc)) {
			vcd_do_client_state_transition(cctxt,
						       VCD_CLIENT_STATE_RUN,
						       CLIENT_STATE_EVENT_NUMBER
						       (resume));
			vcd_try_submit_frame(dev_ctxt);
		}
	} else {
		vcd_do_client_state_transition(cctxt,
					       VCD_CLIENT_STATE_RUN,
					       CLIENT_STATE_EVENT_NUMBER
					       (resume));
	}

	return rc;
}

static u32 vcd_close_in_ready
(struct vcd_drv_ctxt_type_t *p_drv_ctxt,
 struct vcd_clnt_ctxt_type_t *p_cctxt) {
    u32 rc;

    VCD_MSG_LOW("vcd_close_in_dev_ready:");

    if (p_cctxt->clnt_state.p_state_table->ev_hdlr.pf_close) {
        rc = p_cctxt->clnt_state.p_state_table->ev_hdlr.
             pf_close(p_cctxt);
    } else {
        VCD_MSG_ERROR("Unsupported API in client state %d",
                      p_cctxt->clnt_state.e_state);

        rc = VCD_ERR_BAD_STATE;
    }

    if (!VCD_FAILED(rc))
        vcd_handle_for_last_clnt_close(&p_drv_ctxt->dev_ctxt, TRUE);

    return rc;
}

static u32 vcd_pause_in_run(struct vcd_clnt_ctxt *cctxt)
{
	u32 rc = VCD_S_SUCCESS;

	VCD_MSG_LOW("vcd_pause_in_run:");

	if (cctxt->sched_clnt_hdl) {
		rc = vcd_sched_suspend_resume_clnt(cctxt, false);
		VCD_FAILED_RETURN(rc, "Failed: vcd_sched_suspend_resume_clnt");
	}

	if (cctxt->status.frame_submitted > 0) {
		vcd_do_client_state_transition(cctxt,
					       VCD_CLIENT_STATE_PAUSING,
					       CLIENT_STATE_EVENT_NUMBER
					       (pause));

	} else {
		VCD_MSG_HIGH("No client frames are currently being processed");

		vcd_do_client_state_transition(cctxt,
					       VCD_CLIENT_STATE_PAUSED,
					       CLIENT_STATE_EVENT_NUMBER
					       (pause));

		cctxt->callback(VCD_EVT_RESP_PAUSE,
				  VCD_S_SUCCESS,
				  NULL, 0, cctxt, cctxt->client_data);

		rc = vcd_power_event(cctxt->dev_ctxt, cctxt,
				     VCD_EVT_PWR_CLNT_PAUSE);

		if (VCD_FAILED(rc))
			VCD_MSG_ERROR("VCD_EVT_PWR_CLNT_PAUSE_END failed");

	}

	return VCD_S_SUCCESS;
}

static u32 vcd_flush_cmn(struct vcd_clnt_ctxt_type_t *p_cctxt, u32 n_mode)
{
	u32 rc = VCD_S_SUCCESS;

	VCD_MSG_LOW("vcd_flush_cmn in %d:", p_cctxt->clnt_state.e_state);

	rc = vcd_flush_buffers(p_cctxt, n_mode);

	VCD_FAILED_RETURN(rc, "Failed: vcd_flush_buffers");

	if (p_cctxt->status.n_frame_submitted > 0) {
		vcd_do_client_state_transition(p_cctxt,
					       VCD_CLIENT_STATE_FLUSHING,
					       CLIENT_STATE_EVENT_NUMBER
					       (pf_flush));
	} else {
		VCD_MSG_HIGH("All buffers are flushed");
		p_cctxt->status.n_flush_mode = n_mode;
		vcd_send_flush_done(p_cctxt, VCD_S_SUCCESS);
	}

	return rc;
}

void vcd_handle_device_err_fatal(struct vcd_dev_ctxt_type *p_dev_ctxt,
                                 struct vcd_clnt_ctxt_type_t *p_trig_clnt)
{
    struct vcd_clnt_ctxt_type_t *p_cctxt = p_dev_ctxt->p_cctxt_list_head;
    struct vcd_clnt_ctxt_type_t *p_tmp_clnt = NULL;
    VCD_MSG_LOW("vcd_handle_device_err_fatal:");
    while (p_cctxt) {
        p_tmp_clnt = p_cctxt;
        p_cctxt = p_cctxt->p_next;
        if (p_tmp_clnt != p_trig_clnt)
            vcd_clnt_handle_device_err_fatal(p_tmp_clnt,
                                             VCD_EVT_IND_HWERRFATAL);
    }
    p_dev_ctxt->e_pending_cmd = VCD_CMD_DEVICE_RESET;
    if (!p_dev_ctxt->p_cctxt_list_head)
        vcd_do_device_state_transition(vcd_get_drv_context(),
                                       VCD_DEVICE_STATE_NOT_INIT,
                                       DEVICE_STATE_EVENT_NUMBER(pf_timeout));
    else
        vcd_do_device_state_transition(vcd_get_drv_context(),
                                       VCD_DEVICE_STATE_INVALID,
                                       DEVICE_STATE_EVENT_NUMBER(pf_dev_cb));
}

static u32 vcd_flush_cmn(struct vcd_clnt_ctxt *cctxt, u32 mode)
{
	u32 rc = VCD_S_SUCCESS;

	VCD_MSG_LOW("vcd_flush_cmn in %d:", cctxt->clnt_state.state);

	rc = vcd_flush_buffers(cctxt, mode);

	VCD_FAILED_RETURN(rc, "Failed: vcd_flush_buffers");

	if (cctxt->status.frame_submitted > 0) {
		vcd_do_client_state_transition(cctxt,
					       VCD_CLIENT_STATE_FLUSHING,
					       CLIENT_STATE_EVENT_NUMBER
					       (flush));
	} else {
		VCD_MSG_HIGH("All buffers are flushed");
		cctxt->status.mask |= (mode & VCD_FLUSH_ALL);
		vcd_send_flush_done(cctxt, VCD_S_SUCCESS);
	}

	return rc;
}

static u32 vcd_allocate_buffer_cmn
    (struct vcd_clnt_ctxt_type_t *p_cctxt,
     enum vcd_buffer_type e_buffer,
     u32 n_buf_size, u8 **pp_vir_buf_addr, u8 **pp_phy_buf_addr)
{
	u32 rc;
	struct vcd_buffer_pool_type *p_buf_pool;

	VCD_MSG_LOW("vcd_allocate_buffer_cmn in %d:",
		    p_cctxt->clnt_state.e_state);

	rc = vcd_common_allocate_set_buffer(p_cctxt, e_buffer, n_buf_size,
					    &p_buf_pool);

	if (!VCD_FAILED(rc)) {
		rc = vcd_allocate_buffer_internal(p_cctxt,
						  p_buf_pool,
						  n_buf_size,
						  pp_vir_buf_addr,
						  pp_phy_buf_addr);
	}

	return rc;
}

static u32 vcd_allocate_buffer_cmn
    (struct vcd_clnt_ctxt *cctxt,
     enum vcd_buffer_type buffer,
     u32 buf_size, u8 **vir_buf_addr, u8 **phy_buf_addr)
{
	u32 rc;
	struct vcd_buffer_pool *buf_pool;

	VCD_MSG_LOW("vcd_allocate_buffer_cmn in %d:",
		    cctxt->clnt_state.state);

	rc = vcd_common_allocate_set_buffer(cctxt, buffer, buf_size,
					    &buf_pool);

	if (!VCD_FAILED(rc)) {
		rc = vcd_allocate_buffer_internal(cctxt,
						  buf_pool,
						  buf_size,
						  vir_buf_addr,
						  phy_buf_addr);
	}

	return rc;
}

static u32 vcd_set_property_cmn
    (struct vcd_clnt_ctxt *cctxt,
     struct vcd_property_hdr *prop_hdr, void *prop_val)
{
	u32 rc;
	VCD_MSG_LOW("vcd_set_property_cmn in %d:", cctxt->clnt_state.state);
	VCD_MSG_LOW("property Id = %d", prop_hdr->prop_id);
	if (!prop_hdr->sz || !prop_hdr->prop_id) {
		VCD_MSG_MED("Bad parameters");
		return VCD_ERR_ILLEGAL_PARM;
	}

	rc = ddl_set_property(cctxt->ddl_handle, prop_hdr, prop_val);
	VCD_FAILED_RETURN(rc, "Failed: ddl_set_property");
	switch (prop_hdr->prop_id) {
	case VCD_I_META_BUFFER_MODE:
		{
			struct vcd_property_live *live =
			    (struct vcd_property_live *)prop_val;
			cctxt->meta_mode = live->live;
			break;
		}
	case VCD_I_LIVE:
		{
			struct vcd_property_live *live =
			    (struct vcd_property_live *)prop_val;
			cctxt->live = live->live;
			break;
		}
	case VCD_I_FRAME_RATE:
		{
			if (cctxt->sched_clnt_hdl) {
				rc = vcd_set_frame_rate(cctxt,
					(struct vcd_property_frame_rate *)
					prop_val);
			}
			break;
		}
	case VCD_I_FRAME_SIZE:
		{
			if (cctxt->sched_clnt_hdl) {
				rc = vcd_set_frame_size(cctxt,
					(struct vcd_property_frame_size *)
					prop_val);
			}
			break;
		}
	case VCD_I_INTRA_PERIOD:
	   {
		  struct vcd_property_i_period *iperiod =
			 (struct vcd_property_i_period *)prop_val;
		  cctxt->bframe = iperiod->b_frames;
		  break;
	   }
	default:
		{
			break;
		}
	}
	return rc;
}

void vcd_continue(void)
{
    struct vcd_drv_ctxt_type_t *p_drv_ctxt;
    struct vcd_dev_ctxt_type *p_dev_ctxt;
    u32 b_continue;
    struct vcd_transc_type *p_transc;
    u32 rc;
    VCD_MSG_LOW("vcd_continue:");

    p_drv_ctxt = vcd_get_drv_context();
    p_dev_ctxt = &p_drv_ctxt->dev_ctxt;

    p_dev_ctxt->b_continue = FALSE;

    if (p_dev_ctxt->e_pending_cmd == VCD_CMD_DEVICE_INIT) {
        VCD_MSG_HIGH("VCD_CMD_DEVICE_INIT is pending");

        p_dev_ctxt->e_pending_cmd = VCD_CMD_NONE;

        (void)vcd_init_device_context(p_drv_ctxt,
                                      DEVICE_STATE_EVENT_NUMBER(pf_open));
    } else if (p_dev_ctxt->e_pending_cmd == VCD_CMD_DEVICE_TERM) {
        VCD_MSG_HIGH("VCD_CMD_DEVICE_TERM is pending");

        p_dev_ctxt->e_pending_cmd = VCD_CMD_NONE;

        (void)vcd_deinit_device_context(p_drv_ctxt,
                                        DEVICE_STATE_EVENT_NUMBER(pf_close));
    } else if (p_dev_ctxt->e_pending_cmd == VCD_CMD_DEVICE_RESET) {
        VCD_MSG_HIGH("VCD_CMD_DEVICE_RESET is pending");
        p_dev_ctxt->e_pending_cmd = VCD_CMD_NONE;
        (void)vcd_reset_device_context(p_drv_ctxt,
                                       DEVICE_STATE_EVENT_NUMBER(pf_dev_cb));
    } else {
        if (p_dev_ctxt->b_set_perf_lvl_pending) {
            rc = vcd_power_event(p_dev_ctxt, NULL,
                                 VCD_EVT_PWR_DEV_SET_PERFLVL);

            if (VCD_FAILED(rc)) {
                VCD_MSG_ERROR
                ("VCD_EVT_PWR_CLNT_SET_PERFLVL failed");
                VCD_MSG_HIGH
                ("Not running at desired perf level."
                 "curr=%d, reqd=%d",
                 p_dev_ctxt->n_curr_perf_lvl,
                 p_dev_ctxt->n_reqd_perf_lvl);
            } else {
                p_dev_ctxt->b_set_perf_lvl_pending = FALSE;
            }
        }

        do {
            b_continue = FALSE;

            if (vcd_get_command_channel_in_loop
                    (p_dev_ctxt, &p_transc)) {
                if (vcd_submit_command_in_continue(p_dev_ctxt,
                                                   p_transc))
                    b_continue = TRUE;
                else {
                    VCD_MSG_MED
                    ("No more commands to submit");

                    vcd_release_command_channel(p_dev_ctxt,
                                                p_transc);

                    vcd_release_interim_command_channels
                    (p_dev_ctxt);
                }
            }
        } while (b_continue);

        do {
            b_continue = FALSE;

            if (vcd_get_frame_channel_in_loop
                    (p_dev_ctxt, &p_transc)) {
                if (vcd_try_submit_frame_in_continue(p_dev_ctxt,
                                                     p_transc)) {
                    b_continue = TRUE;
                } else {
                    VCD_MSG_MED("No more frames to submit");

                    vcd_release_frame_channel(p_dev_ctxt,
                                              p_transc);

                    vcd_release_interim_frame_channels
                    (p_dev_ctxt);
                }
            }

        } while (b_continue);

        if (!vcd_core_is_busy(p_dev_ctxt)) {
            rc = vcd_power_event(p_dev_ctxt, NULL,
                                 VCD_EVT_PWR_CLNT_CMD_END);

            if (VCD_FAILED(rc))
                VCD_MSG_ERROR("Failed:"
                              "VCD_EVT_PWR_CLNT_CMD_END");
//.........这里部分代码省略.........

static void  vcd_clnt_cb_in_invalid(
   struct vcd_clnt_ctxt *cctxt, u32 event, u32 status,
   void *payload, size_t sz, u32 *ddl_handle,
   void *const client_data
)
{
	struct vcd_dev_ctxt *dev_ctxt = cctxt->dev_ctxt;
	VCD_MSG_LOW("vcd_clnt_cb_in_invalid:");
	if (cctxt->ddl_handle != ddl_handle) {
		VCD_MSG_ERROR("ddl_handle mismatch");
		return;
	}
	switch (event) {
	case VCD_EVT_RESP_STOP:
		{
			vcd_handle_stop_done_in_invalid(cctxt,
				(struct vcd_transc *)client_data,
				status);
			break;
		}
	case VCD_EVT_RESP_INPUT_DONE:
	case VCD_EVT_RESP_OUTPUT_REQ:
		{
			if (cctxt->status.frame_submitted)
				cctxt->status.frame_submitted--;
			if (payload && ((struct ddl_frame_data_tag *)
							payload)->frm_trans_end)
				vcd_mark_frame_channel(cctxt->dev_ctxt);
			break;
		}
	case VCD_EVT_RESP_OUTPUT_DONE:
		{
			if (payload && ((struct ddl_frame_data_tag *)
							payload)->frm_trans_end)
				vcd_mark_frame_channel(cctxt->dev_ctxt);
			break;
		}
	case VCD_EVT_RESP_TRANSACTION_PENDING:
		{
			if (cctxt->status.frame_submitted)
				cctxt->status.frame_submitted--;
			vcd_mark_frame_channel(cctxt->dev_ctxt);
			break;
		}
	case VCD_EVT_IND_HWERRFATAL:
		{
			if (status == VCD_ERR_HW_FATAL)
				vcd_handle_stop_done_in_invalid(cctxt,
					(struct vcd_transc *)client_data,
					status);

			break;
		}
	case VCD_EVT_RESP_EOS_DONE:
		{
			vcd_mark_frame_channel(cctxt->dev_ctxt);
			break;
		}
	case VCD_EVT_IND_OUTPUT_RECONFIG:
		{
			if (cctxt->status.frame_submitted > 0)
				cctxt->status.frame_submitted--;
			else
				cctxt->status.frame_delayed--;
			vcd_mark_frame_channel(cctxt->dev_ctxt);
			break;
		}
	default:
		{
			VCD_MSG_ERROR("Unexpected callback event=%d status=%d"
				"from DDL",	event, status);
			dev_ctxt->command_continue = false;
			break;
		}
	}
}

void vcd_read_and_clear_interrupt(void)
{
   VCD_MSG_LOW("vcd_read_and_clear_interrupt:");
   ddl_read_and_clear_interrupt();
}

void vcd_ddl_callback(u32 event, u32 status, void *p_payload,
                      u32 n_size, u32 *ddl_handle, void *const p_client_data)
{
    struct vcd_drv_ctxt_type_t *p_drv_ctxt;
    struct vcd_dev_ctxt_type *p_dev_ctxt;
    struct vcd_dev_state_ctxt_type_t *p_dev_state;
    struct vcd_clnt_ctxt_type_t *p_cctxt;
    struct vcd_transc_type *p_transc;

    VCD_MSG_LOW("vcd_ddl_callback:");

    VCD_MSG_LOW("event=0x%x status=0x%x", event, status);

    p_drv_ctxt = vcd_get_drv_context();
    p_dev_ctxt = &p_drv_ctxt->dev_ctxt;
    p_dev_state = &p_drv_ctxt->dev_state;

    p_dev_ctxt->b_continue = TRUE;
    vcd_device_timer_stop(p_dev_ctxt);

    switch (p_dev_state->e_state) {
    case VCD_DEVICE_STATE_NULL:
    {
        VCD_MSG_HIGH("Callback unexpected in NULL state");
        break;
    }

    case VCD_DEVICE_STATE_NOT_INIT:
    {
        VCD_MSG_HIGH("Callback unexpected in NOT_INIT state");
        break;
    }

    case VCD_DEVICE_STATE_INITING:
    {
        if (p_dev_state->p_state_table->ev_hdlr.pf_dev_cb) {
            p_dev_state->p_state_table->ev_hdlr.
            pf_dev_cb(p_drv_ctxt, event, status,
                      p_payload, n_size, ddl_handle,
                      p_client_data);
        } else {
            VCD_MSG_HIGH("No device handler in %d state",
                         p_dev_state->e_state);
        }
        break;
    }

    case VCD_DEVICE_STATE_READY:
    {
        p_transc = (struct vcd_transc_type *)p_client_data;

        if (!p_transc || !p_transc->b_in_use
                || !p_transc->p_cctxt) {
            VCD_MSG_ERROR("Invalid clientdata "
                          "received from DDL ");
        } else {
            p_cctxt = p_transc->p_cctxt;

            if (p_cctxt->clnt_state.p_state_table->ev_hdlr.
                    pf_clnt_cb) {
                p_cctxt->clnt_state.p_state_table->
                ev_hdlr.pf_clnt_cb(p_cctxt,
                                   event, status, p_payload,
                                   n_size,	ddl_handle,
                                   p_client_data);
            } else {
                VCD_MSG_HIGH
                ("No client handler in"
                 " (dsm:READY, csm:%d) state",
                 (int)p_cctxt->clnt_state.e_state);

                if (VCD_FAILED(status)) {
                    VCD_MSG_FATAL("DDL callback"
                                  " returned failure 0x%x",
                                  status);
                }
            }
        }
        break;
    }

    default:
    {
        VCD_MSG_ERROR("Unknown state");
        break;
    }

    }

}

static void vcd_clnt_cb_in_eos
    (struct vcd_clnt_ctxt *cctxt,
     u32 event,
     u32 status,
     void *payload, size_t sz, u32 *ddl_handle, void *const client_data) {
	struct vcd_dev_ctxt *dev_ctxt = cctxt->dev_ctxt;
	struct vcd_transc *transc = NULL;
	u32 frm_trans_end = false, rc = VCD_S_SUCCESS;

	if (cctxt->ddl_handle != ddl_handle) {
		VCD_MSG_ERROR("ddl_handle mismatch");

		return;
	}

	switch (event) {
	case VCD_EVT_RESP_INPUT_DONE:
		{
			rc = vcd_handle_input_done_in_eos(cctxt, payload,
						     status);

			break;
		}

	case VCD_EVT_RESP_OUTPUT_DONE:
		{
			rc = vcd_handle_frame_done_in_eos(cctxt, payload,
						     status);

			break;
		}
	case VCD_EVT_RESP_OUTPUT_REQ:
		{
			rc = vcd_handle_output_required(cctxt, payload,
					status);
			break;
		}
	case VCD_EVT_RESP_EOS_DONE:
		{
			transc = (struct vcd_transc *)client_data;
			vcd_handle_eos_done(cctxt, transc, status);
			vcd_mark_frame_channel(cctxt->dev_ctxt);
			break;
		}
	case VCD_EVT_IND_OUTPUT_RECONFIG:
		{
			rc = vcd_handle_ind_output_reconfig(cctxt,
				payload, status);
			if (!VCD_FAILED(rc)) {
				frm_trans_end = true;
				payload = NULL;
				vcd_do_client_state_transition(cctxt,
					VCD_CLIENT_STATE_RUN,
					CLIENT_STATE_EVENT_NUMBER
					(clnt_cb));
				VCD_MSG_LOW
					("RECONFIGinEOS:Suspending Client");
				rc = vcd_sched_suspend_resume_clnt(cctxt,
						false);
				if (VCD_FAILED(rc)) {
					VCD_MSG_ERROR
					("Failed: suspend_resume_clnt. rc=0x%x",
						rc);
				}
			}
			break;
		}
	case VCD_EVT_IND_HWERRFATAL:
		{
			vcd_handle_ind_hw_err_fatal(cctxt,
				VCD_EVT_IND_HWERRFATAL,	status);
			break;
		}
	case VCD_EVT_IND_INFO_OUTPUT_RECONFIG:
		{
			vcd_handle_ind_info_output_reconfig(cctxt, status);
			break;
		}
	default:
		{
			VCD_MSG_ERROR
			    ("Unexpected callback event=%d status=%d from DDL",
			     event, status);

			dev_ctxt->command_continue = false;

			break;
		}

	}
	if (!VCD_FAILED(rc) &&
		(event == VCD_EVT_RESP_INPUT_DONE ||
		event == VCD_EVT_RESP_OUTPUT_DONE ||
		event == VCD_EVT_RESP_OUTPUT_REQ ||
		event == VCD_EVT_IND_OUTPUT_RECONFIG)) {
		if (payload && ((struct ddl_frame_data_tag *)
			payload)->frm_trans_end) {
			vcd_mark_frame_channel(cctxt->dev_ctxt);
			frm_trans_end = true;
		}
//.........这里部分代码省略.........