gceSTATUS gcfDump( IN gcoOS Os, IN gctCONST_STRING Message, ... ) { gctUINT offset = 0; gctARGUMENTS args; char buffer[80]; if (!setDumpFlag) return gcvSTATUS_OK; #if gcdDUMP_IN_KERNEL gcsHAL_INTERFACE ioctl; gcmARGUMENTS_START(args, Message); gcmVERIFY_OK(gcoOS_PrintStrVSafe(ioctl.u.Debug.message, gcmSIZEOF(ioctl.u.Debug.message), &offset, Message, args)); gcmARGUMENTS_END(args); ioctl.command = gcvHAL_DEBUG; ioctl.u.Debug.set = gcvFALSE; #if gcdDUMP ioctl.u.Debug.type = gcvMESSAGE_TEXT; #else ioctl.u.Debug.type = gcvMESSAGE_DUMP; #endif ioctl.u.Debug.messageSize = (gctUINT32)gcmSIZEOF(ioctl.u.Debug.message); gcmVERIFY_OK(gcoOS_DeviceControl(Os, IOCTL_GCHAL_INTERFACE, &ioctl, gcmSIZEOF(ioctl), &ioctl, gcmSIZEOF(ioctl))); #else gcmARGUMENTS_START(args, Message); gcmVERIFY_OK(gcoOS_PrintStrVSafe(buffer, gcmSIZEOF(buffer), &offset, Message, args)); gcmARGUMENTS_END(args); gcoOS_Print("%s", buffer); #endif return gcvSTATUS_OK; }
gceSTATUS gcoQUEUE_Commit( IN gcoQUEUE Queue ) { gceSTATUS status = gcvSTATUS_OK; gcsHAL_INTERFACE iface; gcmHEADER_ARG("Queue=0x%x", Queue); /* Verify the arguments. */ gcmVERIFY_OBJECT(Queue, gcvOBJ_QUEUE); if (Queue->head != gcvNULL) { /* Initialize event commit command. */ iface.command = gcvHAL_EVENT_COMMIT; iface.u.Event.queue = Queue->head; /* Send command to kernel. */ gcmONERROR( gcoOS_DeviceControl(gcvNULL, IOCTL_GCHAL_INTERFACE, &iface, gcmSIZEOF(iface), &iface, gcmSIZEOF(iface))); /* Test for error. */ gcmONERROR(iface.status); /* Free any records in the queue. */ gcmONERROR(gcoQUEUE_Free(Queue)); } /* Success. */ gcmFOOTER_NO(); return gcvSTATUS_OK; OnError: /* Return the status. */ gcmFOOTER(); return status; }
/** * * @param Hal * @param Node * @return */ static gceSTATUS UnlockVideoNode( IN gcoHAL Hal, IN gcuVIDMEM_NODE_PTR Node, IN gceSURF_TYPE surftype) { gcsHAL_INTERFACE iface; gceSTATUS status; gcmASSERT(Node != gcvNULL); iface.command = gcvHAL_UNLOCK_VIDEO_MEMORY; iface.u.UnlockVideoMemory.node = Node; iface.u.UnlockVideoMemory.type = surftype; iface.u.UnlockVideoMemory.asynchroneous = gcvTRUE; /* Call the kernel. */ gcmONERROR(gcoOS_DeviceControl( gcvNULL, IOCTL_GCHAL_INTERFACE, &iface, gcmSIZEOF(iface), &iface, gcmSIZEOF(iface) )); /* Success? */ gcmONERROR(iface.status); /* Do we need to schedule an event for the unlock? */ if (iface.u.UnlockVideoMemory.asynchroneous) { iface.u.UnlockVideoMemory.asynchroneous = gcvFALSE; gcmONERROR(gcoHAL_ScheduleEvent(Hal, &iface)); } OnError: /* Call kernel API. */ return gcvSTATUS_FALSE; }
/*#endif*/ gcmFOOTER_NO(); return gcvSTATUS_OK; } #endif /* vivante_no_3d */ gceSTATUS gcoPROFILER_EndFrame( IN gcoHAL Hal ) { /*#if (PROFILE_HAL_COUNTERS || PROFILE_HW_COUNTERS)*/ gcsHAL_INTERFACE iface; gceSTATUS status; /*#endif*/ gcmHEADER(); if (!gcPLS.hal->profiler.enable) { gcmFOOTER_NO(); return gcvSTATUS_OK; } /*#if PROFILE_HAL_COUNTERS*/ if (gcPLS.hal->profiler.enableHal) { #if gcdNEW_PROFILER_FILE gcmWRITE_CONST(VPG_HAL); gcmWRITE_COUNTER(VPC_HALVERTBUFNEWBYTEALLOC, gcPLS.hal->profiler.vertexBufferNewBytesAlloc); gcmWRITE_COUNTER(VPC_HALVERTBUFTOTALBYTEALLOC, gcPLS.hal->profiler.vertexBufferTotalBytesAlloc); gcmWRITE_COUNTER(VPC_HALVERTBUFNEWOBJALLOC, gcPLS.hal->profiler.vertexBufferNewObjectsAlloc); gcmWRITE_COUNTER(VPC_HALVERTBUFTOTALOBJALLOC, gcPLS.hal->profiler.vertexBufferTotalObjectsAlloc); gcmWRITE_COUNTER(VPC_HALINDBUFNEWBYTEALLOC, gcPLS.hal->profiler.indexBufferNewBytesAlloc); gcmWRITE_COUNTER(VPC_HALINDBUFTOTALBYTEALLOC, gcPLS.hal->profiler.indexBufferTotalBytesAlloc); gcmWRITE_COUNTER(VPC_HALINDBUFNEWOBJALLOC, gcPLS.hal->profiler.indexBufferNewObjectsAlloc); gcmWRITE_COUNTER(VPC_HALINDBUFTOTALOBJALLOC, gcPLS.hal->profiler.indexBufferTotalObjectsAlloc); gcmWRITE_COUNTER(VPC_HALTEXBUFNEWBYTEALLOC, gcPLS.hal->profiler.textureBufferNewBytesAlloc); gcmWRITE_COUNTER(VPC_HALTEXBUFTOTALBYTEALLOC, gcPLS.hal->profiler.textureBufferTotalBytesAlloc); gcmWRITE_COUNTER(VPC_HALTEXBUFNEWOBJALLOC, gcPLS.hal->profiler.textureBufferNewObjectsAlloc); gcmWRITE_COUNTER(VPC_HALTEXBUFTOTALOBJALLOC, gcPLS.hal->profiler.textureBufferTotalObjectsAlloc); gcmWRITE_CONST(VPG_END); #else gcmWRITE_STRING("<HALCounters>\n"); gcmPRINT_XML_COUNTER(vertexBufferNewBytesAlloc); gcmPRINT_XML_COUNTER(vertexBufferTotalBytesAlloc); gcmPRINT_XML_COUNTER(vertexBufferNewObjectsAlloc); gcmPRINT_XML_COUNTER(vertexBufferTotalObjectsAlloc); gcmPRINT_XML_COUNTER(indexBufferNewBytesAlloc); gcmPRINT_XML_COUNTER(indexBufferTotalBytesAlloc); gcmPRINT_XML_COUNTER(indexBufferNewObjectsAlloc); gcmPRINT_XML_COUNTER(indexBufferTotalObjectsAlloc); gcmPRINT_XML_COUNTER(textureBufferNewBytesAlloc); gcmPRINT_XML_COUNTER(textureBufferTotalBytesAlloc); gcmPRINT_XML_COUNTER(textureBufferNewObjectsAlloc); gcmPRINT_XML_COUNTER(textureBufferTotalObjectsAlloc); gcmWRITE_STRING("</HALCounters>\n"); #endif /* Reset per-frame counters. */ gcPLS.hal->profiler.vertexBufferNewBytesAlloc = 0; gcPLS.hal->profiler.vertexBufferNewObjectsAlloc = 0; gcPLS.hal->profiler.indexBufferNewBytesAlloc = 0; gcPLS.hal->profiler.indexBufferNewObjectsAlloc = 0; gcPLS.hal->profiler.textureBufferNewBytesAlloc = 0; gcPLS.hal->profiler.textureBufferNewObjectsAlloc = 0; } /*#endif*/ /*#if PROFILE_HW_COUNTERS*/ /* gcvHAL_READ_ALL_PROFILE_REGISTERS. */ if (gcPLS.hal->profiler.enableHW) { iface.command = gcvHAL_READ_ALL_PROFILE_REGISTERS; /* Call the kernel. */ status = gcoOS_DeviceControl(gcvNULL, IOCTL_GCHAL_INTERFACE, &iface, gcmSIZEOF(iface), &iface, gcmSIZEOF(iface)); /* Verify result. */ if (gcmNO_ERROR(status)) { #define gcmCOUNTER(name) iface.u.RegisterProfileData.counters.name #if gcdNEW_PROFILER_FILE gcmWRITE_CONST(VPG_HW); gcmWRITE_CONST(VPG_GPU); gcmWRITE_COUNTER(VPC_GPUREAD64BYTE, gcmCOUNTER(gpuTotalRead64BytesPerFrame)); gcmWRITE_COUNTER(VPC_GPUWRITE64BYTE, gcmCOUNTER(gpuTotalWrite64BytesPerFrame)); gcmWRITE_COUNTER(VPC_GPUCYCLES, gcmCOUNTER(gpuCyclesCounter)); gcmWRITE_CONST(VPG_END); gcmWRITE_CONST(VPG_VS); gcmWRITE_COUNTER(VPC_VSINSTCOUNT, gcmCOUNTER(vs_inst_counter) - gcPLS.hal->profiler.prevVSInstCount); gcmWRITE_COUNTER(VPC_VSBRANCHINSTCOUNT, gcmCOUNTER(vtx_branch_inst_counter) - gcPLS.hal->profiler.prevVSBranchInstCount); gcmWRITE_COUNTER(VPC_VSTEXLDINSTCOUNT, gcmCOUNTER(vtx_texld_inst_counter) - gcPLS.hal->profiler.prevVSTexInstCount); gcmWRITE_COUNTER(VPC_VSRENDEREDVERTCOUNT, gcmCOUNTER(rendered_vertice_counter) - gcPLS.hal->profiler.prevVSVertexCount); gcmWRITE_CONST(VPG_END); gcPLS.hal->profiler.prevVSInstCount = gcmCOUNTER(vs_inst_counter); gcPLS.hal->profiler.prevVSBranchInstCount = gcmCOUNTER(vtx_branch_inst_counter); gcPLS.hal->profiler.prevVSTexInstCount = gcmCOUNTER(vtx_texld_inst_counter); gcPLS.hal->profiler.prevVSVertexCount = gcmCOUNTER(rendered_vertice_counter); gcmWRITE_CONST(VPG_PA); gcmWRITE_COUNTER(VPC_PAINVERTCOUNT, gcmCOUNTER(pa_input_vtx_counter)); gcmWRITE_COUNTER(VPC_PAINPRIMCOUNT, gcmCOUNTER(pa_input_prim_counter)); gcmWRITE_COUNTER(VPC_PAOUTPRIMCOUNT, gcmCOUNTER(pa_output_prim_counter)); gcmWRITE_COUNTER(VPC_PADEPTHCLIPCOUNT, gcmCOUNTER(pa_depth_clipped_counter)); gcmWRITE_COUNTER(VPC_PATRIVIALREJCOUNT, gcmCOUNTER(pa_trivial_rejected_counter)); gcmWRITE_COUNTER(VPC_PACULLCOUNT, gcmCOUNTER(pa_culled_counter)); gcmWRITE_CONST(VPG_END); gcmWRITE_CONST(VPG_SETUP); gcmWRITE_COUNTER(VPC_SETRIANGLECOUNT, gcmCOUNTER(se_culled_triangle_count)); gcmWRITE_COUNTER(VPC_SELINECOUNT, gcmCOUNTER(se_culled_lines_count)); gcmWRITE_CONST(VPG_END); gcmWRITE_CONST(VPG_RA); gcmWRITE_COUNTER(VPC_RAVALIDPIXCOUNT, gcmCOUNTER(ra_valid_pixel_count)); gcmWRITE_COUNTER(VPC_RATOTALQUADCOUNT, gcmCOUNTER(ra_total_quad_count)); gcmWRITE_COUNTER(VPC_RAVALIDQUADCOUNTEZ, gcmCOUNTER(ra_valid_quad_count_after_early_z)); gcmWRITE_COUNTER(VPC_RATOTALPRIMCOUNT, gcmCOUNTER(ra_total_primitive_count)); gcmWRITE_COUNTER(VPC_RAPIPECACHEMISSCOUNT, gcmCOUNTER(ra_pipe_cache_miss_counter)); gcmWRITE_COUNTER(VPC_RAPREFCACHEMISSCOUNT, gcmCOUNTER(ra_prefetch_cache_miss_counter)); gcmWRITE_COUNTER(VPC_RAEEZCULLCOUNT, gcmCOUNTER(ra_eez_culled_counter)); gcmWRITE_CONST(VPG_END); gcmWRITE_CONST(VPG_TX); gcmWRITE_COUNTER(VPC_TXTOTBILINEARREQ, gcmCOUNTER(tx_total_bilinear_requests)); gcmWRITE_COUNTER(VPC_TXTOTTRILINEARREQ, gcmCOUNTER(tx_total_trilinear_requests)); gcmWRITE_COUNTER(VPC_TXTOTTEXREQ, gcmCOUNTER(tx_total_texture_requests)); gcmWRITE_COUNTER(VPC_TXMEMREADCOUNT, gcmCOUNTER(tx_mem_read_count)); gcmWRITE_COUNTER(VPC_TXMEMREADIN8BCOUNT, gcmCOUNTER(tx_mem_read_in_8B_count)); gcmWRITE_COUNTER(VPC_TXCACHEMISSCOUNT, gcmCOUNTER(tx_cache_miss_count)); gcmWRITE_COUNTER(VPC_TXCACHEHITTEXELCOUNT, gcmCOUNTER(tx_cache_hit_texel_count)); gcmWRITE_COUNTER(VPC_TXCACHEMISSTEXELCOUNT, gcmCOUNTER(tx_cache_miss_texel_count)); gcmWRITE_CONST(VPG_END); gcmWRITE_CONST(VPG_PS); gcmWRITE_COUNTER(VPC_PSINSTCOUNT, gcmCOUNTER(ps_inst_counter) - gcPLS.hal->profiler.prevPSInstCount); gcmWRITE_COUNTER(VPC_PSBRANCHINSTCOUNT, gcmCOUNTER(pxl_branch_inst_counter) - gcPLS.hal->profiler.prevPSBranchInstCount); gcmWRITE_COUNTER(VPC_PSTEXLDINSTCOUNT, gcmCOUNTER(pxl_texld_inst_counter) - gcPLS.hal->profiler.prevPSTexInstCount); gcmWRITE_COUNTER(VPC_PSRENDEREDPIXCOUNT, gcmCOUNTER(rendered_pixel_counter) - gcPLS.hal->profiler.prevPSPixelCount); gcmWRITE_CONST(VPG_END); gcPLS.hal->profiler.prevPSInstCount = gcmCOUNTER(ps_inst_counter); gcPLS.hal->profiler.prevPSBranchInstCount = gcmCOUNTER(pxl_branch_inst_counter); gcPLS.hal->profiler.prevPSTexInstCount = gcmCOUNTER(pxl_texld_inst_counter); gcPLS.hal->profiler.prevPSPixelCount = gcmCOUNTER(rendered_pixel_counter); gcmWRITE_CONST(VPG_PE); gcmWRITE_COUNTER(VPC_PEKILLEDBYCOLOR, gcmCOUNTER(pe_pixel_count_killed_by_color_pipe)); gcmWRITE_COUNTER(VPC_PEKILLEDBYDEPTH, gcmCOUNTER(pe_pixel_count_killed_by_depth_pipe)); gcmWRITE_COUNTER(VPC_PEDRAWNBYCOLOR, gcmCOUNTER(pe_pixel_count_drawn_by_color_pipe)); gcmWRITE_COUNTER(VPC_PEDRAWNBYDEPTH, gcmCOUNTER(pe_pixel_count_drawn_by_depth_pipe)); gcmWRITE_CONST(VPG_END); gcmWRITE_CONST(VPG_MC); gcmWRITE_COUNTER(VPC_MCREADREQ8BPIPE, gcmCOUNTER(mc_total_read_req_8B_from_pipeline)); gcmWRITE_COUNTER(VPC_MCREADREQ8BIP, gcmCOUNTER(mc_total_read_req_8B_from_IP)); gcmWRITE_COUNTER(VPC_MCWRITEREQ8BPIPE, gcmCOUNTER(mc_total_write_req_8B_from_pipeline)); gcmWRITE_CONST(VPG_END); gcmWRITE_CONST(VPG_AXI); gcmWRITE_COUNTER(VPC_AXIREADREQSTALLED, gcmCOUNTER(hi_axi_cycles_read_request_stalled)); gcmWRITE_COUNTER(VPC_AXIWRITEREQSTALLED, gcmCOUNTER(hi_axi_cycles_write_request_stalled)); gcmWRITE_COUNTER(VPC_AXIWRITEDATASTALLED, gcmCOUNTER(hi_axi_cycles_write_data_stalled)); gcmWRITE_CONST(VPG_END); gcmWRITE_CONST(VPG_END); #else gcmWRITE_STRING("<HWCounters>\n"); gcmPRINT_XML("<read_64Byte value=\"%u\"/>\n", gcmCOUNTER(gpuTotalRead64BytesPerFrame)); gcmPRINT_XML("<write_64Byte value=\"%u\"/>\n", gcmCOUNTER(gpuTotalWrite64BytesPerFrame)); gcmPRINT_XML("<gpu_cycles value=\"%u\"/>\n", gcmCOUNTER(gpuCyclesCounter)); gcmPRINT_XML("<pe_pixel_count_killed_by_color_pipe value=\"%u\"/>\n", gcmCOUNTER(pe_pixel_count_killed_by_color_pipe)); gcmPRINT_XML("<pe_pixel_count_killed_by_depth_pipe value=\"%u\"/>\n", gcmCOUNTER(pe_pixel_count_killed_by_depth_pipe)); gcmPRINT_XML("<pe_pixel_count_drawn_by_color_pipe value=\"%u\"/>\n", gcmCOUNTER(pe_pixel_count_drawn_by_color_pipe)); gcmPRINT_XML("<pe_pixel_count_drawn_by_depth_pipe value=\"%u\"/>\n", gcmCOUNTER(pe_pixel_count_drawn_by_depth_pipe)); gcmPRINT_XML("<ps_inst_counter value=\"%u\"/>\n", gcmCOUNTER(ps_inst_counter)); gcmPRINT_XML("<rendered_pixel_counter value=\"%u\"/>\n", gcmCOUNTER(rendered_pixel_counter)); gcmPRINT_XML("<vs_inst_counter value=\"%u\"/>\n", gcmCOUNTER(vs_inst_counter)); gcmPRINT_XML("<rendered_vertice_counter value=\"%u\"/>\n", gcmCOUNTER(rendered_vertice_counter)); gcmPRINT_XML("<vtx_branch_inst_counter value=\"%u\"/>\n", gcmCOUNTER(vtx_branch_inst_counter)); gcmPRINT_XML("<vtx_texld_inst_counter value=\"%u\"/>\n", gcmCOUNTER(vtx_texld_inst_counter)); gcmPRINT_XML("<pxl_branch_inst_counter value=\"%u\"/>\n", gcmCOUNTER(pxl_branch_inst_counter)); gcmPRINT_XML("<pxl_texld_inst_counter value=\"%u\"/>\n", gcmCOUNTER(pxl_texld_inst_counter)); gcmPRINT_XML("<pa_input_vtx_counter value=\"%u\"/>\n", gcmCOUNTER(pa_input_vtx_counter)); gcmPRINT_XML("<pa_input_prim_counter value=\"%u\"/>\n", gcmCOUNTER(pa_input_prim_counter)); gcmPRINT_XML("<pa_output_prim_counter value=\"%u\"/>\n", gcmCOUNTER(pa_output_prim_counter)); gcmPRINT_XML("<pa_depth_clipped_counter value=\"%u\"/>\n", gcmCOUNTER(pa_depth_clipped_counter)); gcmPRINT_XML("<pa_trivial_rejected_counter value=\"%u\"/>\n", gcmCOUNTER(pa_trivial_rejected_counter)); gcmPRINT_XML("<pa_culled_counter value=\"%u\"/>\n", gcmCOUNTER(pa_culled_counter)); gcmPRINT_XML("<se_culled_triangle_count value=\"%u\"/>\n", gcmCOUNTER(se_culled_triangle_count)); gcmPRINT_XML("<se_culled_lines_count value=\"%u\"/>\n", gcmCOUNTER(se_culled_lines_count)); gcmPRINT_XML("<ra_valid_pixel_count value=\"%u\"/>\n", gcmCOUNTER(ra_valid_pixel_count)); gcmPRINT_XML("<ra_total_quad_count value=\"%u\"/>\n", gcmCOUNTER(ra_total_quad_count)); gcmPRINT_XML("<ra_valid_quad_count_after_early_z value=\"%u\"/>\n", gcmCOUNTER(ra_valid_quad_count_after_early_z)); gcmPRINT_XML("<ra_total_primitive_count value=\"%u\"/>\n", gcmCOUNTER(ra_total_primitive_count)); gcmPRINT_XML("<ra_pipe_cache_miss_counter value=\"%u\"/>\n", gcmCOUNTER(ra_pipe_cache_miss_counter)); gcmPRINT_XML("<ra_prefetch_cache_miss_counter value=\"%u\"/>\n", gcmCOUNTER(ra_prefetch_cache_miss_counter)); gcmPRINT_XML("<ra_eez_culled_counter value=\"%u\"/>\n", gcmCOUNTER(ra_eez_culled_counter)); gcmPRINT_XML("<tx_total_bilinear_requests value=\"%u\"/>\n", gcmCOUNTER(tx_total_bilinear_requests)); gcmPRINT_XML("<tx_total_trilinear_requests value=\"%u\"/>\n", gcmCOUNTER(tx_total_trilinear_requests)); gcmPRINT_XML("<tx_total_discarded_texture_requests value=\"%u\"/>\n", gcmCOUNTER(tx_total_discarded_texture_requests)); gcmPRINT_XML("<tx_total_texture_requests value=\"%u\"/>\n", gcmCOUNTER(tx_total_texture_requests)); gcmPRINT_XML("<tx_mem_read_count value=\"%u\"/>\n", gcmCOUNTER(tx_mem_read_count)); gcmPRINT_XML("<tx_mem_read_in_8B_count value=\"%u\"/>\n", gcmCOUNTER(tx_mem_read_in_8B_count)); gcmPRINT_XML("<tx_cache_miss_count value=\"%u\"/>\n", gcmCOUNTER(tx_cache_miss_count)); gcmPRINT_XML("<tx_cache_hit_texel_count value=\"%u\"/>\n", gcmCOUNTER(tx_cache_hit_texel_count)); gcmPRINT_XML("<tx_cache_miss_texel_count value=\"%u\"/>\n", gcmCOUNTER(tx_cache_miss_texel_count)); gcmPRINT_XML("<mc_total_read_req_8B_from_pipeline value=\"%u\"/>\n", gcmCOUNTER(mc_total_read_req_8B_from_pipeline)); gcmPRINT_XML("<mc_total_read_req_8B_from_IP value=\"%u\"/>\n", gcmCOUNTER(mc_total_read_req_8B_from_IP)); gcmPRINT_XML("<mc_total_write_req_8B_from_pipeline value=\"%u\"/>\n", gcmCOUNTER(mc_total_write_req_8B_from_pipeline)); gcmPRINT_XML("<hi_axi_cycles_read_request_stalled value=\"%u\"/>\n", gcmCOUNTER(hi_axi_cycles_read_request_stalled)); gcmPRINT_XML("<hi_axi_cycles_write_request_stalled value=\"%u\"/>\n", gcmCOUNTER(hi_axi_cycles_write_request_stalled)); gcmPRINT_XML("<hi_axi_cycles_write_data_stalled value=\"%u\"/>\n", gcmCOUNTER(hi_axi_cycles_write_data_stalled)); gcmWRITE_STRING("</HWCounters>\n"); #endif } } /*#endif*/ /* Success. */ gcmFOOTER_NO(); return gcvSTATUS_OK; }
gceSTATUS gcoPROFILER_Initialize( IN gcoHAL Hal ) { gceSTATUS status = gcvSTATUS_OK; char* fileName; char* filter = gcvNULL; gctSTRING portName; gctINT port; gcsHAL_INTERFACE iface; gcmHEADER(); /* Check if already initialized. */ if (gcPLS.hal->profiler.enable) { gcPLS.hal->profiler.enable++; gcmFOOTER(); return status; } /* Get profile setting. */ iface.command = gcvHAL_GET_PROFILE_SETTING; /* Call the kernel. */ status = gcoOS_DeviceControl(gcvNULL, IOCTL_GCHAL_INTERFACE, &iface, gcmSIZEOF(iface), &iface, gcmSIZEOF(iface)); if (gcmIS_ERROR(status) || !iface.u.GetProfileSetting.enable) { gcPLS.hal->profiler.enable = 0; status = gcvSTATUS_GENERIC_IO; gcmFOOTER(); return status; } gcmVERIFY_OK(gcoOS_ZeroMemory(&gcPLS.hal->profiler, gcmSIZEOF(gcPLS.hal->profiler))); gcoOS_GetEnv(gcvNULL, "VP_COUNTER_FILTER", &filter); /* Enable/Disable specific counters. */ if ((filter != gcvNULL)) { gctSIZE_T bitsLen; gcoOS_StrLen(filter, &bitsLen); if (bitsLen > 2) { gcPLS.hal->profiler.enableHal = (filter[2] == '1'); } else { gcPLS.hal->profiler.enableHal = gcvTRUE; } if (bitsLen > 3) { gcPLS.hal->profiler.enableHW = (filter[3] == '1'); } else { gcPLS.hal->profiler.enableHW = gcvTRUE; } if (bitsLen > 8) { gcPLS.hal->profiler.enableSH = (filter[8] == '1'); } else { gcPLS.hal->profiler.enableSH = gcvTRUE; } } else { gcPLS.hal->profiler.enableHal = gcvTRUE; gcPLS.hal->profiler.enableHW = gcvTRUE; gcPLS.hal->profiler.enableSH = gcvTRUE; } gcoOS_GetEnv(gcvNULL, "VPROFILER_OUTPUT", &fileName); gcPLS.hal->profiler.useSocket = gcvFALSE; if (fileName && *fileName != '\0' && *fileName != ' ') { /* Extract port info. */ gcoOS_StrFindReverse(fileName, ':', &portName); if (portName) { gcoOS_StrToInt(portName + 1, &port); if (port > 0) { /*status = gcoOS_Socket(gcvNULL, AF_INET, SOCK_STREAM, 0, &gcPLS.hal->profiler.sockFd);*/ status = gcoOS_Socket(gcvNULL, 2, 1, 0, &gcPLS.hal->profiler.sockFd); if (gcmIS_SUCCESS(status)) { *portName = '\0'; status = gcoOS_Connect(gcvNULL, gcPLS.hal->profiler.sockFd, fileName, port); *portName = ':'; if (gcmIS_SUCCESS(status)) { gcPLS.hal->profiler.useSocket = gcvTRUE; } } } } } else { fileName = iface.u.GetProfileSetting.fileName; } if (! gcPLS.hal->profiler.useSocket) { status = gcoOS_Open(gcvNULL, fileName, #ifdef gcdNEW_PROFILER_FILE gcvFILE_CREATE, #else gcvFILE_CREATETEXT, #endif &gcPLS.hal->profiler.file); } if (gcmIS_ERROR(status)) { gcPLS.hal->profiler.enable = 0; status = gcvSTATUS_GENERIC_IO; gcmFOOTER(); return status; } gcPLS.hal->profiler.enable = 1; gcoOS_GetTime(&gcPLS.hal->profiler.frameStart); gcPLS.hal->profiler.frameStartTimeusec = gcPLS.hal->profiler.frameStart; gcPLS.hal->profiler.prevVSInstCount = 0; gcPLS.hal->profiler.prevVSBranchInstCount = 0; gcPLS.hal->profiler.prevVSTexInstCount = 0; gcPLS.hal->profiler.prevVSVertexCount = 0; gcPLS.hal->profiler.prevPSInstCount = 0; gcPLS.hal->profiler.prevPSBranchInstCount = 0; gcPLS.hal->profiler.prevPSTexInstCount = 0; gcPLS.hal->profiler.prevPSPixelCount = 0; #if gcdNEW_PROFILER_FILE gcmWRITE_CONST(VPHEADER); gcmWRITE_BUFFER(4, "VP12"); #else gcmWRITE_STRING("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<VProfile>\n"); #endif /* Success. */ gcmFOOTER(); return status; }
/******************************************************************************* ** ** gcoBUFFER_Commit ** ** Commit the command buffer to the hardware. ** ** INPUT: ** ** gcoBUFFER Buffer ** Pointer to a gcoBUFFER object. ** ** gcePIPE_SELECT CurrentPipe ** Current graphics pipe. ** ** gcsSTATE_DELTA_PTR StateDelta ** Pointer to the state delta. ** ** gcoQUEUE Queue ** Pointer to a gcoQUEUE object. ** ** OUTPUT: ** ** Nothing. */ gceSTATUS gcoBUFFER_Commit( IN gcoBUFFER Buffer, IN gcePIPE_SELECT CurrentPipe, IN gcsSTATE_DELTA_PTR StateDelta, IN gcoQUEUE Queue ) { gcsHAL_INTERFACE iface; gceSTATUS status; gcoCMDBUF current; gcmHEADER_ARG("Buffer=0x%x Queue=0x%x", Buffer, Queue); /* Verify the arguments. */ gcmVERIFY_OBJECT(Buffer, gcvOBJ_BUFFER); gcmVERIFY_OBJECT(Queue, gcvOBJ_QUEUE); /* Grab current command buffer. */ current = Buffer->currentCommandBuffer; if (current == gcvNULL) { /* No command buffer, done. */ gcmFOOTER_NO(); return gcvSTATUS_OK; } if (current->offset - current->startOffset <= Buffer->info.reservedHead) { /* Commit the event queue. */ status = gcoQUEUE_Commit(Queue); gcmFOOTER(); return status; } /* Make sure the tail got aligned properly. */ current->offset = gcmALIGN(current->offset, Buffer->info.alignment); if (gcPLS.hal->dump != gcvNULL) { /* Dump the command buffer. */ gcmVERIFY_OK( gcoDUMP_DumpData(gcPLS.hal->dump, gcvTAG_COMMAND, 0, current->offset - current->startOffset - Buffer->info.reservedHead, (gctUINT8_PTR) current->logical + current->startOffset + Buffer->info.reservedHead)); } /* The current pipe becomes the exit pipe for the current command buffer. */ current->exitPipe = CurrentPipe; /* Send command and context buffer to hardware. */ iface.command = gcvHAL_COMMIT; iface.u.Commit.context = #ifndef VIVANTE_NO_3D (current->using2D && !current->using3D) ? gcvNULL : Buffer->context; #else gcvNULL; #endif iface.u.Commit.commandBuffer = current; iface.u.Commit.delta = StateDelta; iface.u.Commit.queue = Queue->head; /* Call kernel service. */ gcmONERROR( gcoOS_DeviceControl(gcvNULL, IOCTL_GCHAL_INTERFACE, &iface, gcmSIZEOF(iface), &iface, gcmSIZEOF(iface))); gcmONERROR(iface.status); /* Free the event queue. */ gcmONERROR(gcoQUEUE_Free(Queue)); /* Advance the offset for next commit. */ current->startOffset = current->offset + Buffer->info.reservedTail; if (current->bytes - current->startOffset > Buffer->totalReserved) { /* Adjust buffer offset and size. */ current->offset = current->startOffset + Buffer->info.reservedHead; current->free = current->bytes - current->offset - Buffer->info.alignment - Buffer->info.reservedTail; } else { /* Buffer is full. */ current->startOffset = current->bytes; current->offset = current->bytes; current->free = 0; } /* The exit pipe becomes the entry pipe for the next command buffer. */ current->entryPipe = current->exitPipe; #if gcdSECURE_USER /* Reset the state array tail. */ current->hintArrayTail = current->hintArray; #endif /* Reset usage flags. */ current->using2D = gcvFALSE; current->using3D = gcvFALSE; current->usingFilterBlit = gcvFALSE; current->usingPalette = gcvFALSE; /* Success. */ gcmFOOTER_NO(); return gcvSTATUS_OK; OnError: /* Return the status. */ gcmFOOTER(); return status; }
/******************************************************************************* ** ** gcoHAL_Construct ** ** Construct a new gcoHAL object. ** ** INPUT: ** ** gctPOINTER Context ** Pointer to a context that can be used by the platform specific ** functions. ** ** gcoOS Os ** Pointer to an gcoOS object. ** ** OUTPUT: ** ** gcoHAL * Hal ** Pointer to a variable that will hold the gcoHAL object pointer. */ gceSTATUS gcoHAL_Construct( IN gctPOINTER Context, IN gcoOS Os, OUT gcoHAL * Hal ) { gctBOOL created = gcvFALSE; gcoHAL hal = gcPLS.hal; gceSTATUS status; gctPOINTER pointer = gcvNULL; gctBOOL separated3D = gcvFALSE; gctBOOL separated2D = gcvFALSE; gcsHAL_INTERFACE iface; gctINT32 i; gcmHEADER_ARG("Context=0x%x OS=0x%x", Context, Os); /* Verify the arguments. */ gcmDEBUG_VERIFY_ARGUMENT(Hal != gcvNULL); if (hal == gcvNULL) { /* Create the gcoHAL object. */ gcmONERROR(gcoOS_Allocate(gcvNULL, gcmSIZEOF(struct _gcoHAL), &pointer)); hal = pointer; created = gcvTRUE; gcoOS_ZeroMemory(hal, gcmSIZEOF(struct _gcoHAL)); /* Initialize the object. */ hal->object.type = gcvOBJ_HAL; /* Zero the gco2D, gco3D, and gcoDUMP objects. */ hal->dump = gcvNULL; hal->reference = gcvNULL; /* Initialize timeOut value */ hal->timeOut = gcdGPU_TIMEOUT; /* Query the kernel version number. */ iface.command = gcvHAL_VERSION; gcmONERROR(gcoOS_DeviceControl(gcvNULL, IOCTL_GCHAL_INTERFACE, &iface, gcmSIZEOF(iface), &iface, gcmSIZEOF(iface))); /* Test if versions match. */ if ((iface.u.Version.major != gcvVERSION_MAJOR) || (iface.u.Version.minor != gcvVERSION_MINOR) || (iface.u.Version.patch != gcvVERSION_PATCH) || (iface.u.Version.build != gcvVERSION_BUILD) ) { gcmPRINT("HAL user version %d.%d.%d build %u %s %s", gcvVERSION_MAJOR, gcvVERSION_MINOR, gcvVERSION_PATCH, gcvVERSION_BUILD, gcvVERSION_DATE, gcvVERSION_TIME); gcmPRINT("HAL kernel version %d.%d.%d build %u", iface.u.Version.major, iface.u.Version.minor, iface.u.Version.patch, iface.u.Version.build); gcmONERROR(gcvSTATUS_VERSION_MISMATCH); } #if gcmIS_DEBUG(gcdDEBUG_TRACE) gcmTRACE_ZONE(gcvLEVEL_INFO, gcvZONE_HAL, "HAL user version %d.%d.%d build %u %s %s", gcvVERSION_MAJOR, gcvVERSION_MINOR, gcvVERSION_PATCH, gcvVERSION_BUILD, gcvVERSION_DATE, gcvVERSION_TIME); gcmTRACE_ZONE(gcvLEVEL_INFO, gcvZONE_HAL, "HAL kernel version %d.%d.%d build %u", iface.u.Version.major, iface.u.Version.minor, iface.u.Version.patch, iface.u.Version.build); #endif /* Query chip info */ iface.command = gcvHAL_CHIP_INFO; gcmONERROR(gcoOS_DeviceControl(gcvNULL, IOCTL_GCHAL_INTERFACE, &iface, gcmSIZEOF(iface), &iface, gcmSIZEOF(iface))); hal->chipCount = iface.u.ChipInfo.count; for (i = 0; i < hal->chipCount; i++) { hal->chipTypes[i] = iface.u.ChipInfo.types[i]; switch (hal->chipTypes[i]) { case gcvHARDWARE_3D: separated3D = gcvTRUE; break; case gcvHARDWARE_2D: separated2D = gcvTRUE; break; default: break; } } hal->separated3D2D = (separated3D && separated2D); #if VIVANTE_PROFILER hal->profiler.enable = 0; #endif /* Create reference. */ gcmONERROR(gcoOS_AtomConstruct(Os, &hal->reference)); }