innovator_misc.c

eCos操作系统源码

    // This should be protected by some sort of #ifdef to test to see if
    // the ethernet has been enabled or not.  I'll add that later.
    HAL_READ_UINT8(0x0800000B, tmp);
    HAL_WRITE_UINT8(0x0800000B, tmp & ~1);
    HAL_DELAY_US(750);

}

// -------------------------------------------------------------------------
void
hal_clock_initialize(cyg_uint32 period)
{
#ifdef LATER
    cyg_uint32 cr;

    HAL_WRITE_UINT32(INNOVATOR_TIMER0_CR, 0);
    HAL_WRITE_UINT32(INNOVATOR_TIMER0_PRE, CYGNUM_HAL_ARM_INNOVATOR_TIMER_PRESCALE - 1);
    HAL_WRITE_UINT32(INNOVATOR_TIMER0_LIMIT, period);
    cr = INNOVATOR_TIMER_CR_MODE_HEARBEAT | INNOVATOR_TIMER_CR_IE;
    HAL_WRITE_UINT32(INNOVATOR_TIMER0_CR, cr);
    HAL_WRITE_UINT32(INNOVATOR_TIMER0_CR, cr | INNOVATOR_TIMER_CR_S);

    // Unmask timer 0 interrupt
    HAL_INTERRUPT_CONFIGURE( CYGNUM_HAL_INTERRUPT_RTC, 1, 1 );
    HAL_INTERRUPT_UNMASK( CYGNUM_HAL_INTERRUPT_RTC );
#endif
}

// This routine is called during a clock interrupt.
void
hal_clock_reset(cyg_uint32 vector, cyg_uint32 period)
{
#ifdef LATER
    cyg_uint32 cr;

    // Clear pending interrupt bit
    HAL_READ_UINT32(INNOVATOR_TIMER0_CR, cr);
    cr |= INNOVATOR_TIMER_CR_CI;
    HAL_WRITE_UINT32(INNOVATOR_TIMER0_CR, cr);
#endif
}

// Read the current value of the clock, returning the number of hardware
// "ticks" that have occurred (i.e. how far away the current value is from
// the start)

void
hal_clock_read(cyg_uint32 *pvalue)
{
#ifdef LATER
    cyg_uint32 ctr;

    HAL_READ_UINT32(INNOVATOR_TIMER0_READ, ctr);
    *pvalue = ctr;
#endif
}

//
// Delay for some number of micro-seconds
//
void
hal_delay_us(cyg_int32 usecs)
{
#ifdef LATER
    // Use timer 2 
    cyg_uint32 cr;
    // Divide by 1000000 in two steps to preserve precision.
    cyg_uint32 wait_clocks = ((CYGNUM_HAL_ARM_INNOVATOR_PERIPHERAL_CLOCK/100000)*usecs)/10;

    HAL_WRITE_UINT32(INNOVATOR_TIMER1_CR, 0);
    HAL_WRITE_UINT32(INNOVATOR_TIMER1_PRE, 0);
    HAL_WRITE_UINT32(INNOVATOR_TIMER1_LIMIT, wait_clocks);
    cr = INNOVATOR_TIMER_CR_MODE_ONE_SHOT|INNOVATOR_TIMER_CR_CI;
    HAL_WRITE_UINT32(INNOVATOR_TIMER1_CR, cr);
    HAL_WRITE_UINT32(INNOVATOR_TIMER1_CR, cr | INNOVATOR_TIMER_CR_S);

    // wait for start bit to clear
    do {
        HAL_READ_UINT32(INNOVATOR_TIMER1_CR, cr);
    } while ((INNOVATOR_TIMER_CR_S & cr) != 0);

    //clear interrupt flag
    HAL_WRITE_UINT32(INNOVATOR_TIMER1_CR, 0);
#else
#if 0
    volatile unsigned long long x;
    volatile unsigned long long loop_count = usecs / 10 + 1;

    for (x = 0; x < loop_count; x++) ;
#else
    volatile cyg_uint32 *CNTL_TIMER = (volatile cyg_uint32 *)(0xFFFEC500 + 0x00);
    volatile cyg_uint32 *LOAD_TIM   = (volatile cyg_uint32 *)(0xFFFEC500 + 0x04);
    volatile cyg_uint32 *READ_TIM   = (volatile cyg_uint32 *)(0xFFFEC500 + 0x08);
    cyg_uint32 timer_val, prev_val;
    int too_long = 0;

    if (usecs <= 0) {
      return;
    } else if (usecs > 357913941) {
      /* Clamp at MAX_INT32 / 6 */
      usecs = 357913941;
    }
    /* Enable the clock and halt the timer */
    HAL_WRITE_UINT32(CNTL_TIMER, 0x00000020);

    /* Load the timer */
    HAL_WRITE_UINT32(LOAD_TIM, 6 * usecs);

    /* Start the timer */
    HAL_READ_UINT32(READ_TIM, prev_val);
    HAL_WRITE_UINT32(CNTL_TIMER, 0x00000021);

    /* Wait for it to load (but not too long) */
    do {
      HAL_READ_UINT32(READ_TIM, timer_val);
      if (++too_long >= 100) {
        break;
      }
    } while (timer_val == prev_val);

    /* Wait for it to count down to zero */
    do {
      HAL_READ_UINT32(READ_TIM, timer_val);
    } while (timer_val > 0);
#endif
#endif
}

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

// This routine is called to respond to a hardware interrupt (IRQ).  It
// should interrogate the hardware and return the IRQ vector number.
int
hal_IRQ_handler(void)
{
#ifdef LATER
    int vec;
    cyg_uint32 isr;

    HAL_READ_UINT32(INNOVATOR_INT_REQUEST_STATUS, isr);
    for (vec = CYGNUM_HAL_INTERRUPT_PLD_0;
         vec <= CYGNUM_HAL_INTERRUPT_FAST_COMMS; vec++) {
        if (isr & (1<<vec)) {
            return vec;
        }
    }
#endif
    return CYGNUM_HAL_INTERRUPT_NONE;
}

//----------------------------------------------------------------------------
// Interrupt control
//
void
hal_interrupt_mask(int vector)
{
#ifdef LATER
    CYG_ASSERT(vector <= CYGNUM_HAL_ISR_MAX &&
               vector >= CYGNUM_HAL_ISR_MIN , "Invalid vector");

    HAL_WRITE_UINT32(INNOVATOR_INT_MASK_CLEAR, 1<<vector);
#endif
}

void
hal_interrupt_unmask(int vector)
{
#ifdef LATER
    CYG_ASSERT(vector <= CYGNUM_HAL_ISR_MAX &&
               vector >= CYGNUM_HAL_ISR_MIN , "Invalid vector");

    HAL_WRITE_UINT32(INNOVATOR_INT_MASK_SET, 1<<vector);
#endif
}

void
hal_interrupt_acknowledge(int vector)
{
#ifdef LATER
    CYG_ASSERT(vector <= CYGNUM_HAL_ISR_MAX &&
               vector >= CYGNUM_HAL_ISR_MIN , "Invalid vector");
#endif

}

void
hal_interrupt_configure(int vector, int level, int up)
{
#ifdef LATER
    CYG_ASSERT(vector <= CYGNUM_HAL_ISR_MAX &&
               vector >= CYGNUM_HAL_ISR_MIN, "Invalid vector");
    CYG_ASSERT(level || up, "Cannot do falling edge");
#endif
}

void
hal_interrupt_set_level(int vector, int level)
{
#ifdef LATER
    cyg_uint32 reg;
    CYG_ASSERT(vector <= CYGNUM_HAL_ISR_MAX &&
               vector >= CYGNUM_HAL_ISR_MIN, "Invalid vector");
    CYG_ASSERT(level <= 63 && level >= 0, "Invalid level");

    HAL_READ_UINT32(INNOVATOR_INT_PRIORITY_0+4*vector, reg);
    reg &= ~INNOVATOR_INT_PRIORITY_LVL_mask;
    reg |= (level & INNOVATOR_INT_PRIORITY_LVL_mask);
    HAL_WRITE_UINT32(INNOVATOR_INT_PRIORITY_0+4*vector, reg);
#endif
}

#include CYGHWR_MEMORY_LAYOUT_H
typedef void code_fun(void);
void innovator_program_new_stack(void *func)
{
    register CYG_ADDRESS stack_ptr asm("sp");
    register CYG_ADDRESS old_stack asm("r4");
    register code_fun *new_func asm("r0");
    old_stack = stack_ptr;
    stack_ptr = CYGMEM_REGION_ram + CYGMEM_REGION_ram_SIZE - sizeof(CYG_ADDRESS);
    new_func = (code_fun*)func;
    new_func();
    stack_ptr = old_stack;
    return;
}