sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Adding M16C support

Browse Source 
git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@1486 42af7a65-404d-4744-a932-0658087f49c3
This commit is contained in:
patacongo 2009-02-09 00:11:22 +00:00
parent 24fea23151
commit 97bdcb112f
13 changed files with 314 additions and 212 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
arch/sh/include/m16c/irq.h
View File

@ -191,7 +191,7 @@
# define M16C_INT0_IRQ (_LAST_FIXED+24) /* ffd74: INT0 */
# define M16C_INT1_IRQ (_LAST_FIXED+25) /* ffd78: INT1 */
# define NR_IRQS (_LAST_FIXED+26 /* Total number of supported IRQs */
# define NR_IRQS (_LAST_FIXED+26) /* Total number of supported IRQs */
#endif
#define M16C_SYSTIMER_IRQ M16C_TMRA0_IRQ
@ -226,6 +226,34 @@ extern "C" {
************************************************************************************/
#ifndef __ASSEMBLY__
/* Save the current interrupt enable state & disable IRQs */
static inline irqstate_t irqsave(void)
{
irqstate_t flags;
__asm__ __volatile__
(
"\tstc flg, %0\n"
"\tfclr I\n"
: "=r" (flags)
:
: "memory");
return flags;
}
/* Restore saved IRQ & FIQ state */
static inline void irqrestore(irqstate_t flags)
{
__asm__ __volatile__
(
"ldc %0, flg"
:
: "r" (flags)
: "memory");
}
#endif
/************************************************************************************

2
arch/sh/include/m16c/types.h
View File

@ -72,7 +72,7 @@ typedef unsigned long long uint64;
* irqsave()
*/
typedef unsigned int irqstate_t;
typedef uint16 irqstate_t;
#endif /* __ASSEMBLY__ */

171
arch/sh/src/common/up_assert.c
View File

@ -72,177 +72,6 @@
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: up_getsp
****************************************************************************/
/****************************************************************************
* Name: getsp
****************************************************************************/
static inline uint32 up_getsp(void)
{
uint32 sp;
__asm__ __volatile__
(
"mov r15, %0\n\t"
: "=&z" (sp)
:
: "memory"
);
return sp;
}
/****************************************************************************
* Name: up_stackdump
****************************************************************************/
#ifdef CONFIG_ARCH_STACKDUMP
static void up_stackdump(uint32 sp, uint32 stack_base)
{
uint32 stack ;
for (stack = sp & ~0x1f; stack < stack_base; stack += 32)
{
uint32 *ptr = (uint32*)stack;
lldbg("%08x: %08x %08x %08x %08x %08x %08x %08x %08x\n",
stack, ptr[0], ptr[1], ptr[2], ptr[3],
ptr[4], ptr[5], ptr[6], ptr[7]);
}
}
#else
# define up_stackdump()
#endif
/****************************************************************************
* Name: up_registerdump
****************************************************************************/
#ifdef CONFIG_ARCH_STACKDUMP
static inline void up_registerdump(void)
{
uint32 *ptr = current_regs;
/* Are user registers available from interrupt processing? */
if (ptr)
{
/* Yes.. dump the interrupt registers */
lldbg("PC: %08x SR=%08x\n",
ptr[REG_PC], ptr[REG_SR]);
lldbg("PR: %08x GBR: %08x MACH: %08x MACL: %08x\n",
ptr[REG_PR], ptr[REG_GBR], ptr[REG_MACH], ptr[REG_MACL]);
lldbg("R%d: %08x %08x %08x %08x %08x %08x %08x %08x\n", 0,
ptr[REG_R0], ptr[REG_R1], ptr[REG_R2], ptr[REG_R3],
ptr[REG_R4], ptr[REG_R5], ptr[REG_R6], ptr[REG_R7]);
lldbg("R%d: %08x %08x %08x %08x %08x %08x %08x %08x\n", 8,
ptr[REG_R8], ptr[REG_R9], ptr[REG_R10], ptr[REG_R11],
ptr[REG_R12], ptr[REG_R13], ptr[REG_R14], ptr[REG_R15]);
}
}
#else
# define up_registerdump()
#endif
/****************************************************************************
* Name: up_dumpstate
****************************************************************************/
#ifdef CONFIG_ARCH_STACKDUMP
static void up_dumpstate(void)
{
_TCB *rtcb = (_TCB*)g_readytorun.head;
uint32 sp = up_getsp();
uint32 ustackbase;
uint32 ustacksize;
#if CONFIG_ARCH_INTERRUPTSTACK > 3
uint32 istackbase;
uint32 istacksize;
#endif
/* Get the limits on the user stack memory */
if (rtcb->pid == 0)
{
ustackbase = g_heapbase - 4;
ustacksize = CONFIG_IDLETHREAD_STACKSIZE;
}
else
{
ustackbase = (uint32)rtcb->adj_stack_ptr;
ustacksize = (uint32)rtcb->adj_stack_size;
}
/* Get the limits on the interrupt stack memory */
#if CONFIG_ARCH_INTERRUPTSTACK > 3
istackbase = (uint32)&g_userstack;
istacksize = (CONFIG_ARCH_INTERRUPTSTACK & ~3) - 4;
/* Show interrupt stack info */
lldbg("sp: %08x\n", sp);
lldbg("IRQ stack:\n");
lldbg(" base: %08x\n", istackbase);
lldbg(" size: %08x\n", istacksize);
/* Does the current stack pointer lie within the interrupt
* stack?
*/
if (sp <= istackbase && sp > istackbase - istacksize)
{
/* Yes.. dump the interrupt stack */
up_stackdump(sp, istackbase);
/* Extract the user stack pointer which should lie
* at the base of the interrupt stack.
*/
sp = g_userstack;
lldbg("sp: %08x\n", sp);
}
/* Show user stack info */
lldbg("User stack:\n");
lldbg(" base: %08x\n", ustackbase);
lldbg(" size: %08x\n", ustacksize);
#else
lldbg("sp: %08x\n", sp);
lldbg("stack base: %08x\n", ustackbase);
lldbg("stack size: %08x\n", ustacksize);
#endif
/* Dump the user stack if the stack pointer lies within the allocated user
* stack memory.
*/
if (sp > ustackbase || sp <= ustackbase - ustacksize)
{
#if !defined(CONFIG_ARCH_INTERRUPTSTACK) || CONFIG_ARCH_INTERRUPTSTACK < 4
lldbg("ERROR: Stack pointer is not within allocated stack\n");
#endif
}
else
{
up_stackdump(sp, ustackbase);
}
/* Then dump the registers (if available) */
up_registerdump();
}
#else
# define up_dumpstate()
#endif
/****************************************************************************
* Name: _up_assert
****************************************************************************/

8
arch/sh/src/common/up_internal.h
View File

@ -209,6 +209,14 @@ extern void up_usbuninitialize(void);
# define up_usbuninitialize()
#endif
/* Defined in chip-specific logic */
#ifdef CONFIG_ARCH_STACKDUMP
extern void up_dumpstate(void);
#else
# define up_dumpstate()
#endif
#endif /* __ASSEMBLY__ */
#endif /* ___ARCH_SH_SRC_COMMON_UP_INTERNAL_H */

6
arch/sh/src/m16c/Make.defs
View File

@ -38,9 +38,9 @@ HEAD_ASRC = m16c_head.S
CMN_ASRCS =
CMN_CSRCS = up_allocateheap.c up_assert.c up_blocktask.c up_copystate.c \
up_createstack.c up_doirq.c up_exit.c up_idle.c up_initialize.c \
up_initialstate.c up_interruptcontext.c up_lowputs.c \
up_mdelay.c up_puts.c up_releasepending.c up_releasestack.c \
up_reprioritizertr.c up_udelay.c up_unblocktask.c up_usestack.c
up_interruptcontext.c up_lowputs.c up_mdelay.c up_puts.c \
up_releasepending.c up_releasestack.c up_reprioritizertr.c \
up_udelay.c up_unblocktask.c up_usestack.c
ifneq ($(CONFIG_DISABLE_SIGNALS),y)
CMN_CSRCS += up_schedulesigaction.c up_sigdeliver.c

20
arch/sh/src/m16c/m16c_head.S
View File

@ -91,12 +91,13 @@
* 0x00400 - DATA Size: Determined by linker
* BSS Size: Determined by linker
* Idle stack Size: CONFIG_IDLETHREAD_STACKSIZE
* Interrupt stack Size: CONFIG_M16C_ISTACKSIZE
* Interrupt stack Size: CONFIG_ARCH_INTERRUPTSTACK
* Heap Size: Everything remaining
* 0x00bff - (end+1)
*/
.data
#if 0
.globl _g_stackbase
.type _g_stackbase, object
_g_stackbase:
@ -107,16 +108,13 @@ _g_stackbase:
.globl _g_istackbase
.type _g_istackbase, object
_g_istackbase:
.word _enbss+CONFIG_IDLETHREAD_STACKSIZE-4
.word _enbss+CONFIG_IDLETHREAD_STACKSIZE
.size _g_istackbase, .-_g_istackbase
* The heap extends from _g_heapbase to the end of RAM.
*/
#endif
.globl _g_heapbase
.type _g_heapbase, object
_g_heapbase:
.word _enbss+CONFIG_IDLETHREAD_STACKSIZE+CONFIG_M16C_ISTACKSIZE
.word _enbss+CONFIG_IDLETHREAD_STACKSIZE+CONFIG_ARCH_INTERRUPTSTACK
.size _g_heapbase, .-_g_heapbase
/************************************************************************************
@ -346,9 +344,13 @@ _g_heapbase:
.type __start, #function
__start:
/* Set the istack pointer */
/* Set the interrupt and user stack pointers */
ldc #_enbss, isp /* Set idle thread stack pointer to the end of BSS */
mov.w #_enbss, R0
ldc R0, usp /* Set the user stack pointer */
add.w #CONFIG_IDLETHREAD_STACKSIZE, R0
ldc R0, isp /* Set interrupt thread stack pointer to the end of BSS */
fset U /* Set bit 7 (U) to select the user stack pointer */
/* Set BCLK speed. At reset, the processor clock (BLCK) defaults to a divisor of 8.
* This sets clock to F1 (divide by 1) on XIN: BCLK = XIN frequency.

3
arch/sh/src/sh1/Make.defs
View File

@ -47,7 +47,8 @@ CMN_CSRCS += up_schedulesigaction.c up_sigdeliver.c
endif
CHIP_ASRCS = sh1_vector.S sh1_saveusercontext.S
CHIP_CSRCS = sh1_lowputc.c sh1_irq.c sh1_timerisr.c sh1_serial.c
CHIP_CSRCS = sh1_lowputc.c sh1_irq.c sh1_timerisr.c sh1_serial.c \
sh1_initialstate.c sh1_dumpstate.c
ifeq ($(CONFIG_USBDEV),y)
CHIP_CSRCS +=

240
arch/sh/src/sh1/sh1_dumpstate.c Executable file
View File

@ -0,0 +1,240 @@
/****************************************************************************
* arch/sh/src/sh1/sh1_assert.c
*
* Copyright (C) 2008, 2009 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <sys/types.h>
#include <debug.h>
#include "up_internal.h"
include <nuttx/config.h>
#include <sys/types.h>
#include <debug.h>
#include <nuttx/irq.h>
#include <nuttx/arch.h>
#include "up_arch.h"
#include "up_internal.h"
#ifdef CONFIG_ARCH_STACKDUMP
/****************************************************************************
* Definitions
****************************************************************************/
/* Output debug info if stack dump is selected -- even if
* debug is not selected.
*/
#ifdef CONFIG_ARCH_STACKDUMP
# undef lldbg
# define lldbg lib_lowprintf
#endif
/****************************************************************************
* Private Data
****************************************************************************/
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: sh1_getsp
****************************************************************************/
static inline uint32 sh1_getsp(void)
{
uint32 sp;
__asm__ __volatile__
(
"mov r15, %0\n\t"
: "=&z" (sp)
:
: "memory"
);
return sp;
}
/****************************************************************************
* Name: sh1_stackdump
****************************************************************************/
static void sh1_stackdump(uint32 sp, uint32 stack_base)
{
uint32 stack ;
for (stack = sp & ~0x1f; stack < stack_base; stack += 32)
{
uint32 *ptr = (uint32*)stack;
lldbg("%08x: %08x %08x %08x %08x %08x %08x %08x %08x\n",
stack, ptr[0], ptr[1], ptr[2], ptr[3],
ptr[4], ptr[5], ptr[6], ptr[7]);
}
}
/****************************************************************************
* Name: sh1_registerdump
****************************************************************************/
static inline void sh1_registerdump(void)
{
uint32 *ptr = current_regs;
/* Are user registers available from interrupt processing? */
if (ptr)
{
/* Yes.. dump the interrupt registers */
lldbg("PC: %08x SR=%08x\n",
ptr[REG_PC], ptr[REG_SR]);
lldbg("PR: %08x GBR: %08x MACH: %08x MACL: %08x\n",
ptr[REG_PR], ptr[REG_GBR], ptr[REG_MACH], ptr[REG_MACL]);
lldbg("R%d: %08x %08x %08x %08x %08x %08x %08x %08x\n", 0,
ptr[REG_R0], ptr[REG_R1], ptr[REG_R2], ptr[REG_R3],
ptr[REG_R4], ptr[REG_R5], ptr[REG_R6], ptr[REG_R7]);
lldbg("R%d: %08x %08x %08x %08x %08x %08x %08x %08x\n", 8,
ptr[REG_R8], ptr[REG_R9], ptr[REG_R10], ptr[REG_R11],
ptr[REG_R12], ptr[REG_R13], ptr[REG_R14], ptr[REG_R15]);
}
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: up_dumpstate
****************************************************************************/
void up_dumpstate(void)
{
_TCB *rtcb = (_TCB*)g_readytorun.head;
uint32 sp = sh1_getsp();
uint32 ustackbase;
uint32 ustacksize;
#if CONFIG_ARCH_INTERRUPTSTACK > 3
uint32 istackbase;
uint32 istacksize;
#endif
/* Get the limits on the user stack memory */
if (rtcb->pid == 0)
{
ustackbase = g_heapbase - 4;
ustacksize = CONFIG_IDLETHREAD_STACKSIZE;
}
else
{
ustackbase = (uint32)rtcb->adj_stack_ptr;
ustacksize = (uint32)rtcb->adj_stack_size;
}
/* Get the limits on the interrupt stack memory */
#if CONFIG_ARCH_INTERRUPTSTACK > 3
istackbase = (uint32)&g_userstack;
istacksize = (CONFIG_ARCH_INTERRUPTSTACK & ~3) - 4;
/* Show interrupt stack info */
lldbg("sp: %08x\n", sp);
lldbg("IRQ stack:\n");
lldbg(" base: %08x\n", istackbase);
lldbg(" size: %08x\n", istacksize);
/* Does the current stack pointer lie within the interrupt
* stack?
*/
if (sp <= istackbase && sp > istackbase - istacksize)
{
/* Yes.. dump the interrupt stack */
sh1_stackdump(sp, istackbase);
/* Extract the user stack pointer which should lie
* at the base of the interrupt stack.
*/
sp = g_userstack;
lldbg("sp: %08x\n", sp);
}
/* Show user stack info */
lldbg("User stack:\n");
lldbg(" base: %08x\n", ustackbase);
lldbg(" size: %08x\n", ustacksize);
#else
lldbg("sp: %08x\n", sp);
lldbg("stack base: %08x\n", ustackbase);
lldbg("stack size: %08x\n", ustacksize);
#endif
/* Dump the user stack if the stack pointer lies within the allocated user
* stack memory.
*/
if (sp > ustackbase || sp <= ustackbase - ustacksize)
{
#if !defined(CONFIG_ARCH_INTERRUPTSTACK) || CONFIG_ARCH_INTERRUPTSTACK < 4
lldbg("ERROR: Stack pointer is not within allocated stack\n");
#endif
}
else
{
sh1_stackdump(sp, ustackbase);
}
/* Then dump the registers (if available) */
sh1_registerdump();
}
#endif /* CONFIG_ARCH_STACKDUMP */

4
arch/sh/src/common/up_initialstate.c → arch/sh/src/sh1/sh1_initialstate.c
View File

@ -1,7 +1,7 @@
/****************************************************************************
* arch/sh/src/common/up_initialstate.c
* arch/sh/src/sh1/sh1_initialstate.c
*
* Copyright (C) 2008 Gregory Nutt. All rights reserved.
* Copyright (C) 2008, 2009 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
*
* Redistribution and use in source and binary forms, with or without

5
configs/skp16c26/include/board.h
View File

@ -44,8 +44,6 @@
#ifndef __ASSEMBLY__
# include <sys/types.h>
#endif
#include "sfr262.h" /* M16C/26 special function register definitions */
#include "skp_lcd.h" /* SKP LCD function definitions */
/************************************************************************************
* Definitions
@ -80,9 +78,6 @@
#define LED_ON 0
#define LED_OFF 1
#define ENABLE_IRQ {_asm(" FSET I");}
#define DISABLE_IRQ {_asm(" FCLR I");}
/* Use these macros for switch inputs */
#define ENABLE_SWITCHES {S1_DDR = 0; S2_DDR = 0; S3_DDR = 0;}

2
configs/skp16c26/ostest/Make.defs
View File

@ -53,7 +53,7 @@ else
ARCHOPTIMIZATION = -Os -fno-strict-aliasing -fno-strength-reduce -fomit-frame-pointer
endif
ARCHCPUFLAGS = --m16c -msoft-float -fno-builtin
ARCHCPUFLAGS = -mcpu=m16c -fno-builtin
ARCHPICFLAGS = -fpic
ARCHWARNINGS = -Wall -Wstrict-prototypes -Wshadow
ARCHDEFINES =

33
configs/skp16c26/ostest/defconfig
View File

@ -47,9 +47,9 @@
# CONFIG_ARCH_BOARD_name - for use in C code
# CONFIG_ENDIAN_BIG - define if big endian (default is little endian)
# CONFIG_BOARD_LOOPSPERMSEC - for delay loops
# CONFIG_DRAM_SIZE - Describes the installed DRAM.
# CONFIG_DRAM_START - The start address of DRAM (physical)
# CONFIG_DRAM_VSTART - The startaddress of DRAM (virtual)
# CONFIG_DRAM_SIZE - Describes the internal SRAM.
# CONFIG_DRAM_START - The start address of internal SRAM
# CONFIG_DRAM_END - The end+1 address of internal SRAM
# CONFIG_ARCH_INTERRUPTSTACK - This architecture supports an interrupt
# stack. If defined, this symbol is the size of the interrupt
# stack in bytes. If not defined, the user task stacks will be
@ -63,12 +63,11 @@ CONFIG_ARCH_CHIP_M30262F8=y
CONFIG_ARCH_BOARD=skp16c26
CONFIG_ARCH_BOARD_SKP16C26=y
CONFIG_ENDIAN_BIG=y
CONFIG_DRAM_SIZE=0x00800
CONFIG_DRAM_START=0x00400
CONFIG_DRAM_END=(CONFIG_DRAM_START+CONFIG_DRAM_SIZE)
CONFIG_BOARD_LOOPSPERMSEC=16945
CONFIG_DRAM_SIZE=0x01000000
CONFIG_DRAM_START=0x01000000
CONFIG_DRAM_VSTART=0x00000000
CONFIG_DRAM_NUTTXENTRY=0x01008000
CONFIG_ARCH_INTERRUPTSTACK=0
CONFIG_ARCH_INTERRUPTSTACK=128
CONFIG_ARCH_STACKDUMP=y
#
@ -87,12 +86,12 @@ CONFIG_ARCH_STACKDUMP=y
#
CONFIG_UART0_SERIAL_CONSOLE=y
CONFIG_UART1_SERIAL_CONSOLE=n
CONFIG_UART0_TXBUFSIZE=256
CONFIG_UART1_TXBUFSIZE=256
CONFIG_UART0_RXBUFSIZE=256
CONFIG_UART1_RXBUFSIZE=256
CONFIG_UART0_BAUD=115200
CONFIG_UART1_BAUD=115200
CONFIG_UART0_TXBUFSIZE=64
CONFIG_UART1_TXBUFSIZE=64
CONFIG_UART0_RXBUFSIZE=64
CONFIG_UART1_RXBUFSIZE=64
CONFIG_UART0_BAUD=9600
CONFIG_UART1_BAUD=9600
CONFIG_UART0_BITS=8
CONFIG_UART1_BITS=8
CONFIG_UART0_PARITY=0
@ -160,9 +159,9 @@ CONFIG_ARCH_LOWPUTC=y
CONFIG_RR_INTERVAL=200
CONFIG_SCHED_INSTRUMENTATION=n
CONFIG_TASK_NAME_SIZE=0
CONFIG_START_YEAR=2008
CONFIG_START_MONTH=8
CONFIG_START_DAY=29
CONFIG_START_YEAR=2009
CONFIG_START_MONTH=2
CONFIG_START_DAY=8
CONFIG_JULIAN_TIME=n
CONFIG_DEV_CONSOLE=y
CONFIG_DEV_LOWCONSOLE=n