271 lines
7.8 KiB
C
271 lines
7.8 KiB
C
/***************************************************************************
|
|
* __________ __ ___.
|
|
* 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]
|
|
|
|
#ifndef SIMULATOR
|
|
|
|
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));
|
|
}
|
|
|
|
#endif
|
|
|
|
/* 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
|