static void returnMsgHandler(int bytes, void* user_data)
{
returnMsg msg;
if((message_pointer + bytes) < MAX_MESSAGE_POINTER)
{
fifoGetDatamsg(FIFO_RETURN, bytes, (u8*) &message_data[message_pointer]);
message_pointer+=bytes;
}
else
fifoGetDatamsg(FIFO_RETURN, bytes, (u8*) &msg); //Toss the overflowing message.
}
static void sndsysMsgHandler(int bytes, void* user_data)
{
//iprintf("S before:");
sndsysMsg msg;
fifoGetDatamsg(FIFO_SNDSYS, bytes, (u8*) &msg);
//iprintf("after, recv %d bytes\n",bytes);
}
void CommandRecvHandler(int bytes, void *user_data) {
NTXMFifoMessage msg;
fifoGetDatamsg(FIFO_NTXM, bytes, (u8*)&msg);
switch(msg.commandType) {
case DBG_OUT: // TODO it's not safe to do this in an interrupt handler
iprintf(msg.dbgOut.msg);
break;
case UPDATE_ROW:
RecvCommandUpdateRow(&msg.updateRow);
break;
case UPDATE_POTPOS:
RecvCommandUpdatePotPos(&msg.updatePotPos);
break;
case NOTIFY_STOP:
RecvCommandNotifyStop();
break;
case SAMPLE_FINISH:
RecvCommandSampleFinish();
break;
default:
break;
}
}
static void I_PollArm9Messages(int bytes, void *userdata)
{
fifomsg_t msg;
fifoGetDatamsg(FIFO_USER_01, bytes, (u8*)&msg);
switch(msg.type)
{
case FIFO_MSG_PLAYERDATA:
player = (player_t*)msg.arg[0].arg_p;
break;
case FIFO_MSG_LINEDEFDATA:
lines = (line_t*)msg.arg[0].arg_p;
numlines = msg.arg[1].arg_i;
break;
case FIFO_MSG_SSECTDATA:
subsectors = (subsector_t*)msg.arg[0].arg_p;
numsubsectors = msg.arg[1].arg_i;
break;
case FIFO_MSG_VERTEXDATA:
vertexes = (vertex_t*)msg.arg[0].arg_p;
numvertexes = msg.arg[1].arg_i;
break;
case FIFO_MSG_FINESINEDATA:
finesine = (fixed_t*)msg.arg[0].arg_p;
break;
case FIFO_MSG_FINECOSINEDATA:
finecosine = (fixed_t*)msg.arg[0].arg_p;
break;
default:
break;
}
}
void micBufferHandler(int bytes, void* user_data){
FifoMessage msg;
fifoGetDatamsg(FIFO_SOUND, bytes, (u8*)&msg);
if(msg.type == MIC_BUFFER_FULL_MESSAGE) {
if(micCallback) micCallback(msg.MicBufferFull.buffer, msg.MicBufferFull.length);
}
}
//---------------------------------------------------------------------------------
void avrDataHandler(int bytes, void *user_data) {
//---------------------------------------------------------------------------------
AvrFifoMessage msg;
int value;
fifoGetDatamsg(FIFO_AVR, bytes, (u8*)&msg);
if(msg.type == PROFILE_MESSAGE) {
long int i;
for(i=0;i < (50000);i++) {
swiDelay(10000);
}
fifoSendValue32(FIFO_AVR, (u32)1337 );
} else if(msg.type == CONFIG_MESSAGE) {
shortwait = WAIT_1MS * msg.SPIConfig.m1;
speed = msg.SPIConfig.m2;
spi_debug = msg.SPIConfig.debug;
} else if(msg.type == LED_FLASH_MESSAGE) {
send_chars(2, FLASH_LED_COMMAND, msg.LEDFlash.count);
} else if (msg.type == ANALOG_READ_MESSAGE) {
send_chars(2, ANALOG_READ_COMMAND, msg.AnalogRead.pin);
swiDelay(10000);
send_chars(3, NULL_COMMAND, 0, 0);
fifoSendDatamsg(FIFO_AVR, sizeof(incoming), incoming);
//value = incoming[1];
//value |= (incoming[2] << 8);
/*value = read_increment(1);
swiDelay(COMMAND_WAIT);
value |= (read_increment(1) << 8);*/
//fifoSendValue32(FIFO_AVR, (u32)value);
} else if (msg.type == IO_PORT_GET_MESSAGE) {
value = ioport_get(msg.IOPortGetSet.address);
fifoSendValue32(FIFO_AVR, (u32)value);
} else if (msg.type == IO_PORT_SET_MESSAGE) {
ioport_set(msg.IOPortGetSet.address, msg.IOPortGetSet.value);
} else if (msg.type == PWM_MESSAGE) {
if(msg.PWM.command == PWM_ON) {
if(msg.PWM.output == PWM5) {
reg_orequal(TCCR2B, _BV(CS22));
//TCCR2B |= CS22
}
}
}
}
void CommandRecvHandler(int bytes, void *user_data) {
NTXMFifoMessage command;
fifoGetDatamsg(FIFO_NTXM, bytes, (u8*)&command);
switch(command.commandType) {
case PLAY_SAMPLE:
RecvCommandPlaySample(&command.playSample);
break;
case STOP_SAMPLE:
RecvCommandStopSample(&command.stopSample);
break;
case START_RECORDING:
RecvCommandStartRecording(&command.startRecording);
break;
case STOP_RECORDING:
RecvCommandStopRecording();
break;
case SET_SONG:
RecvCommandSetSong(&command.setSong);
break;
case START_PLAY:
RecvCommandStartPlay(&command.startPlay);
break;
case STOP_PLAY:
RecvCommandStopPlay(&command.stopPlay);
break;
case PLAY_INST:
RecvCommandPlayInst(&command.playInst);
break;
case STOP_INST:
RecvCommandStopInst(&command.stopInst);
break;
case MIC_ON:
RecvCommandMicOn();
break;
case MIC_OFF:
RecvCommandMicOff();
break;
case PATTERN_LOOP:
RecvCommandPatternLoop(&command.ptnLoop);
break;
default:
break;
}
}
//---------------------------------------------------------------------------------
void sdmmcMsgHandler(int bytes, void *user_data) {
//---------------------------------------------------------------------------------
FifoMessage msg;
int retval;
fifoGetDatamsg(FIFO_SDMMC, bytes, (u8*)&msg);
switch (msg.type) {
case SDMMC_SD_READ_SECTORS:
sdmmc_sdcard_readsectors(msg.sdParams.startsector, msg.sdParams.numsectors, msg.sdParams.buffer);
break;
case SDMMC_SD_WRITE_SECTORS:
sdmmc_sdcard_writesectors(msg.sdParams.startsector, msg.sdParams.numsectors, msg.sdParams.buffer);
break;
}
}
void fifo_DataHandler(int bytes, void *user_data) {
//---------------------------------------------------------------------------------
fifo_msg msg;
fifoGetDatamsg(FIFO_9to7, bytes, (u8*)&msg);
switch(msg.type) {
case kInit:
{
// *(unsigned int *)malloc = compute_jump((unsigned int)malloc, (unsigned int)new_malloc);
#if 1
quake_ipc_9to7_buf = msg.buf_9to7;
quake_ipc_7to9_buf = msg.buf_7to9;
fifoSendValue32(FIFO_9to7,1);
#else
quake_ipc_9to7->message = 0;
while (quake_ipc_9to7->message == 0);
quake_ipc_9to7_buf = (unsigned char *)quake_ipc_9to7->message;
quake_ipc_9to7->message = 0xffffffff;
while (quake_ipc_9to7->message == 0xffffffff);
quake_ipc_7to9_buf = (unsigned char *)quake_ipc_9to7->message;
ARM7_PRINT("done\n");
// ARM7_PRINTF("7: 9->7 %08x 7->9 %08x\n", quake_ipc_9to7_buf, quake_ipc_7to9_buf);
quake_ipc_9to7->message = 0xffffffff;
#endif
arm7_initialised = 1;
break;
}
default:
handle_ipc(msg.type);
break;
}
}
// fifoSetDatamsgHandler - Set a callback to receive incoming data sequences on a specific channel.
bool fifoSetDatamsgHandler(int channel, FifoDatamsgHandlerFunc newhandler, void * userdata) {
if(channel<0 || channel>=FIFO_NUM_CHANNELS) return false;
int oldIME = enterCriticalSection();
fifo_datamsg_func[channel] = newhandler;
fifo_datamsg_data[channel] = userdata;
if(newhandler) {
while(fifoCheckDatamsg(channel)) {
int block = fifo_data_queue[channel].head;
int n_bytes = FIFO_UNPACK_DATALENGTH(FIFO_BUFFER_DATA(block));
newhandler(n_bytes, userdata);
if (block == fifo_data_queue[channel].head) fifoGetDatamsg(channel,0,0);
}
}
leaveCriticalSection(oldIME);
return true;
}
static void fifoInternalRecvInterrupt() {
REG_IE &= ~IRQ_FIFO_NOT_EMPTY;
REG_IME=1;
u32 data, block=FIFO_BUFFER_TERMINATE;
while( !(REG_IPC_FIFO_CR & IPC_FIFO_RECV_EMPTY) ) {
REG_IME=0;
block=fifo_allocBlock();
if (block != FIFO_BUFFER_TERMINATE ) {
FIFO_BUFFER_DATA(block)=REG_IPC_FIFO_RX;
fifo_queueBlock(&fifo_receive_queue,block,block);
}
REG_IME=1;
}
REG_IME=0;
REG_IE |= IRQ_FIFO_NOT_EMPTY;
if (!processing && fifo_receive_queue.head != FIFO_BUFFER_TERMINATE) {
processing = 1;
REG_IME=1;
do {
block = fifo_receive_queue.head;
data = FIFO_BUFFER_DATA(block);
u32 channel = FIFO_UNPACK_CHANNEL(data);
if ( (data & (FIFO_ADDRESSBIT | FIFO_IMMEDIATEBIT)) == (FIFO_ADDRESSBIT | FIFO_IMMEDIATEBIT) ) {
if ((data & FIFO_ADDRESSDATA_MASK) == 0x4000c ) {
REG_IPC_SYNC = 0x100;
while((REG_IPC_SYNC&0x0f) != 1);
REG_IPC_SYNC = 0;
swiSoftReset();
}
} else if (FIFO_IS_ADDRESS(data)) {
volatile void * address = FIFO_UNPACK_ADDRESS(data);
REG_IME=0;
fifo_receive_queue.head = FIFO_BUFFER_GETNEXT(block);
if (fifo_address_func[channel]) {
fifo_freeBlock(block);
REG_IME=1;
fifo_address_func[channel]( (void*)address, fifo_address_data[channel] );
} else {
FIFO_BUFFER_DATA(block)=(u32)address;
fifo_queueBlock(&fifo_address_queue[channel],block,block);
}
REG_IME=1;
} else if(FIFO_IS_VALUE32(data)) {
u32 value32;
if (FIFO_UNPACK_VALUE32_NEEDEXTRA(data)) {
int next = FIFO_BUFFER_GETNEXT(block);
if (next==FIFO_BUFFER_TERMINATE) break;
fifo_freeBlock(block);
block = next;
value32 = FIFO_BUFFER_DATA(block);
} else {
value32 = FIFO_UNPACK_VALUE32_NOEXTRA(data);
}
REG_IME=0;
fifo_receive_queue.head = FIFO_BUFFER_GETNEXT(block);
if (fifo_value32_func[channel]) {
fifo_freeBlock(block);
REG_IME=1;
fifo_value32_func[channel]( value32, fifo_value32_data[channel] );
} else {
FIFO_BUFFER_DATA(block)=value32;
fifo_queueBlock(&fifo_value32_queue[channel],block,block);
}
REG_IME=1;
} else if(FIFO_IS_DATA(data)) {
int n_bytes = FIFO_UNPACK_DATALENGTH(data);
int n_words = (n_bytes+3)>>2;
int count=0;
int end=block;
while(count<n_words && FIFO_BUFFER_GETNEXT(end)!=FIFO_BUFFER_TERMINATE){
end = FIFO_BUFFER_GETNEXT(end);
count++;
}
if (count!=n_words) break;
REG_IME=0;
fifo_receive_queue.head = FIFO_BUFFER_GETNEXT(end);
int tmp=FIFO_BUFFER_GETNEXT(block);
fifo_freeBlock(block);
FIFO_BUFFER_SETCONTROL(tmp, FIFO_BUFFER_GETNEXT(tmp), FIFO_BUFFERCONTROL_DATASTART, n_bytes);
fifo_queueBlock(&fifo_data_queue[channel],tmp,end);
if(fifo_datamsg_func[channel]) {
block = fifo_data_queue[channel].head;
REG_IME=1;
fifo_datamsg_func[channel](n_bytes, fifo_datamsg_data[channel]);
if (block == fifo_data_queue[channel].head) fifoGetDatamsg(channel,0,0);
}
REG_IME=1;
} else {
fifo_receive_queue.head = FIFO_BUFFER_GETNEXT(block);
fifo_freeBlock(block);
}
} while( fifo_receive_queue.head != FIFO_BUFFER_TERMINATE);
