MIライブラリ追加。

git-svn-id: file:///Volumes/Transfer/gigaleak_20231201/2020-09-30%20-%20paladin.7z/paladin/ctr_firmware@118 b871894f-2f95-9b40-918c-086798483c85

trunk/bootrom/build/buildtools/commondefs

@@ -245,6 +245,7 @@ ifeq	($(CODEGEN_PROC),ARM11)
 
 BROM_LIBS_BASE	?= \
 			   libos \
+			   libmi \
 
 ifdef		BROM_PROFILE_TYPE
 BROM_LIBS_BASE	+= libos.$(BROM_PROFILE_TYPE)
@@ -254,6 +255,7 @@ else #	($(CODEGEN_PROC),ARM9)
 
 BROM_LIBS_BASE	?= \
 			   libos_sp \
+			   libmi_sp \
 
 ifdef		BROM_PROFILE_TYPE
 BROM_LIBS_BASE	+= libos_sp.$(BROM_PROFILE_TYPE)

trunk/bootrom/build/libraries/Makefile

@@ -23,6 +23,7 @@ include	$(CTRBROM_ROOT)/build/buildtools/commondefs
 SUBDIRS		= \
 			init \
 			os \
+			mi \
 
 #----------------------------------------------------------------------------
 

trunk/bootrom/build/libraries/mi/ARM11/Makefile

@@ -0,0 +1,46 @@
+#! make -f
+#----------------------------------------------------------------------------
+# Project:  CtrBrom - libraries - mi
+# File:     Makefile
+#
+# Copyright 2008 Nintendo.  All rights reserved.
+#
+# These coded instructions, statements, and computer programs contain
+# proprietary information of Nintendo of America Inc. and/or Nintendo
+# Company Ltd., and are protected by Federal copyright law.  They may
+# not be disclosed to third parties or copied or duplicated in any form,
+# in whole or in part, without the prior written consent of Nintendo.
+#
+# $Date::            $
+# $Rev$
+# $Author$
+#----------------------------------------------------------------------------
+
+SUBDIRS		=
+SUBMAKES	=
+
+
+#----------------------------------------------------------------------------
+
+# build ARM & THUMB libraries
+BROM_CODEGEN_ALL 	?= TRUE
+
+SRCDIR		= . ../common
+
+SRCS			= \
+				mi_memory.c \
+
+TARGET_LIB		= libmi$(BROM_LIBSUFFIX).a
+
+include	$(CTRBROM_ROOT)/build/buildtools/commondefs
+
+INSTALL_TARGETS		= $(TARGETS)
+INSTALL_DIR		= $(BROM_INSTALL_LIBDIR)
+
+#----------------------------------------------------------------------------
+
+do-build:		$(TARGETS)
+
+include	$(CTRBROM_ROOT)/build/buildtools/modulerules
+
+#===== End of Makefile =====

trunk/bootrom/build/libraries/mi/ARM9/Makefile

@@ -0,0 +1,54 @@
+#! make -f
+#----------------------------------------------------------------------------
+# Project:  TwlBrom - libraries_sp - mi
+# File:     Makefile
+#
+# Copyright 2008 Nintendo.  All rights reserved.
+#
+# These coded instructions, statements, and computer programs contain
+# proprietary information of Nintendo of America Inc. and/or Nintendo
+# Company Ltd., and are protected by Federal copyright law.  They may
+# not be disclosed to third parties or copied or duplicated in any form,
+# in whole or in part, without the prior written consent of Nintendo.
+#
+# $Date::            $
+# $Rev$
+# $Author$
+#----------------------------------------------------------------------------
+
+SUBDIRS			=
+#SUBMAKES		= Makefile.CALLTRACE 	\
+#			  Makefile.FUNCTIONCOST
+
+#----------------------------------------------------------------------------
+
+# build ARM & THUMB libraries
+BROM_CODEGEN_ALL 	?= TRUE
+
+# Codegen for sub processer
+BROM_PROC		= ARM9
+
+SRCDIR			= . ../common
+
+SRCS			= \
+				mi_memory.c \
+
+TARGET_LIB		= libmi_sp$(BROM_LIBSUFFIX).a
+
+
+#----------------------------------------------------------------------------
+
+include	$(CTRBROM_ROOT)/build/buildtools/commondefs
+
+INSTALL_TARGETS		= $(TARGETS)
+INSTALL_DIR		= $(BROM_INSTALL_LIBDIR)
+
+
+#----------------------------------------------------------------------------
+
+do-build:		$(TARGETS)
+
+include	$(CTRBROM_ROOT)/build/buildtools/modulerules
+
+
+#===== End of Makefile =====

trunk/bootrom/build/libraries/mi/Makefile

@@ -0,0 +1,34 @@
+#! make -f
+#----------------------------------------------------------------------------
+# Project:  CtrBrom - libraries - mi
+# File:     Makefile
+#
+# Copyright 2008 Nintendo.  All rights reserved.
+#
+# These coded instructions, statements, and computer programs contain
+# proprietary information of Nintendo of America Inc. and/or Nintendo
+# Company Ltd., and are protected by Federal copyright law.  They may
+# not be disclosed to third parties or copied or duplicated in any form,
+# in whole or in part, without the prior written consent of Nintendo.
+#
+# $Date::            $
+# $Rev$
+# $Author$
+#----------------------------------------------------------------------------
+
+include	$(CTRBROM_ROOT)/build/buildtools/commondefs
+
+#----------------------------------------------------------------------------
+
+SUBDIRS =	ARM11
+
+#ifdef	CTR_WITH_ARM9
+SUBDIRS +=	ARM9
+#endif
+
+#----------------------------------------------------------------------------
+
+include	$(CTRBROM_ROOT)/build/buildtools/modulerules
+
+
+#===== End of Makefile =====

trunk/bootrom/build/libraries/mi/common/mi_memory.c

@@ -0,0 +1,805 @@
+/*---------------------------------------------------------------------------*
+  Project:  TwlBrom - MI
+  File:     mi_memory.c
+
+  Copyright 2008 Nintendo.  All rights reserved.
+
+  These coded instructions, statements, and computer programs contain
+  proprietary information of Nintendo of America Inc. and/or Nintendo
+  Company Ltd., and are protected by Federal copyright law.  They may
+  not be disclosed to third parties or copied or duplicated in any form,
+  in whole or in part, without the prior written consent of Nintendo.
+
+  $Date::            $
+  $Rev$
+  $Author$
+ *---------------------------------------------------------------------------*/
+#include <brom/types.h>
+#include <brom/mi/memory.h>
+
+//#define BROM_ENABLE_CONVINIENCE_COPY
+
+
+//****バグ対策****
+//  CW のバグで、ldrh や strh といった、ハーフワードアクセス命令が
+//  inline assembler で通らないので、直に命令の値を dcd で書いて
+//  回避する。バグがなおったら下のdefine は削除する。
+
+//  Fixed with CodeWarrior 0.4 or later
+//#define CW_BUG_FOR_LDRH_AND_STRH
+
+
+#define HALFW_CONDAL  0xe0000000       // condition(ALL)
+#define HALFW_CONDNE  0x10000000       // condition(NE)
+#define HALFW_CONDEQ  0x00000000       // condition(EQ)
+
+#define HALFW_OFF_PL  0x00800000       // offset plus
+#define HALFW_OFF_MI  0x00000000       // offset minus
+#define HALFW_LOAD    0x00100000       // load
+#define HALFW_STORE   0x00000000       // store
+#define HALFW_RN(n)   ((n)<<16)        // register Rn
+#define HALFW_RD(n)   ((n)<<12)        // register Rd
+
+#define HALFW_DEF1    0x004000B0       // fixed
+#define HALFW_DEF2    0x014000B0       // fixed
+
+#define HALFW_IMM(n)   ( ((n)&0xf)  |  (((n)&0xf0)<<4) )        // immediate
+
+
+#define HALFW_DCD( cond, d, n, offset, sign, ldst, def ) \
+   dcd (def)|(cond)|(sign)|(ldst)|HALFW_RN(n)|HALFW_RD(d)|HALFW_IMM(offset)
+
+//---- ldrh Rn, [Rd], +#offset
+#define LDRH_AD1( cond, d, n, offset ) \
+   HALFW_DCD( cond, d, n, offset, HALFW_OFF_PL, HALFW_LOAD, HALFW_DEF1 )
+
+//---- ldrh Rn, [Rd, +#offset]
+#define LDRH_AD2( cond, d, n, offset ) \
+   HALFW_DCD( cond, d, n, offset, HALFW_OFF_PL, HALFW_LOAD, HALFW_DEF2 )
+
+//---- ldrh Rn, [Rd], -#offset
+#define LDRH_AD3( cond, d, n, offset ) \
+   HALFW_DCD( cond, d, n, offset, HALFW_OFF_MI, HALFW_LOAD, HALFW_DEF1 )
+
+//---- ldrh Rn, [Rd, -#offset]
+#define LDRH_AD4( cond, d, n, offset ) \
+   HALFW_DCD( cond, d, n, offset, HALFW_OFF_MI, HALFW_LOAD, HALFW_DEF2 )
+
+//---- strh Rn, [Rd], +#offset
+#define STRH_AD1( cond, d, n, offset ) \
+   HALFW_DCD( cond, d, n, offset, HALFW_OFF_PL, HALFW_STORE, HALFW_DEF1 )
+
+//---- strh Rn, [Rd, +#offset]
+#define STRH_AD2( cond, d, n, offset ) \
+   HALFW_DCD( cond, d, n, offset, HALFW_OFF_PL, HALFW_STORE, HALFW_DEF2 )
+
+//---- strh Rn, [Rd], -#offset
+#define STRH_AD3( cond, d, n, offset ) \
+   HALFW_DCD( cond, d, n, offset, HALFW_OFF_MI, HALFW_STORE, HALFW_DEF1 )
+
+//---- strh Rn, [Rd, -#offset]
+#define STRH_AD4( cond, d, n, offset ) \
+   HALFW_DCD( cond, d, n, offset, HALFW_OFF_MI, HALFW_STORE, HALFW_DEF2 )
+
+
+
+#include <brom/code32.h>
+//=======================================================================
+//           MEMORY OPERATIONS
+//=======================================================================
+/*---------------------------------------------------------------------------*
+  Name:         i_miCpuClear16
+
+  Description:  fill memory with specified data.
+                16bit version
+
+  Arguments:    data  : fill data
+                destp : destination address
+                size  : size (byte)
+
+  Returns:      None
+ *---------------------------------------------------------------------------*/
+asm void i_miCpuClear16( register u16 data, register void* destp, register u32 size )
+{
+        mov     r3, #0                  // n = 0
+
+LSYM(0)
+        cmp     r3, r2                  // n < size ?
+        strlth  r0, [r1, r3]            // *((vu16 *)(destp + n)) = data
+        addlt   r3, r3, #2              // n += 2
+        blt     BSYM(0)
+
+        bx      lr
+}
+
+/*---------------------------------------------------------------------------*
+  Name:         i_miCpuCopy16
+
+  Description:  copy memory by CPU
+                16bit version
+
+  Arguments:    srcp  : source address
+                destp : destination address
+                size  : size (byte)
+
+  Returns:      None
+ *---------------------------------------------------------------------------*/
+asm void i_miCpuCopy16( register const void *srcp, register void *destp, register u32 size )
+{
+        mov     r12, #0                 // n = 0
+
+LSYM(10)
+        cmp     r12, r2                 // n < size ?
+
+#ifndef CW_BUG_FOR_LDRH_AND_STRH
+        ldrlth  r3, [r0, r12]           // *((vu16 *)(destp + n)) = *((vu16 *)(srcp + n))
+#else
+        dcd     0xb19030bc
+#endif
+#ifndef CW_BUG_FOR_LDRH_AND_STRH
+        strlth  r3, [r1, r12]
+#else
+        dcd     0xb18130bc
+#endif
+        addlt   r12, r12, #2            // n += 2
+        blt     BSYM(10)
+
+        bx      lr
+}
+
+/*---------------------------------------------------------------------------*
+  Name:         i_miCpuSend16
+
+  Description:  send u16 data to fixed address
+                16bit version
+
+  Arguments:    src   : data stream to send
+                dest  : destination address. not incremented
+                size  : size (byte)
+
+  Returns:      None
+ *---------------------------------------------------------------------------*/
+asm void i_miCpuSend16( register const void *srcp, register volatile void* destp, register u32 size )
+{
+        mov     r12, #0                 // n = 0
+
+LSYM(11)
+        cmp     r12, r2                 // n < size ?
+#ifndef CW_BUG_FOR_LDRH_AND_STRH
+        ldrlth  r3, [r0, r12]           // *((vu16 *)(destp + n)) = *((vu16 *)(srcp + n))
+#else
+        dcd     0xb19030bc
+#endif
+        strlth  r3, [r1, #0]
+        addlt   r12, r12, #2            // n += 2
+        blt     BSYM(11)
+
+        bx      lr
+}
+
+
+/*---------------------------------------------------------------------------*
+  Name:         i_miCpuClear32
+
+  Description:  fill memory with specified data.
+                32bit version
+
+  Arguments:    data  : fill data
+                destp : destination address
+                size  : size (byte)
+
+  Returns:      None
+ *---------------------------------------------------------------------------*/
+asm void i_miCpuClear32( register u32 data, register void *destp, register u32 size )
+{
+        add     r12, r1, r2             // r12: destEndp = destp + size
+
+LSYM(20)
+        cmp     r1, r12                 // while (destp < destEndp)
+        stmltia r1!, {r0}               // *((vu32 *)(destp++)) = data
+        blt     BSYM(20)
+        bx      lr
+}
+
+/*---------------------------------------------------------------------------*
+  Name:         i_miCpuCopy32
+
+  Description:  copy memory by CPU
+                32bit version
+
+  Arguments:    srcp  : source address
+                destp : destination address
+                size  : size (byte)
+
+  Returns:      None
+ *---------------------------------------------------------------------------*/
+asm void i_miCpuCopy32( register const void *srcp, register void *destp, register u32 size )
+{
+        add     r12, r1, r2             // r12: destEndp = destp + size
+
+LSYM(30)
+        cmp     r1, r12                 // while (destp < destEndp)
+        ldmltia r0!, {r2}               // *((vu32 *)(destp)++) = *((vu32 *)(srcp)++)
+        stmltia r1!, {r2}
+        blt     BSYM(30)
+
+        bx      lr
+}
+
+/*---------------------------------------------------------------------------*
+  Name:         i_miCpuSend32
+
+  Description:  send u32 data to fixed address
+                32bit version
+
+  Arguments:    src   : data stream to send
+                dest  : destination address. not incremented
+                size  : size (byte)
+
+  Returns:      None
+ *---------------------------------------------------------------------------*/
+asm void i_miCpuSend32( register const void *srcp, volatile void *destp, u32 size )
+{
+        add     r12, r0, r2             // r12: srcEndp = srcp + size
+
+LSYM(31)
+        cmp     r0, r12                 // while (srcp < srcEndp)
+        ldmltia r0!, {r2}               // *((vu32 *)(destp)) = *((vu32 *)(srcp)++)
+        strlt   r2, [r1]
+        blt     BSYM(31)
+
+        bx      lr
+}
+
+/*---------------------------------------------------------------------------*
+  Name:         i_miCpuClearFast
+
+  Description:  fill memory with specified data.
+                high speed by writing 32byte at a time using stm
+
+  Arguments:    data  : fill data
+                destp : destination address
+                size  : size (byte)
+
+  Returns:      None
+ *---------------------------------------------------------------------------*/
+asm void i_miCpuClearFast( register u32 data, register void *destp, register u32 size )
+{
+        stmfd   sp!, {r4-r9}
+
+        add     r9, r1, r2              // r9:  destEndp = destp + size
+        mov     r12, r2, lsr #5         // r12: destBlockEndp = destp + size/32*32
+        add     r12, r1, r12, lsl #5
+
+        mov     r2, r0
+        mov     r3, r2
+        mov     r4, r2
+        mov     r5, r2
+        mov     r6, r2
+        mov     r7, r2
+        mov     r8, r2
+
+LSYM(40)
+        cmp     r1, r12                 // while (destp < destBlockEndp)
+        stmltia r1!, {r0, r2-r8}        // *((vu32 *)(destp++)) = data
+        blt     BSYM(40)
+LSYM(41)
+        cmp     r1, r9                  // while (destp < destEndp)
+        stmltia r1!, {r0}               // *((vu32 *)(destp++)) = data
+        blt     BSYM(41)
+
+        ldmfd   sp!, {r4-r9}
+        bx      lr
+}
+
+/*---------------------------------------------------------------------------*
+  Name:         i_miCpuCopyFast
+
+  Description:  copy memory by CPU
+                high speed by loading/writing 32byte at a time using stm/ldm
+
+  Arguments:    srcp  : source address
+                destp : destination address
+                size  : size (byte)
+
+  Returns:      None
+ *---------------------------------------------------------------------------*/
+asm void i_miCpuCopyFast( register const void *srcp, register void *destp, register u32 size )
+{
+        stmfd   sp!, {r4-r10}
+
+        add     r10, r1, r2             // r10:  destEndp = destp + size
+        mov     r12, r2, lsr #5         // r12: destBlockEndp = destp + size/32*32
+        add     r12, r1, r12, lsl #5
+
+LSYM(50)
+        cmp     r1, r12                 // while (destp < destBlockEndp)
+        ldmltia r0!, {r2-r9}            // *((vu32 *)(destp)++) = *((vu32 *)(srcp)++)
+        stmltia r1!, {r2-r9}
+        blt     BSYM(50)
+LSYM(51)
+        cmp     r1, r10                 // while (destp < destEndp)
+        ldmltia r0!, {r2}               // *((vu32 *)(destp)++) = *((vu32 *)(srcp)++)
+        stmltia r1!, {r2}
+        blt     BSYM(51)
+
+        ldmfd   sp!, {r4-r10}
+        bx      lr
+}
+
+//=======================================================================
+//           FOR CONVINIENCE (memory copy)
+//=======================================================================
+#ifdef BROM_ENABLE_CONVINIENCE_COPY
+/*---------------------------------------------------------------------------*
+  Name:         miCopy16B
+
+  Description:  copy 16byte data by CPU
+
+  Arguments:    srcp  : source address
+                destp : destination address
+
+  Returns:      None
+ *---------------------------------------------------------------------------*/
+asm void miCopy16B(register const void* pSrc, register void* pDest)
+{
+    ldmia   r0!, {r2, r3, r12}         // r0-r3, r12 need not saved
+    stmia   r1!, {r2, r3, r12}
+    ldmia   r0!, {r2}
+    stmia   r1!, {r2}
+
+    bx      lr
+}
+
+/*---------------------------------------------------------------------------*
+  Name:         miCopy32B
+
+  Description:  copy 32byte data by CPU
+
+  Arguments:    srcp  : source address
+                destp : destination address
+
+  Returns:      None
+ *---------------------------------------------------------------------------*/
+asm void miCopy32B(register const void* pSrc, register void* pDest)
+{
+    ldmia   r0!, {r2, r3, r12}         // r0-r3, r12 need not saved
+    stmia   r1!, {r2, r3, r12}
+    ldmia   r0!, {r2, r3, r12}
+    stmia   r1!, {r2, r3, r12}
+    ldmia   r0!, {r2, r3}
+    stmia   r1!, {r2, r3}
+
+    bx      lr
+}
+
+/*---------------------------------------------------------------------------*
+  Name:         miCopy36B
+
+  Description:  copy 36byte data by CPU
+
+  Arguments:    srcp  : source address
+                destp : destination address
+
+  Returns:      None
+ *---------------------------------------------------------------------------*/
+asm void miCopy36B(register const void* pSrc, register void* pDest)
+{
+    ldmia   r0!, {r2, r3, r12}         // r0-r3, r12 need not saved
+    stmia   r1!, {r2, r3, r12}
+    ldmia   r0!, {r2, r3, r12}
+    stmia   r1!, {r2, r3, r12}
+    ldmia   r0!, {r2, r3, r12}
+    stmia   r1!, {r2, r3, r12}
+
+    bx      lr
+}
+
+/*---------------------------------------------------------------------------*
+  Name:         miCopy48B
+
+  Description:  copy 48byte data by CPU
+
+  Arguments:    srcp  : source address
+                destp : destination address
+
+  Returns:      None
+ *---------------------------------------------------------------------------*/
+asm void miCopy48B(register const void* pSrc, register void* pDest)
+{
+    ldmia   r0!, {r2, r3, r12}         // r0-r3, r12 need not saved
+    stmia   r1!, {r2, r3, r12}
+    ldmia   r0!, {r2, r3, r12}
+    stmia   r1!, {r2, r3, r12}
+    ldmia   r0!, {r2, r3, r12}
+    stmia   r1!, {r2, r3, r12}
+    ldmia   r0!, {r2, r3, r12}
+    stmia   r1!, {r2, r3, r12}
+
+    bx      lr
+}
+
+/*---------------------------------------------------------------------------*
+  Name:         miCopy64B
+
+  Description:  copy 64byte data by CPU
+
+  Arguments:    srcp  : source address
+                destp : destination address
+
+  Returns:      None
+ *---------------------------------------------------------------------------*/
+asm void miCopy64B(register const void* pSrc, register void* pDest)
+{
+    ldmia   r0!, {r2, r3, r12}         // r0-r3, r12 need not saved
+    stmia   r1!, {r2, r3, r12}
+    ldmia   r0!, {r2, r3, r12}
+    stmia   r1!, {r2, r3, r12}
+    ldmia   r0!, {r2, r3, r12}
+    stmia   r1!, {r2, r3, r12}
+    ldmia   r0!, {r2, r3, r12}
+    stmia   r1!, {r2, r3, r12}
+    ldmia   r0,  {r0, r2, r3, r12}
+    stmia   r1!, {r0, r2, r3, r12}
+
+    bx      lr
+}
+
+/*---------------------------------------------------------------------------*
+  Name:         miCopy128B
+
+  Description:  copy 128byte data by CPU
+
+  Arguments:    srcp  : source address
+                destp : destination address
+
+  Returns:      None
+ *---------------------------------------------------------------------------*/
+asm void miCopy128B(register const void* pSrc, register void* pDest)
+{
+    stmfd   sp!, {r4}
+
+    ldmia   r0!, {r2, r3, r4, r12}         // r0-r3, r12 need not saved
+    stmia   r1!, {r2, r3, r4, r12}
+    ldmia   r0!, {r2, r3, r4, r12}
+    stmia   r1!, {r2, r3, r4, r12}
+    ldmia   r0!, {r2, r3, r4, r12}
+    stmia   r1!, {r2, r3, r4, r12}
+    ldmia   r0!, {r2, r3, r4, r12}
+    stmia   r1!, {r2, r3, r4, r12}
+    ldmia   r0!, {r2, r3, r4, r12}
+    stmia   r1!, {r2, r3, r4, r12}
+    ldmia   r0!, {r2, r3, r4, r12}
+    stmia   r1!, {r2, r3, r4, r12}
+    ldmia   r0!, {r2, r3, r4, r12}
+    stmia   r1!, {r2, r3, r4, r12}
+    ldmia   r0!, {r2, r3, r4, r12}
+    stmia   r1!, {r2, r3, r4, r12}
+
+    ldmfd   sp!, {r4}
+    bx      lr
+}
+#endif // BROM_BROM_ENABLE_CONVINIENCE_COPY
+
+
+//=======================================================================
+//           FOR SDK USE (needless set alignment)
+//=======================================================================
+/*---------------------------------------------------------------------------*
+  Name:         miCpuFill8
+
+  Description:  fill memory with specified data.
+                consider for alignment automatically.
+
+  Arguments:    dstp  : destination address
+                data  : fill data
+                size  : size (byte)
+
+  Returns:      None
+ *---------------------------------------------------------------------------*/
+#ifdef SDK_SMALL_BUILD
+asm void miCpuFill8( register void *dstp, register u8 data, register u32 size )
+{
+        mov     r12, #0                 // n = 0
+LSYM(1)
+        cmp     r12, r2                 // n < size ?
+        strltb  r1, [r0, r12]           // *((u8*)( dstp + n ) ) = data
+
+        addlt   r12, r12, #1            // n ++
+        blt     BYM(1)
+
+        bx      lr
+}
+#else  //ifdef SDK_SMALL_BUILD
+asm void miCpuFill8( register void *dstp, register u8 data, register u32 size )
+{
+    cmp     r2, #0
+    bxeq    lr
+
+    // dstp を 16bit アライン.
+    tst     r0, #1
+    beq     FSYM(1)
+#ifndef CW_BUG_FOR_LDRH_AND_STRH
+    ldrh    r12, [r0, #-1]
+#else
+    LDRH_AD4( HALFW_CONDAL, 12, 0, 1 ) // *** for CW BUG
+#endif
+    and     r12, r12, #0x00FF
+    orr     r3, r12, r1, lsl #8
+#ifndef CW_BUG_FOR_LDRH_AND_STRH
+    strh    r3, [r0, #-1]
+#else
+    STRH_AD4( HALFW_CONDAL, 3, 0, 1 ) // *** for CW BUG
+#endif
+    add     r0, r0, #1
+    subs    r2, r2, #1
+    bxeq    lr
+LSYM(1)
+
+    // 32bit アライン.
+    cmp     r2, #2
+    bcc     FSYM(6)
+    orr     r1, r1, r1, lsl #8
+    tst     r0, #2
+    beq     FSYM(8)
+#ifndef CW_BUG_FOR_LDRH_AND_STRH
+    strh    r1, [r0], #2
+#else
+    STRH_AD1( HALFW_CONDAL, 1, 0, 2 ) // *** for CW BUG
+#endif
+    subs    r2, r2, #2
+    bxeq    lr
+LSYM(8)
+    // 32bit 転送.
+    orr     r1, r1, r1, lsl #16
+    bics    r3, r2, #3
+    beq     FSYM(10)
+    sub     r2, r2, r3
+    add     r12, r3, r0
+LSYM(9)
+    str     r1, [r0], #4
+    cmp     r0, r12
+    bcc     BSYM(9)
+
+LSYM(10)
+    //  最後の 16bit 転送.
+    tst     r2, #2
+#ifndef CW_BUG_FOR_LDRH_AND_STRH
+    strneh  r1, [r0], #2
+#else
+    STRH_AD1( HALFW_CONDNE, 1, 0, 2 ) // *** for CW BUG
+#endif
+
+LSYM(6)
+    //  最後の 8bit 転送.
+    tst     r2, #1
+    bxeq    lr
+#ifndef CW_BUG_FOR_LDRH_AND_STRH
+    ldrh    r3, [r0]
+#else
+    LDRH_AD2( HALFW_CONDAL, 3, 0, 0 ) // *** for CW BUG
+#endif
+    and     r3, r3, #0xFF00
+    and     r1, r1, #0x00FF
+    orr     r1, r1, r3
+#ifndef CW_BUG_FOR_LDRH_AND_STRH
+    strh    r1, [r0]
+#else
+    STRH_AD2( HALFW_CONDAL, 1, 0, 0 ) // *** for CW BUG
+#endif
+    bx      lr
+}
+#endif // ifdef SDK_SMALL_BUILD
+
+/*---------------------------------------------------------------------------*
+  Name:         miCpuCopy8
+
+  Description:  copy memory by CPU
+                consider for alignment automatically.
+
+  Arguments:    srcp  : source address
+                dstp  : destination address
+                size  : size (byte)
+
+  Returns:      None
+ *---------------------------------------------------------------------------*/
+#ifdef SDK_SMALL_BUILD
+asm void miCpuCopy8( register const void *srcp, register void *dstp, register u32 size )
+{
+        mov     r12, #0                 // n = 0
+LSYM(1)
+        cmp     r12, r2                 // n < size ?
+        ldrltb  r3, [r0, r12]           // *((vu8 *)(destp + p)) = *((vu8 *)(srcp + n))
+        strltb  r3, [r1, r12]
+
+        addlt   r12, r12, #1            // n ++
+        blt     BSYM(1)
+
+        bx      lr
+}
+#else  //ifdef SDK_SMALL_BUILD
+asm void miCpuCopy8( register const void *srcp, register void *dstp, register u32 size )
+{
+    cmp     r2, #0
+    bxeq    lr
+
+    // dstp を 16bit アライン.
+    tst     r1, #1
+    beq     FSYM(1)
+#ifndef CW_BUG_FOR_LDRH_AND_STRH
+    ldrh    r12, [r1, #-1]
+#else
+    LDRH_AD4( HALFW_CONDAL, 12, 1, 1 ) // *** for CW BUG
+#endif
+    and     r12, r12, #0x00FF
+    tst     r0, #1
+#ifndef CW_BUG_FOR_LDRH_AND_STRH
+    ldrneh  r3, [r0, #-1]
+#else
+    LDRH_AD4( HALFW_CONDNE, 3, 0, 1 ) // *** for CW BUG
+#endif
+    movne   r3, r3, lsr #8
+#ifndef CW_BUG_FOR_LDRH_AND_STRH
+    ldreqh  r3, [r0]
+#else
+    LDRH_AD2( HALFW_CONDEQ, 3, 0, 0 ) // *** for CW BUG
+#endif
+    orr     r3, r12, r3, lsl #8
+#ifndef CW_BUG_FOR_LDRH_AND_STRH
+    strh    r3, [r1, #-1]
+#else
+    STRH_AD4( HALFW_CONDAL, 3, 1, 1 ) // *** for CW BUG
+#endif
+    add     r0, r0, #1
+    add     r1, r1, #1
+    subs    r2, r2, #1
+    bxeq    lr
+LSYM(1)
+
+    // アドレス端数の 16/32bit 同期をチェック.
+    eor     r12, r1, r0
+    tst     r12, #1
+    beq     FSYM(2)
+
+    // 全く同期しないので変則 16bit 転送.
+    //  tmp = *(u16*)src++ >> 8;
+    //  while((size -= 2) >= 0) {
+    //      tmp |= (*(u16*)src++ << 8);
+    //      *(u16*)dst++ = (u16)tmp;
+    //      tmp >>= 16;
+    //  }
+    bic     r0, r0, #1
+#ifndef CW_BUG_FOR_LDRH_AND_STRH
+    ldrh    r12, [r0], #2
+#else
+        LDRH_AD1( HALFW_CONDAL, 12, 0, 2 ) // *** for CW BUG
+#endif
+    mov     r3, r12, lsr #8
+    subs    r2, r2, #2
+    bcc     FSYM(3)
+LSYM(4)
+#ifndef CW_BUG_FOR_LDRH_AND_STRH
+    ldrh    r12, [r0], #2
+#else
+    LDRH_AD1( HALFW_CONDAL, 12, 0, 2 ) // *** for CW BUG
+#endif
+    orr     r12, r3, r12, lsl #8
+#ifndef CW_BUG_FOR_LDRH_AND_STRH
+    strh    r12, [r1], #2
+#else
+    STRH_AD1( HALFW_CONDAL, 12, 1, 2 ) // *** for CW BUG
+#endif
+    mov     r3, r12, lsr #16
+    subs    r2, r2, #2
+    bcs     BSYM(4)
+    
+LSYM(3)
+    //  if(size & 1)
+    //      *dst = (u16)((*dst & 0xFF00) | tmp);
+    //  return;
+    tst     r2, #1
+    bxeq    lr
+#ifndef CW_BUG_FOR_LDRH_AND_STRH
+    ldrh    r12, [r1]
+#else
+    LDRH_AD2( HALFW_CONDAL, 12, 1, 0 ) // *** for CW BUG
+#endif
+    and     r12, r12, #0xFF00
+    orr     r12, r12, r3
+#ifndef CW_BUG_FOR_LDRH_AND_STRH
+    strh    r12, [r1]
+#else
+    STRH_AD2( HALFW_CONDAL, 12, 1, 0 ) // *** for CW BUG
+#endif
+    bx      lr
+
+LSYM(2)
+    tst     r12, #2
+    beq     FSYM(5)
+    // 16bit 転送.
+    bics    r3, r2, #1
+    beq     FSYM(6)
+    sub     r2, r2, r3
+    add     r12, r3, r1
+LSYM(7)
+#ifndef CW_BUG_FOR_LDRH_AND_STRH
+    ldrh    r3, [r0], #2
+#else
+    LDRH_AD1( HALFW_CONDAL, 3, 0, 2 ) // *** for CW BUG
+#endif
+#ifndef CW_BUG_FOR_LDRH_AND_STRH
+    strh    r3, [r1], #2
+#else
+    STRH_AD1( HALFW_CONDAL, 3, 1, 2 ) // *** for CW BUG
+#endif
+    cmp     r1, r12
+    bcc     BSYM(7)
+    b       FSYM(6)
+
+LSYM(5)
+    // 32bit アライン.
+    cmp     r2, #2
+    bcc     FSYM(6)
+    tst     r1, #2
+    beq     FSYM(8)
+#ifndef CW_BUG_FOR_LDRH_AND_STRH
+    ldrh    r3, [r0], #2
+#else
+    LDRH_AD1( HALFW_CONDAL, 3, 0, 2 ) // *** for CW BUG
+#endif
+#ifndef CW_BUG_FOR_LDRH_AND_STRH
+    strh    r3, [r1], #2
+#else
+        STRH_AD1( HALFW_CONDAL, 3, 1, 2 ) // *** for CW BUG
+#endif
+    subs    r2, r2, #2
+    bxeq    lr
+LSYM(8)
+    // 32bit 転送.
+    bics    r3, r2, #3
+    beq     FSYM(10)
+    sub     r2, r2, r3
+    add     r12, r3, r1
+LSYM(9)
+    ldr     r3, [r0], #4
+    str     r3, [r1], #4
+    cmp     r1, r12
+    bcc     BSYM(9)
+
+LSYM(10)
+    //  最後の 16bit 転送.
+    tst     r2, #2
+#ifndef CW_BUG_FOR_LDRH_AND_STRH
+    ldrneh  r3, [r0], #2
+    strneh  r3, [r1], #2
+#else
+    LDRH_AD1( HALFW_CONDNE, 3, 0, 2 ) // *** for CW BUG
+    STRH_AD1( HALFW_CONDNE, 3, 1, 2 ) // *** for CW BUG
+#endif
+
+LSYM(6)
+    //  最後の 8bit 転送.
+    tst     r2, #1
+    bxeq    lr
+#ifndef CW_BUG_FOR_LDRH_AND_STRH
+    ldrh    r2, [r1]
+    ldrh    r0, [r0]
+#else
+    LDRH_AD2( HALFW_CONDAL, 2, 1, 0 ) // *** for CW BUG
+    LDRH_AD2( HALFW_CONDAL, 0, 0, 0 ) // *** for CW BUG
+#endif
+    and     r2, r2, #0xFF00
+    and     r0, r0, #0x00FF
+    orr     r0, r2, r0
+#ifndef CW_BUG_FOR_LDRH_AND_STRH
+    strh    r0, [r1]
+#else
+    STRH_AD2( HALFW_CONDAL, 0, 1, 0 ) // *** for CW BUG
+#endif
+    bx      lr
+}
+#endif //ifdef SDK_SMALL_BUILD
+
+#include <brom/codereset.h>
+
+

trunk/bootrom/build/libraries/os/common/os_thread.c

@@ -676,7 +676,7 @@ void osCreateThread(OSThread *thread,
     thread->context.lr = (u32)osExitThread;
 
     //---- clear Stack (except check code (=sizeof(u32)*2) and padding(sizeof(u32))
-    MI_CpuClear32((void *)((u32)stack - stackSize + sizeof(u32)), stackSize - sizeof(u32) * 2 - sizeof(u32) );
+    miCpuClear32((void *)((u32)stack - stackSize + sizeof(u32)), stackSize - sizeof(u32) * 2 - sizeof(u32) );
 
     //---- clear mutex
     thread->mutex = NULL;
@@ -699,7 +699,7 @@ void osCreateThread(OSThread *thread,
     thread->link.prev = thread->link.next = NULL;
 
     //---- clear specific member
-    MI_CpuClear32(&thread->specific[0], sizeof(void *) * OS_THREAD_SPECIFIC_MAX);
+    miCpuClear32(&thread->specific[0], sizeof(void *) * OS_THREAD_SPECIFIC_MAX);
 #endif
 
     //---- clear alarm pointer for sleep

trunk/bootrom/include/brom/mi/memory.h

@@ -26,36 +26,36 @@ extern "C" {
 
 
 //======================================================================
-void    MIi_CpuClear16(u16 data, void *destp, u32 size);
+void    i_miCpuClear16(u16 data, void *destp, u32 size);
-void    MIi_CpuCopy16(const void *srcp, void *destp, u32 size);
+void    i_miCpuCopy16(const void *srcp, void *destp, u32 size);
-void    MIi_CpuSend16(const void *srcp, volatile void *destp, u32 size);
+void    i_miCpuSend16(const void *srcp, volatile void *destp, u32 size);
-void    MIi_CpuRecv16(volatile const void *srcp, void *destp, u32 size);
+void    i_miCpuRecv16(volatile const void *srcp, void *destp, u32 size);
-void    MIi_CpuPipe16(volatile const void *srcp, volatile void *destp, u32 size);
+void    i_miCpuPipe16(volatile const void *srcp, volatile void *destp, u32 size);
-void    MIi_CpuMove16(const void *src, void *dest, u32 size);
+void    i_miCpuMove16(const void *src, void *dest, u32 size);
-void*   MIi_CpuFind16(const void *src, u16 data, u32 size);
+void*   i_miCpuFind16(const void *src, u16 data, u32 size);
-int     MIi_CpuComp16(const void *mem1, const void *mem2, u32 size);
+int     i_miCpuComp16(const void *mem1, const void *mem2, u32 size);
 
-void    MIi_CpuClear32(u32 data, void *destp, u32 size);
+void    i_miCpuClear32(u32 data, void *destp, u32 size);
-void    MIi_CpuCopy32(const void *srcp, void *destp, u32 size);
+void    i_miCpuCopy32(const void *srcp, void *destp, u32 size);
-void    MIi_CpuSend32(const void *srcp, volatile void *destp, u32 size);
+void    i_miCpuSend32(const void *srcp, volatile void *destp, u32 size);
-void    MIi_CpuRecv32(volatile const void *srcp, void *destp, u32 size);
+void    i_miCpuRecv32(volatile const void *srcp, void *destp, u32 size);
-void    MIi_CpuPipe32(volatile const void *srcp, volatile void *destp, u32 size);
+void    i_miCpuPipe32(volatile const void *srcp, volatile void *destp, u32 size);
-void    MIi_CpuMove32(const void *src, void *dest, u32 size);
+void    i_miCpuMove32(const void *src, void *dest, u32 size);
-void*   MIi_CpuFind32(const void *src, u32 data, u32 size);
+void*   i_miCpuFind32(const void *src, u32 data, u32 size);
-int     MIi_CpuComp32(const void *mem1, const void *mem2, u32 size);
+int     i_miCpuComp32(const void *mem1, const void *mem2, u32 size);
 
-void    MIi_CpuClearFast(u32 data, void *destp, u32 size);
+void    i_miCpuClearFast(u32 data, void *destp, u32 size);
-void    MIi_CpuCopyFast(const void *srcp, void *destp, u32 size);
+void    i_miCpuCopyFast(const void *srcp, void *destp, u32 size);
-void    MIi_CpuSendFast(const void *srcp, volatile void *destp, u32 size);
+void    i_miCpuSendFast(const void *srcp, volatile void *destp, u32 size);
-void    MIi_CpuRecvFast(volatile const void *srcp, void *destp, u32 size);
+void    i_miCpuRecvFast(volatile const void *srcp, void *destp, u32 size);
-void    MIi_CpuMoveFast(const void *src, void *dest, u32 size);
+void    i_miCpuMoveFast(const void *src, void *dest, u32 size);
 
 
 //================================================================================
 //               32 bit version
 //================================================================================
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuFill32
+  Name:         miCpuFill32
 
   Description:  fill memory with specified data.  (32 bit version)
 
@@ -65,16 +65,16 @@ void    MIi_CpuMoveFast(const void *src, void *dest, u32 size);
 
   Returns:      None
  *---------------------------------------------------------------------------*/
-static inline void MI_CpuFill32(void *dest, u32 data, u32 size)
+static inline void miCpuFill32(void *dest, u32 data, u32 size)
 {
     SDK_ASSERTMSG((size & 3) == 0, "size & 3 must be 0");
     SDK_ASSERTMSG(((u32)dest & 3) == 0, "destination address must be in 4-byte alignment");
 
-    MIi_CpuClear32(data, dest, size);
+    i_miCpuClear32(data, dest, size);
 }
 
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuCopy32
+  Name:         miCpuCopy32
 
   Description:  copy memory data (32 bit version)
 
@@ -84,17 +84,17 @@ static inline void MI_CpuFill32(void *dest, u32 data, u32 size)
 
   Returns:      None
  *---------------------------------------------------------------------------*/
-static inline void MI_CpuCopy32(const void *src, void *dest, u32 size)
+static inline void miCpuCopy32(const void *src, void *dest, u32 size)
 {
     SDK_ASSERTMSG((size & 3) == 0, "size & 3 must be 0");
     SDK_ASSERTMSG(((u32)src & 3) == 0, "source address must be in 4-byte alignment");
     SDK_ASSERTMSG(((u32)dest & 3) == 0, "destination address must be in 4-byte alignment");
 
-    MIi_CpuCopy32(src, dest, size);
+    i_miCpuCopy32(src, dest, size);
 }
 
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuClear32
+  Name:         miCpuClear32
 
   Description:  fill memory with 0 (32 bit version)
 
@@ -103,13 +103,13 @@ static inline void MI_CpuCopy32(const void *src, void *dest, u32 size)
 
   Returns:      None
  *---------------------------------------------------------------------------*/
-static inline void MI_CpuClear32(void *dest, u32 size)
+static inline void miCpuClear32(void *dest, u32 size)
 {
-    MI_CpuFill32(dest, 0, size);
+    miCpuFill32(dest, 0, size);
 }
 
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuSend32
+  Name:         miCpuSend32
 
   Description:  write some data to fixed address (32 bit version)
 
@@ -119,17 +119,17 @@ static inline void MI_CpuClear32(void *dest, u32 size)
 
   Returns:      None
  *---------------------------------------------------------------------------*/
-static inline void MI_CpuSend32(const void *src, volatile void *dest, u32 size)
+static inline void miCpuSend32(const void *src, volatile void *dest, u32 size)
 {
     SDK_ASSERTMSG((size & 3) == 0, "size & 3 must be 0");
     SDK_ASSERTMSG(((u32)src & 3) == 0, "source address must be in 4-byte alignment");
     SDK_ASSERTMSG(((u32)dest & 3) == 0, "destination address must be in 4-byte alignment");
 
-    MIi_CpuSend32(src, dest, size);
+    i_miCpuSend32(src, dest, size);
 }
 
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuRecv32
+  Name:         miCpuRecv32
 
   Description:  receive u32 data from fixed address
                 32bit version
@@ -140,17 +140,17 @@ static inline void MI_CpuSend32(const void *src, volatile void *dest, u32 size)
 
   Returns:      None
  *---------------------------------------------------------------------------*/
-static inline void MI_CpuRecv32(volatile const void *src, void *dest, u32 size)
+static inline void miCpuRecv32(volatile const void *src, void *dest, u32 size)
 {
     SDK_ASSERTMSG((size & 3) == 0, "size & 3 must be 0");
     SDK_ASSERTMSG(((u32)src & 3) == 0, "source address must be in 4-byte alignment");
     SDK_ASSERTMSG(((u32)dest & 3) == 0, "destination address must be in 4-byte alignment");
 
-    MIi_CpuRecv32(src, dest, size);
+    i_miCpuRecv32(src, dest, size);
 }
 
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuPipe32
+  Name:         miCpuPipe32
 
   Description:  pipe data from fixed address to fixed address.
                 32bit version
@@ -161,17 +161,17 @@ static inline void MI_CpuRecv32(volatile const void *src, void *dest, u32 size)
 
   Returns:      None
  *---------------------------------------------------------------------------*/
-static inline void MI_CpuPipe32(volatile const void *src, volatile void *dest, u32 size)
+static inline void miCpuPipe32(volatile const void *src, volatile void *dest, u32 size)
 {
     SDK_ASSERTMSG((size & 3) == 0, "size & 3 must be 0");
     SDK_ASSERTMSG(((u32)src & 3) == 0, "source address must be in 4-byte alignment");
     SDK_ASSERTMSG(((u32)dest & 3) == 0, "destination address must be in 4-byte alignment");
 
-    MIi_CpuPipe32(src, dest, size);
+    i_miCpuPipe32(src, dest, size);
 }
 
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuMove32
+  Name:         miCpuMove32
 
   Description:  move memory data (32 bit version)
 
@@ -181,17 +181,17 @@ static inline void MI_CpuPipe32(volatile const void *src, volatile void *dest, u
 
   Returns:      None
  *---------------------------------------------------------------------------*/
-static inline void MI_CpuMove32(const void *src, void *dest, u32 size)
+static inline void miCpuMove32(const void *src, void *dest, u32 size)
 {
     SDK_ASSERTMSG((size & 3) == 0, "size & 3 must be 0");
     SDK_ASSERTMSG(((u32)src & 3) == 0, "source address must be in 4-byte alignment");
     SDK_ASSERTMSG(((u32)dest & 3) == 0, "destination address must be in 4-byte alignment");
 
-    MIi_CpuMove32(src, dest, size);
+    i_miCpuMove32(src, dest, size);
 }
 
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuFind32
+  Name:         miCpuFind32
 
   Description:  find memory data (32 bit version)
 
@@ -201,16 +201,16 @@ static inline void MI_CpuMove32(const void *src, void *dest, u32 size)
 
   Returns:      pointer to found data or NULL.
  *---------------------------------------------------------------------------*/
-static inline void* MI_CpuFind32(const void *src, u32 data, u32 size)
+static inline void* miCpuFind32(const void *src, u32 data, u32 size)
 {
     SDK_ASSERTMSG((size & 3) == 0, "size & 3 must be 0");
     SDK_ASSERTMSG(((u32)src & 3) == 0, "source address must be in 4-byte alignment");
 
-    return MIi_CpuFind32(src, data, size);
+    return i_miCpuFind32(src, data, size);
 }
 
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuComp32
+  Name:         miCpuComp32
 
   Description:  compare memory data (32 bit version)
 
@@ -222,20 +222,20 @@ static inline void* MI_CpuFind32(const void *src, u32 data, u32 size)
                 = 0 : mem1 equals mem2
                 > 0 : mem1 larger than mem2
  *---------------------------------------------------------------------------*/
-static inline int MI_CpuComp32(const void *mem1, const void *mem2, u32 size)
+static inline int miCpuComp32(const void *mem1, const void *mem2, u32 size)
 {
     SDK_ASSERTMSG((size & 3) == 0, "size & 3 must be 0");
     SDK_ASSERTMSG(((u32)mem1 & 3) == 0, "target address 1 must be in 4-byte alignment");
     SDK_ASSERTMSG(((u32)mem2 & 3) == 0, "target address 2 must be in 4-byte alignment");
 
-    return MIi_CpuComp32(mem1, mem2, size);
+    return i_miCpuComp32(mem1, mem2, size);
 }
 
 //================================================================================
 //               16 bit version
 //================================================================================
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuFill16
+  Name:         miCpuFill16
 
   Description:  fill memory with specified data.  (16 bit version)
 
@@ -245,16 +245,16 @@ static inline int MI_CpuComp32(const void *mem1, const void *mem2, u32 size)
 
   Returns:      None
  *---------------------------------------------------------------------------*/
-static inline void MI_CpuFill16(void *dest, u16 data, u32 size)
+static inline void miCpuFill16(void *dest, u16 data, u32 size)
 {
     SDK_ASSERTMSG((size & 1) == 0, "size & 1 must be 0");
     SDK_ASSERTMSG(((u32)dest & 1) == 0, "source address must be in 2-byte alignment");
 
-    MIi_CpuClear16(data, dest, size);
+    i_miCpuClear16(data, dest, size);
 }
 
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuCopy16
+  Name:         miCpuCopy16
 
   Description:  copy memory data (16 bit version)
 
@@ -264,17 +264,17 @@ static inline void MI_CpuFill16(void *dest, u16 data, u32 size)
 
   Returns:      None
  *---------------------------------------------------------------------------*/
-static inline void MI_CpuCopy16(const void *src, void *dest, u32 size)
+static inline void miCpuCopy16(const void *src, void *dest, u32 size)
 {
     SDK_ASSERTMSG((size & 1) == 0, "size & 1 must be 0");
     SDK_ASSERTMSG(((u32)src & 1) == 0, "source address must be in 2-byte alignment");
     SDK_ASSERTMSG(((u32)dest & 1) == 0, "destination address must be in 2-byte alignment");
 
-    MIi_CpuCopy16(src, dest, size);
+    i_miCpuCopy16(src, dest, size);
 }
 
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuClear16
+  Name:         miCpuClear16
 
   Description:  fill memory with 0 (16 bit version)
 
@@ -283,13 +283,13 @@ static inline void MI_CpuCopy16(const void *src, void *dest, u32 size)
 
   Returns:      None
  *---------------------------------------------------------------------------*/
-static inline void MI_CpuClear16(void *dest, u32 size)
+static inline void miCpuClear16(void *dest, u32 size)
 {
-    MI_CpuFill16(dest, 0, size);
+    miCpuFill16(dest, 0, size);
 }
 
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuSend16
+  Name:         miCpuSend16
 
   Description:  write some data to fixed address (16 bit version)
 
@@ -299,17 +299,17 @@ static inline void MI_CpuClear16(void *dest, u32 size)
 
   Returns:      None
  *---------------------------------------------------------------------------*/
-static inline void MI_CpuSend16(const void *src, volatile void *dest, u32 size)
+static inline void miCpuSend16(const void *src, volatile void *dest, u32 size)
 {
     SDK_ASSERTMSG((size & 1) == 0, "size & 1 must be 0");
     SDK_ASSERTMSG(((u32)src & 1) == 0, "source address must be in 2-byte alignment");
     SDK_ASSERTMSG(((u32)dest & 1) == 0, "destination address must be in 2-byte alignment");
 
-    MIi_CpuSend16(src, dest, size);
+    i_miCpuSend16(src, dest, size);
 }
 
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuRecv16
+  Name:         miCpuRecv16
 
   Description:  receive u16 data from fixed address
                 16bit version
@@ -320,17 +320,17 @@ static inline void MI_CpuSend16(const void *src, volatile void *dest, u32 size)
 
   Returns:      None
  *---------------------------------------------------------------------------*/
-static inline void MI_CpuRecv16(volatile const void *src, void *dest, u32 size)
+static inline void miCpuRecv16(volatile const void *src, void *dest, u32 size)
 {
     SDK_ASSERTMSG((size & 1) == 0, "size & 1 must be 0");
     SDK_ASSERTMSG(((u32)src & 1) == 0, "source address must be in 2-byte alignment");
     SDK_ASSERTMSG(((u32)dest & 1) == 0, "destination address must be in 2-byte alignment");
 
-    MIi_CpuRecv16(src, dest, size);
+    i_miCpuRecv16(src, dest, size);
 }
 
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuRecv16
+  Name:         miCpuRecv16
 
   Description:  pipe data from fixed address to fixed address.
                 16bit version
@@ -341,17 +341,17 @@ static inline void MI_CpuRecv16(volatile const void *src, void *dest, u32 size)
 
   Returns:      None
  *---------------------------------------------------------------------------*/
-static inline void MI_CpuPipe16(volatile const void *src, volatile void *dest, u32 size)
+static inline void miCpuPipe16(volatile const void *src, volatile void *dest, u32 size)
 {
     SDK_ASSERTMSG((size & 1) == 0, "size & 1 must be 0");
     SDK_ASSERTMSG(((u32)src & 1) == 0, "source address must be in 2-byte alignment");
     SDK_ASSERTMSG(((u32)dest & 1) == 0, "destination address must be in 2-byte alignment");
 
-    MIi_CpuPipe16(src, dest, size);
+    i_miCpuPipe16(src, dest, size);
 }
 
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuMove16
+  Name:         miCpuMove16
 
   Description:  move memory data (16 bit version)
 
@@ -361,17 +361,17 @@ static inline void MI_CpuPipe16(volatile const void *src, volatile void *dest, u
 
   Returns:      None
  *---------------------------------------------------------------------------*/
-static inline void MI_CpuMove16(const void *src, void *dest, u32 size)
+static inline void miCpuMove16(const void *src, void *dest, u32 size)
 {
     SDK_ASSERTMSG((size & 1) == 0, "size & 1 must be 0");
     SDK_ASSERTMSG(((u32)src & 1) == 0, "source address must be in 2-byte alignment");
     SDK_ASSERTMSG(((u32)dest & 1) == 0, "destination address must be in 2-byte alignment");
 
-    MIi_CpuMove16(src, dest, size);
+    i_miCpuMove16(src, dest, size);
 }
 
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuFind16
+  Name:         miCpuFind16
 
   Description:  find memory data (16 bit version)
 
@@ -381,16 +381,16 @@ static inline void MI_CpuMove16(const void *src, void *dest, u32 size)
 
   Returns:      pointer to found data or NULL.
  *---------------------------------------------------------------------------*/
-static inline void* MI_CpuFind16(const void *src, u16 data, u32 size)
+static inline void* miCpuFind16(const void *src, u16 data, u32 size)
 {
     SDK_ASSERTMSG((size & 1) == 0, "size & 1 must be 0");
     SDK_ASSERTMSG(((u32)src & 1) == 0, "source address must be in 2-byte alignment");
 
-    return MIi_CpuFind16(src, data, size);
+    return i_miCpuFind16(src, data, size);
 }
 
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuComp16
+  Name:         miCpuComp16
 
   Description:  compare memory data (16 bit version)
 
@@ -402,20 +402,20 @@ static inline void* MI_CpuFind16(const void *src, u16 data, u32 size)
                 = 0 : mem1 equals mem2
                 > 0 : mem1 larger than mem2
  *---------------------------------------------------------------------------*/
-static inline int MI_CpuComp16(const void *mem1, const void *mem2, u32 size)
+static inline int miCpuComp16(const void *mem1, const void *mem2, u32 size)
 {
     SDK_ASSERTMSG((size & 1) == 0, "size & 1 must be 0");
     SDK_ASSERTMSG(((u32)mem1 & 1) == 0, "target address 1 must be in 2-byte alignment");
     SDK_ASSERTMSG(((u32)mem2 & 1) == 0, "target address 2 must be in 2-byte alignment");
 
-    return MIi_CpuComp16(mem1, mem2, size);
+    return i_miCpuComp16(mem1, mem2, size);
 }
 
 //================================================================================
 //               32 byte unit version
 //================================================================================
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuFillFast
+  Name:         miCpuFillFast
 
   Description:  fill memory with specified data quickly.  (32 byte unit version)
 
@@ -425,16 +425,16 @@ static inline int MI_CpuComp16(const void *mem1, const void *mem2, u32 size)
 
   Returns:      None
  *---------------------------------------------------------------------------*/
-static inline void MI_CpuFillFast(void *dest, u32 data, u32 size)
+static inline void miCpuFillFast(void *dest, u32 data, u32 size)
 {
     SDK_ASSERTMSG((size & 3) == 0, "size & 3 must be 0");
     SDK_ASSERTMSG(((u32)dest & 3) == 0, "source address must be in 4-byte alignment");
 
-    MIi_CpuClearFast(data, dest, size);
+    i_miCpuClearFast(data, dest, size);
 }
 
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuCopyFast
+  Name:         miCpuCopyFast
 
   Description:  copy memory data quickly (32 byte unit version)
 
@@ -444,17 +444,17 @@ static inline void MI_CpuFillFast(void *dest, u32 data, u32 size)
 
   Returns:      None
  *---------------------------------------------------------------------------*/
-static inline void MI_CpuCopyFast(const void *src, void *dest, u32 size)
+static inline void miCpuCopyFast(const void *src, void *dest, u32 size)
 {
     SDK_ASSERTMSG((size & 3) == 0, "size & 3 must be 0");
     SDK_ASSERTMSG(((u32)src & 3) == 0, "source address must be in 4-byte alignment");
     SDK_ASSERTMSG(((u32)dest & 3) == 0, "destination address must be in 4-byte alignment");
 
-    MIi_CpuCopyFast(src, dest, size);
+    i_miCpuCopyFast(src, dest, size);
 }
 
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuClearFast
+  Name:         miCpuClearFast
 
   Description:  fill memory with 0 quickly (32 byte unit version)
 
@@ -463,15 +463,15 @@ static inline void MI_CpuCopyFast(const void *src, void *dest, u32 size)
 
   Returns:      None
  *---------------------------------------------------------------------------*/
-static inline void MI_CpuClearFast(void *dest, u32 size)
+static inline void miCpuClearFast(void *dest, u32 size)
 {
     SDK_ASSERTMSG((size & 3) == 0, "size & 3 must be 0");
     SDK_ASSERTMSG(((u32)dest & 3) == 0, "destination address must be in 4-byte alignment");
 
-    MI_CpuFillFast(dest, 0, size);
+    miCpuFillFast(dest, 0, size);
 }
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuSendFast
+  Name:         miCpuSendFast
 
   Description:  move memory data (32 byte unit version)
 
@@ -481,17 +481,17 @@ static inline void MI_CpuClearFast(void *dest, u32 size)
 
   Returns:      None
  *---------------------------------------------------------------------------*/
-static inline void MI_CpuSendFast( register const void *src, register volatile void *dest, register u32 size )
+static inline void miCpuSendFast( register const void *src, register volatile void *dest, register u32 size )
 {
     SDK_ASSERTMSG((size & 3) == 0, "size & 3 must be 0");
     SDK_ASSERTMSG(((u32)src & 3) == 0, "source address must be in 4-byte alignment");
     SDK_ASSERTMSG(((u32)dest & 3) == 0, "destination address must be in 4-byte alignment");
 
-	MIi_CpuSendFast(src, dest, size);
+	i_miCpuSendFast(src, dest, size);
 }
 
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuRecvFast
+  Name:         miCpuRecvFast
 
   Description:  move memory data (32 byte unit version)
 
@@ -501,17 +501,17 @@ static inline void MI_CpuSendFast( register const void *src, register volatile v
 
   Returns:      None
  *---------------------------------------------------------------------------*/
-static inline void MI_CpuRecvFast(volatile const void *src, register void *dest, register u32 size)
+static inline void miCpuRecvFast(volatile const void *src, register void *dest, register u32 size)
 {
     SDK_ASSERTMSG((size & 3) == 0, "size & 3 must be 0");
     SDK_ASSERTMSG(((u32)src & 3) == 0, "source address must be in 4-byte alignment");
     SDK_ASSERTMSG(((u32)dest & 3) == 0, "destination address must be in 4-byte alignment");
 
-	MIi_CpuRecvFast(src, dest, size);
+	i_miCpuRecvFast(src, dest, size);
 }
 
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuMoveFast
+  Name:         miCpuMoveFast
 
   Description:  move memory data (32 byte unit version)
 
@@ -521,13 +521,13 @@ static inline void MI_CpuRecvFast(volatile const void *src, register void *dest,
 
   Returns:      None
  *---------------------------------------------------------------------------*/
-static inline void MI_CpuMoveFast(const void *src, void *dest, u32 size)
+static inline void miCpuMoveFast(const void *src, void *dest, u32 size)
 {
     SDK_ASSERTMSG((size & 3) == 0, "size & 3 must be 0");
     SDK_ASSERTMSG(((u32)src & 3) == 0, "source address must be in 4-byte alignment");
     SDK_ASSERTMSG(((u32)dest & 3) == 0, "destination address must be in 4-byte alignment");
 
-    MIi_CpuMoveFast(src, dest, size);
+    i_miCpuMoveFast(src, dest, size);
 }
 
 
@@ -535,7 +535,7 @@ static inline void MI_CpuMoveFast(const void *src, void *dest, u32 size)
 //               8 bit version
 //================================================================================
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuFill8
+  Name:         miCpuFill8
 
   Description:  fill memory with specified data.  (8 bit version)
 
@@ -545,10 +545,10 @@ static inline void MI_CpuMoveFast(const void *src, void *dest, u32 size)
 
   Returns:      None
  *---------------------------------------------------------------------------*/
-void    MI_CpuFill8(void *dest, u8 data, u32 size);
+void    miCpuFill8(void *dest, u8 data, u32 size);
 
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuCopy8
+  Name:         miCpuCopy8
 
   Description:  copy memory data (8 bit version)
 
@@ -558,10 +558,10 @@ void    MI_CpuFill8(void *dest, u8 data, u32 size);
 
   Returns:      None
  *---------------------------------------------------------------------------*/
-void    MI_CpuCopy8(const void *src, void *dest, u32 size);
+void    miCpuCopy8(const void *src, void *dest, u32 size);
 
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuFind8
+  Name:         miCpuFind8
 
   Description:  find memory data (8 bit version)
 
@@ -571,10 +571,10 @@ void    MI_CpuCopy8(const void *src, void *dest, u32 size);
 
   Returns:      pointer to found data or NULL.
  *---------------------------------------------------------------------------*/
-void*   MI_CpuFind8(const void *src, u8 data, u32 size);
+void*   miCpuFind8(const void *src, u8 data, u32 size);
 
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuComp8
+  Name:         miCpuComp8
 
   Description:  compare memory data (8 bit version)
 
@@ -586,10 +586,10 @@ void*   MI_CpuFind8(const void *src, u8 data, u32 size);
                 = 0 : mem1 equals mem2
                 > 0 : mem1 larger than mem2
  *---------------------------------------------------------------------------*/
-int     MI_CpuComp8(const void *mem1, const void *mem2, u32 size);
+int     miCpuComp8(const void *mem1, const void *mem2, u32 size);
 
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuClear8
+  Name:         miCpuClear8
 
   Description:  fill memory with 0 (8 bit version)
 
@@ -598,16 +598,16 @@ int     MI_CpuComp8(const void *mem1, const void *mem2, u32 size);
 
   Returns:      None
  *---------------------------------------------------------------------------*/
-static inline void MI_CpuClear8(void *dest, u32 size)
+static inline void miCpuClear8(void *dest, u32 size)
 {
-    MI_CpuFill8(dest, 0, size);
+    miCpuFill8(dest, 0, size);
 }
 
 //================================================================================
 //               32 bit version
 //================================================================================
 /*---------------------------------------------------------------------------*
-  Name:         MI_ReadWord
+  Name:         miReadWord
 
   Description:  read 32 bit data from specified address
 
@@ -616,11 +616,11 @@ static inline void MI_CpuClear8(void *dest, u32 size)
   Returns:      data which is read
  *---------------------------------------------------------------------------*/
 #ifndef SDK_ASM
-#define MI_ReadWord( adrs )   (*(vu32 *)(adrs))
+#define miReadWord( adrs )   (*(vu32 *)(adrs))
 #endif
 
 /*---------------------------------------------------------------------------*
-  Name:         MI_WriteWord
+  Name:         miWriteWord
 
   Description:  write 32 bit data to specified adress
 
@@ -630,7 +630,7 @@ static inline void MI_CpuClear8(void *dest, u32 size)
   Returns:      None
  *---------------------------------------------------------------------------*/
 #ifndef SDK_ASM
-#define MI_WriteWord( adrs, val )  do { (*(vu32 *)(adrs)) = (u32)(val); } while(0)
+#define miWriteWord( adrs, val )  do { (*(vu32 *)(adrs)) = (u32)(val); } while(0)
 #endif
 
 
@@ -639,7 +639,7 @@ static inline void MI_CpuClear8(void *dest, u32 size)
 //================================================================================
 
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuFill
+  Name:         miCpuFill
 
   Description:  fill memory with specified data.  (mixed version)
 
@@ -649,10 +649,10 @@ static inline void MI_CpuClear8(void *dest, u32 size)
 
   Returns:      None
  *---------------------------------------------------------------------------*/
-void    MI_CpuFill(void *dest, u8 data, u32 size);
+void    miCpuFill(void *dest, u8 data, u32 size);
 
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuCopy
+  Name:         miCpuCopy
 
   Description:  copy memory data (mixed version)
 
@@ -662,10 +662,10 @@ void    MI_CpuFill(void *dest, u8 data, u32 size);
 
   Returns:      None
  *---------------------------------------------------------------------------*/
-void    MI_CpuCopy(const void *srcp, void *destp, u32 size);
+void    miCpuCopy(const void *srcp, void *destp, u32 size);
 
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuMove
+  Name:         miCpuMove
 
   Description:  move memory data (mixed version)
 
@@ -675,10 +675,10 @@ void    MI_CpuCopy(const void *srcp, void *destp, u32 size);
 
   Returns:      None
  *---------------------------------------------------------------------------*/
-void    MI_CpuMove(const void *srcp, void *destp, u32 size);
+void    miCpuMove(const void *srcp, void *destp, u32 size);
 
 /*---------------------------------------------------------------------------*
-  Name:         MI_CpuClear
+  Name:         miCpuClear
 
   Description:  fill memory with 0 (mixed version)
 
@@ -687,26 +687,26 @@ void    MI_CpuMove(const void *srcp, void *destp, u32 size);
 
   Returns:      None
  *---------------------------------------------------------------------------*/
-static inline void MI_CpuClear(void *dest, u32 size)
+static inline void miCpuClear(void *dest, u32 size)
 {
-    MI_CpuFill(dest, 0, size);
+    miCpuFill(dest, 0, size);
 }
 
 //================================================================================
 //      the following functions are prepared for SDK private use.
 //      don't use in application thoughtlessly
 //================================================================================
-void    MI_Copy16B(register const void *pSrc, register void *pDest);
+void    miCopy16B(register const void *pSrc, register void *pDest);
-void    MI_Copy32B(register const void *pSrc, register void *pDest);
+void    miCopy32B(register const void *pSrc, register void *pDest);
-void    MI_Copy36B(register const void *pSrc, register void *pDest);
+void    miCopy36B(register const void *pSrc, register void *pDest);
-void    MI_Copy48B(register const void *pSrc, register void *pDest);
+void    miCopy48B(register const void *pSrc, register void *pDest);
-void    MI_Copy64B(register const void *pSrc, register void *pDest);
+void    miCopy64B(register const void *pSrc, register void *pDest);
-void    MI_Copy128B(register const void *pSrc, register void *pDest);
+void    miCopy128B(register const void *pSrc, register void *pDest);
 
-void    MI_Zero32B(register void *pDest);
+void    miZero32B(register void *pDest);
-void    MI_Zero36B(register void *pDest);
+void    miZero36B(register void *pDest);
-void    MI_Zero48B(register void *pDest);
+void    miZero48B(register void *pDest);
-void    MI_Zero64B(register void *pDest);
+void    miZero64B(register void *pDest);
 
 #ifdef __cplusplus
 } /* extern "C" */