bsp.c

官方的UCOSii的移植文件

    CPU_CRITICAL_EXIT();

    while ((PLLSTAT & DEF_BIT_25) == 0) {                       /* Wait PLLC, the PLL connect status bit to become set      */
        ;
    }
}


/*
*********************************************************************************************************
*                                       MAM_Init()
*
* Description : Initialize the Memory Acceleration Module.
*
* Argument(s) : none.
*
* Return(s)   : none.
*********************************************************************************************************
*/

static  void  MAM_Init (void)
{
    CPU_INT32U  clk_freq;


    clk_freq = BSP_CPU_ClkFreq();                               /* Get the current core clock frequency                     */

    MAMCR    = 0;                                               /* Disable MAM functionality                                */

    if (clk_freq < 20000000) {                                  /* Compare current clock frequency with MAM modes           */
        MAMTIM = 1;                                             /* Set MAM fetch cycles to 1 processor clock in duration    */
    }

    if (clk_freq < 40000000) {
        MAMTIM = 2;                                             /* Set MAM fetch cycles to 2 processor clock in duration    */
    }

    if (clk_freq >= 40000000) {
        MAMTIM = 3;                                             /* Set MAM fetch cycles to 3 processor clock in duration    */
    }

    MAMCR = 2;                                                  /* Enable full MAM functionality                            */
}


/*
*********************************************************************************************************
*                                          GPIO_Init()
*
* Description : Initializes the GPIO pins.  All the I/O pins are initialized in this function
*               so you don't have to look at multiple places for I/O initialization.
*
* Argument(s) : none.
*
* Return(s)   : none.
*
* Note(s)     : (1) Refer to the LPC2378 User Manual, Chapter 9 for a detailed Pin Assignment
*********************************************************************************************************
*/

static  void  GPIO_Init (void)
{
    CPU_INT32U  value;


    IO0DIR   = 0;
    IO1DIR   = 0;
    FIO0DIR  = 0;
    FIO1DIR  = 0;
    FIO2DIR  = 0;
    FIO3DIR  = 0;
    FIO4DIR  = 0;

    FIO0MASK = 0;
    FIO1MASK = 0;
    FIO2MASK = 0;
    FIO3MASK = 0;
    FIO4MASK = 0;

    PINSEL0  = 0;
    PINSEL1  = 0;
    PINSEL2  = 0;
    PINSEL3  = 0;
    PINSEL4  = 0;
    PINSEL5  = 0;
    PINSEL6  = 0;
    PINSEL7  = 0;
    PINSEL8  = 0;
    PINSEL9  = 0;
    PINSEL10 = 0;

#ifdef DISP_MODULE_PRESENT
    value    =  (3 << 24) | (3 << 26) | (3 << 28);     	        /* Create a mask for the LCD Control function bits          */
    PINSEL3 &=  ~value;                                    	    /* Clear and configure the associated function bits as GPIO */

    value    =  (3 << 16) | (3 << 18) | (3 << 20) | (3 << 22);  /* Create a mask for the LCD Data function bits             */
    PINSEL3 &=  ~value;                                     	/* Clear and configure the associated function bits as GPIO */

    value    =   GPIO1_LCD_DB4 | GPIO1_LCD_DB5 | GPIO1_LCD_DB6 | GPIO1_LCD_DB7 | GPIO1_LCD_RS | GPIO1_LCD_RW | GPIO1_LCD_E;
    IO1DIR  |=   value;                                    	    /* Configure all of the LCD pins as outputs                 */

    DispRW_High();                                           	/* Initialize the state of the LCD RW bit to High           */
#endif

    PINSEL2 &= ~(0xFF <<  0);                                	/* Clear P2[7:0] function bits enabling GPIO for the LEDs   */
    FIO2DIR |=  (0xFF <<  0);                              	    /* Configure P2[7:0] as output bits                         */

    PINSEL2 &= ~(0x03 << 30);                              	    /* Clear P2.10 function bits, enabling GPIO function        */
    FIO2DIR &= ~(0x01 << 10);                                	/* Configure P2.10 as an input bit                          */

    PINSEL10 =   0;                                         	/* Release ETM control of PORT 2 I/O pins                   */

    PINSEL1  = ~(0x03 << 20);                                	/* Select Port 0, pin 26 as GPIO (speaker pin)              */
    IO0CLR   =  (0x01 << 26);                              	    /* Clear pin 26, prevent speaker usage humming              */
}


/*
*********************************************************************************************************
*                                     VIC_Init()
*
* Description : Initialize the Vectored Interrupt Controller
*
* Argument(s) : none.
*
* Return(s)   : none.
*********************************************************************************************************
*/

static  void  VIC_Init (void)
{
    VICIntEnClear =  0xFFFFFFFF;                                /* Disable ALL interrupts                                   */
    VICAddress    =  0;                                         /* Acknowlege any pending VIC interrupt                     */
    VICProtection =  0;                                         /* Allow VIC register access in User of Priviledged modes   */

    VICVectAddr0  = (CPU_INT32U)VIC_DummyWDT;                   /* Set the vector address                                   */
    VICVectAddr1  = (CPU_INT32U)VIC_DummySW;
    VICVectAddr2  = (CPU_INT32U)VIC_DummyDEBUGRX;
    VICVectAddr3  = (CPU_INT32U)VIC_DummyDEBUGTX;
    VICVectAddr4  = (CPU_INT32U)VIC_DummyTIMER0;
    VICVectAddr5  = (CPU_INT32U)VIC_DummyTIMER1;
    VICVectAddr6  = (CPU_INT32U)VIC_DummyUART0;
    VICVectAddr7  = (CPU_INT32U)VIC_DummyUART1;
    VICVectAddr8  = (CPU_INT32U)VIC_DummyPWM01;
    VICVectAddr9  = (CPU_INT32U)VIC_DummyI2C0;
    VICVectAddr10 = (CPU_INT32U)VIC_DummySPI;
    VICVectAddr11 = (CPU_INT32U)VIC_DummySSP1;
    VICVectAddr12 = (CPU_INT32U)VIC_DummyPLL;
    VICVectAddr13 = (CPU_INT32U)VIC_DummyRTC;
    VICVectAddr14 = (CPU_INT32U)VIC_DummyEINT0;
    VICVectAddr15 = (CPU_INT32U)VIC_DummyEINT1;
    VICVectAddr16 = (CPU_INT32U)VIC_DummyEINT2;
    VICVectAddr17 = (CPU_INT32U)VIC_DummyEINT3;
    VICVectAddr18 = (CPU_INT32U)VIC_DummyAD0;
    VICVectAddr19 = (CPU_INT32U)VIC_DummyI2C1;
    VICVectAddr20 = (CPU_INT32U)VIC_DummyBOD;
    VICVectAddr21 = (CPU_INT32U)VIC_DummyETHERNET;
    VICVectAddr22 = (CPU_INT32U)VIC_DummyUSB;
    VICVectAddr23 = (CPU_INT32U)VIC_DummyCAN01;
    VICVectAddr24 = (CPU_INT32U)VIC_DummyMMC;
    VICVectAddr25 = (CPU_INT32U)VIC_DummyGP_DMA;
    VICVectAddr26 = (CPU_INT32U)VIC_DummyTIMER2;
    VICVectAddr27 = (CPU_INT32U)VIC_DummyTIMER3;
    VICVectAddr28 = (CPU_INT32U)VIC_DummyUART2;
    VICVectAddr29 = (CPU_INT32U)VIC_DummyUART3;
    VICVectAddr30 = (CPU_INT32U)VIC_DummyI2C2;
    VICVectAddr31 = (CPU_INT32U)VIC_DummyI2S;
}


/*
*********************************************************************************************************
*********************************************************************************************************
**                                       DUMMY INTERRUPT HANDLERS
*********************************************************************************************************
*********************************************************************************************************
*/

static  void  VIC_Dummy (void)
{
    while (DEF_TRUE) {
        ;
    }
}

static  void  VIC_DummyWDT (void)
{
    VIC_SpuriousInt = VIC_WDT;
    VIC_Dummy();
}

static  void  VIC_DummySW (void)
{
    VIC_SpuriousInt = VIC_SW;
    VIC_Dummy();
}

static  void  VIC_DummyDEBUGRX (void)
{
    VIC_SpuriousInt = VIC_DEBUGRX;
    VIC_Dummy();
}

static  void  VIC_DummyDEBUGTX (void)
{
    VIC_SpuriousInt = VIC_DEBUGTX;
    VIC_Dummy();
}

static  void  VIC_DummyTIMER0 (void)
{
    VIC_SpuriousInt = VIC_TIMER0;
    VIC_Dummy();
}

static  void  VIC_DummyTIMER1 (void)
{
    VIC_SpuriousInt = VIC_TIMER1;
    VIC_Dummy();
}

static  void  VIC_DummyUART0 (void)
{
    VIC_SpuriousInt = VIC_UART0;
    VIC_Dummy();
}

static  void  VIC_DummyUART1 (void)
{
    VIC_SpuriousInt = VIC_UART1;
    VIC_Dummy();
}

static  void  VIC_DummyPWM01 (void)
{
    VIC_SpuriousInt = VIC_PWM01;
    VIC_Dummy();
}

static  void  VIC_DummyI2C0 (void)
{
    VIC_SpuriousInt = VIC_I2C0;
    VIC_Dummy();
}

static  void  VIC_DummySPI (void)
{
    VIC_SpuriousInt = VIC_SPI;
    VIC_Dummy();
}

static  void  VIC_DummySSP1 (void)
{
    VIC_SpuriousInt = VIC_SSP1;
    VIC_Dummy();
}

static  void  VIC_DummyPLL (void)
{
    VIC_SpuriousInt = VIC_PLL;
    VIC_Dummy();
}

static  void  VIC_DummyRTC (void)
{
    VIC_SpuriousInt = VIC_RTC;
    VIC_Dummy();
}

static  void  VIC_DummyEINT0 (void)
{
    VIC_SpuriousInt = VIC_EINT0;
    VIC_Dummy();
}

static  void  VIC_DummyEINT1 (void)
{
    VIC_SpuriousInt = VIC_EINT1;
    VIC_Dummy();
}

static  void  VIC_DummyEINT2 (void)
{
    VIC_SpuriousInt = VIC_EINT2;
    VIC_Dummy();
}

static  void  VIC_DummyEINT3 (void)
{
    VIC_SpuriousInt = VIC_EINT3;
    VIC_Dummy();
}

static  void  VIC_DummyAD0 (void)
{
    VIC_SpuriousInt = VIC_AD0;
    VIC_Dummy();
}

static  void  VIC_DummyI2C1 (void)
{
    VIC_SpuriousInt = VIC_I2C1;
    VIC_Dummy();
}

static  void  VIC_DummyBOD (void)
{
    VIC_SpuriousInt = VIC_BOD;
    VIC_Dummy();
}

static  void  VIC_DummyETHERNET (void)
{
    VIC_SpuriousInt = VIC_ETHERNET;
    VIC_Dummy();
}

static  void  VIC_DummyUSB (void)
{
    VIC_SpuriousInt = VIC_USB;
    VIC_Dummy();
}

static  void  VIC_DummyCAN01 (void)
{
    VIC_SpuriousInt = VIC_CAN12;
    VIC_Dummy();
}

static  void  VIC_DummyMMC (void)
{
    VIC_SpuriousInt = VIC_MMC;
    VIC_Dummy();
}

static  void  VIC_DummyGP_DMA (void)
{
    VIC_SpuriousInt = VIC_GP_DMA;
    VIC_Dummy();
}

static  void  VIC_DummyTIMER2 (void)
{
    VIC_SpuriousInt = VIC_TIMER2;
    VIC_Dummy();
}

static  void  VIC_DummyTIMER3 (void)
{
    VIC_SpuriousInt = VIC_TIMER3;
    VIC_Dummy();
}

static  void  VIC_DummyUART2 (void)
{
    VIC_SpuriousInt = VIC_UART2;
    VIC_Dummy();
}

static  void  VIC_DummyUART3 (void)
{
    VIC_SpuriousInt = VIC_UART3;
    VIC_Dummy();
}

static  void  VIC_DummyI2C2 (void)
{
    VIC_SpuriousInt = VIC_I2C2;
    VIC_Dummy();
}

static  void  VIC_DummyI2S (void)
{
    VIC_SpuriousInt = VIC_I2S;
    VIC_Dummy();
}