Void copyTaskFxn(UArg arg0, UArg arg1) { MessageQCopy_Handle handle; Char buffer[128]; UInt32 myEndpoint = 0; UInt32 remoteEndpoint; UInt16 dstProc; UInt16 len; Int i; System_printf("copyTask %d: Entered...:\n", arg0); dstProc = MultiProc_getId("HOST"); /* Create the messageQ for receiving (and get our endpoint for sending). */ handle = MessageQCopy_create(arg0, &myEndpoint); NameMap_register("rpmsg-client-sample", arg0); for (i = 0; i < APP_NUM_ITERATIONS; i++) { /* Await a character message: */ MessageQCopy_recv(handle, (Ptr)buffer, &len, &remoteEndpoint, MessageQCopy_FOREVER); buffer[len] = '\0'; System_printf("copyTask %d: Received data: %s, len:%d\n", i + 1, buffer, len); /* Send data back to remote endpoint: */ MessageQCopy_send(dstProc, remoteEndpoint, myEndpoint, (Ptr)buffer, len); } /* Teardown our side: */ MessageQCopy_delete(&handle); }
Int IpcResource_disconnect(IpcResource_Handle handle) { Int status; IpcResource_Req req; if (!handle) { System_printf("IpcResource_disconnect: handle is NULL\n"); } req.resType = 0; req.reqType = IpcResource_REQ_TYPE_DISCONN; status = MessageQCopy_send(MultiProc_getId("HOST"), IpcResource_server, handle->endPoint, &req, sizeof(req)); if (status) { System_printf("IpcResource_disconnect: MessageQCopy_send " "failed status %d\n", status); return status; } status = MessageQCopy_delete(&handle->msgq); if (status) { System_printf("IpcResource_disconnect: MessageQCopy_delete " "failed status %d\n", status); return status; } Memory_free(NULL, handle, sizeof(*handle)); return 0; }
Int IpcResource_release(IpcResource_Handle handle, IpcResource_ResHandle resHandle) { Int status; Char msg[sizeof(IpcResource_Req) + sizeof(IpcResource_FreeData)]; IpcResource_Req *req = (Void *)msg; IpcResource_FreeData *rel = (Void *)req->data; if (!handle) { System_printf("IpcResource_release: handle is NULL\n"); return IpcResource_E_INVALARGS; } req->reqType = IpcResource_ReqType_FREE; rel->resHandle = resHandle; status = MessageQCopy_send(MultiProc_getId("HOST"), handle->remote, handle->endPoint, req, sizeof(msg)); if (status) { System_printf("IpcResource_release: MessageQCopy_send " "failed status %d\n", status); } return status; }
Int IpcResource_setConstraints(IpcResource_Handle handle, IpcResource_ResHandle resHandle, UInt32 action, Void *constraints) { Char msg[MAXMSGSIZE]; IpcResource_Ack *ack = (Void *)msg; IpcResource_Req *req = (Void *)msg; UInt16 rlen = sizeof(IpcResource_ConstraintData); UInt16 alen = sizeof(*ack); UInt16 len; UInt32 remote; Int status; if (!handle) { System_printf("IpcResource_setConstraints: Invalid paramaters\n"); return IpcResource_E_INVALARGS; } if (rlen && !constraints) { System_printf("IpcResource_setConstraints: needs parameters\n"); return IpcResource_E_INVALARGS; } req->resType = 0; req->reqType = action; req->resHandle = resHandle; memcpy(req->resParams, constraints, rlen); status = MessageQCopy_send(MultiProc_getId("HOST"), IpcResource_server, handle->endPoint, req, sizeof(*req) + rlen); if (status) { System_printf("IpcResource_setConstraints: MessageQCopy_send " "failed status %d\n", status); status = IpcResource_E_FAIL; goto end; } if (action == IpcResource_REQ_TYPE_REL_CONSTRAINTS) goto end; status = MessageQCopy_recv(handle->msgq, ack, &len, &remote, handle->timeout); if (status) { System_printf("IpcResource_setConstraints: MessageQCopy_recv " "failed status %d\n", status); status = (status == MessageQCopy_E_TIMEOUT) ? IpcResource_E_TIMEOUT : IpcResource_E_FAIL; goto end; } Assert_isTrue(len == (rlen + alen), NULL); status = _IpcResource_translateError(ack->status); end: return status; }
IpcResource_Handle IpcResource_connect(UInt timeout) { UInt16 dstProc; UInt16 len; UInt32 remote; IpcResource_Handle handle; IpcResource_Req req; IpcResource_Ack ack; Int status; handle = Memory_alloc(NULL, sizeof(*handle), 0, NULL); if (!handle) { System_printf("IpcResource_connect: No memory"); return NULL; } handle->timeout = (!timeout) ? DEFAULT_TIMEOUT : (timeout == IpcResource_FOREVER) ? MessageQCopy_FOREVER : timeout; dstProc = MultiProc_getId("HOST"); handle->msgq= MessageQCopy_create(MessageQCopy_ASSIGN_ANY, &handle->endPoint); req.resType = 0; req.reqType = IpcResource_REQ_TYPE_CONN; req.resHandle = 0; status = MessageQCopy_send(dstProc, IpcResource_server, handle->endPoint, &req, sizeof(req)); if (status) { System_printf("IpcResource_connect: MessageQCopy_send " " failed status %d\n", status); goto err; } status = MessageQCopy_recv(handle->msgq, &ack, &len, &remote, handle->timeout); if (status) { System_printf("IpcResource_connect: MessageQCopy_recv " "failed status %d\n", status); goto err; } status = _IpcResource_translateError(ack.status); if (status) { System_printf("IpcResource_connect: A9 Resource Manager " "failed status %d\n", status); goto err; } return handle; err: Memory_free(NULL, handle, sizeof(*handle)); return NULL; }
Void ServiceMgr_send(Service_Handle srvc, Ptr data, UInt16 len) { UInt32 local; UInt32 remote; struct omx_msg_hdr * hdr = (struct omx_msg_hdr *)data; UInt16 dstProc; /* Get reply endpoint and local address for sending: */ remote = RcmServer_getRemoteAddress(srvc); dstProc = RcmServer_getRemoteProc(srvc); local = RcmServer_getLocalAddress(srvc); /* Set special rpmsg_omx header so Linux side can strip it off: */ hdr->type = OMX_RAW_MSG; hdr->len = len; hdr->flags = 0; /* Send it off (and no response expected): */ MessageQCopy_send(dstProc, remote, local, data, HDRSIZE+len); }
static Void startExchange(Uint32 arg) { MessageQCopy_Handle handle; Char buffer[128]; UInt32 myEndpoint = 0; UInt32 remoteEndpoint; UInt16 len; UInt16 dstProc; Int i; sb_printf("copyTask %d: Entered...:\n", arg); dstProc = MultiProc_getId("HOST"); MessageQCopy_init(dstProc); /* Create the messageQ for receiving (and get our endpoint for sending). */ handle = MessageQCopy_create(arg, &myEndpoint); NameMap_register("fuckit-all", arg); for (i = 0; i < APP_NUM_ITERATIONS; i++) { /* Await a character message: */ MessageQCopy_recv(handle, (Ptr)buffer, &len, &remoteEndpoint, MessageQCopy_FOREVER); buffer[len] = '\0'; len = 8; memcpy((Ptr)buffer, "response", 8); /* Send data back to remote endpoint: */ MessageQCopy_send(dstProc, remoteEndpoint, myEndpoint, (Ptr)buffer, len); } /* Teardown our side: */ MessageQCopy_delete(&handle); /* Free MessageQCopy module wide resources: */ MessageQCopy_finalize(); }
Int IpcResource_release(IpcResource_Handle handle, IpcResource_ResHandle resHandle) { Int status; IpcResource_Req req; if (!handle) { System_printf("IpcResource_release: handle is NULL\n"); return IpcResource_E_INVALARGS; } req.resType = 0; req.reqType = IpcResource_REQ_TYPE_FREE; req.resHandle = resHandle; status = MessageQCopy_send(MultiProc_getId("HOST"), IpcResource_server, handle->endPoint, &req, sizeof(req)); if (status) { System_printf("IpcResource_release: MessageQCopy_send " "failed status %d\n", status); } return status; }
Void OmxSrvMgr_taskFxn(UArg arg0, UArg arg1) { MessageQCopy_Handle msgq; UInt32 local; UInt32 remote; Char msg[HDRSIZE + sizeof(struct omx_connect_req)]; struct omx_msg_hdr * hdr = (struct omx_msg_hdr *)msg; struct omx_connect_rsp * rsp = (struct omx_connect_rsp *)hdr->data; struct omx_connect_req * req = (struct omx_connect_req *)hdr->data; struct omx_disc_req * disc_req = (struct omx_disc_req *)hdr->data; struct omx_disc_rsp * disc_rsp = (struct omx_disc_rsp *)hdr->data; UInt16 dstProc; UInt16 len; UInt32 newAddr = 0; #ifdef BIOS_ONLY_TEST dstProc = MultiProc_self(); #else dstProc = MultiProc_getId("HOST"); #endif MessageQCopy_init(dstProc); msgq = MessageQCopy_create(OMX_MGR_PORT, &local); System_printf("OmxSrvMgr: started on port: %d\n", OMX_MGR_PORT); #ifdef SMP NameMap_register("rpmsg-omx1", OMX_MGR_PORT); System_printf("OmxSrvMgr: Proc#%d sending BOOTINIT_DONE\n", MultiProc_self()); VirtQueue_postInitDone(); #else if (MultiProc_self() == MultiProc_getId("CORE0")) { NameMap_register("rpmsg-omx0", OMX_MGR_PORT); } if (MultiProc_self() == MultiProc_getId("CORE1")) { NameMap_register("rpmsg-omx1", OMX_MGR_PORT); } if (MultiProc_self() == MultiProc_getId("DSP")) { NameMap_register("rpmsg-omx2", OMX_MGR_PORT); } if ((MultiProc_self() == MultiProc_getId("CORE1")) || (MultiProc_self() == MultiProc_getId("DSP"))) { System_printf("OmxSrvMgr: Proc#%d sending BOOTINIT_DONE\n", MultiProc_self()); VirtQueue_postInitDone(); } #endif while (1) { MessageQCopy_recv(msgq, (Ptr)msg, &len, &remote, MessageQCopy_FOREVER); System_printf("OmxSrvMgr: received msg type: %d from addr: %d\n", hdr->type, remote); switch (hdr->type) { case OMX_CONN_REQ: /* This is a request to create a new service, and return * it's connection endpoint. */ System_printf("OmxSrvMgr: CONN_REQ: len: %d, name: %s\n", hdr->len, req->name); rsp->status = ServiceMgr_createService(req->name, &newAddr); hdr->type = OMX_CONN_RSP; rsp->addr = newAddr; hdr->len = sizeof(struct omx_connect_rsp); len = HDRSIZE + hdr->len; break; case OMX_DISC_REQ: /* Destroy the service instance at given service addr: */ System_printf("OmxSrvMgr: OMX_DISCONNECT: len %d, addr: %d\n", hdr->len, disc_req->addr); disc_rsp->status = ServiceMgr_deleteService(disc_req->addr); /* currently, no response expected from rpmsg_omx: */ continue; #if 0 // rpmsg_omx is not listening for this ... yet. hdr->type = OMX_DISC_RSP; hdr->len = sizeof(struct omx_disc_rsp); len = HDRSIZE + hdr->len; break; #endif default: System_printf("unexpected msg type: %d\n", hdr->type); hdr->type = OMX_NOTSUPP; break; } System_printf("OmxSrvMgr: Replying with msg type: %d to addr: %d " " from: %d\n", hdr->type, remote, local); MessageQCopy_send(dstProc, remote, local, msg, len); } }
Int IpcResource_request(IpcResource_Handle handle, IpcResource_ResHandle *resHandle, IpcResource_Type type, Void *resParams) { Char msg[MAXMSGSIZE]; IpcResource_Req *req = (Void *)msg; IpcResource_Ack *ack = (Void *)msg; UInt16 hlen = sizeof(*req); UInt16 alen = sizeof(*ack); UInt16 rlen = IpcResource_resLen(type); UInt16 len; UInt32 remote; Int status; if (!handle || !resHandle) { System_printf("IpcResource_request: Invalid paramaters\n"); return IpcResource_E_INVALARGS; } if (rlen && !resParams) { System_printf("IpcResource_request: resource type %d " "needs parameters\n", type); return IpcResource_E_INVALARGS; } req->resType = type; req->reqType = IpcResource_REQ_TYPE_ALLOC; memcpy(req->resParams, resParams, rlen); status = MessageQCopy_send(MultiProc_getId("HOST"), IpcResource_server, handle->endPoint, req, hlen + rlen); if (status) { System_printf("IpcResource_request: MessageQCopy_send " "failed status %d\n", status); status = IpcResource_E_FAIL; goto end; } status = MessageQCopy_recv(handle->msgq, ack, &len, &remote, handle->timeout); if (status) { System_printf("IpcResource_request: MessageQCopy_recv " "failed status %d\n", status); status = (status == MessageQCopy_E_TIMEOUT) ? IpcResource_E_TIMEOUT : IpcResource_E_FAIL; goto end; } status = _IpcResource_translateError(ack->status); if (status) { System_printf("IpcResource_request: error from Host " "failed status %d\n", status); goto end; } Assert_isTrue(len == (rlen + alen), NULL); *resHandle = ack->resHandle; memcpy(resParams, ack->resParams, rlen); end: return status; }
void serviceMgrTaskFxn(UArg arg0, UArg arg1) { MessageQCopy_Handle msgq; UInt32 local; UInt32 remote; Char msg[HDRSIZE + sizeof(struct omx_connect_req)]; struct omx_msg_hdr * hdr = (struct omx_msg_hdr *)msg; struct omx_connect_rsp * rsp = (struct omx_connect_rsp *)hdr->data; struct omx_connect_req * req = (struct omx_connect_req *)hdr->data; struct omx_disc_req * disc_req = (struct omx_disc_req *)hdr->data; struct omx_disc_rsp * disc_rsp = (struct omx_disc_rsp *)hdr->data; UInt16 dstProc; UInt16 len; UInt32 newAddr = 0; #ifdef BIOS_ONLY_TEST dstProc = MultiProc_self(); #else dstProc = MultiProc_getId("HOST"); #endif msgq = MessageQCopy_create(SERVICE_MGR_PORT, &local); System_printf("serviceMgr: started on port: %d\n", SERVICE_MGR_PORT); /* * Yeah, this is horrible. * * Without it, we might try to send a message before buffers are * available in the ring, and then the code just bluntly fails. * * The real fix is to pause initialization until buffers are available, * or allow users to get notified when a buffer is available after * they failed getting one. */ Task_sleep(500); NameMap_register("rpmsg-omx", SERVICE_MGR_PORT); while (1) { MessageQCopy_recv(msgq, (Ptr)msg, &len, &remote, MessageQCopy_FOREVER); System_printf("serviceMgr: received msg type: %d from addr: %d\n", hdr->type, remote); switch (hdr->type) { case OMX_CONN_REQ: /* This is a request to create a new service, and return * it's connection endpoint. */ System_printf("serviceMgr: CONN_REQ: len: %d, name: %s\n", hdr->len, req->name); rsp->status = createService(req->name, &newAddr); hdr->type = OMX_CONN_RSP; rsp->addr = newAddr; hdr->len = sizeof(struct omx_connect_rsp); len = HDRSIZE + hdr->len; break; case OMX_DISC_REQ: /* Destroy the service instance at given service addr: */ System_printf("serviceMgr: OMX_DISCONNECT: len %d, addr: %d\n", hdr->len, disc_req->addr); disc_rsp->status = deleteService(disc_req->addr); /* currently, no response expected from rpmsg_omx: */ continue; #if 0 // rpmsg_omx is not listening for this ... yet. hdr->type = OMX_DISC_RSP; hdr->len = sizeof(struct omx_disc_rsp); len = HDRSIZE + hdr->len; break; #endif default: System_printf("unexpected msg type: %d\n", hdr->type); hdr->type = OMX_NOTSUPP; break; } System_printf("serviceMgr: Replying with msg type: %d to addr: %d " " from: %d\n", hdr->type, remote, local); MessageQCopy_send(dstProc, remote, local, msg, len); } }
Int IpcResource_setConstraints(IpcResource_Handle handle, IpcResource_ResHandle resHandle, UInt32 reqType, IpcResource_ConstraintData *constraints) { Char msg[MAXMSGSIZE]; IpcResource_Ack *ack = (Void *)msg; IpcResource_Req *req = (Void *)msg; IpcResource_Constraint *c = (Void *)req->data; UInt16 rlen = sizeof(*c); UInt16 alen = sizeof(*ack); UInt16 len; UInt32 remote; Int status; if (!handle) { System_printf("IpcResource_setConstraints: Invalid paramaters\n"); return IpcResource_E_INVALARGS; } if (!constraints) { System_printf("IpcResource_setConstraints: needs parameters\n"); return IpcResource_E_INVALARGS; } req->reqType = reqType; c->resHandle = resHandle; c->cdata = *constraints; Semaphore_pend(handle->sem, BIOS_WAIT_FOREVER); status = MessageQCopy_send(MultiProc_getId("HOST"), handle->remote, handle->endPoint, req, sizeof(*req) + rlen); if (status) { Semaphore_post(handle->sem); System_printf("IpcResource_setConstraints: MessageQCopy_send " "failed status %d\n", status); status = IpcResource_E_FAIL; goto end; } if (reqType == IpcResource_ReqType_REL_CONSTRAINTS) { Semaphore_post(handle->sem); goto end; } status = MessageQCopy_recv(handle->msgq, ack, &len, &remote, handle->timeout); Semaphore_post(handle->sem); if (status) { System_printf("IpcResource_setConstraints: MessageQCopy_recv " "failed status %d\n", status); status = (status == MessageQCopy_E_TIMEOUT) ? IpcResource_E_TIMEOUT : IpcResource_E_FAIL; goto end; } if (remote != handle->remote) { System_printf("IpcResource_setConstraints: MessageQCopy_recv " "invalid message source %d, channel source %d\n", remote, handle->remote); status = IpcResource_E_FAIL; goto end; } status = _IpcResource_translateError(ack->status); if (status) { System_printf("IpcResource_setConstraints: error from Host " "failed status %d\n", status); goto end; } Assert_isTrue(len == (rlen + alen), NULL); end: return status; }
Int IpcResource_requestData(IpcResource_Handle handle, IpcResource_ResHandle resHandle, IpcResource_ReqDataType dataType, Void *data) { Char msg[MAXMSGSIZE]; IpcResource_Ack *ack = (Void *)msg; IpcResource_Req *req = (Void *)msg; IpcResource_ReqData *reqData = (Void *)req->data; UInt16 hlen = sizeof(*reqData); UInt16 alen = sizeof(*ack); UInt16 rlen = IpcResource_reqDataLen(dataType); UInt16 len; UInt32 remote; Int status; if (!handle) { System_printf("IpcResource_requestData: Invalid handle\n"); return IpcResource_E_INVALARGS; } if (rlen && !data) { System_printf("IpcResource_requestData: needs data struct\n"); return IpcResource_E_INVALARGS; } req->reqType = IpcResource_ReqType_REQ_DATA; reqData->resHandle = resHandle; reqData->type = dataType; Semaphore_pend(handle->sem, BIOS_WAIT_FOREVER); status = MessageQCopy_send(MultiProc_getId("HOST"), handle->remote, handle->endPoint, req, sizeof(*req) + hlen + rlen); if (status) { Semaphore_post(handle->sem); System_printf("IpcResource_requestData: MessageQCopy_send " "failed status %d\n", status); status = IpcResource_E_FAIL; goto end; } status = MessageQCopy_recv(handle->msgq, ack, &len, &remote, handle->timeout); Semaphore_post(handle->sem); if (status) { System_printf("IpcResource_requestData: MessageQCopy_recv " "failed status %d\n", status); status = (status == MessageQCopy_E_TIMEOUT) ? IpcResource_E_TIMEOUT : IpcResource_E_FAIL; goto end; } status = _IpcResource_translateError(ack->status); if (status) { System_printf("IpcResource_requestData: error from Host " "failed status %d\n", status); goto end; } Assert_isTrue(len == (rlen + alen), NULL); memcpy(data, ack->data, rlen); end: return status; }
Int IpcResource_request(IpcResource_Handle handle, IpcResource_ResHandle *resHandle, IpcResource_Type type, Void *resParams) { Char msg[MAXMSGSIZE]; IpcResource_Req *req = (Void *)msg; IpcResource_AllocData *rdata = (Void *)req->data; IpcResource_Ack *ack = (Void *)msg; IpcResource_AckData *adata = (Void *)ack->data; UInt16 hlen = sizeof(*rdata) + sizeof(*req); UInt16 alen = sizeof(*ack); UInt16 rlen = IpcResource_resLen(type); UInt16 len; UInt32 remote; Int status; Char *name; IpcResource_Processor rproc; if (!handle || !resHandle) { System_printf("IpcResource_request: Invalid paramaters\n"); return IpcResource_E_INVALARGS; } name = IpcResource_toName(type); if (!name) { System_printf("IpcResource_request: resource type %d " "is invalid\n", type); return IpcResource_E_INVALARGS; } if (rlen && !resParams) { System_printf("IpcResource_request: resource type %d " "needs parameters\n", type); return IpcResource_E_INVALARGS; } strncpy(rdata->resName, name, 16); req->reqType = IpcResource_ReqType_ALLOC; switch(type) { case IpcResource_TYPE_IPU: case IpcResource_TYPE_DSP: strcpy(rproc.name, rdata->resName); strncpy(rdata->resName, "rproc", 16); resParams = &rproc; rlen = sizeof(rproc); break; default: break; } memcpy(rdata->resParams, resParams, rlen); Semaphore_pend(handle->sem, BIOS_WAIT_FOREVER); status = MessageQCopy_send(MultiProc_getId("HOST"), handle->remote, handle->endPoint, req, hlen + rlen); if (status) { Semaphore_post(handle->sem); System_printf("IpcResource_request: MessageQCopy_send " "failed status %d\n", status); status = IpcResource_E_FAIL; goto end; } status = MessageQCopy_recv(handle->msgq, ack, &len, &remote, handle->timeout); Semaphore_post(handle->sem); if (status) { System_printf("IpcResource_request: MessageQCopy_recv " "failed status %d\n", status); status = (status == MessageQCopy_E_TIMEOUT) ? IpcResource_E_TIMEOUT : IpcResource_E_FAIL; goto end; } if (remote != handle->remote) { System_printf("IpcResource_request: MessageQCopy_recv " "invalid message source %d, channel source %d\n", remote, handle->remote); status = IpcResource_E_FAIL; goto end; } status = _IpcResource_translateError(ack->status); if (status) { System_printf("IpcResource_request: error from Host " "failed status %d\n", status); goto end; } Assert_isTrue(len == rlen + alen + sizeof(*adata), NULL); *resHandle = adata->resHandle; memcpy(resParams, adata->resParams, rlen); end: return status; }
/* * ======== HdmiWa_taskFxn ======== */ static Void HdmiWa_taskFxn(UArg arg0, UArg arg1) { MessageQCopy_Handle handle; UInt32 myEndpoint = 0; UInt32 remoteEndpoint; UInt16 dstProc; UInt16 len; UInt32 temp; UInt32 ctsInterval = 0; UInt32 timerPeriod = 0; HdmiWa_PayloadData payload; System_printf("HdmiWa_taskFxn Entered...:\n"); dstProc = MultiProc_getId("HOST"); MessageQCopy_init(dstProc); /* Create the messageQ for receiving (and get our endpoint for sending). */ handle = MessageQCopy_create(70, &myEndpoint); NameMap_register("rpmsg-hdmiwa", 70); while (TRUE) { /* Await a character message: */ MessageQCopy_recv(handle, (Ptr)&payload, &len, &remoteEndpoint, MessageQCopy_FOREVER); if (!payload.trigger) { System_printf("HDMI payload received CTSInterval = %d, " "ACRRate = %d, SysCLK = %d\n", payload.ctsInterval, payload.acrRate, payload.sysClockFreq); if (!payload.ctsInterval || !payload.acrRate || !payload.sysClockFreq) { System_printf("Stop ACR WA, set auto reload timer to " "default periodicity\n"); module->waEnable = FALSE; timerPeriod = Clock_tickPeriod; goto set_timer; } /* ACR period in microseconds */ timerPeriod = 1000000 / payload.acrRate; ctsInterval = TIME_IN_NS_TO_GPT_CYCLES(payload.ctsInterval, payload.sysClockFreq); /* Set 1ms interval*/ temp = ONE_MILLISECOND % payload.ctsInterval; if (temp < TEN_MICROSECONDS) { module->ctsIntervalDelta = 1; } else { module->ctsIntervalDelta = TIME_IN_NS_TO_GPT_CYCLES(temp, payload.sysClockFreq); } /* Set ACR in SW mode */ REG32(HDMI_ACR_CTRL) = HDMI_CTS_SEL_SW; REG32(HDMI_INTR2) = HDMI_CTS_CHG_INT; REG32(HDMI_FREQ_SVAL) = HDMI_FREQ_SVAL_MCLK_IS_1024_FS; while (REG32(HDMI_FREQ_SVAL) != HDMI_FREQ_SVAL_MCLK_IS_1024_FS); temp = module->pTmr->tcrr; temp += module->ctsIntervalDelta; while (module->pTmr->tcrr < temp); REG32(HDMI_FREQ_SVAL) = HDMI_FREQ_SVAL_MCLK_IS_128_FS; for (temp = 0; (temp < 100000) && ((REG32(HDMI_INTR2) & HDMI_CTS_CHG_INT) != HDMI_CTS_CHG_INT); temp++); REG32(HDMI_INTR2) = HDMI_CTS_CHG_INT; module->gptTcrrHalfCts = ctsInterval / 2; module->gptTcrrFullCts = ctsInterval; set_timer: System_printf("Autoreload timer to %d\n", timerPeriod); Timer_setPeriodMicroSecs(SysM3TickTmr, timerPeriod); Timer_start(SysM3TickTmr); MessageQCopy_send(dstProc, remoteEndpoint, myEndpoint, (Ptr)&payload, len); } else { System_printf("Start HDMI ACRWA\n"); module->waEnable = TRUE; } } }