libs/rt-thread
libs/rt-thread
4
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

modify format

Browse Source 
git-svn-id: https://rt-thread.googlecode.com/svn/trunk@1844 bbd45198-f89e-11dd-88c7-29a3b14d5316
This commit is contained in:
nongli1031@gmail.com 2011-12-18 05:13:10 +00:00
parent 08f25161d9
commit ae73bd59bc
9 changed files with 514 additions and 536 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
bsp/microblaze/board.c
View File

@ -11,7 +11,7 @@
* Date Author Notes
* 2006-08-23 Bernard first implementation
*
* 2011-12-17 nl1031 for MacroBlaze
* 2011-12-17 nl1031 for MicroBlaze
*
*/
@ -49,8 +49,6 @@ XUartLite uart_lite; /* Instance of the UartLite device */
XIntc int_ctl; /* The instance of the Interrupt Controller */
static rt_uint32_t led_data;
static void rt_hw_board_led_init(void);
/**
@ -98,19 +96,17 @@ void rt_hw_board_led_off(rt_uint32_t led)
XGpio_DiscreteWrite(&gpio_output, 1, led_data);
}
void rt_hw_led_flash(void)
{
rt_uint32_t i;
rt_hw_board_led_off(1);
for (i = 0; i < 20000; i ++);
for (i = 0; i < 20000; i++) ;
rt_hw_board_led_on(1);
for (i = 0; i < 20000; i ++);
for (i = 0; i < 20000; i++) ;
}
#ifdef RT_USING_CONSOLE
/*
@ -151,7 +147,6 @@ static void rt_hw_console_init()
}
#endif
void rt_hw_timer_handler(void)
{
rt_uint32_t csr;
@ -162,26 +157,26 @@ void rt_hw_timer_handler(void)
if (csr & XTC_CSR_INT_OCCURED_MASK)
{
rt_tick_increase();
XTmrCtr_WriteReg(timer.BaseAddress, TIMER_CNTR_0, XTC_TCSR_OFFSET, csr | XTC_CSR_INT_OCCURED_MASK);
}
}
/*
*********************************************************************************************************
* rt_intc_init()
*
* Description: This function intializes the interrupt controller by registering the appropriate handler
* functions and enabling interrupts.
*
* Arguments : None
*
* Returns : None
*********************************************************************************************************
*/
*********************************************************************************************************
* rt_intc_init()
*
* Description: This function intializes the interrupt controller by registering the appropriate handler
* functions and enabling interrupts.
*
* Arguments : None
*
* Returns : None
*********************************************************************************************************
*/
void rt_intc_init (void)
void rt_intc_init(void)
{
XStatus status;
@ -190,27 +185,27 @@ void rt_intc_init (void)
status = XIntc_Initialize(&int_ctl, XPAR_INTC_0_DEVICE_ID);
/* install interrupt handler */
rt_hw_interrupt_install(XPAR_INTC_0_TMRCTR_0_VEC_ID, (rt_isr_handler_t)rt_hw_timer_handler, RT_NULL);
rt_hw_interrupt_install(XPAR_INTC_0_TMRCTR_0_VEC_ID, (rt_isr_handler_t) rt_hw_timer_handler, RT_NULL);
rt_hw_interrupt_umask(XPAR_INTC_0_TMRCTR_0_VEC_ID);
XIntc_Start(&int_ctl, XIN_REAL_MODE);
}
void rt_tmr_init (void)
void rt_tmr_init(void)
{
rt_uint32_t ctl;
XStatus status;
status = XTmrCtr_Initialize(&timer,XPAR_AXI_TIMER_0_DEVICE_ID);
status = XTmrCtr_Initialize(&timer, XPAR_AXI_TIMER_0_DEVICE_ID);
XTmrCtr_WriteReg(timer.BaseAddress, TIMER_CNTR_0, XTC_TLR_OFFSET, PIV);
ctl = XTC_CSR_ENABLE_TMR_MASK | XTC_CSR_ENABLE_INT_MASK | XTC_CSR_AUTO_RELOAD_MASK | XTC_CSR_DOWN_COUNT_MASK;
XTmrCtr_WriteReg(timer.BaseAddress, TIMER_CNTR_0, XTC_TCSR_OFFSET, ctl);
}
/**
* This function will initial SPARTAN 6 LX9 board.
*/
@ -228,5 +223,4 @@ void rt_hw_board_init()
/* timer init */
rt_tmr_init();
}

1
bsp/microblaze/board.h
View File

@ -13,7 +13,6 @@
#define __BOARD_H__
#define MCK 50000000
void rt_hw_board_led_on(rt_uint32_t);
void rt_hw_board_led_off(rt_uint32_t);

2
bsp/microblaze/rtconfig.h
View File

@ -16,7 +16,6 @@
/* Tick per Second*/
#define RT_TICK_PER_SECOND 100
/* SECTION: RT_DEBUG */
/* Thread Debug*/
/* #define RT_THREAD_DEBUG */
@ -89,7 +88,6 @@
#define FINSH_THREAD_STACK_SIZE 8192
#define RT_USING_TC
/* SECTION: a runtime libc library */
/* a runtime libc library*/
/* #define RT_USING_NEWLIB */

12
bsp/microblaze/startup.c
View File

@ -16,7 +16,6 @@
#include <rthw.h>
#include <rtthread.h>
//#include <AT91SAM7S.h>
#include "board.h"
#ifdef RT_USING_FINSH
@ -26,7 +25,6 @@ extern void finsh_system_init(void);
extern void rt_hw_led_flash(void);
/*@{*/
#ifdef __CC_ARM
extern int Image$$RW_IRAM1$$ZI$$Limit;
@ -71,7 +69,7 @@ void rtthread_startup(void)
#elif __ICCARM__
rt_system_heap_init(__segment_end("HEAP"), (void*)0x204000);
#else
rt_system_heap_init((void*)&__bss_end, (void*)(&__bss_end+0x4000));
rt_system_heap_init((void*) &__bss_end, (void*) (&__bss_end + 0x4000));
#endif
#endif
@ -83,12 +81,12 @@ void rtthread_startup(void)
rt_thread_idle_sethook(rt_hw_led_flash);
#endif
//#ifdef RT_USING_DEVICE
#ifdef RT_USING_DEVICE
/* init hardware serial device */
rt_hw_serial_init();
/* init all device */
rt_device_init_all();
//#endif
#endif
/* init application */
rt_application_init();
@ -106,10 +104,10 @@ void rtthread_startup(void)
rt_system_scheduler_start();
/* never reach here */
return ;
return;
}
int main (void)
int main(void)
{
/* invoke rtthread_startup */
rtthread_startup();

2
libcpu/xilinx/microblaze/context_gcc.S
View File

@ -13,7 +13,7 @@
*
*/
#include "microbalze.inc"
#include "microblaze.inc"
.text
.globl rt_interrupt_enter

72
libcpu/xilinx/microblaze/serial.c
View File

@ -58,7 +58,7 @@ static void rt_hw_serial_isr(void)
RT_ASSERT(serial != RT_NULL);
/* get generic device object */
device = (rt_device_t)serial;
device = (rt_device_t) serial;
/* disable interrupt */
level = rt_hw_interrupt_disable();
@ -71,14 +71,14 @@ static void rt_hw_serial_isr(void)
serial->rx_buffer[serial->save_index] = serial->hw_base->Rx_FIFO;
/* move to next position */
serial->save_index ++;
serial->save_index++;
if (serial->save_index >= RT_UART_RX_BUFFER_SIZE)
serial->save_index = 0;
/* if the next position is read index, discard this 'read char' */
if (serial->save_index == serial->read_index)
{
serial->read_index ++;
serial->read_index++;
if (serial->read_index >= RT_UART_RX_BUFFER_SIZE)
serial->read_index = 0;
}
@ -93,7 +93,7 @@ static void rt_hw_serial_isr(void)
}
static rt_err_t rt_serial_init (rt_device_t dev)
static rt_err_t rt_serial_init(rt_device_t dev)
{
struct rt_mb_uart_lite* serial = (struct rt_mb_uart_lite*) dev;
@ -101,9 +101,6 @@ static rt_err_t rt_serial_init (rt_device_t dev)
RT_ASSERT(serial->peripheral_id != XPAR_INTC_0_UARTLITE_1_VEC_ID);
// serial->hw_base->CTRL_REG = XUL_CR_FIFO_RX_RESET | /* Reset Receiver */
// XUL_CR_FIFO_TX_RESET; /* Reset Transmitter */
/* reset rx index */
serial->save_index = 0;
serial->read_index = 0;
@ -116,7 +113,7 @@ static rt_err_t rt_serial_init (rt_device_t dev)
static rt_err_t rt_serial_open(rt_device_t dev, rt_uint16_t oflag)
{
struct rt_mb_uart_lite *serial = (struct rt_mb_uart_lite*)dev;
struct rt_mb_uart_lite *serial = (struct rt_mb_uart_lite*) dev;
RT_ASSERT(serial != RT_NULL);
if (dev->flag & RT_DEVICE_FLAG_INT_RX)
@ -125,7 +122,7 @@ static rt_err_t rt_serial_open(rt_device_t dev, rt_uint16_t oflag)
serial->hw_base->CTRL_REG = XUL_CR_ENABLE_INTR; /* enable interrupt */
/* install UART handler */
rt_hw_interrupt_install(serial->peripheral_id, (rt_isr_handler_t)rt_hw_serial_isr, RT_NULL);
rt_hw_interrupt_install(serial->peripheral_id, (rt_isr_handler_t) rt_hw_serial_isr, RT_NULL);
rt_hw_interrupt_umask(serial->peripheral_id);
}
@ -134,7 +131,7 @@ static rt_err_t rt_serial_open(rt_device_t dev, rt_uint16_t oflag)
static rt_err_t rt_serial_close(rt_device_t dev)
{
struct rt_mb_uart_lite *serial = (struct rt_mb_uart_lite*)dev;
struct rt_mb_uart_lite *serial = (struct rt_mb_uart_lite*) dev;
RT_ASSERT(serial != RT_NULL);
if (dev->flag & RT_DEVICE_FLAG_INT_RX)
@ -146,10 +143,10 @@ static rt_err_t rt_serial_close(rt_device_t dev)
return RT_EOK;
}
static rt_size_t rt_serial_read (rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size)
static rt_size_t rt_serial_read(rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size)
{
rt_uint8_t* ptr;
struct rt_mb_uart_lite *serial = (struct rt_mb_uart_lite*)dev;
struct rt_mb_uart_lite *serial = (struct rt_mb_uart_lite*) dev;
RT_ASSERT(serial != RT_NULL);
/* point to buffer */
@ -168,11 +165,10 @@ static rt_size_t rt_serial_read (rt_device_t dev, rt_off_t pos, void* buffer, rt
{
*ptr = serial->rx_buffer[serial->read_index];
serial->read_index ++;
serial->read_index++;
if (serial->read_index >= RT_UART_RX_BUFFER_SIZE)
serial->read_index = 0;
}
else
} else
{
/* no data in rx buffer */
@ -184,40 +180,40 @@ static rt_size_t rt_serial_read (rt_device_t dev, rt_off_t pos, void* buffer, rt
/* enable interrupt */
rt_hw_interrupt_enable(level);
ptr ++; size --;
ptr++;
size--;
}
return (rt_uint32_t)ptr - (rt_uint32_t)buffer;
}
else if (dev->flag & RT_DEVICE_FLAG_DMA_RX)
return (rt_uint32_t) ptr - (rt_uint32_t) buffer;
} else if (dev->flag & RT_DEVICE_FLAG_DMA_RX)
{
/* not support right now */
RT_ASSERT(0);
}
else
} else
{
/* poll mode */
while (size)
{
/* Wait for Full Rx Buffer */
while (!(serial->hw_base->STAT_REG & XUL_SR_RX_FIFO_VALID_DATA));
while (!(serial->hw_base->STAT_REG & XUL_SR_RX_FIFO_VALID_DATA))
;
/* Read Character */
*ptr = serial->hw_base->Rx_FIFO;
ptr ++;
size --;
ptr++;
size--;
}
return (rt_size_t)ptr - (rt_size_t)buffer;
return (rt_size_t) ptr - (rt_size_t) buffer;
}
return 0;
}
static rt_size_t rt_serial_write (rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size)
static rt_size_t rt_serial_write(rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size)
{
rt_uint8_t* ptr;
struct rt_mb_uart_lite *serial = (struct rt_mb_uart_lite*)dev;
struct rt_mb_uart_lite *serial = (struct rt_mb_uart_lite*) dev;
RT_ASSERT(serial != RT_NULL);
ptr = (rt_uint8_t*) buffer;
@ -231,16 +227,18 @@ static rt_size_t rt_serial_write (rt_device_t dev, rt_off_t pos, const void* buf
/* stream mode */
if (*ptr == '\n')
{
while (!(serial->hw_base->STAT_REG & XUL_SR_TX_FIFO_EMPTY));
while (!(serial->hw_base->STAT_REG & XUL_SR_TX_FIFO_EMPTY))
;
serial->hw_base->Tx_FIFO = '\r';
}
/* Wait for Empty Tx Buffer */
while (!(serial->hw_base->STAT_REG & XUL_SR_TX_FIFO_EMPTY));
while (!(serial->hw_base->STAT_REG & XUL_SR_TX_FIFO_EMPTY)) ;
/* Transmit Character */
serial->hw_base->Tx_FIFO = *ptr;
ptr ++; size --;
ptr++;
size--;
}
}
else
@ -248,19 +246,21 @@ static rt_size_t rt_serial_write (rt_device_t dev, rt_off_t pos, const void* buf
while (size)
{
/* Wait for Empty Tx Buffer */
while (!(serial->hw_base->STAT_REG & XUL_SR_TX_FIFO_EMPTY));
while (!(serial->hw_base->STAT_REG & XUL_SR_TX_FIFO_EMPTY))
;
/* Transmit Character */
serial->hw_base->Tx_FIFO = *ptr;
ptr ++; size --;
ptr++;
size--;
}
}
}
return (rt_size_t)ptr - (rt_size_t)buffer;
return (rt_size_t) ptr - (rt_size_t) buffer;
}
static rt_err_t rt_serial_control (rt_device_t dev, rt_uint8_t cmd, void *args)
static rt_err_t rt_serial_control(rt_device_t dev, rt_uint8_t cmd, void *args)
{
return RT_EOK;
}
@ -287,7 +287,7 @@ rt_err_t rt_hw_serial_init()
device = (rt_device_t) &serial1;
/* init serial device private data */
serial1.hw_base = (struct rt_mb_uart_lite_hw*)XPAR_USB_UART_BASEADDR;
serial1.hw_base = (struct rt_mb_uart_lite_hw*) XPAR_USB_UART_BASEADDR;
serial1.peripheral_id = XPAR_INTC_0_UARTLITE_1_VEC_ID;
serial1.baudrate = 9600;
@ -303,8 +303,6 @@ rt_err_t rt_hw_serial_init()
rt_device_register(device, "uart1", RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX);
#endif
return RT_EOK;
}

17
libcpu/xilinx/microblaze/stack.c
View File

@ -16,8 +16,6 @@
extern void *_SDA_BASE_;
extern void *_SDA2_BASE_;
/**
* This function will initialize thread stack
*
@ -28,12 +26,11 @@ extern void *_SDA2_BASE_;
*
* @return stack address
*/
rt_uint8_t *rt_hw_stack_init(void *tentry, void *parameter,
rt_uint8_t *stack_addr, void *texit)
rt_uint8_t *rt_hw_stack_init(void *tentry, void *parameter, rt_uint8_t *stack_addr, void *texit)
{
unsigned long *stk;
stk = (unsigned long *)stack_addr;
stk = (unsigned long *) stack_addr;
stk--;
stk--;
*stk-- = 0; /* r31 */
@ -51,9 +48,9 @@ rt_uint8_t *rt_hw_stack_init(void *tentry, void *parameter,
*stk-- = 0; /* r19 */
*stk-- = 0; /* r18 */
*stk-- = 0; /* r17 */
*stk-- = (unsigned long)texit; /* r15 = task return address*/
*stk-- = (unsigned long)tentry; /* r14 = entry address*/
*stk-- = (unsigned long)&_SDA_BASE_; /* r13 */
*stk-- = (unsigned long) texit; /* r15 = task return address*/
*stk-- = (unsigned long) tentry; /* r14 = entry address*/
*stk-- = (unsigned long) &_SDA_BASE_; /* r13 */
*stk-- = 0; /* r12 */
*stk-- = 0; /* r11 */
*stk-- = 0; /* r10 */
@ -64,8 +61,8 @@ rt_uint8_t *rt_hw_stack_init(void *tentry, void *parameter,
*stk-- = (unsigned long) parameter; /* r05 */
*stk-- = 0; /* r04 */
*stk-- = 0; /* r03 */
*stk-- = (unsigned long)&_SDA2_BASE_; /* r02 */
*stk-- = (unsigned long) &_SDA2_BASE_; /* r02 */
*stk = 2; /* enable interrupt */
return (rt_uint8_t *)stk;
return (rt_uint8_t *) stk;
}

78
libcpu/xilinx/microblaze/trap.c
View File

@ -20,17 +20,14 @@
#include "xintc_i.h"
#include "xintc_l.h"
#define MAX_HANDLERS XPAR_INTC_MAX_NUM_INTR_INPUTS
extern XIntc int_ctl; /* The instance of the Interrupt Controller */
extern rt_uint32_t rt_interrupt_nest;
rt_uint32_t rt_interrupt_from_thread, rt_interrupt_to_thread;
rt_uint32_t rt_thread_switch_interrupt_flag;
void rt_hw_interrupt_handler(int vector)
{
rt_kprintf("Unhandled interrupt %d occured!!!\n", vector);
@ -45,13 +42,11 @@ void rt_hw_interrupt_init()
XIntc_Config *CfgPtr;
CfgPtr = &XIntc_ConfigTable[0];
for (index = 0; index < MAX_HANDLERS; index ++)
for (index = 0; index < MAX_HANDLERS; index++)
{
CfgPtr->HandlerTable[index].Handler = (XInterruptHandler)rt_hw_interrupt_handler;
CfgPtr->HandlerTable[index].Handler = (XInterruptHandler) rt_hw_interrupt_handler;
}
/* init interrupt nest, and context in thread sp */
@ -68,7 +63,7 @@ void rt_hw_interrupt_init()
void rt_hw_interrupt_mask(int vector)
{
/* disable interrupt */
XIntc_Disable(&int_ctl,vector);
XIntc_Disable(&int_ctl, vector);
}
/**
@ -77,7 +72,7 @@ void rt_hw_interrupt_mask(int vector)
*/
void rt_hw_interrupt_umask(int vector)
{
XIntc_Enable(&int_ctl,vector);
XIntc_Enable(&int_ctl, vector);
}
/**
@ -92,44 +87,45 @@ void rt_hw_interrupt_install(int vector, rt_isr_handler_t new_handler, rt_isr_ha
CfgPtr = &XIntc_ConfigTable[0];
if(vector >= 0 && vector < MAX_HANDLERS)
if (vector >= 0 && vector < MAX_HANDLERS)
{
if (*old_handler != RT_NULL) *old_handler = (rt_isr_handler_t)CfgPtr->HandlerTable[vector].Handler;
if (new_handler != RT_NULL) CfgPtr->HandlerTable[vector].Handler = (XInterruptHandler)new_handler;
if (*old_handler != RT_NULL)
*old_handler = (rt_isr_handler_t) CfgPtr->HandlerTable[vector].Handler;
if (new_handler != RT_NULL)
CfgPtr->HandlerTable[vector].Handler = (XInterruptHandler) new_handler;
}
}
/*****************************************************************************/
/** copy from XIntc_DeviceInterruptHandler in xintc_l.c nl1031
*
* This function is the primary interrupt handler for the driver. It must be
* connected to the interrupt source such that is called when an interrupt of
* the interrupt controller is active. It will resolve which interrupts are
* active and enabled and call the appropriate interrupt handler. It uses
* the AckBeforeService flag in the configuration data to determine when to
* acknowledge the interrupt. Highest priority interrupts are serviced first.
* The driver can be configured to service only the highest priority interrupt
* or all pending interrupts using the {XIntc_SetOptions()} function or
* the {XIntc_SetIntrSrvOption()} function.
*
* This function assumes that an interrupt vector table has been previously
* initialized. It does not verify that entries in the table are valid before
* calling an interrupt handler.
*
*
* @return None.
*
* @note
*
* The constant XPAR_INTC_MAX_NUM_INTR_INPUTS must be setup for this to compile.
* Interrupt IDs range from 0 - 31 and correspond to the interrupt input signals
* for the interrupt controller. XPAR_INTC_MAX_NUM_INTR_INPUTS specifies the
* highest numbered interrupt input signal that is used.
*
******************************************************************************/
*
* This function is the primary interrupt handler for the driver. It must be
* connected to the interrupt source such that is called when an interrupt of
* the interrupt controller is active. It will resolve which interrupts are
* active and enabled and call the appropriate interrupt handler. It uses
* the AckBeforeService flag in the configuration data to determine when to
* acknowledge the interrupt. Highest priority interrupts are serviced first.
* The driver can be configured to service only the highest priority interrupt
* or all pending interrupts using the {XIntc_SetOptions()} function or
* the {XIntc_SetIntrSrvOption()} function.
*
* This function assumes that an interrupt vector table has been previously
* initialized. It does not verify that entries in the table are valid before
* calling an interrupt handler.
*
*
* @return None.
*
* @note
*
* The constant XPAR_INTC_MAX_NUM_INTR_INPUTS must be setup for this to compile.
* Interrupt IDs range from 0 - 31 and correspond to the interrupt input signals
* for the interrupt controller. XPAR_INTC_MAX_NUM_INTR_INPUTS specifies the
* highest numbered interrupt input signal that is used.
*
******************************************************************************/
void rt_hw_trap_irq(void )
void rt_hw_trap_irq(void)
{
u32 intr_status;
u32 intr_mask = 1;
@ -137,7 +133,6 @@ void rt_hw_trap_irq(void )
volatile u32 reg; /* used as bit bucket */
XIntc_Config *cfg_ptr;
/* Get the configuration data using the device ID */
cfg_ptr = &XIntc_ConfigTable[0];
@ -208,4 +203,3 @@ void rt_hw_trap_irq(void )
}
}