void MtSync_GetNextBlock(CMtSync *p)
{
if (p->needStart)
{
p->numProcessedBlocks = 1;
p->needStart = False;
p->stopWriting = False;
p->exit = False;
Event_Reset(&p->wasStarted);
Event_Reset(&p->wasStopped);
Event_Set(&p->canStart);
Event_Wait(&p->wasStarted);
}
else
{
CriticalSection_Leave(&p->cs);
p->csWasEntered = False;
p->numProcessedBlocks++;
Semaphore_Release1(&p->freeSemaphore);
}
Semaphore_Wait(&p->filledSemaphore);
CriticalSection_Enter(&p->cs);
p->csWasEntered = True;
}
void Task_P3(int parameter)
{
Mutex_Lock(mut);
Event_Wait(evt);
Mutex_Unlock(mut);
for(;;);
}
void Task_P2()
{
Event_Wait(evt);
for(;;){
}
}
void BtThreadFunc(CMatchFinderMt *mt)
{
CMtSync *p = &mt->btSync;
for (;;)
{
UInt32 blockIndex = 0;
Event_Wait(&p->canStart);
Event_Set(&p->wasStarted);
for (;;)
{
if (p->exit)
return;
if (p->stopWriting)
{
p->numProcessedBlocks = blockIndex;
MtSync_StopWriting(&mt->hashSync);
Event_Set(&p->wasStopped);
break;
}
Semaphore_Wait(&p->freeSemaphore);
BtFillBlock(mt, blockIndex++);
Semaphore_Release1(&p->filledSemaphore);
}
}
}
void MtSync_StopWriting(CMtSync *p)
{
UInt32 myNumBlocks = p->numProcessedBlocks;
if (!Thread_WasCreated(&p->thread) || p->needStart)
return;
EnterGlobalLock();
TraceObjectSync("MtSync_StopWriting:stop", p);
p->stopWriting = True;
TraceObjectSync("MtSync_StopWriting:stop", p);
LeaveGlobalLock();
if (p->csWasEntered)
{
CriticalSection_Leave(&p->cs);
p->csWasEntered = False;
}
Semaphore_Release1(&p->freeSemaphore);
Event_Wait(&p->wasStopped);
while (myNumBlocks++ != p->numProcessedBlocks)
{
Semaphore_Wait(&p->filledSemaphore);
Semaphore_Release1(&p->freeSemaphore);
}
p->needStart = True;
}
void Ping()
{
for(;;){
PORTA|=(1<<PA2);
PORTA&=~(1<<PA2);
Event_Wait(e);
PORTA|=(1<<PA2);
PORTA&=~(1<<PA2);
}
}
static SRes MtThread_Process(CMtThread *p, Bool *stop)
{
CMtThread *next;
*stop = True;
if (Event_Wait(&p->canRead) != 0)
return SZ_ERROR_THREAD;
next = GET_NEXT_THREAD(p);
if (p->stopReading)
{
next->stopReading = True;
return Event_Set(&next->canRead) == 0 ? SZ_OK : SZ_ERROR_THREAD;
}
{
size_t size = p->mtCoder->blockSize;
size_t destSize = p->outBufSize;
RINOK(FullRead(p->mtCoder->inStream, p->inBuf, &size));
next->stopReading = *stop = (size != p->mtCoder->blockSize);
if (Event_Set(&next->canRead) != 0)
return SZ_ERROR_THREAD;
RINOK(p->mtCoder->mtCallback->Code(p->mtCoder->mtCallback, p->index,
p->outBuf, &destSize, p->inBuf, size, *stop));
MtProgress_Reinit(&p->mtCoder->mtProgress, p->index);
if (Event_Wait(&p->canWrite) != 0)
return SZ_ERROR_THREAD;
if (p->stopWriting)
return SZ_ERROR_FAIL;
if (p->mtCoder->outStream->Write(p->mtCoder->outStream, p->outBuf, destSize) != destSize)
return SZ_ERROR_WRITE;
return Event_Set(&next->canWrite) == 0 ? SZ_OK : SZ_ERROR_THREAD;
}
}
static THREAD_FUNC_RET_TYPE THREAD_FUNC_CALL_TYPE LoopThreadFunc(void *pp)
{
CLoopThread *p = (CLoopThread *)pp;
for (;;)
{
if (Event_Wait(&p->startEvent) != 0)
return SZ_ERROR_THREAD;
if (p->stop)
return 0;
p->res = p->func(p->param);
if (Event_Set(&p->finishedEvent) != 0)
return SZ_ERROR_THREAD;
}
}
void Task_P3(){
PORTB = 0x40;
_delay_ms(10);
PORTB = 0x00;
Mutex_Lock(mut);
Event_Wait(evt);
PORTB = 0x40;
_delay_ms(10);
PORTB = 0x00;
Mutex_Unlock(mut);
for(;;);
}
int main(void)
{
/* setup the test */
uart_init();
uart_write((uint8_t*)"\r\nSTART\r\n", 9);
set_test(3);
print_event = Event_Init();
Task_Create(generic_task, 1, RR, A);
Task_Create(generic_task, 2, RR, B);
Task_Create(generic_task, 3, RR, C);
Task_Create(generic_task, 4, RR, D);
Task_Create(generic_task, 5, RR, E);
Task_Create(generic_task, 6, RR, F);
Event_Wait(print_event);
print_trace();
}
void Task_2() {
//2. Create Task_1 which will signal Task_2
Task_Create(Task_1, 1, 0);
//3. Wait for signal, this will yield to the lower priority task_1
Event_Wait(blink_increment);
//6. Run the blink
int i;
for(i = 0; i<blinks; i++) {
PORTB = 0x10;
_delay_ms(500);
PORTB = 0x00;
_delay_ms(500);
}
//7.Terminate Task_2, continue to Task_1
Task_Terminate();
}
int main(void)
{
/* setup the test */
uart_init();
uart_write((uint8_t*)"\r\nSTART\r\n", 9);
set_test(2);
print_event = Event_Init();
Task_Create(generic_task, A, PERIODIC, A);
Task_Create(generic_task, B, PERIODIC, B);
Task_Create(generic_task, C, PERIODIC, C);
Task_Create(generic_task, D, PERIODIC, D);
Task_Create(generic_task, E, PERIODIC, E);
Task_Create(generic_task, F, PERIODIC, F);
Event_Wait(print_event);
print_trace();
}
void HashThreadFunc(CMatchFinderMt *mt)
{
CMtSync *p = &mt->hashSync;
for (;;)
{
UInt32 numProcessedBlocks = 0;
Event_Wait(&p->canStart);
Event_Set(&p->wasStarted);
for (;;)
{
if (p->exit)
return;
if (p->stopWriting)
{
p->numProcessedBlocks = numProcessedBlocks;
Event_Set(&p->wasStopped);
break;
}
{
CMatchFinder *mf = mt->MatchFinder;
if (MatchFinder_NeedMove(mf))
{
CriticalSection_Enter(&mt->btSync.cs);
CriticalSection_Enter(&mt->hashSync.cs);
{
const Byte *beforePtr = MatchFinder_GetPointerToCurrentPos(mf);
const Byte *afterPtr;
MatchFinder_MoveBlock(mf);
afterPtr = MatchFinder_GetPointerToCurrentPos(mf);
mt->pointerToCurPos -= beforePtr - afterPtr;
mt->buffer -= beforePtr - afterPtr;
}
CriticalSection_Leave(&mt->btSync.cs);
CriticalSection_Leave(&mt->hashSync.cs);
continue;
}
Semaphore_Wait(&p->freeSemaphore);
MatchFinder_ReadIfRequired(mf);
if (mf->pos > (kMtMaxValForNormalize - kMtHashBlockSize))
{
UInt32 subValue = (mf->pos - mf->historySize - 1);
MatchFinder_ReduceOffsets(mf, subValue);
MatchFinder_Normalize3(subValue, mf->hash + mf->fixedHashSize, mf->hashMask + 1);
}
{
UInt32 *heads = mt->hashBuf + ((numProcessedBlocks++) & kMtHashNumBlocksMask) * kMtHashBlockSize;
UInt32 num = mf->streamPos - mf->pos;
heads[0] = 2;
heads[1] = num;
if (num >= mf->numHashBytes)
{
num = num - mf->numHashBytes + 1;
if (num > kMtHashBlockSize - 2)
num = kMtHashBlockSize - 2;
mt->GetHeadsFunc(mf->buffer, mf->pos, mf->hash + mf->fixedHashSize, mf->hashMask, heads + 2, num);
heads[0] += num;
}
mf->pos += num;
mf->buffer += num;
}
}
Semaphore_Release1(&p->filledSemaphore);
}
}
}
WRes LoopThread_WaitSubThread(CLoopThread *p) { return Event_Wait(&p->finishedEvent); }
void
stopSystem(void){
Event_Wait(stop);
sendMovements(0,0,FORWARD,FORWARD);
exit(0);
}
int main(void) {
int ret;
void *frame_buffer = NULL;
GXRModeObj *rmode = NULL;
/* The game's boot loader is statically loaded at 0x81200000, so we'd better
* not start mallocing there! */
SYS_SetArena1Hi((void *)0x81200000);
/* initialise all subsystems */
if (!Event_Init(&main_event_fat_loaded))
goto exit_error;
if (!Apploader_Init())
goto exit_error;
if (!Module_Init())
goto exit_error;
if (!Search_Init())
goto exit_error;
/* main thread is UI, so set thread prior to UI */
LWP_SetThreadPriority(LWP_GetSelf(), THREAD_PRIO_UI);
/* configure the video */
VIDEO_Init();
rmode = VIDEO_GetPreferredMode(NULL);
frame_buffer = MEM_K0_TO_K1(SYS_AllocateFramebuffer(rmode));
if (!frame_buffer)
goto exit_error;
console_init(
frame_buffer, 20, 20, rmode->fbWidth, rmode->xfbHeight,
rmode->fbWidth * VI_DISPLAY_PIX_SZ);
/* spawn lots of worker threads to do stuff */
if (!Apploader_RunBackground())
goto exit_error;
if (!Module_RunBackground())
goto exit_error;
if (!Search_RunBackground())
goto exit_error;
VIDEO_Configure(rmode);
VIDEO_SetNextFramebuffer(frame_buffer);
VIDEO_SetBlack(false);
VIDEO_Flush();
VIDEO_WaitVSync();
if (rmode->viTVMode & VI_NON_INTERLACE)
VIDEO_WaitVSync();
/* display the welcome message */
printf("\x1b[2;0H");
printf("BrainSlug Wii v%x.%02x.%04x"
#ifndef NDEBUG
" DEBUG build"
#endif
"\n",
BSLUG_VERSION_MAJOR(BSLUG_LOADER_VERSION),
BSLUG_VERSION_MINOR(BSLUG_LOADER_VERSION),
BSLUG_VERSION_REVISION(BSLUG_LOADER_VERSION));
printf(" by Chadderz\n\n");
if (!__io_wiisd.startup() || !__io_wiisd.isInserted()) {
printf("Please insert an SD card.\n\n");
do {
__io_wiisd.shutdown();
} while (!__io_wiisd.startup() || !__io_wiisd.isInserted());
}
__io_wiisd.shutdown();
if (!fatMountSimple("sd", &__io_wiisd)) {
fprintf(stderr, "Could not mount SD card.\n");
goto exit_error;
}
Event_Trigger(&main_event_fat_loaded);
printf("Waiting for game disk...\n");
Event_Wait(&apploader_event_disk_id);
printf("Game ID: %.4s\n", os0->disc.gamename);
printf("Loading modules...\n");
Event_Wait(&module_event_list_loaded);
if (module_list_count == 0) {
printf("No valid modules found!\n");
} else {
size_t module;
printf(
"%u module%s found.\n",
module_list_count, module_list_count > 1 ? "s" : "");
for (module = 0; module < module_list_count; module++) {
printf(
"\t%s %s by %s (", module_list[module]->name,
module_list[module]->version, module_list[module]->author);
Main_PrintSize(module_list[module]->size);
puts(").");
}
Main_PrintSize(module_list_size);
puts(" total.");
}
Event_Wait(&apploader_event_complete);
Event_Wait(&module_event_complete);
fatUnmount("sd");
__io_wiisd.shutdown();
if (module_has_error) {
printf("\nPress RESET to exit.\n");
goto exit_error;
}
if (apploader_game_entry_fn == NULL) {
fprintf(stderr, "Error... entry point is NULL.\n");
} else {
if (module_has_info || search_has_info) {
printf("\nPress RESET to launch game.\n");
while (!SYS_ResetButtonDown())
VIDEO_WaitVSync();
while (SYS_ResetButtonDown())
VIDEO_WaitVSync();
}
SYS_ResetSystem(SYS_SHUTDOWN, 0, 0);
apploader_game_entry_fn();
}
ret = 0;
goto exit;
exit_error:
ret = -1;
exit:
while (!SYS_ResetButtonDown())
VIDEO_WaitVSync();
while (SYS_ResetButtonDown())
VIDEO_WaitVSync();
VIDEO_SetBlack(true);
VIDEO_Flush();
VIDEO_WaitVSync();
free(frame_buffer);
exit(ret);
return ret;
}
