/*********************************************************** * Name: dispmanx_get_handle * * Arguments: command, parameter buffer, parameter legnth * * Description: same as dispmanx_send_command but returns uint instead * * Returns: handle * ***********************************************************/ static uint32_t dispmanx_get_handle( uint32_t command, void *buffer, uint32_t length) { VCHI_MSG_VECTOR_T vector[] = { {&command, sizeof(command)}, {buffer, length} }; uint32_t success = 0; uint32_t response = 0; lock_obtain(); success += vchi_msg_queuev( dispmanx_client.client_handle[0], vector, sizeof(vector)/sizeof(vector[0]), VCHI_FLAGS_BLOCK_UNTIL_QUEUED, NULL ); if(success == 0) success = dispmanx_wait_for_reply(&response, sizeof(response)); lock_release(); return VC_VTOH32(response); }
/** * <DFN>vc_hdcp2_service_send_command</DFN> sends a command which has no reply to Videocore * side HDCP2 service. * * @param client_handle is the vchi client handle * * @param sema is the locking semaphore to protect the buffer * * @param command is the command (VC_HDCP2_CMD_CODE_T in vc_hdcp2service_defs.h) * * @param buffer is the command buffer to be sent * * @param length is the size of buffer in bytes * * @return zero if successful, VCHI error code if failed */ int32_t vc_hdcp2_service_send_command(VCHI_SERVICE_HANDLE_T client_handle, VCOS_SEMAPHORE_T *sema, uint32_t command, void *buffer, uint32_t length) { VCHI_MSG_VECTOR_T vector[] = { {&command, sizeof(command)}, {buffer, length} }; VCOS_STATUS_T status; int32_t success = 0; vcos_assert(sema); status = vcos_semaphore_wait(sema); vcos_assert(status == VCOS_SUCCESS); success = vchi_msg_queuev( client_handle, vector, sizeof(vector)/sizeof(vector[0]), VCHI_FLAGS_BLOCK_UNTIL_QUEUED, NULL ); status = vcos_semaphore_post(sema); vcos_assert(status == VCOS_SUCCESS); return success; }
static int32_t dispmanx_send_command_reply( uint32_t command, void *buffer, uint32_t length, void *response, uint32_t max_length) { VCHI_MSG_VECTOR_T vector[] = { {&command, sizeof(command)}, {buffer, length} }; int32_t success = 0; lock_obtain(); success = vchi_msg_queuev( dispmanx_client.client_handle[0], vector, sizeof(vector)/sizeof(vector[0]), VCHI_FLAGS_BLOCK_UNTIL_QUEUED, NULL ); if(success == 0) success = dispmanx_wait_for_reply(response, max_length); lock_release(); return success; }
static int32_t dispmanx_send_command( uint32_t command, void *buffer, uint32_t length) { VCHI_MSG_VECTOR_T vector[] = { {&command, sizeof(command)}, {buffer, length} }; int32_t success = 0, response = -1; lock_obtain(); success = vchi_msg_queuev( dispmanx_client.client_handle[0], vector, sizeof(vector)/sizeof(vector[0]), VCHI_FLAGS_BLOCK_UNTIL_QUEUED, NULL ); if(success == 0 && !(command & DISPMANX_NO_REPLY_MASK)) { //otherwise only wait for a reply if we ask for one success = dispmanx_wait_for_reply(&response, sizeof(response)); } else { //Not waiting for a reply, send the success code back instead response = success; } lock_release(); return VC_VTOH32(response); }
/* ---------------------------------------------------------------------- * helper function to transmit an ilcs command/response + payload * -------------------------------------------------------------------- */ static void vc_ilcs_transmit( uint32_t cmd, uint32_t xid, unsigned char *msg, int len, unsigned char *msg2, int len2 ) { // could do this in 3 vectors, but hey VCHI_MSG_VECTOR_T vec[4]; int32_t result; vec[0].vec_base = &cmd; vec[0].vec_len = sizeof(cmd); vec[1].vec_base = &xid; vec[1].vec_len = sizeof(xid); vec[2].vec_base = msg; vec[2].vec_len = len; vec[3].vec_base = msg2; vec[3].vec_len = len2; result = vchi_msg_queuev( vc_ilcsg.vchi_handle, vec, 4, VCHI_FLAGS_BLOCK_UNTIL_QUEUED, NULL ); // call to VCHI vc_assert(result == 0); }
//Send replies/commands across to VMCS static int32_t hostreq_send_command(uint32_t command, void *buffer, uint32_t length) { int success = 0, i; VCHI_MSG_VECTOR_T vector[] = { {&command, sizeof(command)}, {buffer, length} }; assert(hostreq_client.initialised); lock_obtain(); for( i=0; i<hostreq_client.num_connections; i++ ) { success = vchi_msg_queuev(hostreq_client.client_handle[i], vector, sizeof(vector)/sizeof(vector[0]), VCHI_FLAGS_BLOCK_UNTIL_QUEUED, NULL); assert(!success); if(success != 0) break; } lock_release(); return success; }
static int32_t cecservice_send_command( uint32_t command, const void *buffer, uint32_t length, uint32_t has_reply) { VCHI_MSG_VECTOR_T vector[] = { {&command, sizeof(command)}, {buffer, length} }; int32_t success = 0; int32_t response; lock_obtain(); success = vchi_msg_queuev(cecservice_client.client_handle[0], vector, sizeof(vector)/sizeof(vector[0]), VCHI_FLAGS_BLOCK_UNTIL_QUEUED, NULL ); vcos_assert( success == 0 ); if(success == 0 && has_reply) { //otherwise only wait for a reply if we ask for one success = cecservice_wait_for_reply(&response, sizeof(response)); response = VC_VTOH32(response); } else { //No reply expected or failed to send, send the success code back instead response = success; } vcos_assert(success == 0); lock_release(); return response; }