void core3(void){
// Initialisation(s)
communicationInit();
fifoInit(FIFO_Head_broadcastOutput_en__4, 32*sizeof(char), NULL, 0);
cache_wbInv(FIFO_Head_broadcastOutput_en__4, 32*sizeof(char));
fifoInit(FIFO_Head_broadcastOutput_en__0, 32*sizeof(char), NULL, 0);
cache_wbInv(FIFO_Head_broadcastOutput_en__0, 32*sizeof(char));
// Begin the execution loop
while(1){
busy_barrier();
cache_inv(FIFO_Head_broadcastOutput_en__4, 32*sizeof(char));
fifoPop(init_out__runningTotal__6, FIFO_Head_broadcastOutput_en__4, 32*sizeof(char), NULL, 0);
cache_wbInv(accumulateMatrices_5_init_ru__0, 32*sizeof(char));
sendStart(0); // Core3 > Core0: accumulateMatrices_5_init_ru__0
sendEnd(); // Core3 > Core0: accumulateMatrices_5_init_ru__0
cache_inv(FIFO_Head_broadcastOutput_en__0, 32*sizeof(char));
fifoPop(init_out__runningTotal__4, FIFO_Head_broadcastOutput_en__0, 32*sizeof(char), NULL, 0);
receiveStart(); // Core7 > Core3: explode_generateMatrices_sta__7
receiveEnd(7); // Core7 > Core3: explode_generateMatrices_sta__7
cache_inv(explode_generateMatrices_sta__7, 32*sizeof(char));
add(8/*rows*/,8/*columns*/,init_out__runningTotal__4,startArray_56__inputArray__0,output__input_56__0); // accumulateMatrices_7
cache_inv(init_out__runningTotal__4, 8*sizeof(long));
cache_inv(startArray_56__inputArray__0, 8*sizeof(long));
cache_wbInv(accumulateMatrices_7__implod__0, 32*sizeof(char));
sendStart(7); // Core3 > Core7: accumulateMatrices_7__implod__0
sendEnd(); // Core3 > Core7: accumulateMatrices_7__implod__0
receiveStart(); // Core7 > Core3: broadcastOutput__broadcastOu__1
receiveEnd(7); // Core7 > Core3: broadcastOutput__broadcastOu__1
cache_inv(broadcastOutput__broadcastOu__1, 32*sizeof(char));
fifoPush(output1_32__end_in__0, FIFO_Head_broadcastOutput_en__5, 32*sizeof(char), NULL, 0);
cache_wbInv(FIFO_Head_broadcastOutput_en__5, 32*sizeof(char));
cache_inv(output1_32__end_in__0, 8*sizeof(long));
}
}
// Entry point: initialise hardware and interrupts, then start the main loop.
//
int main(void) {
uint8 byte;
MCUSR &= ~(1 << WDRF);
wdt_disable();
clock_prescale_set(clock_div_1);
m_state = IDLE;
m_changed = false;
fifoInit();
USB_Init();
EICRA = (1<<ISC01); // Interrupt on the falling edge...
EICRB = 0x00;
EIMSK = (1<<INT0); // ...of INT0 (PD0): the PS/2 clk
DDRD = 0x00; // Port D is all inputs, except PD6 (LED A on Minimus)
PORTD = 0x00; // Fiddle DDRD for open collector outs
bmInit();
sei();
for ( ; ; ) {
while ( get(&byte) ) {
processScanCode(byte);
}
if ( USB_DeviceState == DEVICE_STATE_Configured ) {
sendNextReport();
receiveNextReport();
}
USB_USBTask();
}
}
int main()
{
readUserSettings();
ledBlink(0);
irqInit();
initClockIRQ();
fifoInit();
SetYtrigger(80);
installWifiFIFO();
//installSoundFIFO();
installSystemFIFO();
installFeOSFIFO();
coopIrqSet(IRQ_VCOUNT, VCountHandler);
irqEnable(IRQ_VBLANK | IRQ_VCOUNT | IRQ_NETWORK);
setPowerButtonCB(powerButtonCB);
while (!exitflag)
{
coopWaitForVBlank();
FeOS_VBlankFunc();
if (!(REG_KEYINPUT & (KEY_SELECT | KEY_START | KEY_L | KEY_R)))
break;
Wifi_Update();
}
return 0;
}
//---------------------------------------------------------------------------------
int main() {
//---------------------------------------------------------------------------------
irqInit();
fifoInit();
// read User Settings from firmware
readUserSettings();
// Start the RTC tracking IRQ
initClockIRQ();
SetYtrigger(80);
installWifiFIFO();
installSoundFIFO();
mmInstall(FIFO_MAXMOD);
installSystemFIFO();
irqSet(IRQ_VCOUNT, VcountHandler);
irqSet(IRQ_VBLANK, VblankHandler);
irqEnable( IRQ_VBLANK | IRQ_VCOUNT | IRQ_NETWORK);
// Keep the ARM7 mostly idle
while (1) swiWaitForVBlank();
}
//---------------------------------------------------------------------------------
int main( ) {
//---------------------------------------------------------------------------------
readUserSettings( );
irqInit( );
// Start the RTC tracking IRQ
initClockIRQ( );
fifoInit( );
touchInit( );
mmInstall( FIFO_MAXMOD );
SetYtrigger( 80 );
installWifiFIFO( );
installSoundFIFO( );
installSystemFIFO( );
irqSet( IRQ_VCOUNT, VcountHandler );
irqSet( IRQ_VBLANK, VblankHandler );
irqEnable( IRQ_VBLANK | IRQ_VCOUNT | IRQ_NETWORK );
setPowerButtonCB( powerButtonCB );
// Keep the ARM7 mostly idle
while( !exitflag ) {
if( 0 == ( REG_KEYINPUT & ( KEY_SELECT | KEY_START | KEY_L | KEY_R ) ) ) {
exitflag = true;
}
swiWaitForVBlank( );
}
return 0;
}
int main()
{
irqInit();
fifoInit();
readUserSettings();
initClockIRQ();
SetYtrigger(80);
installSystemFIFO();
irqSet(IRQ_VCOUNT, VCountHandler);
irqSet(IRQ_VBLANK, 0);
irqEnable(IRQ_VBLANK|IRQ_VCOUNT|IRQ_NETWORK);
powerOn(POWER_SOUND);
REG_SOUNDCNT = SOUND_ENABLE | SOUND_VOL(127);
static Player oPlayer;
Player_Init(& oPlayer);
while ( 1 )
{
swiWaitForVBlank();
Player_Execute(& oPlayer);
}
return 0;
}
//---------------------------------------------------------------------------------
int main() {
u32 i=0;
//---------------------------------------------------------------------------------
readUserSettings();
irqInit();
// Start the RTC tracking IRQ
initClockIRQ();
fifoInit();
//mmInstall(FIFO_MAXMOD);
InstallSoundSys();
SetYtrigger(80);
installWifiFIFO();
installSoundFIFO();
installSystemFIFO();
irqSet(IRQ_VCOUNT, VcountHandler);
irqSet(IRQ_VBLANK, VblankHandler);
irqEnable( IRQ_VBLANK | IRQ_VCOUNT | IRQ_NETWORK);
setPowerButtonCB(powerButtonCB);
// Keep the ARM7 mostly idle
while (!exitflag) {
if ( 0 == (REG_KEYINPUT & (KEY_SELECT | KEY_START | KEY_L | KEY_R))) {
exitflag = true;
}
swiWaitForVBlank();
if(seq_status==STATUS_FADING)
{
if(i<24)
{
i+=10;
}
else
{
i-=24;
ADSR_mastervolume--;
if(!ADSR_mastervolume)
StopSeq();
}
}
}
return 0;
}
void iniciar_mundo ()
{
int i, x, y;
/* Criar a memória partilhada para o mundo */
mundo = sharedInit ("shm.pesca-mundo", sizeof (Mundo));
/* Inicializar a memória partilhada do mundo */
mundo->estado_capitao = C_PLANEAR;
for (x = 0; x < DIMENSAO_MAR; x++) {
for (y = 0; y < DIMENSAO_MAR; y++) {
mundo->mar [x][y].barco = VAZIO;
mundo->mar [x][y].cardume = VAZIO;
}
}
mundo->hora_regressar = 0;
fifoInit (&mundo->espera_barcos);
mundo->barcos_cais = num_barcos;
mundo->peixes_cais = 0;
mundo->jornadas_pesca = num_jornadas_pesca;
/* Criar e inicializar os semáforos */
char *nome;
int max_digitos;
/* ... semáforos dos barcos... */
max_digitos = log (num_barcos) / log (10) + 1;
nome = malloc (strlen ("pesca-barco") + max_digitos + 1);
sem_barcos = semInit (*nome, max_digitos);
free (nome);
/* .. semáforos dos cardumes... */
max_digitos = log (num_cardumes) / log (10) + 1;
nome = malloc (strlen ("pesca-cardume") + max_digitos + 1);
sem_cardumes = semInit (*nome, max_digitos);
free (nome);
/* .. semaforos do mutex .. */
nome = malloc (strlen ("pesca-mutex"));
sem_cardumes = semInit (*nome, 0);
free (nome);
}
//---------------------------------------------------------------------------------
// Reset the DS registers to sensible defaults
//---------------------------------------------------------------------------------
void __attribute__((weak)) initSystem(void) {
//---------------------------------------------------------------------------------
register int i;
// stop timers and dma
for (i=0; i<4; i++)
{
DMA_CR(i) = 0;
DMA_SRC(i) = 0;
DMA_DEST(i) = 0;
TIMER_CR(i) = 0;
TIMER_DATA(i) = 0;
}
// clear video display registers
dmaFillWords(0, (void*)0x04000000, 0x56);
dmaFillWords(0, (void*)0x04001008, 0x56);
videoSetModeSub(0);
vramDefault();
VRAM_E_CR = 0;
VRAM_F_CR = 0;
VRAM_G_CR = 0;
VRAM_H_CR = 0;
VRAM_I_CR = 0;
irqInit();
fifoInit();
fifoSetValue32Handler(FIFO_PM, powerValueHandler, 0);
fifoSetDatamsgHandler(FIFO_SYSTEM, systemMsgHandler, 0);
if(REG_DSIMODE) {
fifoSendValue32(FIFO_PM,PM_DSI_HACK);
__dsimode = true;
}
__transferRegion()->buttons = 0xffff;
punixTime = (time_t*)memUncached((void *)&__transferRegion()->unixTime);
__syscalls.exit = __libnds_exit;
extern char *fake_heap_end;
__transferRegion()->bootcode = (struct __bootstub *)fake_heap_end;
irqEnable(IRQ_VBLANK);
}
//---------------------------------------------------------------------------------
int main() {
//---------------------------------------------------------------------------------
irqInit();
fifoInit();
int channel = -1;
// read User Settings from firmware
readUserSettings();
// Start the RTC tracking IRQ
initClockIRQ();
SetYtrigger(80);
installWifiFIFO();
installSoundFIFO();
mmInstall(FIFO_MAXMOD);
installSystemFIFO();
irqSet(IRQ_VCOUNT, VcountHandler);
irqSet(IRQ_VBLANK, VblankHandler);
irqEnable( IRQ_VBLANK | IRQ_VCOUNT | IRQ_NETWORK);
//sound play
// ARM 7 sweeps up FIFO_USER_01 and plays the notes left there.
while (1) {
/* while (fifoGetDatamsg(FIFO_USER_01, int buffersize, u8 * destbuffer) != -1)
channel = getFreePSGChannel();
BIT(24);
BIT(25);
swiWaitForVBlank(); */
}
}
void main()
{
int i=0;
char mymac[6]={0x74,0xf7,0x26,0x00,0x00,0x01};
unsigned char data[]={0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x04,0x74,0xf7,0x26,0x00,0x00,0x01,0x65,0x00,0x00,0x0a,0x05,0x00,0x01,0x02,0x03,0x05,0x06,0x07,0x08,0x09};
bowler4_header bh;
for (i=0; i<sizeof(bowler4_header); i++) bh.bytes[i]=0;
bh.fields.version=0x04;
bh.fields.affect=setPriority(5,setState(setAsync(bh.fields.affect)));
bh.fields.payloadLength=10;
bh.fields.payloadType=0;
set_mac_address(mymac,&bh);
calculate_checksum(&bh);
printf("Verify?\t%d\n",verify_checksum(&bh));
printf("Verify?\t%d\n",verify_checksum(&bh));
printf("%X\n",check_mac_address(mymac,&bh) );
printHeader(bh);
V4MicroParser_state parser;
parser.state=align;
parser.macaddr=&mymac;
fifoInit(&parser.fifo);
fifoPrint(&parser.fifo);
for (i=0; i<sizeof(data); i++){
fifoPush(&parser.fifo,data[i]);
int delta=parser.fifo.inPointer;
printf("Pushing:\t%i\n",i);
/*fifoPrint(&parser.fifo);*/
runParserSM(&parser);
if (parser.fifo.inPointer!=delta) {printf("\nNew Contents of FIFO:");fifoPrint(&parser.fifo);}
printf("===================\n");
}
/* fifoPull(&fifo,15); */
/* fifoPrint(&fifo); */
}
//---------------------------------------------------------------------------------
int main() {
//---------------------------------------------------------------------------------
// clear sound registers
dmaFillWords(0, (void*)0x04000400, 0x100);
REG_SOUNDCNT |= SOUND_ENABLE;
writePowerManagement(PM_CONTROL_REG, ( readPowerManagement(PM_CONTROL_REG) & ~PM_SOUND_MUTE ) | PM_SOUND_AMP );
powerOn(POWER_SOUND);
readUserSettings();
ledBlink(0);
irqInit();
// Start the RTC tracking IRQ
initClockIRQ();
fifoInit();
mmInstall(FIFO_MAXMOD);
SetYtrigger(80);
installWifiFIFO();
installSoundFIFO();
installSystemFIFO();
irqSet(IRQ_VCOUNT, VcountHandler);
irqSet(IRQ_VBLANK, VblankHandler);
irqEnable( IRQ_VBLANK | IRQ_VCOUNT | IRQ_NETWORK);
setPowerButtonCB(powerButtonCB);
// Keep the ARM7 mostly idle
while (!exitflag) {
if ( 0 == (REG_KEYINPUT & (KEY_SELECT | KEY_START | KEY_L | KEY_R))) {
exitflag = true;
}
swiWaitForVBlank();
}
return 0;
}
// Προς υλοποίηση
int main(int argc, char **argv) {
pthread_t table[TABLE];
int i;
queue = fifoInit(TABLE/2);
for (i = 0; i < TABLE; i++) {
pthread_mutex_init(&(forks[i]), NULL);
}
for (i = 0; i < TABLE; i++) {
pthread_create(&table[i], NULL, philosopher, (void *) i);
}
for (i = 0; i < TABLE; i++) {
pthread_join(table[i], NULL);
}
fifoDelete(queue);
return 0;
}
int main (int argc, char **argv)
{
pthread_t p[TABLE];
int i;
if (argc < 2) return 1;
srand(atoi(argv[1]));
queue = fifoInit (TABLE / 2);
printf ("Begin %d-diners\n", TABLE );
pthread_cond_init (&newfork, NULL);
for (i = 0; i < TABLE; i++)
pthread_mutex_init (&(forks[i]), NULL);
for (i = 0; i < TABLE; i++)
pthread_create (&p[i], NULL, philosopher, (void *)i);
for (i = 0; i < TABLE; i++)
pthread_join (p[i], NULL);
printf ("End %d-diners\n", TABLE / 2);
fifoDelete (queue);
return 0;
}
int
main()
{
irqInit();
fifoInit();
readUserSettings();
initClockIRQ();
SetYtrigger(80);
installSystemFIFO();
irqSet(IRQ_VCOUNT, isrVCount);
irqEnable(IRQ_VCOUNT);
SoundEngine::init();
while (1) {
swiWaitForVBlank();
}
return 0;
}
int ARM7_MAIN(void)
{
readUserSettings();
// init irq
irqInit();
initClockIRQ();
// init irq callback
irqSet(IRQ_VCOUNT, IRQ_VCount);
irqSet(IRQ_VBLANK, IRQ_VBlank);
irqEnable(IRQ_VBLANK | IRQ_VCOUNT | IRQ_NETWORK);
// init fifo system
fifoInit();
// install fifo subsystems
installWifiFIFO();
installSoundFIFO();
installSystemFIFO();
mmInstall(FIFO_MAXMOD);
// init fifo callback for arm9 communication
fifoSetDatamsgHandler(FIFO_USER_01, I_PollArm9Messages, 0);
SetYtrigger(80);
setPowerButtonCB(powerButtonCB);
// Keep the ARM7 mostly idle
while(!exitflag)
{
if(0 == (REG_KEYINPUT & (KEY_SELECT | KEY_START | KEY_L | KEY_R)))
exitflag = true;
swiIntrWait(1, IRQ_FIFO_NOT_EMPTY | IRQ_VBLANK);
}
return 0;
}
//---------------------------------------------------------------------------------
int main(int argc, char ** argv) {
//---------------------------------------------------------------------------------
readUserSettings();
irqInit();
initClockIRQ();
fifoInit();
SetYtrigger(80);
#ifdef USE_WIFI
installWifiFIFO();
#endif
//installSoundFIFO();
installSystemFIFO();
//TIMER_CR(0) = TIMER_ENABLE | TIMER_IRQ_REQ | TIMER_DIV_1;
vcount = 80;
irqSet(IRQ_VBLANK, VblankHandler);
irqSet(IRQ_VCOUNT, VcountHandler);
irqSet(IRQ_HBLANK, hblank_handler);
irqEnable(IRQ_VBLANK | IRQ_VCOUNT | IRQ_HBLANK);
setPowerButtonCB(powerButtonCB);
fifoSetDatamsgHandler(FIFO_9to7, fifo_DataHandler, 0);
// irqSet(IRQ_LID, lid);
// irqEnable(IRQ_LID);
#ifdef IPC_IN_TIMER
irqSet(IRQ_TIMER0, handle_ipc);
TIMER_DATA(0) = TIMER_FREQ_256(20 * 60);
TIMER_CR(0) = TIMER_ENABLE | TIMER_IRQ_REQ | TIMER_DIV_256;
#endif
#ifdef USE_WIFI
#ifndef WIFI_ON_DEMAND
wifi_go();
#endif
#endif
#ifdef USE_ADHOC
IPC_Init() ;
LWIFI_Init() ;
#endif
// Keep the ARM7 idle
while (!exitflag)
{
//ARM7_PRINT("arm7 ");
if ( 0 == (REG_KEYINPUT & (KEY_SELECT | KEY_START | KEY_L | KEY_R))) {
exitflag = true;
}
#ifdef USE_ADHOC
LWIFI_IPC_UpdateNOIRQ() ;
#endif
if (do_mp3 != 0)
{
#ifdef USE_MP3
ds_enable_interrupts(0);
if (helix_initialised == 0)
{
ARM7_PRINT("beginning helix init\n");
helix_init();
ARM7_PRINT("helix init done\n");
helix_initialised = 1;
}
char helix_argv1[100];
char helix_argv2[100];
memset(helix_argv1, 0, 100);
memset(helix_argv2, 0, 100);
strcpy(helix_argv1, "/jones.mp3");
// sprintf(helix_argv1, "/quake soundtrack/0%d-AudioTrack 0%d.mp3", mp3_track_no, mp3_track_no);
// strcpy(helix_argv2, "/jones.pcm");
char *proper_helix_argv[3];
proper_helix_argv[0] = NULL;
proper_helix_argv[1] = helix_argv1;
// proper_helix_argv[1] = (char *)track_name;
proper_helix_argv[2] = helix_argv2;
ARM7_PRINT("Starting Helix...\n");
decoder_stopped = 0;
ds_enable_interrupts(1);
helix_main(3, proper_helix_argv);
ds_enable_interrupts(0);
decoder_stopped = 1;
ARM7_PRINT("out of helix\n");
// ARM7_HALT();
send_mp3_stop_message();
ds_enable_interrupts(1);
#endif
}
// if (REG_KEYXY & (1 << 7))
// {
// while (quake_ipc_7to9->message == 0xffffffff);
//
// quake_ipc_7to9->message_type = kLidHasClosed;
// quake_ipc_7to9->message = 0xffffffff;
//
// while (quake_ipc_7to9->message == 0xffffffff);
//
// ARM7_PRINT("ARM7: waiting...\n");
// while (REG_IPC_FIFO_CR&IPC_FIFO_RECV_EMPTY);
// ARM7_PRINT("ARM7: disabling interrupts\n");
//
// irqDisable(IRQ_HBLANK);
// irqDisable(IRQ_VBLANK);
// irqDisable(IRQ_VCOUNT);
//
//// irqEnable(IRQ_LID);
//
// powerOFF(POWER_SOUND);
//
// swiWaitForVBlank(); //wake up when the lid re-enables the interrupt
// }
if (arm7_initialised && ((hblanks & 0x3f) == 0))
{
arm7_initialised = 1;
//ARM7_PRINT("ping");
//while (quake_ipc_7to9->message == 0xffffffff);
//quake_ipc_7to9->message_type = kPing;
//quake_ipc_7to9->message = 0xffffffff;
//while (quake_ipc_7to9->message == 0xffffffff);
}
// int total = 0;
// for (int count = 0 ; count < 16; count++)
// if (!is_channel_enabled(count))
// total++;
// if (free_time == kFreeTime)
// ARM7_PRINTF("%d channels free\n", total);
// if (free_time == kFreeTime)
// if (needs_defrag())
// {
// ARM7_PRINT("NEEDS DEFRAG\n");
// defrag(&free_time);
// }
// swiWaitForVBlank();
#ifdef IPC_IN_MAIN_THREAD
//handle_ipc();
#endif
// if (arm7_initialised == true)
// {
//// temp_test();
//
// arm7_initialised = false;
// ARM7_PRINT("installing exception handler\n");
// install();
// register unsigned int sp asm ("13");
// ARM7_PRINT("done\nlet\'s try and crash it\n");
// /*ARM7_PRINT_NUMBER(sp);*/
//
//// asm("LDR r12,=MyReg2\n"
//// "STMIA r12,{r0-r15}\n"
//// :
//// :
//// : "r12");
//
//// ARM7_PRINT_NUMBER(MyReg2[12]);
//
//// for (int count = 0; count < 16; count++)
//// ARM7_PRINT_NUMBER(MyReg2[count]);
//// ARM7_PRINT("\n");
//// while(1);
//// asm (".word 0xffffffff");
//// asm (".word 0x0");
//
//
//// Exception();
//
//// asm (".word 0xe6000010");
//
//// asm("LDR r12,=MyReg2\n"
//// "STMIA r12,{r0-r15}\n"
//// :
//// :
//// : "r12");
////
//// for (int count = 0; count < 8; count++)
//// {
//// ARM7_PRINT_NUMBER(MyReg[count + 8]);
//// ARM7_PRINT_NUMBER(MyReg2[count + 8]);
//// }
//
//
//// asm ("mcr 15,0,r0,c0,c0,0");
//// asm ("bkpt");
//// *(int *)0 = 0;
//// asm ("b debugger_hit");
//// debugger_hit();
//// debugger_handle_breakpoint(0,0,0);
//
//// asm (".word 0xe6000010");
//// asm (".short 0xe801");
// ARM7_PRINT("shouldn\'t make it here\n");
// ARM7_PRINT_NUMBER(ProperCPSR);
// while(1);
// }
swiIntrWait(1, 1);
}
}
void core7(void){
// Initialisation(s)
communicationInit();
fifoInit(FIFO_Head_generateMatrices_e__0, 4*sizeof(char), NULL, 0);
cache_wbInv(FIFO_Head_generateMatrices_e__0, 4*sizeof(char));
// Begin the execution loop
while(1){
busy_barrier();
receiveStart(); // Core2 > Core7: accumulateMatrices_0_init_ru__0
receiveEnd(2); // Core2 > Core7: accumulateMatrices_0_init_ru__0
cache_inv(accumulateMatrices_0_init_ru__0, 32*sizeof(char));
cache_inv(FIFO_Head_generateMatrices_e__0, 4*sizeof(char));
fifoPop(init_out__countIn__0, FIFO_Head_generateMatrices_e__0, 4*sizeof(char), NULL, 0);
cache_wbInv(generateMatrices_init_countI__0, 4*sizeof(char));
sendStart(0); // Core7 > Core0: generateMatrices_init_countI__0
sendEnd(); // Core7 > Core0: generateMatrices_init_countI__0
receiveStart(); // Core0 > Core7: generateMatrices__explode_ge__0
receiveEnd(0); // Core0 > Core7: generateMatrices__explode_ge__0
cache_inv(generateMatrices__explode_ge__0, 256*sizeof(char));
// Fork explode_generateMatrices_startArray
{
cache_wb(startArray__inputArray__0, 64*sizeof(long));
memcpy((void*)(startArray_8__inputArray__0+0),(void*)( startArray__inputArray__0+8), 8*sizeof(long));
memcpy((void*)(startArray_16__inputArray__0+0),(void*)( startArray__inputArray__0+16), 8*sizeof(long));
memcpy((void*)(startArray_24__inputArray__0+0),(void*)( startArray__inputArray__0+24), 8*sizeof(long));
memcpy((void*)(startArray_40__inputArray__0+0),(void*)( startArray__inputArray__0+40), 8*sizeof(long));
memcpy((void*)(startArray_48__inputArray__0+0),(void*)( startArray__inputArray__0+48), 8*sizeof(long));
memcpy((void*)(startArray_56__inputArray__0+0),(void*)( startArray__inputArray__0+56), 8*sizeof(long));
}
cache_wb(((char*)startArray__inputArray__0) + 0, 32);
cache_wb(((char*)startArray__inputArray__0) + 128, 32);
cache_inv(startArray__inputArray__0, 64*sizeof(long));
cache_wbInv(explode_generateMatrices_sta__7, 32*sizeof(char));
sendStart(3); // Core7 > Core3: explode_generateMatrices_sta__7
sendEnd(); // Core7 > Core3: explode_generateMatrices_sta__7
cache_wbInv(explode_generateMatrices_sta__3, 32*sizeof(char));
sendStart(6); // Core7 > Core6: explode_generateMatrices_sta__3
sendEnd(); // Core7 > Core6: explode_generateMatrices_sta__3
cache_wbInv(explode_generateMatrices_sta__6, 32*sizeof(char));
sendStart(0); // Core7 > Core0: explode_generateMatrices_sta__6
sendEnd(); // Core7 > Core0: explode_generateMatrices_sta__6
cache_wbInv(explode_generateMatrices_sta__1, 32*sizeof(char));
sendStart(4); // Core7 > Core4: explode_generateMatrices_sta__1
sendEnd(); // Core7 > Core4: explode_generateMatrices_sta__1
cache_wbInv(explode_generateMatrices_sta__4, 32*sizeof(char));
sendStart(1); // Core7 > Core1: explode_generateMatrices_sta__4
sendEnd(); // Core7 > Core1: explode_generateMatrices_sta__4
cache_wbInv(explode_generateMatrices_sta__0, 32*sizeof(char));
sendStart(2); // Core7 > Core2: explode_generateMatrices_sta__0
sendEnd(); // Core7 > Core2: explode_generateMatrices_sta__0
cache_wbInv(explode_generateMatrices_sta__5, 32*sizeof(char));
sendStart(5); // Core7 > Core5: explode_generateMatrices_sta__5
sendEnd(); // Core7 > Core5: explode_generateMatrices_sta__5
add(8/*rows*/,8/*columns*/,init_out__runningTotal__5,startArray_0__inputArray__0,output__input_0__0); // accumulateMatrices_0
cache_inv(init_out__runningTotal__5, 8*sizeof(long));
cache_inv(startArray_0__inputArray__0, 8*sizeof(long));
receiveStart(); // Core5 > Core7: accumulateMatrices_1__implod__0
receiveEnd(5); // Core5 > Core7: accumulateMatrices_1__implod__0
cache_inv(accumulateMatrices_1__implod__0, 32*sizeof(char));
receiveStart(); // Core2 > Core7: accumulateMatrices_2__implod__0
receiveEnd(2); // Core2 > Core7: accumulateMatrices_2__implod__0
cache_inv(accumulateMatrices_2__implod__0, 32*sizeof(char));
receiveStart(); // Core1 > Core7: accumulateMatrices_3__implod__0
receiveEnd(1); // Core1 > Core7: accumulateMatrices_3__implod__0
cache_inv(accumulateMatrices_3__implod__0, 32*sizeof(char));
receiveStart(); // Core4 > Core7: accumulateMatrices_4__implod__0
receiveEnd(4); // Core4 > Core7: accumulateMatrices_4__implod__0
cache_inv(accumulateMatrices_4__implod__0, 32*sizeof(char));
receiveStart(); // Core0 > Core7: accumulateMatrices_5__implod__0
receiveEnd(0); // Core0 > Core7: accumulateMatrices_5__implod__0
cache_inv(accumulateMatrices_5__implod__0, 32*sizeof(char));
receiveStart(); // Core6 > Core7: accumulateMatrices_6__implod__0
receiveEnd(6); // Core6 > Core7: accumulateMatrices_6__implod__0
cache_inv(accumulateMatrices_6__implod__0, 32*sizeof(char));
receiveStart(); // Core3 > Core7: accumulateMatrices_7__implod__0
receiveEnd(3); // Core3 > Core7: accumulateMatrices_7__implod__0
cache_inv(accumulateMatrices_7__implod__0, 32*sizeof(char));
// Join implode_broadcastOutput_input
{
cache_wb(output__input_0__0, 8*sizeof(long));
memcpy((void*)(output__input__0+8),(void*)( output__input_8__0+0), 8*sizeof(long));
memcpy((void*)(output__input__0+16),(void*)( output__input_16__0+0), 8*sizeof(long));
memcpy((void*)(output__input__0+24),(void*)( output__input_24__0+0), 8*sizeof(long));
cache_wb(output__input_32__0, 8*sizeof(long));
memcpy((void*)(output__input__0+40),(void*)( output__input_40__0+0), 8*sizeof(long));
memcpy((void*)(output__input__0+48),(void*)( output__input_48__0+0), 8*sizeof(long));
memcpy((void*)(output__input__0+56),(void*)( output__input_56__0+0), 8*sizeof(long));
}
cache_wb(((char*)output__input_0__0) + 0, 32);
cache_inv(output__input_0__0, 8*sizeof(long));
cache_inv(output__input_8__0, 8*sizeof(long));
cache_inv(output__input_16__0, 8*sizeof(long));
cache_inv(output__input_24__0, 8*sizeof(long));
cache_wb(((char*)output__input_32__0) + 0, 32);
cache_inv(output__input_32__0, 8*sizeof(long));
cache_inv(output__input_40__0, 8*sizeof(long));
cache_inv(output__input_48__0, 8*sizeof(long));
cache_inv(output__input_56__0, 8*sizeof(long));
// Broadcast broadcastOutput
{
cache_wb(output__input__0, 64*sizeof(long));
memcpy((void*)(output1_8__end_in__0+0),(void*)( output__input__0+0), 8*sizeof(long));
memcpy((void*)(output1_40__end_in__0+0),(void*)( output__input__0+8), 8*sizeof(long));
memcpy((void*)(output1_32__end_in__0+0),(void*)( output__input__0+16), 8*sizeof(long));
memcpy((void*)(output1_16__end_in__0+0),(void*)( output__input__0+24), 8*sizeof(long));
memcpy((void*)(output1_0__end_in__0+0),(void*)( output__input__0+32), 8*sizeof(long));
memcpy((void*)(output1_24__end_in__0+0),(void*)( output__input__0+40), 8*sizeof(long));
memcpy((void*)(output1_48__end_in__0+0),(void*)( output__input__0+48), 8*sizeof(long));
memcpy((void*)(output1_56__end_in__0+0),(void*)( output__input__0+56), 8*sizeof(long));
}
cache_wb(((char*)output__input__0) + 0, 256);
cache_inv(output__input__0, 64*sizeof(long));
cache_wbInv(broadcastOutput__broadcastOu__0, 32*sizeof(char));
sendStart(1); // Core7 > Core1: broadcastOutput__broadcastOu__0
sendEnd(); // Core7 > Core1: broadcastOutput__broadcastOu__0
cache_wbInv(broadcastOutput__broadcastOu__3, 32*sizeof(char));
sendStart(2); // Core7 > Core2: broadcastOutput__broadcastOu__3
sendEnd(); // Core7 > Core2: broadcastOutput__broadcastOu__3
cache_wbInv(broadcastOutput__broadcastOu__7, 32*sizeof(char));
sendStart(5); // Core7 > Core5: broadcastOutput__broadcastOu__7
sendEnd(); // Core7 > Core5: broadcastOutput__broadcastOu__7
cache_wbInv(broadcastOutput__broadcastOu__5, 32*sizeof(char));
sendStart(6); // Core7 > Core6: broadcastOutput__broadcastOu__5
sendEnd(); // Core7 > Core6: broadcastOutput__broadcastOu__5
cache_wbInv(broadcastOutput__broadcastOu__1, 32*sizeof(char));
sendStart(3); // Core7 > Core3: broadcastOutput__broadcastOu__1
sendEnd(); // Core7 > Core3: broadcastOutput__broadcastOu__1
cache_wbInv(broadcastOutput__broadcastOu__4, 32*sizeof(char));
sendStart(4); // Core7 > Core4: broadcastOutput__broadcastOu__4
sendEnd(); // Core7 > Core4: broadcastOutput__broadcastOu__4
cache_wbInv(broadcastOutput__displayMatr__0, 256*sizeof(char));
sendStart(0); // Core7 > Core0: broadcastOutput__displayMatr__0
sendEnd(); // Core7 > Core0: broadcastOutput__displayMatr__0
fifoPush(output1_56__end_in__0, FIFO_Head_broadcastOutput_en__0, 32*sizeof(char), NULL, 0);
cache_wbInv(FIFO_Head_broadcastOutput_en__0, 32*sizeof(char));
cache_inv(output1_56__end_in__0, 8*sizeof(long));
fifoPush(output1_8__end_in__0, FIFO_Head_broadcastOutput_en__6, 32*sizeof(char), NULL, 0);
cache_wbInv(FIFO_Head_broadcastOutput_en__6, 32*sizeof(char));
cache_inv(output1_8__end_in__0, 8*sizeof(long));
}
}
sio_status_t * sio_open( int devnum )
{
char dev[20];
/* would be nice with dynamic memory alloc */
sio_status_t * siostate = &statusar[ devnum ];
/* siostruct_t * tmp; */
/* tmp = (siostruct_t*)(netif->state); */
/* tmp->sio = siostate; */
/* tmp = (siostruct_t*)(netif->state); */
/* ((sio_status_t*)(tmp->sio))->fd = 0; */
#if ! PPP_SUPPORT
fifoInit( &siostate->myfifo );
#endif /* ! PPP_SUPPORT */
snprintf( dev, sizeof(dev), "/dev/ttyS%d", devnum );
if ( (devnum == 1) || (devnum == 0) )
{
if ( ( siostate->fd = sio_init( dev, devnum, siostate ) ) == 0 )
{
LWIP_DEBUGF(SIO_DEBUG, ( "sio_open: ERROR opening serial device\n" ));
abort( );
return NULL;
}
}
#if PPP_SUPPORT
else if (devnum == 2) {
pid_t childpid;
childpid = forkpty(&siostate->fd, NULL, NULL, NULL);
if(childpid < 0) {
perror("forkpty");
exit (1);
}
if(childpid == 0) {
execl("/usr/sbin/pppd", "pppd",
"ms-dns", "198.168.100.7",
"local", "crtscts",
"debug",
#ifdef LWIP_PPP_CHAP_TEST
"auth",
"require-chap",
"remotename", "lwip",
#else
"noauth",
#endif
"192.168.1.1:192.168.1.2",
NULL);
perror("execl pppd");
exit (1);
} else {
LWIP_DEBUGF(SIO_DEBUG, ( "sio_open: spawned pppd pid %d\n", childpid));
}
}
#endif
else
{
LWIP_DEBUGF(SIO_DEBUG, ( "sio_open: device %s (%d) is not supported\n", dev, devnum ));
return NULL;
}
LWIP_DEBUGF( 1,("sio_open: dev=%s open.\n", dev ));
return siostate;
}
void vcomInit(void) {
fifoInit(&txfifo, _vcom_txdata, VCOM_FIFO_SIZE);
fifoInit(&rxfifo, _vcom_rxdata, VCOM_FIFO_SIZE);
}
