void SIO2_TransferInit4 ( void ) {
SetEventFlag ( s_EventFlag, 0x00000100 );
WaitEventFlag ( s_EventFlag, 0x00000200, 0, NULL );
ClearEventFlag ( s_EventFlag, ~0x00000200 );
} /* end SIO2_TransferInit4 */
void SIO2_TransferInit1 ( void ) {
SetEventFlag ( s_EventFlag, 0x00000004 );
WaitEventFlag ( s_EventFlag, 0x00000008, 0, NULL );
ClearEventFlag ( s_EventFlag, ~0x00000008 );
} /* end SIO2_TransferInit1 */
void SIO2_TransferInit3 ( void ) {
SetEventFlag ( s_EventFlag, 0x00000040 );
WaitEventFlag ( s_EventFlag, 0x00000080, 0, NULL );
ClearEventFlag ( s_EventFlag, ~0x00000080 );
} /* end SIO2_TransferInit3 */
/* 48 */
void sio2_mtap_transfer_init()
{
SetEventFlag(event_flag, EF_MTAP_TRANSFER_INIT);
WaitEventFlag(event_flag, EF_MTAP_TRANSFER_READY, 0, NULL);
ClearEventFlag(event_flag, ~EF_MTAP_TRANSFER_READY);
}
void SIO2_TransferInit0 ( void ) {
SetEventFlag ( s_EventFlag, 0x00000001 );
WaitEventFlag ( s_EventFlag, 0x00000002, 0, NULL );
ClearEventFlag ( s_EventFlag, ~0x00000002 );
} /* end SIO2_TransferInit0 */
/* 25 */
int sio2_transfer(sio2_transfer_data_t *td)
{
transfer_data = td;
SetEventFlag(event_flag, EF_TRANSFER_START);
WaitEventFlag(event_flag, EF_TRANSFER_FINISH, 0, NULL);
ClearEventFlag(event_flag, ~EF_TRANSFER_FINISH);
return 1;
}
int SIO2_Transfer ( SIO2_TransferData* apData ) {
s_pTransferData = apData;
SetEventFlag ( s_EventFlag, 0x00000400 );
WaitEventFlag ( s_EventFlag, 0x00000800, 0, NULL );
ClearEventFlag ( s_EventFlag, ~0x00000800 );
return 1;
} /* end SIO2_Transfer */
void UBUFThread(void *arg){
void (*RequestResponseHandler)(unsigned int header, volatile unsigned int *buffer, unsigned int nQuads);
unsigned int data, DataBufferLevel;
u32 ef_bits;
while(1){
WaitEventFlag(IntrEventFlag, iLinkEventBusReset|iLinkEventURx, WEF_OR, &ef_bits);
ClearEventFlag(IntrEventFlag, ~(iLinkEventBusReset|iLinkEventURx));
while((DataBufferLevel=ILINKRegisterBase->ubufReceiveLevel)>0){
data=ILINKRegisterBase->ubufReceive;
iDEBUG_PRINTF("Handling UBUF data... handler: 0x%02lx.\n", (data>>4)&0xF);
RequestResponseHandler=RequestHandlers[(data>>4)&0xF];
RequestResponseHandler(data, (volatile unsigned int *)&ILINKRegisterBase->ubufReceive, DataBufferLevel-1);
}
}
}
static void read_thread(void *arg)
{
USE_SPD_REGS;
volatile iop_dmac_chan_t *dev9_chan = (volatile iop_dmac_chan_t *)DEV9_DMAC_BASE;
struct eng_args *args = (struct eng_args *)arg;
ata_dma_transfer_t *t = &dma_transfer;
u32 res;
while (1) {
while (SleepThread() || WaitSema(args->semid))
;
ClearEventFlag(args->evflg, 0);
dma_setup(0);
EnableIntr(IOP_IRQ_DMA_DEV9);
}
}
static void write_thread(void *arg)
{
USE_SPD_REGS;
volatile iop_dmac_chan_t *dev9_chan = (volatile iop_dmac_chan_t *)DEV9_DMAC_BASE;
struct eng_args *args = (struct eng_args *)arg;
ata_dma_transfer_t *t = &dma_transfer;
u32 res;
while (1) {
while (SleepThread() || WaitSema(args->semid))
;
ClearEventFlag(args->evflg, 0);
dma_setup(1);
EnableIntr(IOP_IRQ_DMA_DEV9);
/* Initiate the DMA transfer. */
dev9_chan->madr = (u32)dma_buffer;
dev9_chan->bcr = ((t->size / 128) << 16) | 32;
dev9_chan->chcr = 0x01000201;
SPD_REG8(0x4e) = t->command; /* ATA command register. */
SPD_REG8(SPD_R_PIO_DIR) = 1;
SPD_REG8(SPD_R_PIO_DATA) = 0;
SPD_REG8(SPD_R_XFR_CTRL) |= 0x80;
WaitEventFlag(args->evflg, (EF_DMA_DONE|EF_ATA_DONE), 0x11, &res);
SPD_REG8(SPD_R_XFR_CTRL) &= 0x7f;
DisableIntr(IOP_IRQ_DMA_DEV9, NULL);
/* If we got the ATA end signal, force stop the transfer. */
if (res & EF_ATA_DONE)
dma_stop(1);
SignalSema(args->semid);
}
}
int NetManSetLinkMode(int mode){
int result, evfid;
WaitSema(NetManIOSemaID);
if(MainNetIF!=NULL){
evfid = MainNetIF->EventFlagID;
ClearEventFlag(evfid, ~NETMAN_NETIF_EVF_DOWN);
result = MainNetIF->ioctl(NETMAN_NETIF_IOCTL_ETH_SET_LINK_MODE, &mode, sizeof(mode), NULL, 0);
}
else{
evfid = -1;
result = -1;
}
SignalSema(NetManIOSemaID);
if(result == 0 && evfid >= 0)
WaitEventFlag(evfid, NETMAN_NETIF_EVF_DOWN, WEF_OR, NULL); //Wait for the IF to go down.
return result;
}
void NetManToggleNetIFLinkState(int NetIFID, unsigned char state){
struct NetManNetIF *pNetIF;
WaitSema(NetManIOSemaID);
if((NetIFID&0xFF)<NETMAN_MAX_NETIF_COUNT && NetIFID==NetIFs[NetIFID&0xFF].id && (NetIFs[NetIFID&0xFF].flags&NETMAN_NETIF_IN_USE)){
pNetIF = &NetIFs[NetIFID&0xFF];
ClearEventFlag(pNetIF->EventFlagID, ~(NETMAN_NETIF_EVF_UP|NETMAN_NETIF_EVF_DOWN));
if(state){
pNetIF->flags|=NETMAN_NETIF_LINK_UP;
SetEventFlag(pNetIF->EventFlagID, NETMAN_NETIF_EVF_UP);
}
else{
pNetIF->flags&=~NETMAN_NETIF_LINK_UP;
SetEventFlag(pNetIF->EventFlagID, NETMAN_NETIF_EVF_DOWN);
}
UpdateNetIFStatus();
}
SignalSema(NetManIOSemaID);
}
static void _MainThread ( void* apParam ) {
u32 lBits[ 4 ];
u32 lEventFlag;
while ( 1 ) {
WaitEventFlag ( s_EventFlag, 0x00000155, 1, lBits );
if ( lBits[ 0 ] & 0x00000001 ) { /* SIO2_TransferInit0 */
ClearEventFlag ( s_EventFlag, ~0x00000001 );
lEventFlag = 0x00000002;
} else if ( lBits[ 0 ] & 0x00000004 ) { /* SIO2_TransferInit1 */
ClearEventFlag ( s_EventFlag, ~0x00000004 );
lEventFlag = 0x00000008;
} else if ( lBits[ 0 ] & 0x00000010 ) { /* SIO2_TransferInit2 */
ClearEventFlag ( s_EventFlag, ~0x00000010 );
lEventFlag = 0x00000020;
} else if ( lBits[ 0 ] & 0x00000040 ) { /* SIO2_TransferInit3 */
ClearEventFlag ( s_EventFlag, ~0x00000040 );
lEventFlag = 0x00000080;
} else if ( lBits[ 0 ] & 0x00000100 ) { /* SIO2_TransferInit4 */
ClearEventFlag ( s_EventFlag, ~0x00000100 );
lEventFlag = 0x00000200;
} else break;
loop:
SetEventFlag ( s_EventFlag, lEventFlag );
WaitEventFlag ( s_EventFlag, 0x00001400, 1, lBits ); /* SIO2_Transfer or SIO2_TransferReset */
if ( lBits[ 0 ] & 0x00001000 ) { /* SIO2_TransferReset */
ClearEventFlag ( s_EventFlag, ~0x00001000 );
continue;
} /* end if */
ClearEventFlag ( s_EventFlag, ~0x00000400 ); /* SIO2_Transfer */
SIO2_SwitchCtrlC ();
_Send ( s_pTransferData );
SIO2_SwitchCtrl1 ();
WaitEventFlag ( s_EventFlag, 0x00002000, 0, NULL );
ClearEventFlag ( s_EventFlag, ~0x00002000 );
_Recv ( s_pTransferData );
lEventFlag = 0x00000800;
goto loop;
} /* end while */
} /* end _MainThread */
void main_thread(void *unused)
{
u32 resbits[4];
while (1) {
#ifndef XSIO2MAN
log_flush(0);
#endif
WaitEventFlag(event_flag, EF_PAD_TRANSFER_INIT |
EF_MC_TRANSFER_INIT | EF_MTAP_TRANSFER_INIT,
1, resbits);
if (resbits[0] & EF_PAD_TRANSFER_INIT) {
ClearEventFlag(event_flag, ~EF_PAD_TRANSFER_INIT);
SetEventFlag(event_flag, EF_PAD_TRANSFER_READY);
#ifndef XSIO2MAN
log_default(LOG_PAD_READY);
#endif
} else if (resbits[0] & EF_MC_TRANSFER_INIT) {
ClearEventFlag(event_flag, ~EF_MC_TRANSFER_INIT);
SetEventFlag(event_flag, EF_MC_TRANSFER_READY);
#ifndef XSIO2MAN
log_default(LOG_MC_READY);
#endif
} else if (resbits[0] & EF_MTAP_TRANSFER_INIT) {
ClearEventFlag(event_flag, ~EF_MTAP_TRANSFER_INIT);
SetEventFlag(event_flag, EF_MTAP_TRANSFER_READY);
#ifndef XSIO2MAN
log_default(LOG_MTAP_READY);
#endif
} else {
EPRINTF("Unknown event %08lx. Exiting.\n", resbits[0]);
return;
}
transfer_loop:
WaitEventFlag(event_flag, EF_TRANSFER_START | EF_TRANSFER_RESET, 1, resbits);
if (resbits[0] & EF_TRANSFER_RESET) {
ClearEventFlag(event_flag, ~EF_TRANSFER_RESET);
#ifndef XSIO2MAN
log_default(LOG_RESET);
#endif
continue;
}
ClearEventFlag(event_flag, ~EF_TRANSFER_START);
sio2_ctrl_set(sio2_ctrl_get() | 0xc);
send_td(transfer_data);
sio2_ctrl_set(sio2_ctrl_get() | 1);
WaitEventFlag(event_flag, EF_SIO2_INTR_COMPLETE, 0, NULL);
ClearEventFlag(event_flag, ~EF_SIO2_INTR_COMPLETE);
recv_td(transfer_data);
SetEventFlag(event_flag, EF_TRANSFER_FINISH);
/* Bah... this is needed to get the initial dump from XMCMAN,
but it will kill the IOP when XPADMAN is spamming...
TODO
I guess the correct solution is to do all logging in a
dedicated thread. */
// log_flush(1);
goto transfer_loop;
}
}
