void MemoryClear( IN void *pMemory, IN uint32 Bytes ) { MemoryFill( pMemory, 0, Bytes ); }
int8_t Temp_Exec(int argc, const char* const* argv) { uint8_t OW_Status; ExecFlagDef ExecFlag; CommandToSend_StructInit(&CommandToSend); OW_Status = OW_ERROR; ExecFlag = FindExecFlag(argc--, argv++); switch(ExecFlag) { case DeviceSearch: OW_Status = Device_Search(); break; case SendDataOnlyRead: CommandToSend.Reset = OW_NO_RESET; case SendDataWithRead: CommandToSend.NumByteForRead = (uint8_t)atoi(argv[0]); argc--; argv++; CommandToSend.ReadStartByte = argc; case SendDataNoRead: CommandToSend.NumByteToSend = argc; if(MemoryAllotment() == OW_ERROR) return OW_ERROR; MemoryFill( argc, argv ); OW_Status = SendData(); break; case MesureTempSkipAdress: OW_Status = MeasureTemp( argc, argv ); break; case NoSuchFlag: default: printf("Invalid flag or number of arguments\r\n"); } MemoryFree(); return OW_Status; }
int8_t MeasureTemp( int argc, const char* const* argv ) { uint8_t OW_Status = OW_ERROR, i; int8_t numTermo; char *CommandsArray[10]; uint8_t isNoAdress = 1; if(argc != 0 && argc != 1) { printf("Must be no arguments with -m flag\r\n"); return OW_Status; } if( argc != 0) isNoAdress = 0; CommandToSend.OutputOption = SILENT; if( isNoAdress ) { CommandsArray[0] = "204"; CommandsArray[1] = "68"; CommandToSend.NumByteToSend = 2; } else { numTermo = atoi(argv[0])-1; argv ++; if( numTermo >= 0 && numTermo < 5) { CommandsArray[0] = "85"; for(i = 0; i < 8; i++) { CommandsArray[i+1] = TermAdress[numTermo][i]; } CommandsArray[9] = "68"; CommandToSend.NumByteToSend = 10; } else { printf("Number TermoSensor must be > 0 and < 5\r\n"); return OW_Status; } } if(MemoryAllotment() == OW_ERROR) return OW_ERROR; MemoryFill( CommandToSend.NumByteToSend, CommandsArray ); if(SendData() != OW_OK ) return OW_ERROR; MemoryFree(); Delay(750); CommandToSend_StructInit( &CommandToSend ); CommandToSend.OutputOption = SILENT; if( isNoAdress ) { CommandsArray[1] = "190"; CommandToSend.NumByteToSend = 2; CommandToSend.ReadStartByte = 2; } else { CommandsArray[9] = "190"; CommandToSend.NumByteToSend = 10; CommandToSend.ReadStartByte = 10; } CommandToSend.NumByteForRead = 9; if(MemoryAllotment() == OW_ERROR) return OW_ERROR; MemoryFill( CommandToSend.NumByteToSend, CommandsArray ); if(SendData() != OW_OK ) return OW_ERROR; PrintTemperature(); MemoryFree(); return OW_Status; }
inline void Write(u32 addr, const T data) { addr -= HW::VADDR_GPU; u32 index = addr / 4; // Writes other than u32 are untested, so I'd rather have them abort than silently fail if (index >= Regs::NumIds() || !std::is_same<T, u32>::value) { LOG_ERROR(HW_GPU, "unknown Write%lu 0x%08X @ 0x%08X", sizeof(data) * 8, (u32)data, addr); return; } g_regs[index] = static_cast<u32>(data); switch (index) { // Memory fills are triggered once the fill value is written. case GPU_REG_INDEX_WORKAROUND(memory_fill_config[0].trigger, 0x00004 + 0x3): case GPU_REG_INDEX_WORKAROUND(memory_fill_config[1].trigger, 0x00008 + 0x3): { const bool is_second_filler = (index != GPU_REG_INDEX(memory_fill_config[0].trigger)); auto& config = g_regs.memory_fill_config[is_second_filler]; if (config.trigger) { MemoryFill(config); LOG_TRACE(HW_GPU, "MemoryFill from 0x%08x to 0x%08x", config.GetStartAddress(), config.GetEndAddress()); // It seems that it won't signal interrupt if "address_start" is zero. // TODO: hwtest this if (config.GetStartAddress() != 0) { if (!is_second_filler) { GSP_GPU::SignalInterrupt(GSP_GPU::InterruptId::PSC0); } else { GSP_GPU::SignalInterrupt(GSP_GPU::InterruptId::PSC1); } } // Reset "trigger" flag and set the "finish" flag // NOTE: This was confirmed to happen on hardware even if "address_start" is zero. config.trigger.Assign(0); config.finished.Assign(1); } break; } case GPU_REG_INDEX(display_transfer_config.trigger): { MICROPROFILE_SCOPE(GPU_DisplayTransfer); const auto& config = g_regs.display_transfer_config; if (config.trigger & 1) { if (Pica::g_debug_context) Pica::g_debug_context->OnEvent(Pica::DebugContext::Event::IncomingDisplayTransfer, nullptr); if (config.is_texture_copy) { TextureCopy(config); LOG_TRACE(HW_GPU, "TextureCopy: 0x%X bytes from 0x%08X(%u+%u)-> " "0x%08X(%u+%u), flags 0x%08X", config.texture_copy.size, config.GetPhysicalInputAddress(), config.texture_copy.input_width * 16, config.texture_copy.input_gap * 16, config.GetPhysicalOutputAddress(), config.texture_copy.output_width * 16, config.texture_copy.output_gap * 16, config.flags); } else { DisplayTransfer(config); LOG_TRACE(HW_GPU, "DisplayTransfer: 0x%08x(%ux%u)-> " "0x%08x(%ux%u), dst format %x, flags 0x%08X", config.GetPhysicalInputAddress(), config.input_width.Value(), config.input_height.Value(), config.GetPhysicalOutputAddress(), config.output_width.Value(), config.output_height.Value(), config.output_format.Value(), config.flags); } g_regs.display_transfer_config.trigger = 0; GSP_GPU::SignalInterrupt(GSP_GPU::InterruptId::PPF); } break; } // Seems like writing to this register triggers processing case GPU_REG_INDEX(command_processor_config.trigger): { const auto& config = g_regs.command_processor_config; if (config.trigger & 1) { MICROPROFILE_SCOPE(GPU_CmdlistProcessing); u32* buffer = (u32*)Memory::GetPhysicalPointer(config.GetPhysicalAddress()); if (Pica::g_debug_context && Pica::g_debug_context->recorder) { Pica::g_debug_context->recorder->MemoryAccessed( (u8*)buffer, config.size * sizeof(u32), config.GetPhysicalAddress()); } Pica::CommandProcessor::ProcessCommandList(buffer, config.size); g_regs.command_processor_config.trigger = 0; } break; } default: break; } // Notify tracer about the register write // This is happening *after* handling the write to make sure we properly catch all memory reads. if (Pica::g_debug_context && Pica::g_debug_context->recorder) { // addr + GPU VBase - IO VBase + IO PBase Pica::g_debug_context->recorder->RegisterWritten<T>( addr + 0x1EF00000 - 0x1EC00000 + 0x10100000, data); } }
/* * MakeNOP * Creates a bunch of NOP instructions at address @at */ inline void MakeNOP(memory_pointer_tr at, size_t count = 1, bool vp = true) { MemoryFill(at, 0x90, count, vp); }
// Fills memory at @addr with value @value and size @size and virtual protect @vp void fill(memory_pointer_tr addr, uint8_t value, size_t size, bool vp) { this->save(addr, size, vp); return MemoryFill(addr, value, size, vp); }