OSStatus host_platform_spi_transfer( bus_transfer_direction_t dir, uint8_t* buffer, uint16_t buffer_length ) { OSStatus result; int i; for(i=0; i<buffer_length; i++) { buffer_temp_32[i] = SPI0_TXCMD | (uint32_t)buffer[i];; } dmaSPITX.dmaChStcd = (edma_software_tcd_t *)mem_align(2 * sizeof(edma_software_tcd_t) * dmaSPITX.period, 32); dmaSPITX.srcAddr = (uint32_t)buffer_temp_32; dmaSPITX.length = buffer_length * 4; dmaSPIRX.dmaChStcd = (edma_software_tcd_t *)mem_align(2 * sizeof(edma_software_tcd_t) * dmaSPIRX.period, 32); dmaSPIRX.destAddr = (uint32_t)buffer; dmaSPIRX.length = buffer_length; MCU_CLOCKS_NEEDED(); SPI0_CS_ENABLE; setup_edma_loop(&dmaSPITX); setup_edma_loop(&dmaSPIRX); EDMA_DRV_StartChannel(dmaSPIRX.dmaCh); EDMA_DRV_StartChannel(dmaSPITX.dmaCh); result = mico_rtos_get_semaphore( &spi_transfer_finished_semaphore, 100 ); disable_edma_loop(&dmaSPIRX); disable_edma_loop(&dmaSPITX); SPI0_CS_DISABLE; MCU_CLOCKS_NOT_NEEDED(); free_align(dmaSPITX.dmaChStcd); free_align(dmaSPIRX.dmaChStcd); return result; }
uint64_t heap_sbrk(intptr_t increase) { // Acquire lock spinlock_acquire(&heap_lock); // Increase? if (increase > 0) { // Align increase = mem_align((uintptr_t) increase, 0x1000); // Determine amount of pages size_t pages = increase / 0x1000; size_t i; for (i = 0; i < pages; ++i) { // Allocate frame uintptr_t phys = frame_alloc(); // Map frame page_map( heap_begin + heap_length, phys, PG_PRESENT | PG_GLOBAL | PG_WRITABLE); // Increase length heap_length += 0x1000; } // Decrease } else if (increase < 0) { // Align decrease uintptr_t decrease = mem_align((uintptr_t) (-increase), 0x1000); // Determine amount of pages size_t pages = decrease / 0x1000; size_t i; for (i = 0; i < pages; ++i) { // Get (virtual) begin address of last page uintptr_t virt = heap_begin + heap_length; // Get physical address uintptr_t phys = page_get_physical(virt); // Unmap page page_unmap(virt); // Decrease length heap_length -= 0x1000; } } // Release lock spinlock_release(&heap_lock); // Beginning of the heap return heap_begin; }
s8 VerifyNandBootInfo ( void ) { // path : /shared2/sys/NANDBOOTINFO NANDBootInfo *Boot_Info = (NANDBootInfo *)mem_align( 32, sizeof(NANDBootInfo) ); memset( Boot_Info, 0, sizeof(NANDBootInfo) ); s32 fd = ISFS_Open("/shared2/sys/NANDBOOTINFO", 1 ); if(fd < 0) { mem_free( Boot_Info ); return -1; } s32 ret = ISFS_Read(fd, Boot_Info, sizeof(NANDBootInfo)); if(ret != sizeof(NANDBootInfo)) { ISFS_Close(fd); mem_free( Boot_Info ); return -2 ; } ISFS_Close(fd); u8 r = Boot_Info->titletype; mem_free( Boot_Info ); if (r == 8) { SetBootState(4,132,0,0); return 1; } else return 0; }
void setup_edma_loop(edma_loop_setup_t *loopSetup) { #if 0 #if (defined(__ICCARM__) || defined(__CC_ARM)) loopSetup->dmaChStcd = (edma_software_tcd_t *)mem_align(2 * sizeof(edma_software_tcd_t) * loopSetup->period, 32); #elif defined(__GNUC__) loopSetup->dmaChStcd = (edma_software_tcd_t *)memalign(32, 2 * sizeof(edma_software_tcd_t) * loopSetup->period); #endif #endif loopSetup->dmaChStcd = (edma_software_tcd_t *)(((uint32_t)ptcd + 32)& 0xFFFFFFE0); //printf(" eDMA TCD address is %x, them\r\n", (uint32_t)loopSetup->dmaChStcd); memset(loopSetup->dmaChStcd, 0, sizeof(edma_software_tcd_t)); EDMA_DRV_RequestChannel(loopSetup->dmaChanNum, loopSetup->chSource, loopSetup->dmaCh); EDMA_DRV_ConfigLoopTransfer(loopSetup->dmaCh, loopSetup->dmaChStcd, loopSetup->type, loopSetup->srcAddr, loopSetup->destAddr, loopSetup->size, loopSetup->watermark, loopSetup->length, loopSetup->period); if(loopSetup->dmaCallBack != NULL) { EDMA_DRV_InstallCallback(loopSetup->dmaCh, loopSetup->dmaCallBack, loopSetup->dmaCh); } }
int main(int argc,const char *argv[]) { s32 ret,i; padInfo padinfo; padData paddata; rsxProgramConst *consts = rsxFragmentProgramGetConsts(fpo); initialize(); ioPadInit(7); sphere = createSphere(3.0f,32,32); donut = createDonut(3.0f,1.5f,32,32); cube = createCube(5.0f); rsxConstOffsetTable *co_table = rsxFragmentProgramGetConstOffsetTable(fpo,consts[lightColor_id].index); u32 const_addr = (u32)((u64)fp_buffer + co_table->offset[0]); setup_shared_buffer(const_addr,(u32)(u64)mem_align(128,128),(u32)(u64)gcmGetLabelAddress(64)); signal_spu_ppu(); signal_spu_rsx(); P = transpose(Matrix4::perspective(DEGTORAD(45.0f),aspect_ratio,1.0f,3000.0f)); setRenderTarget(curr_fb); rsxFinish(context,0); ret = atexit(program_exit_callback); ret = sysUtilRegisterCallback(0,sysutil_exit_callback,NULL); delete cube; running = 1; while(running) { ret = sysUtilCheckCallback(); ioPadGetInfo(&padinfo); for(i=0; i<MAX_PADS; i++) { if(padinfo.status[i]) { ioPadGetData(i, &paddata); if(paddata.BTN_CROSS) { return 0; } } } drawFrame(); flip(); } return 0; }
////////////////////////////////////////////////////////////// // Reading in column state sequences for prefiltering ////////////////////////////////////////////////////////////// void Prefilter::init_prefilter(FFindexDatabase* cs219_database) { // Set up variables for prefiltering num_dbs = cs219_database->db_index->n_entries; first = (unsigned char**) mem_align(ALIGN_FLOAT, num_dbs * sizeof(unsigned char*)); length = (int*) mem_align(ALIGN_FLOAT, num_dbs * sizeof(int)); dbnames = (char**) mem_align(ALIGN_FLOAT, num_dbs * sizeof(char*)); for (size_t n = 0; n < num_dbs; n++) { ffindex_entry_t* entry = ffindex_get_entry_by_index( cs219_database->db_index, n); first[n] = (unsigned char*) ffindex_get_data_by_entry( cs219_database->db_data, entry); length[n] = entry->length - 1; dbnames[n] = new char[strlen(entry->name) + 1]; strcpy(dbnames[n], entry->name); } //check if cs219 format is new binary format checkCSFormat(5); HH_LOG(INFO) << "Searching " << num_dbs << " column state sequences." << std::endl; }
OSStatus host_platform_bus_init( void ) { edma_user_config_t g_edmaUserConfig; /* Create a semephore to check for completed eDMA transfers. */ mico_rtos_init_semaphore(&spi_transfer_finished_semaphore, 1); MCU_CLOCKS_NEEDED(); configure_spi_pins(0); // initlize spi0 GPIO PORT_HAL_SetMuxMode(PORTD_BASE,0u,kPortMuxAsGpio); // configure CS as gpio, use software configure CS. GPIO_DRV_OutputPinInit(&spiCsPin[0]); SPI0_CS_DISABLE; /* Initialize eDMA & DMAMUX */ g_edmaUserConfig.chnArbitration = kEDMAChnArbitrationRoundrobin; g_edmaUserConfig.notHaltOnError = false; EDMA_DRV_Init(&g_edmaState, &g_edmaUserConfig); /* DSPI Master Configuration */ dspi_edma_master_setup(&dspiMasterState, 0, 10000000, 8); MCU_CLOCKS_NOT_NEEDED(); dmaSPITX.dmaChanNum = DMA_CH0; dmaSPITX.dmaCh = &dmaCh0; dmaSPITX.type = kEDMAMemoryToPeripheral; dmaSPITX.chSource = kDmaRequestMux0SPI0Tx; dmaSPITX.srcAddr = (uint32_t)NULL; dmaSPITX.destAddr = (uint32_t)&SPI0->PUSHR; dmaSPITX.length = 0; dmaSPITX.size = 4; dmaSPITX.watermark = 4; dmaSPITX.period = 0x01U; dmaSPITX.dmaCallBack = stop_edma_loop; dmaSPIRX.dmaChanNum = DMA_CH1; dmaSPIRX.dmaCh = &dmaCh1; dmaSPIRX.type = kEDMAPeripheralToMemory; dmaSPIRX.chSource = kDmaRequestMux0SPI0Rx; dmaSPIRX.srcAddr = (uint32_t)&SPI0->POPR; dmaSPIRX.destAddr = (uint32_t)NULL; dmaSPIRX.length = 0; dmaSPIRX.size = 1; dmaSPIRX.watermark = 1; dmaSPIRX.period = 0x01U; dmaSPIRX.dmaCallBack = stop_edma_loop_putsem; dmaSPIRX.dmaChStcd = (edma_software_tcd_t *)mem_align(2 * sizeof(edma_software_tcd_t) * dmaSPIRX.period, 32); spi_status_print(SPI0); return kNoErr; }
s32 SetBootState( u8 type , u8 flags , u8 returnto , u8 discstate ) { StateFlags *sf = (StateFlags *)mem_align( 32, sizeof(StateFlags) ); memset( sf, 0, sizeof(StateFlags) ); s32 fd = ISFS_Open("/title/00000001/00000002/data/state.dat", 1|2 ); if(fd < 0) { mem_free( sf ); ISFS_Close(fd); return -1; } s32 ret = ISFS_Read(fd, sf, sizeof(StateFlags)); if(ret != sizeof(StateFlags)) { mem_free( sf ); ISFS_Close(fd); return -2 ; } sf->type = type; sf->returnto = returnto; sf->flags = flags; sf->discstate = discstate; sf->checksum= __CalcChecksum((u32*)sf, sizeof(StateFlags)); if(ISFS_Seek( fd, 0, 0 )<0) { mem_free( sf ); ISFS_Close(fd); return -3; } if(ISFS_Write(fd, sf, sizeof(StateFlags))!=sizeof(StateFlags)) { mem_free( sf ); ISFS_Close(fd); return -4; } ISFS_Close(fd); mem_free( sf ); return 1; }
CACHE* cache_constructor (unsigned int numberOfPages, unsigned int sectorsPerPage, const DISC_INTERFACE* discInterface, sec_t startOfPartition, sec_t endOfPartition, sec_t sectorSize) { CACHE* cache; unsigned int i; CACHE_ENTRY* cacheEntries; if(numberOfPages==0 || sectorsPerPage==0) return NULL; if (numberOfPages < 32) { numberOfPages = 32; } if (sectorsPerPage < 16) { sectorsPerPage = 16; } cache = (CACHE*) mem_alloc (sizeof(CACHE)); if (cache == NULL) { return NULL; } cache->disc = discInterface; cache->endOfPartition = endOfPartition; cache->numberOfPages = numberOfPages; cache->sectorsPerPage = sectorsPerPage; cache->sectorSize = sectorSize; cacheEntries = (CACHE_ENTRY*) mem_alloc ( sizeof(CACHE_ENTRY) * numberOfPages); if (cacheEntries == NULL) { mem_free (cache); return NULL; } for (i = 0; i < numberOfPages; i++) { cacheEntries[i].sector = CACHE_FREE; cacheEntries[i].count = 0; cacheEntries[i].last_access = 0; cacheEntries[i].dirty = false; cacheEntries[i].cache = (uint8_t*) mem_align (32, sectorsPerPage * cache->sectorSize); } cache->cacheEntries = cacheEntries; return cache; }
void mem_allocate(gnum location, mem_node_t *dest) { mem_node_t *new_node = (mem_node_t*)malloc(sizeof(mem_node_t)); new_node->start = mem_align(location); new_node->range = PAGE_SIZE; new_node->page = (char*)malloc(PAGE_SIZE); memset(new_node->page, 0, PAGE_SIZE); if (location < dest->start) { new_node->next = dest; new_node->prev = dest->prev; dest->prev = new_node; } else { new_node->next = dest->next; new_node->prev = dest; dest->next = new_node; } }
s32 CheckBootState( void ) { StateFlags *sf = (StateFlags *)mem_align( 32, sizeof(StateFlags) ); memset( sf, 0, sizeof(StateFlags) ); s32 fd = ISFS_Open("/title/00000001/00000002/data/state.dat", 1); if(fd < 0) { mem_free(sf); return 0; } s32 ret = ISFS_Read(fd, sf, sizeof(StateFlags)); ISFS_Close(fd); if(ret != sizeof(StateFlags)) { mem_free(sf); return 0; } u8 r = sf->type; mem_free( sf ); return r; }
StateFlags GetStateFlags( void ) { StateFlags *sf = (StateFlags *)mem_align( 32, sizeof(StateFlags) ); StateFlags State; memset( sf, 0, sizeof(StateFlags) ); s32 fd = ISFS_Open("/title/00000001/00000002/data/state.dat", 1); if(fd < 0) { mem_free(sf); return State; } s32 ret = ISFS_Read(fd, sf, sizeof(StateFlags)); ISFS_Close(fd); if(ret != sizeof(StateFlags)) { mem_free(sf); return State; } memcpy((StateFlags*)&State,sf,sizeof(StateFlags)); mem_free( sf ); return State; }
uintptr_t boot_modules_relocate(boot_info_t *info, uintptr_t placement) { // Align placement placement = mem_align(placement, 0x1000); // Sort modules by begin address (ASC) boot_info_mod_t *sorted = 0; boot_info_mod_t *sorted_end = sorted; while (0 != info->mods) { // Find ealiest module boot_info_mod_t *current = (boot_info_mod_t *) (uintptr_t) info->mods; boot_info_mod_t *prev = 0; boot_info_mod_t *min_prev = 0; boot_info_mod_t *min = 0; while (0 != current) { if (0 == min || current->address < min->address) { min = current; min_prev = prev; } // Next prev = current; current = (boot_info_mod_t *) (uintptr_t) current->next; } // Remove from list if (0 == min_prev) info->mods = min->next; else min_prev->next = min->next; // Add to sorted list if (0 == sorted_end) sorted = sorted_end = min; else { sorted_end->next = (uintptr_t) min; sorted_end = min; } } // Replace lists info->mods = (uintptr_t) sorted; // Move modules boot_info_mod_t *current = (boot_info_mod_t *) (uintptr_t) info->mods; while (0 != current) { memcpy( (void *) placement, (void *) ((uintptr_t) current->address), (size_t) current->length); current->address = (uint64_t) placement; placement += (uintptr_t) current->length; placement = mem_align(placement, 0x1000); current = (boot_info_mod_t *) (uintptr_t) current->next; } return placement; }
s8 GetTitleName(u64 id, u32 app, char* name,u8* _dst_uncode_name) { s32 r; int lang = 1; //CONF_GetLanguage(); /* languages: enum { CONF_LANG_JAPANESE = 0, CONF_LANG_ENGLISH, CONF_LANG_GERMAN, CONF_LANG_FRENCH, CONF_LANG_SPANISH, CONF_LANG_ITALIAN, CONF_LANG_DUTCH, CONF_LANG_SIMP_CHINESE, CONF_LANG_TRAD_CHINESE, CONF_LANG_KOREAN }; cause we dont support unicode stuff in font.cpp we will force to use english then(1) */ u8 return_unicode_name = 0; if(_dst_uncode_name == NULL) { return_unicode_name = 0; } else { return_unicode_name = 1; } char file[256] ATTRIBUTE_ALIGN(32); memset(file,0,256); sprintf(file, "/title/%08x/%08x/content/%08x.app", (u32)(id >> 32), (u32)(id & 0xFFFFFFFF), app); gdprintf("GetTitleName : %s\n",file); u32 cnt ATTRIBUTE_ALIGN(32); cnt = 0; IMET *data = (IMET *)mem_align(32, ALIGN32( sizeof(IMET) ) ); if(data == NULL) { gprintf("GetTitleName : IMET header align failure\n"); return -1; } memset(data,0,sizeof(IMET) ); r = ES_GetNumTicketViews(id, &cnt); if(r < 0) { gprintf("GetTitleName : GetNumTicketViews error %d!\n",r); mem_free(data); return -1; } tikview *views = (tikview *)mem_align( 32, sizeof(tikview)*cnt ); if(views == NULL) { mem_free(data); return -2; } r = ES_GetTicketViews(id, views, cnt); if (r < 0) { gprintf("GetTitleName : GetTicketViews error %d \n",r); mem_free(data); mem_free(views); return -3; } //lets get this party started with the right way to call ES_OpenTitleContent. and not like how libogc < 1.8.3 does it. patch was passed on , and is done correctly in 1.8.3 //the right way is ES_OpenTitleContent(u64 TitleID,tikview* views,u16 Index); note the views >_> s32 fh = ES_OpenTitleContent(id, views, 0); if (fh == -106) { CheckTitleOnSD(id); mem_free(data); mem_free(views); return -106; } else if(fh < 0) { //ES method failed. remove tikviews from memory and fall back on ISFS method gprintf("GetTitleName : ES_OpenTitleContent error %d\n",fh); mem_free(views); fh = ISFS_Open(file, ISFS_OPEN_READ); // f**k failed. lets check SD & GTFO if (fh == -106) { CheckTitleOnSD(id); return -106; } else if (fh < 0) { mem_free(data); gprintf("open %s error %d\n",file,fh); return -5; } // read the completed IMET header r = ISFS_Read(fh, data, sizeof(IMET)); if (r < 0) { gprintf("IMET read error %d\n",r); ISFS_Close(fh); mem_free(data); return -6; } ISFS_Close(fh); } else { //ES method r = ES_ReadContent(fh,(u8*)data,sizeof(IMET)); if (r < 0) { gprintf("GetTitleName : ES_ReadContent error %d\n",r); ES_CloseContent(fh); mem_free(data); mem_free(views); return -8; } //free data and let it point to IMET_data so everything else can work just fine ES_CloseContent(fh); mem_free(views); } char str[10][84]; char str_unprocessed[10][84]; //clear any memory that is in the place of the array cause we dont want any confusion here memset(str,0,10*84); if(return_unicode_name) memset(str_unprocessed,0,10*84); if(data->imet == 0x494d4554) // check if its a valid imet header { for(u8 y =0;y <= 9;y++) { u8 p = 0; u8 up = 0; for(u8 j=0;j<83;j++) { if(data->names[y][j] < 0x20) if(return_unicode_name && data->names[y][j] == 0x00) str_unprocessed[y][up++] = data->names[y][j]; else continue; else if(data->names[y][j] > 0x7E) continue; else { str[y][p++] = data->names[y][j]; str_unprocessed[y][up++] = data->names[y][j]; } } str[y][83] = '\0'; } mem_free(data); } else { gprintf("invalid IMET header for 0x%08x/0x%08x\n", (u32)(id >> 32), (u32)(id & 0xFFFFFFFF)); return -9; } if(str[lang][0] != '\0') { gdprintf("GetTitleName : title %s\n",str[lang]); snprintf(name,255, "%s", str[lang]); if (return_unicode_name && str_unprocessed[lang][1] != '\0') { memcpy(_dst_uncode_name,&str_unprocessed[lang][0],83); } else if(return_unicode_name) gprintf("WARNING : empty unprocessed string\n"); } else gprintf("GetTitleName: no name found\n"); memset(str,0,10*84); memset(str_unprocessed,0,10*84); return 1; }
s8 LoadHacks_Hash( bool Force_Load_Nand ) { if( hacks_hash.size() ) //hacks_hash already loaded { hacks_hash.clear(); if(states_hash) { mem_free(states_hash); } } if(foff != 0) foff=0; bool mode = true; s32 fd=0; char *buf=NULL; STACK_ALIGN(fstats,status,sizeof(fstats),32); unsigned int size=0; FILE* in = NULL; if(!Force_Load_Nand) { in = fopen ("fat:/apps/priiloader/hacks_hash.ini","rb"); if(!in) gprintf("fopen error : strerror %s\n",strerror(errno)); } if( !in ) { fd = ISFS_Open("/title/00000001/00000002/data/hackshas.ini", 1 ); if( fd < 0 ) { gprintf("LoadHacks : hacks_hash.ini not on FAT or Nand. ISFS_Open error %d\n",fd); return 0; } mode = false; } if( mode ) //read file from FAT { //read whole file in fseek( in, 0, SEEK_END ); size = ftell(in); fseek( in, 0, 0); if( size == 0 ) { PrintFormat( 1, ((640/2)-((strlen("Error \"hacks_hash.ini\" is 0 byte!"))*13/2))>>1, 208, "Error \"hacks_hash.ini\" is 0 byte!"); sleep(5); return 0; } buf = (char*)mem_align( 32, ALIGN32(size)); if( buf == NULL ) { error = ERROR_MALLOC; return 0; } memset( buf, 0, size ); if(fread( buf, sizeof( char ), size, in ) != size ) { mem_free(buf); PrintFormat( 1, ((640/2)-((strlen("Error reading \"hacks_hash.ini\""))*13/2))>>1, 208, "Error reading \"hacks_hash.ini\""); sleep(5); return 0; }