//---------------------------------------------------------------------------------
int main(int argc, char ** argv) {
//---------------------------------------------------------------------------------
// Reset the clock if needed
rtcReset();
//enable sound
powerON(POWER_SOUND);
SOUND_CR = SOUND_ENABLE | SOUND_VOL(0x7F);
IPC->soundData = 0;
irqInit();
irqSet(IRQ_VBLANK, VblankHandler);
SetYtrigger(80);
vcount = 80;
irqSet(IRQ_VCOUNT, VcountHandler);
irqEnable(IRQ_VBLANK | IRQ_VCOUNT);
irqSet(IRQ_TIMER0, playTimerHandler);
irqEnable(IRQ_TIMER0);
player = new Player(playTimerHandler);
player->registerTickCallback(onTick);
player->registerPatternChangeCallback(onPatternChange);
// Keep the ARM7 idle
while (1) swiWaitForVBlank();
}
void arm9_wifiInit()
{
// send fifo message to initialize the arm7 wifi
REG_IPC_FIFO_CR = IPC_FIFO_ENABLE | IPC_FIFO_SEND_CLEAR; // enable & clear FIFO
u32 Wifi_pass= Wifi_Init(WIFIINIT_OPTION_USELED);
REG_IPC_FIFO_TX=0x12345678;
REG_IPC_FIFO_TX=Wifi_pass;
*((volatile u16 *)0x0400010E) = 0; // disable timer3
irqSet(IRQ_TIMER3, arm9_wifiTimer); // setup timer IRQ
irqEnable(IRQ_TIMER3);
irqSet(IRQ_FIFO_NOT_EMPTY, arm9_fifo); // setup fifo IRQ
irqEnable(IRQ_FIFO_NOT_EMPTY);
REG_IPC_FIFO_CR = IPC_FIFO_ENABLE | IPC_FIFO_RECV_IRQ; // enable FIFO IRQ
Wifi_SetSyncHandler(arm9_synctoarm7); // tell wifi lib to use our handler to notify arm7
// set timer3
*((volatile u16 *)0x0400010C) = -(131062*WifiTimerInterval_ms/1000); // 131062 * 256 cycles = ~1000ms;
*((volatile u16 *)0x0400010E) = 0x00C2; // enable, irq, 1/256 clock
while(Wifi_CheckInit()==0)
{ // wait for arm7 to be initted successfully
WaitVbl(); // wait for vblank
}
// wifi init complete - wifi lib can now be used!
}
void wifi_init()
{
REG_IPC_FIFO_CR = IPC_FIFO_ENABLE | IPC_FIFO_SEND_CLEAR;
/*
* Our half of the ARM7 Wifi handshaking:
* Send it a pointer to the shared memory area for Wifi.
*/
REG_IPC_FIFO_TX = IPC_MSG_WIFI_INIT;
REG_IPC_FIFO_TX = Wifi_Init(WIFIINIT_OPTION_USELED);
/* Disable TIMER3 before setting up its IRQ handler */
TIMER3_CR = 0;
irqInit();
irqSet(IRQ_VBLANK, vblank_irq_handler);
irqEnable(IRQ_VBLANK);
irqSet(IRQ_TIMER3, wifi_timer_handler);
irqEnable(IRQ_TIMER3);
irqSet(IRQ_FIFO_NOT_EMPTY, fifo_irq_handler);
irqEnable(IRQ_FIFO_NOT_EMPTY);
REG_IPC_FIFO_CR = IPC_FIFO_ENABLE | IPC_FIFO_RECV_IRQ;
Wifi_SetSyncHandler(wifi_sync_handler);
/* Program TIMER3 for 50ms intervals */
TIMER3_DATA = TIMER_FREQ_256(1000 / WIFI_TIMER_MS);
TIMER3_CR = TIMER_DIV_256 | TIMER_IRQ_REQ;
/* Poll for the ARM7 init to finish */
while (!Wifi_CheckInit()) {
swiWaitForVBlank();
}
}
int main(int argc, char **argv)
{
REG_IPC_FIFO_CR = IPC_FIFO_ENABLE | IPC_FIFO_SEND_CLEAR ;
u32 old_reg = readPowerManagement(PM_CONTROL_REG);
writePowerManagement(PM_CONTROL_REG, old_reg |PM_LED_ON); // enable fast
// Reset the clock if needed
rtcReset();
// Turn on Sound
powerON(POWER_SOUND);
// Set up sound defaults.
SOUND_CR = SOUND_ENABLE | SOUND_VOL(0x7F);
IPC->soundData = 0;
// Set up the interrupt handler
irqInit();
irqSet(IRQ_VBLANK, VblankHandler);
irqEnable(IRQ_VBLANK);
// Setup FIFO
irqSet(IRQ_FIFO_NOT_EMPTY,FifoInterruptHandler);
irqEnable(IRQ_FIFO_NOT_EMPTY);
REG_IPC_FIFO_CR = IPC_FIFO_ENABLE | IPC_FIFO_SEND_CLEAR | IPC_FIFO_RECV_IRQ ;
// Keep the ARM7 out of main RAM
while (1)
swiWaitForVBlank();
return 0;
}
int main()
{
// REG_WAITCNT = 0x46d6; // lets set some cool waitstates...
REG_WAITCNT = 0x46da; // lets set some cool waitstates...
irqInit();
irqEnable(IRQ_VBLANK);
consoleInit(0, 4, 0, NULL, 0, 15);
BG_COLORS[0] = RGB5(0, 0, 0);
BG_COLORS[241] = RGB5(31, 31, 31);
REG_DISPCNT = MODE_0 | BG0_ON;
gbfs_init(1);
pimp_sample_bank sb;
FILE *fp = fopen("dxn-oopk.xm", "rb");
if (!fp)
{
fprintf(stderr, "file not found\n");
return 1;
}
pimp_module *mod = load_module_xm(fp, &sb);
fclose(fp);
fp = NULL;
if (NULL == mod)
{
fprintf(stderr, "failed to load module\n");
return 1;
}
pimp_gba_init(mod, sb.data);
pimp_gba_set_callback(callback);
irqSet(IRQ_TIMER3, timer3);
irqEnable(IRQ_TIMER3);
REG_TM3CNT_L = 0;
REG_TM3CNT_H = TIMER_START | TIMER_IRQ | 2;
irqSet(IRQ_VBLANK, vblank);
irqEnable(IRQ_VBLANK);
while (1)
{
VBlankIntrWait();
scanKeys();
int keys = keysDown();
if (keys & KEY_UP) pimp_gba_set_pos(0, pimp_gba_get_order() - 1);
if (keys & KEY_DOWN) pimp_gba_set_pos(0, pimp_gba_get_order() + 1);
if (keys & KEY_RIGHT) pimp_gba_set_pos(pimp_gba_get_row() + 8, pimp_gba_get_order());
if (keys & KEY_LEFT) pimp_gba_set_pos(pimp_gba_get_row() - 8, pimp_gba_get_order());
iprintf("%d %d\n", pimp_gba_get_order(), pimp_gba_get_row());
}
pimp_gba_close();
return 0;
}
int main(void) {
REG_IPC_FIFO_CR = IPC_FIFO_ENABLE | IPC_FIFO_SEND_CLEAR;
IPC->mailData=0;
IPC->mailSize=0;
PA_SoundBusyInit = 0;
PA_Init();
irqInit();
irqSet(IRQ_VBLANK, PA_VBL);
irqEnable(IRQ_VBLANK);
irqSet(IRQ_TIMER0, timer0);
irqEnable(IRQ_TIMER0);
SetYtrigger(80);
vcount = 80;
irqSet(IRQ_VCOUNT, VcountHandler);
irqEnable(IRQ_VBLANK | IRQ_VCOUNT);
// irqSet(IRQ_TIMER3, ProcessMicrophoneTimerIRQ);
// irqEnable(IRQ_TIMER3);
//swiWaitForVBlank();
//swiWaitForVBlank();
//supprime pour test
irqSet(IRQ_WIFI, Wifi_Interrupt); // set up wifi interrupt
irqEnable(IRQ_WIFI);
//swiWaitForVBlank();
//swiWaitForVBlank();
//supprime pour test
SndInit7 ();
u32 fifo_temp;
while(1) { // wait for magic number
while(REG_IPC_FIFO_CR&IPC_FIFO_RECV_EMPTY) swiWaitForVBlank();
fifo_temp=REG_IPC_FIFO_RX;
if(fifo_temp==0x12345678) break;
}
while(REG_IPC_FIFO_CR&IPC_FIFO_RECV_EMPTY) swiWaitForVBlank();
fifo_temp=REG_IPC_FIFO_RX; // give next value to wifi_init
Wifi_Init(fifo_temp);
irqSet(IRQ_FIFO_NOT_EMPTY,arm7_fifo); // set up fifo irq
irqEnable(IRQ_FIFO_NOT_EMPTY);
REG_IPC_FIFO_CR = IPC_FIFO_ENABLE | IPC_FIFO_RECV_IRQ;
Wifi_SetSyncHandler(arm7_synctoarm9); // allow wifi lib to notify arm9
// Keep the ARM7 out of main RAM
while (1) {
swiWaitForVBlank();
}
return 0;
}
int main() {
REG_IPC_FIFO_CR = IPC_FIFO_ENABLE | IPC_FIFO_SEND_CLEAR;
IPC->mailData=0;
IPC->mailSize=0;
PA_SoundBusyInit = 0;
PA_Init();
irqInit();
irqSet(IRQ_VBLANK, PA_VBL);
irqEnable(IRQ_VBLANK);
irqSet(IRQ_TIMER2, timer2);
irqEnable(IRQ_TIMER2);
SetYtrigger(80);
vcount = 80;
irqSet(IRQ_VCOUNT, VcountHandler);
irqEnable(IRQ_VBLANK | IRQ_VCOUNT);
//supprime pour test
irqSet(IRQ_WIFI, Wifi_Interrupt); // set up wifi interrupt
irqEnable(IRQ_WIFI);
//supprime pour test
SndInit7 ();
// Initialize AS_Lib
AS_Init();
u32 fifo_temp;
while(1) { // wait for magic number
while (REG_IPC_FIFO_CR & IPC_FIFO_RECV_EMPTY)
{
AS_MP3Engine();
swiWaitForVBlank();
}
fifo_temp=REG_IPC_FIFO_RX;
if(fifo_temp==0x12345678)
break;
}
while (REG_IPC_FIFO_CR & IPC_FIFO_RECV_EMPTY) swiWaitForVBlank();
fifo_temp = REG_IPC_FIFO_RX; // give next value to wifi_init
Wifi_Init(fifo_temp);
irqSet(IRQ_FIFO_NOT_EMPTY, arm7_fifo); // set up fifo irq
irqEnable(IRQ_FIFO_NOT_EMPTY);
REG_IPC_FIFO_CR = IPC_FIFO_ENABLE | IPC_FIFO_RECV_IRQ;
Wifi_SetSyncHandler(arm7_synctoarm9); // allow wifi lib to notify arm9
while (1) {
AS_MP3Engine();
swiWaitForVBlank();
}
return 0;
}
int main()
{
irqInit();
REG_IPC_FIFO_CR = IPC_FIFO_ENABLE | IPC_FIFO_RECV_IRQ;
irqSet(IRQ_VBLANK, vblank_irq_handler);
irqEnable(IRQ_VBLANK);
irqSet(IRQ_FIFO_NOT_EMPTY, fifo_irq_handler);
irqEnable(IRQ_FIFO_NOT_EMPTY);
while (1) {
swiWaitForVBlank();
}
}
/*
DS_SysInit
Initializes DS specific system hardware and interrupts.
*/
LOCALPROC DS_SysInit(void)
{
defaultExceptionHandler();
powerOn(POWER_ALL_2D);
lcdMainOnTop();
irqSet(IRQ_VBLANK, DS_VBlank_IRQ);
irqSet(IRQ_HBLANK, DS_HBlank_IRQ);
irqSet(IRQ_TIMER1, DS_Timer1_IRQ);
irqEnable(IRQ_VBLANK);
irqEnable(IRQ_HBLANK);
irqEnable(IRQ_TIMER1);
/*
This sets up 2 timers as a milisecond counter.
TIMER0_DATA Will overflow roughly every 1 msec into TIMER1_DATA.
When TIMER1_DATA overflows an interrupt will be generated
and DS_Timer1_IRQ will be called.
*/
TIMER0_DATA = 32768;
TIMER0_CR = TIMER_DIV_1 | TIMER_ENABLE;
TIMER1_DATA = 0;
TIMER1_CR = TIMER_ENABLE | TIMER_CASCADE | TIMER_IRQ_REQ;
/*
Testing.
*/
consoleDemoInit();
consoleDebugInit(DebugDevice_NOCASH);
/*
Use the default keyboard until I design a (good) UI...
*/
DSKeyboard = keyboardDemoInit();
keyboardShow();
/*
Drop back to a read only filesystem embedded in the
Mini vMac binary if we cannot open a media device.
*/
if (! fatInitDefault()) {
nitroFSInit();
}
}
static int NDS_SetDisplayMode(_THIS, SDL_VideoDisplay *display, SDL_DisplayMode *mode)
{
display->driverdata = mode->driverdata;
#ifdef USE_HW_RENDERER
videoSetMode(MODE_5_3D);
videoSetModeSub(MODE_5_2D);
/* initialize gl2d */
glScreen2D();
vramSetBankA(VRAM_A_TEXTURE);
vramSetBankB(VRAM_B_TEXTURE );
vramSetBankC(VRAM_C_SUB_BG_0x06200000);
vramSetBankE(VRAM_E_TEX_PALETTE);
powerOn(POWER_ALL_2D);
irqInit();
irqEnable(IRQ_VBLANK);
// sub sprites hold the bottom image when 3D directed to top
initSubSprites();
// sub background holds the top image when 3D directed to bottom
bgInitSub(3, BgType_Bmp16, BgSize_B16_256x256, 0, 0);
#else
/* Select mode 5 for both screens. Can do Extended Rotation
* Background on both (BG 2 and 3). */
videoSetMode(MODE_5_2D);
videoSetModeSub(MODE_5_2D);
vramSetBankA(VRAM_A_MAIN_BG_0x06000000);
vramSetBankB(VRAM_B_TEXTURE );
vramSetBankC(VRAM_C_SUB_BG_0x06200000);
vramSetBankE(VRAM_E_TEX_PALETTE);
powerOn(POWER_ALL_2D);
irqInit();
irqEnable(IRQ_VBLANK);
#endif
return 0;
}
//---------------------------------------------------------------------------------
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;
}
void bsp_start (void)
{
/* initialize irq management */
BSP_rtems_irq_mngt_init ();
/* setup console mode for lower screen */
irqEnable (IRQ_VBLANK);
videoSetMode (0);
videoSetModeSub (MODE_0_2D | DISPLAY_BG0_ACTIVE);
vramSetBankC (VRAM_C_SUB_BG);
SUB_BG0_CR = BG_MAP_BASE (31);
BG_PALETTE_SUB[255] = RGB15 (31, 31, 31);
consoleInitDefault ((u16 *) SCREEN_BASE_BLOCK_SUB (31),
(u16 *) CHAR_BASE_BLOCK_SUB (0), 16);
/* print status message */
printk ("[+] kernel console started\n");
/* set the cpu mode to system user */
arm_cpu_mode = 0x1f;
/* configure clock period */
Configuration.microseconds_per_tick = 10000; /* us */
defaultExceptionHandler ();
}
/*----------------------------------------------------------------------------*/
static enum Result streamEnable(void *object)
{
struct DmaOneShot * const stream = object;
const uint8_t number = stream->base.number;
assert(stream->state == STATE_READY);
if (dmaSetInstance(number, object))
{
STM_DMA_CHANNEL_Type * const reg = stream->base.reg;
reg->CMAR = stream->memoryAddress;
reg->CPAR = stream->periphAddress;
reg->CNDTR = stream->transfers;
/* Start the transfer */
stream->state = STATE_BUSY;
irqEnable(stream->base.irq);
reg->CCR = stream->base.config | CCR_EN;
return E_OK;
}
else
return E_BUSY;
}
void Menu::Init()
{
iprintf("Menu.Init\n");
KSIN1 = u8(K1 *(360/57.3f));
KSIN2 = u8(K2 *(360/57.3f));
KSIN3 = u8(K3 *(360/57.3f));
for (int i = 0; i< ((2048) - 1); i++)
{
lsin1[i] = sin(i/(float)K1) * 32+32;
lsin2[i] = sin(i/(float)K2) * 16+16;
lsin3[i] = sin(i/(float)K3) * 20+20;
}
for (int i=0; i<256; i++)
{
u8 r = (u8)(abs(int(16 - 15 * sin(i * M_PI / 16.0f))));
u8 g = (u8)(abs(int(16 - 15 * sin(i * M_PI / 12.0f))));
u8 b = (u8)(abs(int(16 - 15 * sin(i * M_PI / 18.0f))));
pal[i] = RGB15(r,g,b);
}
irqInit();
irqEnable(IRQ_VBLANK);
videoSetMode(MODE_FB0);
vramSetBankA(VRAM_A_LCD);
}
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()
{
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;
}
/*----------------------------------------------------------------------------*/
static enum result eepromInit(void *object, const void *configBase)
{
const struct EepromConfig * const config = configBase;
struct Eeprom * const interface = object;
if (!setDescriptor(0, interface))
return E_BUSY;
interface->position = 0;
interface->size = (uintptr_t)&_eeeprom - (uintptr_t)&_seeprom;
interface->blocking = true;
/* Enable clock to register interface and peripheral */
sysClockEnable(CLK_M4_EEPROM);
/* Reset registers to default values */
sysResetEnable(RST_EEPROM);
const uint32_t frequency = clockFrequency(MainClock);
LPC_EEPROM->CLKDIV = (frequency + (EEPROM_CLOCK - 1)) / EEPROM_CLOCK - 1;
LPC_EEPROM->INTENSET = INT_PROG_DONE;
if (config)
irqSetPriority(EEPROM_IRQ, config->priority);
irqEnable(EEPROM_IRQ);
return E_OK;
}
int main(int argc, char **argv)
{
//irqInit();
irqEnable(IRQ_VBLANK);
/* Setup logging console on top screen */
init_consoles();
print_to_debug("AirScan v1.0 by Raphael Rigo");
print_to_debug("released 07/11/2010");
print_to_debug("");
print_to_debug("B: Toggle OPN");
print_to_debug("A: Toggle WEP");
print_to_debug("X: Toggle WPA");
print_to_debug("Up/Down : scroll");
print_to_debug("Left/Right : Timeout -/+");
print_to_debug("");
print_to_debug("Initializing Wifi...");
Wifi_InitDefault(false);
wardriving_loop();
return 0;
}
int main()
{
irqInit();
irqEnable(IRQ_VBLANK);
consoleInit(0, 4, 0, NULL, 0, 15);
BG_COLORS[0]=RGB8(58,110,165);
BG_COLORS[241]=RGB5(31,31,31);
SetMode(MODE_0 | BG0_ON);
/* verify that the overlays are indeed overlapping */
printf("overlay1_test: %p\noverlay2_test: %p\n", overlay1_test, overlay2_test);
/* set overlay 1 and run code from it */
memcpy(__iwram_overlay_start, __load_start_iwram1, (int)__load_stop_iwram1 - (int)__load_start_iwram1);
overlay1_test();
/* set overlay 2 and run code from it */
memcpy(__iwram_overlay_start, __load_start_iwram2, (int)__load_stop_iwram2 - (int)__load_start_iwram2);
overlay2_test();
/* back to normal */
memcpy(__iwram_overlay_start, __load_start_iwram0, (int)__load_stop_iwram0 - (int)__load_start_iwram0);
while(1);
}
void keyboardInit()
{
extKIrqHandler = 0;
kBuffer = 16;
int x;
/*
* set 5-8 lines to input with pull down,
* detecting rising edge
*/
for (x = 5; x <= 8; x++) {
setGpioFunct(pinToGpio[x], GPINPUT);
setPull(pinToGpio[x], GPDOWN);
setDetect(pinToGpio[x], GPENABLE, GPRISE);
}
/*
* turn 1-4 lines high to allow interrupt
* to be generated
*/
for (x = 1; x <= 4; x++) {
setGpioFunct(pinToGpio[x], GPOUTPUT);
setPin(pinToGpio[x]);
setPull(pinToGpio[x], GPDOWN);
}
/*
* sets interrupt controller
*/
*irqEnable2 = ((1 << 20) | (1 << 19) | (1 << 18) | (1 << 17));
/*
* takes care of CPSR
*/
irqEnable();
return;
}
//---------------------------------------------------------------------------------
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();
}
/*-------------------------------------------------------------------------------*/
void cardSpiSetHandler(void (*irqHandler)(void)) {
/*-------------------------------------------------------------------------------*/
card_spi_settings.enable_irq = irqHandler == NULL ? 0 : CR1_ENABLE_IRQ;
irqSet(IRQ_CARD_LINE, irqHandler);
irqEnable(IRQ_CARD_LINE);
cardSpiStop(); /* update CR1 register */
}
/*
* Setup the timer 0 to generate the tick interrupts at the required frequency.
*/
static void prvSetupTimerInterrupt( void )
{
unsigned long ulCompareMatch;
/* Calculate the match value required for our wanted tick rate. */
ulCompareMatch = 1000000 / configTICK_RATE_HZ;
/* Protect against divide by zero. Using an if() statement still results
in a warning - hence the #if. */
#if portPRESCALE_VALUE != 0
{
ulCompareMatch /= ( portPRESCALE_VALUE + 1 );
}
#endif
irqBlock();
pRegs->CTL = 0x003E0000;
pRegs->LOD = 1000 - 1;
pRegs->RLD = 1000 - 1;
pRegs->DIV = portTIMER_PRESCALE;
pRegs->CLI = 0;
pRegs->CTL = 0x003E00A2;
irqRegister(64, vTickISR, NULL);
irqEnable(64);
irqUnblock();
}
static int init(void) {
LOG_DEBUG(2,"Initialising NDS audio (ARM9 side)\n");
flush_event = event_new();
flush_event->dispatch = flush_frame;
memset(buf, 0x80, sizeof(buf));
writing_buf = 0;
frame_base = buf;
wrptr = buf;
frame_cycle_base = current_cycle;
frame_cycle = 0;
flush_event->at_cycle = frame_cycle_base + FRAME_CYCLES;
event_queue(&MACHINE_EVENT_LIST, flush_event);
lastsample = 0x80; //0;
/* handshake with ARM7 to pass sound buffer address */
REG_IPC_FIFO_CR = (1 << 3) | (1 << 15); /* enable FIFO, clear sendq */
REG_IPC_SYNC = (14 << 8);
while ((REG_IPC_SYNC & 15) != 14);
REG_IPC_FIFO_TX = (uint32_t)buf;
REG_IPC_SYNC = (1 << 14) | (0 << 8); /* IRQ on sync */
irqEnable(IRQ_IPC_SYNC);
/* now wait for ARM7 to be playing frame 1 */
while ((REG_IPC_SYNC & 1) != 1) {
swiIntrWait(1, IRQ_IPC_SYNC);
}
return 0;
}
//---------------------------------------------------------------------------------
int main(int argc, char ** argv) {
//---------------------------------------------------------------------------------
// read User Settings from firmware
readUserSettings();
REG_IPC_FIFO_CR = IPC_FIFO_ENABLE | IPC_FIFO_SEND_CLEAR; // enable & prepare fifo asap
rtcReset();
//enable sound
powerON(POWER_SOUND);
writePowerManagement(PM_CONTROL_REG, ( readPowerManagement(PM_CONTROL_REG) & ~PM_SOUND_MUTE ) | PM_SOUND_AMP );
SOUND_CR = SOUND_ENABLE | SOUND_VOL(0x7F);
irqInit();
// Start the RTC tracking IRQ
initClockIRQ();
SetYtrigger(80);
irqSet(IRQ_VCOUNT, VcountHandler);
irqSet(IRQ_VBLANK, VblankHandler);
irqSet(IRQ_WIFI, Wifi_Interrupt); // set up wifi interrupt
irqEnable( IRQ_VBLANK | IRQ_VCOUNT | IRQ_WIFI);
{ // sync with arm9 and init wifi
u32 fifo_temp;
while(1) { // wait for magic number
while(REG_IPC_FIFO_CR&IPC_FIFO_RECV_EMPTY) swiWaitForVBlank();
fifo_temp=REG_IPC_FIFO_RX;
if(fifo_temp==0x12345678) break;
}
while(REG_IPC_FIFO_CR&IPC_FIFO_RECV_EMPTY) swiWaitForVBlank();
fifo_temp=REG_IPC_FIFO_RX; // give next value to wifi_init
Wifi_Init(fifo_temp);
irqSet(IRQ_FIFO_NOT_EMPTY,arm7_fifo); // set up fifo irq
irqEnable(IRQ_FIFO_NOT_EMPTY);
REG_IPC_FIFO_CR = IPC_FIFO_ENABLE | IPC_FIFO_RECV_IRQ;
Wifi_SetSyncHandler(arm7_synctoarm9); // allow wifi lib to notify arm9
} // arm7 wifi init complete
// Keep the ARM7 mostly idle
while (1) swiWaitForVBlank();
}
void Timer::initSystemTimer() {
TIMER1_CR = 0;
TIMER1_DATA = TIMER_FREQ_1024(1000);
TIMER1_CR = TIMER_ENABLE | TIMER_DIV_1024 | TIMER_IRQ_REQ;
irqSet(IRQ_TIMER1, OnTimer);
irqEnable(IRQ_TIMER1);
systemTime = 0;
}
/*----------------------------------------------------------------------------*/
static void enableInterrupt(const struct PinInterrupt *interrupt)
{
const IrqNumber irq = calcVector(interrupt->channel);
LPC_GPIO_INT->IST = 1UL << interrupt->pin.offset;
irqClearPending(irq);
irqEnable(irq);
}
static void setupTimer0(void)
{
tpl_disable_interrupts();
TIMER0_DATA = TIMER_FREQ_256(1000); /* 1ms */
TIMER0_CR = TIMER_ENABLE | TIMER_IRQ_REQ | TIMER_DIV_256;
irqSet(IRQ_TIMER0, tpl_tick_timer0_overflow);
irqEnable(IRQ_TIMER0);
}
int main(int argc, char ** argv)
{
u32 fifo_temp;
REG_IPC_FIFO_CR = IPC_FIFO_ENABLE | IPC_FIFO_SEND_CLEAR;
// Reset the clock if needed
rtcReset();
//enable sound
powerON(POWER_SOUND);
SOUND_CR = SOUND_ENABLE | SOUND_VOL(0x7F);
IPC->soundData = 0;
irqInit();
irqSet(IRQ_VBLANK, VblankHandler);
SetYtrigger(80);
vcount = 80;
irqSet(IRQ_VCOUNT, VcountHandler);
irqEnable(IRQ_VBLANK | IRQ_VCOUNT);
irqSet(IRQ_TIMER0, tob_ProcessMicrophoneTimerIRQ);
tob_MIC_On();
irqSet(IRQ_WIFI, Wifi_Interrupt);
irqEnable(IRQ_WIFI);
// trade some mail, to get a pointer from arm9
while(1)
{
while(REG_IPC_FIFO_CR&IPC_FIFO_RECV_EMPTY) swiWaitForVBlank();
fifo_temp=REG_IPC_FIFO_RX;
if(fifo_temp==0x12345678) break;
}
while(REG_IPC_FIFO_CR&IPC_FIFO_RECV_EMPTY) swiWaitForVBlank();
fifo_temp=REG_IPC_FIFO_RX;
Wifi_Init(fifo_temp);
irqSet(IRQ_FIFO_NOT_EMPTY,arm7_fifo);
irqEnable(IRQ_FIFO_NOT_EMPTY);
REG_IPC_FIFO_CR = IPC_FIFO_ENABLE | IPC_FIFO_RECV_IRQ;
Wifi_SetSyncHandler(arm7_synctoarm9);
// Keep the ARM7 idle
while(1) swiWaitForVBlank();
}
//-----------------------------------------------------------
// setup interrupt handler with vblank irq enabled
//-----------------------------------------------------------
void setupInterrupts( void )
//-----------------------------------------------------------
{
// initialize interrupt handler
irqInit();
// enable vblank interrupt (required for swiWaitForVBlank!)
irqEnable( IRQ_VBLANK );
}
