1 files changed, 267 insertions, 0 deletions

diff --git a/firmware/system.h b/firmware/system.h
new file mode 100644
index 0000000000..bacf90ad66
--- /dev/null
+++ b/firmware/system.h
@@ -0,0 +1,267 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id$
+ *
+ * Copyright (C) 2002 by Alan Korr
+ *
+ * All files in this archive are subject to the GNU General Public License.
+ * See the file COPYING in the source tree root for full license agreement.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+#ifndef __SYSTEM_H__
+#define __SYSTEM_H__
+#include <sh7034.h>
+
+#define KB  *1024
+#define MB  *1024 KB
+#define GB  *1024 MB
+
+#define Hz  *1
+#define KHz *1000 Hz
+#define MHz *1000 KHz
+
+#define ns  *1
+#define us  *1000 ns
+#define ms  *1000 us
+
+/*
+ *   11.059,200 MHz => 90.4224537037037037037037037037037... ns
+ *   12.000,000 MHz => 83.3333333333333333333333333333333... ns 
+ */
+
+#define PHI ((int)(12.000000 MHz))
+#define BAUDRATE 9600
+
+//#define PHI ((int)(11.059200 MHz))
+//#define BAUDRATE 115200 /* 115200 - 9600 */
+
+#define SI(a) \
+  (*((volatile int   *)a)) /* single integer access  - 32-bit */
+#define HI(a) \
+  (*((volatile short *)a)) /* half integer access    - 16-bit */
+#define QI(a) \
+  (*((volatile char  *)a)) /* quarter integer access - 8-bit  */
+
+#define nop \
+  asm volatile ("nop")
+
+#define __set_mask_constant(mask,address) \
+  asm                                     \
+    ("or.b\t%0,@(r0,gbr)"                 \
+     :                                    \
+     : /* %0 */ "I"((char)(mask)),        \
+       /* %1 */ "z"(address-GBR))
+
+#define __clear_mask_constant(mask,address) \
+  asm                                       \
+    ("and.b\t%0,@(r0,gbr)"                  \
+     :                                      \
+     : /* %0 */ "I"((char)~(mask)),         \
+       /* %1 */ "z"(address-GBR))
+
+#define __toggle_mask_constant(mask,address) \
+  asm                                        \
+    ("xor.b\t%0,@(r0,gbr)"                   \
+     :                                       \
+     : /* %0 */ "I"((char)(mask)),           \
+       /* %1 */ "z"(address-GBR))
+
+#define __test_mask_constant(mask,address)    \
+  ({                                          \
+    int result;                               \
+    asm                                       \
+      ("tst.b\t%1,@(r0,gbr)\n\tmovt\t%0"      \
+       : "=r"(result)                         \
+       : "I"((char)(mask)),"z"(address-GBR)); \
+    result;                                   \
+  })
+
+#define __set_bit_constant(bit,address) \
+  asm                                   \
+    ("or.b\t%0,@(r0,gbr)"               \
+     :                                  \
+     : /* %0 */ "I"((char)(1<<(bit))),  \
+       /* %1 */ "z"(address-GBR))
+
+#define __clear_bit_constant(bit,address) \
+  asm                                     \
+    ("and.b\t%0,@(r0,gbr)"                \
+     :                                    \
+     : /* %0 */ "I"((char)~(1<<(bit))),   \
+       /* %1 */ "z"(address-GBR))
+
+#define __toggle_bit_constant(bit,address) \
+  asm                                      \
+    ("xor.b\t%0,@(r0,gbr)"                 \
+     :                                     \
+     : /* %0 */ "I"((char)(1<<(bit))),     \
+       /* %1 */ "z"(address-GBR))
+
+#define __test_bit_constant(bit,address)      \
+  ({                                          \
+    int result;                               \
+    asm                                       \
+      ("tst.b\t%1,@(r0,gbr)\n\tmovt\t%0"      \
+       : "=r"(result)                         \
+       : "I"((char)(1<<(bit))),"z"(address-GBR)); \
+    result;                                   \
+  })
+
+#define __set_mask(mask,address)      /* FIXME */
+#define __test_mask(mask,address)   0 /* FIXME */
+#define __clear_mask(mask,address)    /* FIXME */
+#define __toggle_mask(mask,address)   /* FIXME */
+
+#define __set_bit(bit,address)      /* FIXME */
+#define __test_bit(bit,address)   0 /* FIXME */
+#define __clear_bit(bit,address)    /* FIXME */
+#define __toggle_bit(bit,address)   /* FIXME */
+
+#define set_mask(mask,address)          \
+  if (__builtin_constant_p (mask))      \
+    __set_mask_constant (mask,address); \
+  else                                  \
+    __set_mask (mask,address)
+
+#define clear_mask(mask,address)          \
+  if (__builtin_constant_p (mask))        \
+    __clear_mask_constant (mask,address); \
+  else                                    \
+    __clear_mask (mask,address)
+
+#define toggle_mask(mask,address)          \
+  if (__builtin_constant_p (mask))         \
+    __toggle_mask_constant (mask,address); \
+  else                                     \
+    __toggle_mask (mask,address)
+
+#define test_mask(mask,address)              \
+  (                                          \
+    (__builtin_constant_p (mask))            \
+  ? (int)__test_mask_constant (mask,address) \
+  : (int)__test_mask (mask,address)          \
+  )
+
+
+#define set_bit(bit,address)          \
+  if (__builtin_constant_p (bit))     \
+    __set_bit_constant (bit,address); \
+  else                                \
+    __set_bit (bit,address)
+
+#define clear_bit(bit,address)          \
+  if (__builtin_constant_p (bit))       \
+    __clear_bit_constant (bit,address); \
+  else                                  \
+    __clear_bit (bit,address)
+
+#define toggle_bit(bit,address)          \
+  if (__builtin_constant_p (bit))        \
+    __toggle_bit_constant (bit,address); \
+  else                                   \
+    __toggle_bit (bit,address)
+
+#define test_bit(bit,address)              \
+  (                                        \
+    (__builtin_constant_p (bit))           \
+  ? (int)__test_bit_constant (bit,address) \
+  : (int)__test_bit (bit,address)          \
+  )
+
+
+extern char __swap_bit[256];
+
+#define swap_bit(byte) \
+  __swap_bit[byte]
+
+static inline short swabHI (short value)
+  /*
+    result[15..8] = value[ 7..0];
+    result[ 7..0] = value[15..8];
+  */    
+  {
+    short result;
+    asm volatile ("swap.b\t%1,%0" : "=r"(result) : "r"(value));
+    return result;
+  }
+
+static inline int swawSI (int value)
+  /*
+    result[31..16] = value[15.. 0];
+    result[15.. 0] = value[31..16];
+  */    
+  {
+    int result;
+    asm volatile ("swap.w\t%1,%0" : "=r"(result) : "r"(value));
+    return result;
+  }
+
+static inline int swabSI (int value) // should be avoided as much as possible
+  /*
+    result[31..24] = value[ 7.. 0];
+    result[23..16] = value[15.. 8];
+    result[15.. 8] = value[23..16];
+    result[ 7.. 0] = value[31..24];
+  */    
+  {
+    return swabHI(swawSI(swabSI(value)));
+  }
+
+/* Test And Set - UNTESTED */
+static inline int tas (volatile int *pointer)
+  {
+    int result;
+    asm volatile ("tas.b\t@%1;movt\t%0" : "=t"(result) : "r"((char *)pointer) : "memory");
+    return result;
+  }
+
+static inline void sti (void)
+  {
+    asm volatile ("ldc\t%0,sr" : : "r"(0<<4));
+  }
+
+static inline void cli (void)
+  {
+    asm volatile ("ldc\t%0,sr" : : "r"(15<<4));
+  }
+
+/* Compare And Swap */
+static inline int cas (volatile int *pointer,int requested_value,int new_value)
+  {
+    cli();
+    if (*pointer == requested_value)
+      {
+        *pointer = new_value;
+        sti ();
+        return 1;
+      }
+    sti ();
+    return 0;
+  }
+
+static inline int cas2 (volatile int *pointer1,volatile int *pointer2,int requested_value1,int requested_value2,int new_value1,int new_value2)
+  {
+    cli();
+    if (*pointer1 == requested_value1 && *pointer2 == requested_value2)
+      {
+        *pointer1 = new_value1;
+        *pointer2 = new_value2;
+        sti ();
+        return 1;
+      }
+    sti ();
+    return 0;
+  }
+
+extern void system_reboot (void);
+
+#endif