intr.c

WinCE5.0BSP for Renesas SH7770

    HookInterrupt((0x6C0 - 0x200) / 0x20, HSSI_ISR0);	// HSSI ch1 (11.025KHz:IN)
    IntrPrio[(0x6C0 - 0x200) / 0x20] = 14;

    HookInterrupt((0x6E0 - 0x200) / 0x20, HSSI_ISR0);	// HSSI ch2 (44.1KHz:OUT)
    IntrPrio[(0x6E0 - 0x200) / 0x20] = 14;

    HookInterrupt((0x700 - 0x200) / 0x20, HSSI_ISR0);	// HSSI ch3 (44.1KHz:OUT)
    IntrPrio[(0x700 - 0x200) / 0x20] = 14;

    HookInterrupt((0x720 - 0x200) / 0x20, SRC_ISR0);	// SRC ch0
    IntrPrio[(0x720 - 0x200) / 0x20] = 14;

    HookInterrupt((0x780 - 0x200) / 0x20, DU_ISR);	// DU
    IntrPrio[(0x780 - 0x200) / 0x20] = 4;

    HookInterrupt((0x7A0 - 0x200) / 0x20, VIN_ISR);	// VIN
    IntrPrio[(0x7A0 - 0x200) / 0x20] = 4;

    HookInterrupt((0x7C0 - 0x200) / 0x20, IR_ISR0);	// Remocon
    IntrPrio[(0x7C0 - 0x200) / 0x20] = 11;

    HookInterrupt((0x840 - 0x200) / 0x20, USB_ISR);	// USB Host/Func
    IntrPrio[(0x840 - 0x200) / 0x20] = 8;

    HookInterrupt((0x860 - 0x200) / 0x20, ATAPI_ISR);	// ATAPI
    IntrPrio[(0x860 - 0x200) / 0x20] = 9;

    HookInterrupt((0x8C0 - 0x200) / 0x20, _2D_ISR);	// 2D
    IntrPrio[(0x8C0 - 0x200) / 0x20] = 4;

    HookInterrupt((0x900 - 0x200) / 0x20, _3D_ISR);	// 3D (MBX)
    IntrPrio[(0x900 - 0x200) / 0x20] = 4;

    HookInterrupt((0x920 - 0x200) / 0x20, _3D_DMAC_ISR);	// 3D (DMAC)
    IntrPrio[(0x920 - 0x200) / 0x20] = 4;

    HookInterrupt((0x9A0 - 0x200) / 0x20, SCIF_ISR0);	// SCIF0
    IntrPrio[(0x9A0 - 0x200) / 0x20] = 11;

    HookInterrupt((0xA00 - 0x200) / 0x20, IR_ISR0);	// SCIF3
    IntrPrio[(0xA00 - 0x200) / 0x20] = 11;

    HookInterrupt((0xB00 - 0x200) / 0x20, ADC_ISR1);	// ADC (ADCIF)
    IntrPrio[(0xB00 - 0x200) / 0x20] = 3;

    HookInterrupt((0xB20 - 0x200) / 0x20, ADC_ISR2);	// ADC (ADC)
    IntrPrio[(0xB20 - 0x200) / 0x20] = 3;

    HookInterrupt((0xBA0 - 0x200) / 0x20, HAC_ISR1);	// Busbridge DMAC ch0
    IntrPrio[(0xBA0 - 0x200) / 0x20] = 14;

    HookInterrupt((0xBC0 - 0x200) / 0x20, HAC_ISR2);	// Busbridge DMAC ch1
    IntrPrio[(0xBC0 - 0x200) / 0x20] = 14;

    HookInterrupt((0xBE0 - 0x200) / 0x20, HSPDIF_ISR1);	// Busbridge DMAC ch2
    IntrPrio[(0xBE0 - 0x200) / 0x20] = 14;

    HookInterrupt((0xC00 - 0x200) / 0x20, HSPDIF_ISR2);	// Busbridge DMAC ch3
    IntrPrio[(0xC00 - 0x200) / 0x20] = 14;

    HookInterrupt((0xC20 - 0x200) / 0x20, HSSI_ISR1);	// Busbridge DMAC ch4
    IntrPrio[(0xC20 - 0x200) / 0x20] = 14;

    HookInterrupt((0xC40 - 0x200) / 0x20, HSSI_ISR2);	// Busbridge DMAC ch5
    IntrPrio[(0xC40 - 0x200) / 0x20] = 14;

    HookInterrupt((0xC60 - 0x200) / 0x20, HSSI_ISR3);	// Busbridge DMAC ch6
    IntrPrio[(0xC60 - 0x200) / 0x20] = 14;

    HookInterrupt((0xC80 - 0x200) / 0x20, HSSI_ISR4);	// Busbridge DMAC ch7
    IntrPrio[(0xC80 - 0x200) / 0x20] = 14;

    HookInterrupt((0xCA0 - 0x200) / 0x20, SRC_ISR1);	// Busbridge DMAC ch8
    IntrPrio[(0xCA0 - 0x200) / 0x20] = 14;

    HookInterrupt((0xCC0 - 0x200) / 0x20, SRC_ISR2);	// Busbridge DMAC ch9
    IntrPrio[(0xCC0 - 0x200) / 0x20] = 14;

    HookInterrupt((0xD00 - 0x200) / 0x20, SCIF_ISR1);	// Busbridge DMAC ch11
    IntrPrio[(0xD00 - 0x200) / 0x20] = 11;

    HookInterrupt((0xD20 - 0x200) / 0x20, SCIF_ISR2);	// Busbridge DMAC ch12
    IntrPrio[(0xD20 - 0x200) / 0x20] = 11;

    HookInterrupt((0xD80 - 0x200) / 0x20, IR_ISR1);	// Busbridge DMAC ch15
    IntrPrio[(0xD80 - 0x200) / 0x20] = 11;

    HookInterrupt((0xDA0 - 0x200) / 0x20, IR_ISR2);	// Busbridge DMAC ch16
    IntrPrio[(0xDA0 - 0x200) / 0x20] = 11;

#ifdef DEBUG
	lpWriteDebugStringFunc(TEXT("HookInterrupt Done.\r\n"));
#endif

#ifdef OAL_BSP_CALLBACKS
    // Give BSP change to initialize subordinate controller
    rc = BSPIntrInit();
#else
    rc = TRUE;
#endif

    OALMSG(OAL_INTR&&OAL_FUNC, (L"-OALInterruptInit(rc = %d)\r\n", rc));
    return rc;
}


//------------------------------------------------------------------------------
//
//  Function:  OALIntrRequestIrqs
//
//  This function returns IRQs for CPU/SoC devices based on their
//  physical address.
//
BOOL OALIntrRequestIrqs(DEVICE_LOCATION *pDevLoc, UINT32 *pCount, UINT32 *pIrqs)
{
    BOOL rc = FALSE;

    OALMSG(OAL_INTR&&OAL_FUNC, (
        L"+OALIntrRequestIrqs(0x%08x->%d/%d/0x%08x/%d, 0x%08x, 0x%08x)\r\n",
        pDevLoc, pDevLoc->IfcType, pDevLoc->BusNumber, pDevLoc->LogicalLoc,
        pDevLoc->Pin, pCount, pIrqs
    ));
    // This shouldn't happen
    if (*pCount < 1) goto cleanUp;

#ifdef OAL_BSP_CALLBACKS
    rc = BSPIntrRequestIrqs(pDevLoc, pCount, pIrqs);
#endif    

cleanUp:        
    OALMSG(OAL_INTR&&OAL_FUNC, (L"-OALIntrRequestIrqs(rc = %d)\r\n", rc));
    return rc;
}


//------------------------------------------------------------------------------
//
//  Function:  OALIntrEnableIrqs
//
BOOL OALIntrEnableIrqs(UINT32 count, const UINT32 *pIrqs)
{
    BOOL rc = TRUE;
    UINT32 i,irq;

    OALMSG(OAL_INTR&&OAL_FUNC, (
        L"+OALIntrEnableIrqs(%d, 0x%08x)\r\n", count, pIrqs
    ));

    for (i = 0; i < count; i++) {
#ifndef OAL_BSP_CALLBACKS
        irq = pIrqs[i];
#else
        // Give BSP chance to enable irq on subordinate interrupt controller
        irq = BSPIntrEnableIrq(pIrqs[i]);
#endif
        if (irq == OAL_INTR_IRQ_UNDEFINED) continue;
    }        
    OALMSG(OAL_INTR&&OAL_FUNC, (L"-OALIntrEnableIrqs(rc = %d)\r\n", rc));
    return rc;    
}


//------------------------------------------------------------------------------
//
//  Function:  OALIntrDisableIrqs
//
VOID OALIntrDisableIrqs(UINT32 count, const UINT32 *pIrqs)
{
    UINT32 i,irq;


    OALMSG(OAL_INTR&&OAL_FUNC, (
        L"+OALIntrDisableIrqs(%d, 0x%08x)\r\n", count, pIrqs
    ));

    for (i = 0; i < count; i++) {
#ifndef OAL_BSP_CALLBACKS
        irq = pIrqs[i];
#else
        // Give BSP chance to disable irq on subordinate interrupt controller
        irq = BSPIntrDisableIrq(pIrqs[i]);
        if (irq == OAL_INTR_IRQ_UNDEFINED) continue;
#endif
    }

    OALMSG(OAL_INTR&&OAL_FUNC, (L"-OALIntrDisableIrqs\r\n"));
}


//------------------------------------------------------------------------------
//
//  Function:  OALIntrDoneIrqs
//
VOID OALIntrDoneIrqs(UINT32 count, const UINT32 *pIrqs)
{
    UINT32 i,irq;

    OALMSG(OAL_INTR&&OAL_VERBOSE, (
        L"+OALIntrDoneIrqs(%d, 0x%08x)\r\n", count, pIrqs
    ));
    for (i = 0; i < count; i++) {
#ifndef OAL_BSP_CALLBACKS
        irq = pIrqs[i];
#else
        // Give BSP chance to finish irq on subordinate interrupt controller
        irq = BSPIntrDoneIrq(pIrqs[i]);
#endif    
    }

    OALMSG(OAL_INTR&&OAL_VERBOSE, (L"-OALIntrDoneIrqs\r\n"));
}

//------------------------------------------------------------------------------