firmware/export/system.h - rockbox - Gitiles

 /***************************************************************************
  *             __________               __   ___.
  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
  *                     \/            \/     \/    \/            \/
  * $Id$
  *
  * Copyright (C) 2002 by Alan Korr
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
  *
  * 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 "cpu.h"
 #include "stdbool.h"
 #include "kernel.h"
 #include "gcc_extensions.h" /* for LIKELY/UNLIKELY */

 extern void system_reboot (void);
 /* Called from any UIE handler and panicf - wait for a key and return
  * to reboot system. */
 extern void system_exception_wait(void);
 extern void system_init(void);

 extern long cpu_frequency;

 struct flash_header {
     unsigned long magic;
     unsigned long length;
     char version[32];
 };

 bool detect_flashed_romimage(void);
 bool detect_flashed_ramimage(void);
 bool detect_original_firmware(void);

 #if defined(HAVE_ADJUSTABLE_CPU_FREQ) \
         && defined(ROCKBOX_HAS_LOGF) && (NUM_CORES == 1)
 #define CPU_BOOST_LOGGING
 #endif

 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
 #if NUM_CORES > 1
 extern struct spinlock boostctrl_spin;
 #endif
 void cpu_boost_init(void);
 #define FREQ cpu_frequency
 void set_cpu_frequency(long frequency);
 #ifdef CPU_BOOST_LOGGING
 char * cpu_boost_log_getlog_first(void);
 char * cpu_boost_log_getlog_next(void);
 int cpu_boost_log_getcount(void);
 void cpu_boost_(bool on_off, char* location, int line);
 #else
 void cpu_boost(bool on_off);
 #endif
 void cpu_idle_mode(bool on_off);
 int get_cpu_boost_counter(void);
 #else /* ndef HAVE_ADJUSTABLE_CPU_FREQ */
 #ifndef FREQ
 #define FREQ CPU_FREQ
 #endif
 #define set_cpu_frequency(frequency)
 #define cpu_boost(on_off)
 #define cpu_boost_id(on_off, id)
 #define cpu_idle_mode(on_off)
 #define get_cpu_boost_counter()
 #define get_cpu_boost_tracker()
 #endif /* HAVE_ADJUSTABLE_CPU_FREQ */

 #ifdef CPU_BOOST_LOGGING
 #define cpu_boost(on_off) cpu_boost_(on_off,__FILE__,  __LINE__)
 #endif

 #define BAUDRATE 9600

 #ifndef NULL
 #define NULL ((void*)0)
 #endif

 #ifndef MIN
 #define MIN(a, b) (((a)<(b))?(a):(b))
 #endif

 #ifndef MAX
 #define MAX(a, b) (((a)>(b))?(a):(b))
 #endif

 /* return number of elements in array a */
 #define ARRAYLEN(a) (sizeof(a)/sizeof((a)[0]))

 /* return p incremented by specified number of bytes */
 #define SKIPBYTES(p, count) ((typeof (p))((char *)(p) + (count)))

 #define P2_M1(p2)  ((1 << (p2))-1)

 /* align up or down to nearest 2^p2 */
 #define ALIGN_DOWN_P2(n, p2) ((n) & ~P2_M1(p2))
 #define ALIGN_UP_P2(n, p2)   ALIGN_DOWN_P2((n) + P2_M1(p2),p2)

 /* align up or down to nearest integer multiple of a */
 #define ALIGN_DOWN(n, a)     ((typeof(n))((typeof(a))(n)/(a)*(a)))
 #define ALIGN_UP(n, a)       ALIGN_DOWN((n)+((a)-1),a)

 /* align start and end of buffer to nearest integer multiple of a */
 #define ALIGN_BUFFER(ptr,len,align) \
 {\
     uintptr_t tmp_ptr1 = (uintptr_t)ptr; \
     uintptr_t tmp_ptr2 = tmp_ptr1 + len;\
     tmp_ptr1 = ALIGN_UP(tmp_ptr1,align); \
     tmp_ptr2 = ALIGN_DOWN(tmp_ptr2,align); \
     len = tmp_ptr2 - tmp_ptr1; \
     ptr = (typeof(ptr))tmp_ptr1; \
 }


 /* newer? SDL includes endian.h, So we ignore it */
 #if (CONFIG_PLATFORM & PLATFORM_HOSTED) || defined(__PCTOOL__)
 #undef letoh16
 #undef letoh32
 #undef htole16
 #undef htole32
 #undef betoh16
 #undef betoh32
 #undef htobe16
 #undef htobe32
 #endif

 /* Android NDK contains swap16 and swap32, ignore them */
 #if (CONFIG_PLATFORM & PLATFORM_ANDROID)
 #undef swap16
 #undef swap32
 #endif

 /* Get the byte offset of a type's member */
 #define OFFSETOF(type, membername) ((off_t)&((type *)0)->membername)

 /* Get the type pointer from one of its members */
 #define TYPE_FROM_MEMBER(type, memberptr, membername) \
     ((type *)((intptr_t)(memberptr) - OFFSETOF(type, membername)))

 /* returns index of first set bit or 32 if no bits are set */
 int find_first_set_bit(uint32_t val);

 static inline __attribute__((always_inline))
 uint32_t isolate_first_bit(uint32_t val)
     { return val & -val; }

 /* Functions to set and clear register or variable bits atomically */
 void bitmod16(volatile uint16_t *addr, uint16_t bits, uint16_t mask);
 void bitset16(volatile uint16_t *addr, uint16_t mask);
 void bitclr16(volatile uint16_t *addr, uint16_t mask);

 void bitmod32(volatile uint32_t *addr, uint32_t bits, uint32_t mask);
 void bitset32(volatile uint32_t *addr, uint32_t mask);
 void bitclr32(volatile uint32_t *addr, uint32_t mask);

 /* gcc 3.4 changed the format of the constraints */
 #if (__GNUC__ >= 3) && (__GNUC_MINOR__ > 3) || (__GNUC__ >= 4)
 #define I_CONSTRAINT "I08"
 #else
 #define I_CONSTRAINT "I"
 #endif

 /* Utilize the user break controller to catch invalid memory accesses. */
 int system_memory_guard(int newmode);

 enum {
     MEMGUARD_KEEP = -1,    /* don't change the mode; for reading */
     MEMGUARD_NONE = 0,     /* catch nothing */
     MEMGUARD_FLASH_WRITES, /* catch writes to area 02 (flash ROM) */
     MEMGUARD_ZERO_AREA,    /* catch all accesses to areas 00 and 01 */
     MAXMEMGUARD
 };

 #if !defined(SIMULATOR) && !defined(__PCTOOL__)
 #include "system-target.h"
 #elif defined(HAVE_SDL) /* SDL build */
 #include "system-sdl.h"
 #define NEED_GENERIC_BYTESWAPS
 #endif

 #ifdef NEED_GENERIC_BYTESWAPS
 static inline uint16_t swap16_hw(uint16_t value)
     /*
       result[15..8] = value[ 7..0];
       result[ 7..0] = value[15..8];
     */
 {
     return (value >> 8) | (value << 8);
 }

 static inline uint32_t swap32_hw(uint32_t value)
     /*
       result[31..24] = value[ 7.. 0];
       result[23..16] = value[15.. 8];
       result[15.. 8] = value[23..16];
       result[ 7.. 0] = value[31..24];
     */
 {
     uint32_t hi = swap16_hw(value >> 16);
     uint32_t lo = swap16_hw(value & 0xffff);
     return (lo << 16) | hi;
 }

 static inline uint32_t swap_odd_even32_hw(uint32_t value)
 {
     /*
       result[31..24],[15.. 8] = value[23..16],[ 7.. 0]
       result[23..16],[ 7.. 0] = value[31..24],[15.. 8]
     */
     uint32_t t = value & 0xff00ff00;
     return (t >> 8) | ((t ^ value) << 8);
 }

 static inline uint32_t swaw32_hw(uint32_t value)
 {
     /*
       result[31..16] = value[15.. 0];
       result[15.. 0] = value[31..16];
     */
     return (value >> 16) | (value << 16);
 }

 #endif /* NEED_GENERIC_BYTESWAPS */

 /* static endianness conversion */
 #define SWAP16_CONST(x) \
     ((typeof(x))( ((uint16_t)(x) >> 8) | ((uint16_t)(x) << 8) ))

 #define SWAP32_CONST(x) \
     ((typeof(x))( ((uint32_t)(x) >> 24) | \
                  (((uint32_t)(x) & 0xff0000) >> 8) | \
                  (((uint32_t)(x) & 0xff00) << 8) | \
                   ((uint32_t)(x) << 24) ))

 #define SWAP_ODD_EVEN32_CONST(x) \
     ((typeof(x))( ((uint32_t)SWAP16_CONST((uint32_t)(x) >> 16) << 16) | \
                              SWAP16_CONST((uint32_t)(x))) )

 #define SWAW32_CONST(x) \
     ((typeof(x))( ((uint32_t)(x) << 16) | ((uint32_t)(x) >> 16) ))

 /* Select best method based upon whether x is a constant expression */
 #define swap16(x) \
     ( __builtin_constant_p(x) ? SWAP16_CONST(x) : (typeof(x))swap16_hw(x) )

 #define swap32(x) \
     ( __builtin_constant_p(x) ? SWAP32_CONST(x) : (typeof(x))swap32_hw(x) )

 #define swap_odd_even32(x) \
     ( __builtin_constant_p(x) ? SWAP_ODD_EVEN32_CONST(x) : (typeof(x))swap_odd_even32_hw(x) )

 #define swaw32(x) \
     ( __builtin_constant_p(x) ? SWAW32_CONST(x) : (typeof(x))swaw32_hw(x) )


 #ifdef ROCKBOX_LITTLE_ENDIAN
 #define letoh16(x) (x)
 #define letoh32(x) (x)
 #define htole16(x) (x)
 #define htole32(x) (x)
 #define betoh16(x) swap16(x)
 #define betoh32(x) swap32(x)
 #define htobe16(x) swap16(x)
 #define htobe32(x) swap32(x)
 #define swap_odd_even_be32(x) (x)
 #define swap_odd_even_le32(x) swap_odd_even32(x)
 #else
 #define letoh16(x) swap16(x)
 #define letoh32(x) swap32(x)
 #define htole16(x) swap16(x)
 #define htole32(x) swap32(x)
 #define betoh16(x) (x)
 #define betoh32(x) (x)
 #define htobe16(x) (x)
 #define htobe32(x) (x)
 #define swap_odd_even_be32(x) swap_odd_even32(x)
 #define swap_odd_even_le32(x) (x)
 #endif

 #ifndef BIT_N
 #define BIT_N(n) (1U << (n))
 #endif

 /* Declare this as HIGHEST_IRQ_LEVEL if they don't differ */
 #ifndef DISABLE_INTERRUPTS
 #define DISABLE_INTERRUPTS  HIGHEST_IRQ_LEVEL
 #endif

 /* Just define these as empty if not declared */
 #ifdef HAVE_CPUCACHE_INVALIDATE
 void cpucache_commit_discard(void);
 /* deprecated alias */
 void cpucache_invalidate(void);
 #else
 static inline void cpucache_commit_discard(void)
 {
 }
 /* deprecated alias */
 static inline void cpucache_invalidate(void)
 {
 }
 #endif

 #ifdef HAVE_CPUCACHE_FLUSH
 void cpucache_commit(void);
 /* deprecated alias */
 void cpucache_flush(void);
 #else
 static inline void cpucache_commit(void)
 {
 }
 /* deprecated alias */
 static inline void cpucache_flush(void)
 {
 }
 #endif

 /* Define this, if the CPU may take advantage of cache aligment. Is enabled
  * for all ARM CPUs. */
 #ifdef CPU_ARM
     #define HAVE_CPU_CACHE_ALIGN
 #endif

 /* Calculate CACHEALIGN_SIZE from CACHEALIGN_BITS */
 #ifdef CACHEALIGN_SIZE
     /* undefine, if defined. always calculate from CACHEALIGN_BITS */
     #undef CACHEALIGN_SIZE
 #endif
 #ifdef CACHEALIGN_BITS
     /* CACHEALIGN_SIZE = 2 ^ CACHEALIGN_BITS */
     #define CACHEALIGN_SIZE (1u << CACHEALIGN_BITS)
 #else
     /* FIXME: set to maximum known cache alignment of supported CPUs */
     #define CACHEALIGN_BITS  5
     #define CACHEALIGN_SIZE 32
 #endif

 #ifdef HAVE_CPU_CACHE_ALIGN
     /* Cache alignment attributes and sizes are enabled */
     #define CACHEALIGN_ATTR __attribute__((aligned(CACHEALIGN_SIZE)))
     /* Aligns x up to a CACHEALIGN_SIZE boundary */
     #define CACHEALIGN_UP(x) \
         ((typeof (x))ALIGN_UP_P2((uintptr_t)(x), CACHEALIGN_BITS))
     /* Aligns x down to a CACHEALIGN_SIZE boundary */
     #define CACHEALIGN_DOWN(x) \
         ((typeof (x))ALIGN_DOWN_P2((uintptr_t)(x), CACHEALIGN_BITS))
     /* Aligns at least to the greater of size x or CACHEALIGN_SIZE */
     #define CACHEALIGN_AT_LEAST_ATTR(x) \
         __attribute__((aligned(CACHEALIGN_UP(x))))
     /* Aligns a buffer pointer and size to proper boundaries */
     #define CACHEALIGN_BUFFER(start, size) \
         ALIGN_BUFFER((start), (size), CACHEALIGN_SIZE)
 #else
     /* Cache alignment attributes and sizes are not enabled */
     #define CACHEALIGN_ATTR
     #define CACHEALIGN_AT_LEAST_ATTR(x) __attribute__((aligned(x)))
     #define CACHEALIGN_UP(x) (x)
     #define CACHEALIGN_DOWN(x) (x)
     /* Make no adjustments */
     #define CACHEALIGN_BUFFER(start, size)
 #endif

 /* Define MEM_ALIGN_ATTR which may be used to align e.g. buffers for faster
  * access. */
 #if   defined(CPU_ARM)
     /* Use ARMs cache alignment. */
     #define MEM_ALIGN_ATTR CACHEALIGN_ATTR
     #define MEM_ALIGN_SIZE CACHEALIGN_SIZE
 #elif defined(CPU_COLDFIRE)
     /* Use fixed alignment of 16 bytes. Speed up only for 'movem' in DRAM. */
     #define MEM_ALIGN_ATTR __attribute__((aligned(16)))
     #define MEM_ALIGN_SIZE 16
 #else
     /* Do nothing. */
     #define MEM_ALIGN_ATTR
     /* Align pointer size */
     #define MEM_ALIGN_SIZE sizeof(intptr_t)
 #endif

 #ifdef STORAGE_WANTS_ALIGN
     #define STORAGE_ALIGN_ATTR __attribute__((aligned(CACHEALIGN_SIZE)))
     #define STORAGE_ALIGN_DOWN(x) \
         ((typeof (x))ALIGN_DOWN_P2((uintptr_t)(x), CACHEALIGN_BITS))
     /* Pad a size so the buffer can be aligned later */
     #define STORAGE_PAD(x) ((x) + CACHEALIGN_SIZE - 1)
     /* Number of bytes in the last cacheline assuming buffer of size x is aligned */
     #define STORAGE_OVERLAP(x) ((x) & (CACHEALIGN_SIZE - 1))
     #define STORAGE_ALIGN_BUFFER(start, size) \
         ALIGN_BUFFER((start), (size), CACHEALIGN_SIZE)
 #else
     #define STORAGE_ALIGN_ATTR
     #define STORAGE_ALIGN_DOWN(x) (x)
     #define STORAGE_PAD(x) (x)
     #define STORAGE_OVERLAP(x) 0
     #define STORAGE_ALIGN_BUFFER(start, size)
 #endif

 /* Double-cast to avoid 'dereferencing type-punned pointer will
  * break strict aliasing rules' B.S. */
 #define PUN_PTR(type, p) ((type)(intptr_t)(p))

 #endif /* __SYSTEM_H__ */
	/***************************************************************************
	* __________ __ ___.
	* Open \______ \ ____ ____ \| \| _\_ \|__ _______ ___
	* Source \| _// _ \_/ ___\\| \|/ /\| __ \ / _ \ \/ /
	* Jukebox \| \| ( <_> ) \___\| < \| \_\ ( <_> > < <
	* Firmware \|____\|_ /\____/ \___ >__\|_ \\|___ /\____/__/\_ \
	* \/ \/ \/ \/ \/
	* $Id$
	*
	* Copyright (C) 2002 by Alan Korr
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public License
	* as published by the Free Software Foundation; either version 2
	* of the License, or (at your option) any later version.
	*
	* 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 "cpu.h"
	#include "stdbool.h"
	#include "kernel.h"
	#include "gcc_extensions.h" /* for LIKELY/UNLIKELY */

	extern void system_reboot (void);
	/* Called from any UIE handler and panicf - wait for a key and return
	* to reboot system. */
	extern void system_exception_wait(void);
	extern void system_init(void);

	extern long cpu_frequency;

	struct flash_header {
	unsigned long magic;
	unsigned long length;
	char version[32];
	};

	bool detect_flashed_romimage(void);
	bool detect_flashed_ramimage(void);
	bool detect_original_firmware(void);

	#if defined(HAVE_ADJUSTABLE_CPU_FREQ) \
	&& defined(ROCKBOX_HAS_LOGF) && (NUM_CORES == 1)
	#define CPU_BOOST_LOGGING
	#endif

	#ifdef HAVE_ADJUSTABLE_CPU_FREQ
	#if NUM_CORES > 1
	extern struct spinlock boostctrl_spin;
	#endif
	void cpu_boost_init(void);
	#define FREQ cpu_frequency
	void set_cpu_frequency(long frequency);
	#ifdef CPU_BOOST_LOGGING
	char * cpu_boost_log_getlog_first(void);
	char * cpu_boost_log_getlog_next(void);
	int cpu_boost_log_getcount(void);
	void cpu_boost_(bool on_off, char* location, int line);
	#else
	void cpu_boost(bool on_off);
	#endif
	void cpu_idle_mode(bool on_off);
	int get_cpu_boost_counter(void);
	#else /* ndef HAVE_ADJUSTABLE_CPU_FREQ */
	#ifndef FREQ
	#define FREQ CPU_FREQ
	#endif
	#define set_cpu_frequency(frequency)
	#define cpu_boost(on_off)
	#define cpu_boost_id(on_off, id)
	#define cpu_idle_mode(on_off)
	#define get_cpu_boost_counter()
	#define get_cpu_boost_tracker()
	#endif /* HAVE_ADJUSTABLE_CPU_FREQ */

	#ifdef CPU_BOOST_LOGGING
	#define cpu_boost(on_off) cpu_boost_(on_off,__FILE__, __LINE__)
	#endif

	#define BAUDRATE 9600

	#ifndef NULL
	#define NULL ((void*)0)
	#endif

	#ifndef MIN
	#define MIN(a, b) (((a)<(b))?(a):(b))
	#endif

	#ifndef MAX
	#define MAX(a, b) (((a)>(b))?(a):(b))
	#endif

	/* return number of elements in array a */
	#define ARRAYLEN(a) (sizeof(a)/sizeof((a)[0]))

	/* return p incremented by specified number of bytes */
	#define SKIPBYTES(p, count) ((typeof (p))((char *)(p) + (count)))

	#define P2_M1(p2) ((1 << (p2))-1)

	/* align up or down to nearest 2^p2 */
	#define ALIGN_DOWN_P2(n, p2) ((n) & ~P2_M1(p2))
	#define ALIGN_UP_P2(n, p2) ALIGN_DOWN_P2((n) + P2_M1(p2),p2)

	/* align up or down to nearest integer multiple of a */
	#define ALIGN_DOWN(n, a) ((typeof(n))((typeof(a))(n)/(a)*(a)))
	#define ALIGN_UP(n, a) ALIGN_DOWN((n)+((a)-1),a)

	/* align start and end of buffer to nearest integer multiple of a */
	#define ALIGN_BUFFER(ptr,len,align) \
	{\
	uintptr_t tmp_ptr1 = (uintptr_t)ptr; \
	uintptr_t tmp_ptr2 = tmp_ptr1 + len;\
	tmp_ptr1 = ALIGN_UP(tmp_ptr1,align); \
	tmp_ptr2 = ALIGN_DOWN(tmp_ptr2,align); \
	len = tmp_ptr2 - tmp_ptr1; \
	ptr = (typeof(ptr))tmp_ptr1; \
	}


	/* newer? SDL includes endian.h, So we ignore it */
	#if (CONFIG_PLATFORM & PLATFORM_HOSTED) \|\| defined(__PCTOOL__)
	#undef letoh16
	#undef letoh32
	#undef htole16
	#undef htole32
	#undef betoh16
	#undef betoh32
	#undef htobe16
	#undef htobe32
	#endif

	/* Android NDK contains swap16 and swap32, ignore them */
	#if (CONFIG_PLATFORM & PLATFORM_ANDROID)
	#undef swap16
	#undef swap32
	#endif

	/* Get the byte offset of a type's member */
	#define OFFSETOF(type, membername) ((off_t)&((type *)0)->membername)

	/* Get the type pointer from one of its members */
	#define TYPE_FROM_MEMBER(type, memberptr, membername) \
	((type *)((intptr_t)(memberptr) - OFFSETOF(type, membername)))

	/* returns index of first set bit or 32 if no bits are set */
	int find_first_set_bit(uint32_t val);

	static inline __attribute__((always_inline))
	uint32_t isolate_first_bit(uint32_t val)
	{ return val & -val; }

	/* Functions to set and clear register or variable bits atomically */
	void bitmod16(volatile uint16_t *addr, uint16_t bits, uint16_t mask);
	void bitset16(volatile uint16_t *addr, uint16_t mask);
	void bitclr16(volatile uint16_t *addr, uint16_t mask);

	void bitmod32(volatile uint32_t *addr, uint32_t bits, uint32_t mask);
	void bitset32(volatile uint32_t *addr, uint32_t mask);
	void bitclr32(volatile uint32_t *addr, uint32_t mask);

	/* gcc 3.4 changed the format of the constraints */
	#if (__GNUC__ >= 3) && (__GNUC_MINOR__ > 3) \|\| (__GNUC__ >= 4)
	#define I_CONSTRAINT "I08"
	#else
	#define I_CONSTRAINT "I"
	#endif

	/* Utilize the user break controller to catch invalid memory accesses. */
	int system_memory_guard(int newmode);

	enum {
	MEMGUARD_KEEP = -1, /* don't change the mode; for reading */
	MEMGUARD_NONE = 0, /* catch nothing */
	MEMGUARD_FLASH_WRITES, /* catch writes to area 02 (flash ROM) */
	MEMGUARD_ZERO_AREA, /* catch all accesses to areas 00 and 01 */
	MAXMEMGUARD
	};

	#if !defined(SIMULATOR) && !defined(__PCTOOL__)
	#include "system-target.h"
	#elif defined(HAVE_SDL) /* SDL build */
	#include "system-sdl.h"
	#define NEED_GENERIC_BYTESWAPS
	#endif

	#ifdef NEED_GENERIC_BYTESWAPS
	static inline uint16_t swap16_hw(uint16_t value)
	/*
	result[15..8] = value[ 7..0];
	result[ 7..0] = value[15..8];
	*/
	{
	return (value >> 8) \| (value << 8);
	}

	static inline uint32_t swap32_hw(uint32_t value)
	/*
	result[31..24] = value[ 7.. 0];
	result[23..16] = value[15.. 8];
	result[15.. 8] = value[23..16];
	result[ 7.. 0] = value[31..24];
	*/
	{
	uint32_t hi = swap16_hw(value >> 16);
	uint32_t lo = swap16_hw(value & 0xffff);
	return (lo << 16) \| hi;
	}

	static inline uint32_t swap_odd_even32_hw(uint32_t value)
	{
	/*
	result[31..24],[15.. 8] = value[23..16],[ 7.. 0]
	result[23..16],[ 7.. 0] = value[31..24],[15.. 8]
	*/
	uint32_t t = value & 0xff00ff00;
	return (t >> 8) \| ((t ^ value) << 8);
	}

	static inline uint32_t swaw32_hw(uint32_t value)
	{
	/*
	result[31..16] = value[15.. 0];
	result[15.. 0] = value[31..16];
	*/
	return (value >> 16) \| (value << 16);
	}

	#endif /* NEED_GENERIC_BYTESWAPS */

	/* static endianness conversion */
	#define SWAP16_CONST(x) \
	((typeof(x))( ((uint16_t)(x) >> 8) \| ((uint16_t)(x) << 8) ))

	#define SWAP32_CONST(x) \
	((typeof(x))( ((uint32_t)(x) >> 24) \| \
	(((uint32_t)(x) & 0xff0000) >> 8) \| \
	(((uint32_t)(x) & 0xff00) << 8) \| \
	((uint32_t)(x) << 24) ))

	#define SWAP_ODD_EVEN32_CONST(x) \
	((typeof(x))( ((uint32_t)SWAP16_CONST((uint32_t)(x) >> 16) << 16) \| \
	SWAP16_CONST((uint32_t)(x))) )

	#define SWAW32_CONST(x) \
	((typeof(x))( ((uint32_t)(x) << 16) \| ((uint32_t)(x) >> 16) ))

	/* Select best method based upon whether x is a constant expression */
	#define swap16(x) \
	( __builtin_constant_p(x) ? SWAP16_CONST(x) : (typeof(x))swap16_hw(x) )

	#define swap32(x) \
	( __builtin_constant_p(x) ? SWAP32_CONST(x) : (typeof(x))swap32_hw(x) )

	#define swap_odd_even32(x) \
	( __builtin_constant_p(x) ? SWAP_ODD_EVEN32_CONST(x) : (typeof(x))swap_odd_even32_hw(x) )

	#define swaw32(x) \
	( __builtin_constant_p(x) ? SWAW32_CONST(x) : (typeof(x))swaw32_hw(x) )


	#ifdef ROCKBOX_LITTLE_ENDIAN
	#define letoh16(x) (x)
	#define letoh32(x) (x)
	#define htole16(x) (x)
	#define htole32(x) (x)
	#define betoh16(x) swap16(x)
	#define betoh32(x) swap32(x)
	#define htobe16(x) swap16(x)
	#define htobe32(x) swap32(x)
	#define swap_odd_even_be32(x) (x)
	#define swap_odd_even_le32(x) swap_odd_even32(x)
	#else
	#define letoh16(x) swap16(x)
	#define letoh32(x) swap32(x)
	#define htole16(x) swap16(x)
	#define htole32(x) swap32(x)
	#define betoh16(x) (x)
	#define betoh32(x) (x)
	#define htobe16(x) (x)
	#define htobe32(x) (x)
	#define swap_odd_even_be32(x) swap_odd_even32(x)
	#define swap_odd_even_le32(x) (x)
	#endif

	#ifndef BIT_N
	#define BIT_N(n) (1U << (n))
	#endif

	/* Declare this as HIGHEST_IRQ_LEVEL if they don't differ */
	#ifndef DISABLE_INTERRUPTS
	#define DISABLE_INTERRUPTS HIGHEST_IRQ_LEVEL
	#endif

	/* Just define these as empty if not declared */
	#ifdef HAVE_CPUCACHE_INVALIDATE
	void cpucache_commit_discard(void);
	/* deprecated alias */
	void cpucache_invalidate(void);
	#else
	static inline void cpucache_commit_discard(void)
	{
	}
	/* deprecated alias */
	static inline void cpucache_invalidate(void)
	{
	}
	#endif

	#ifdef HAVE_CPUCACHE_FLUSH
	void cpucache_commit(void);
	/* deprecated alias */
	void cpucache_flush(void);
	#else
	static inline void cpucache_commit(void)
	{
	}
	/* deprecated alias */
	static inline void cpucache_flush(void)
	{
	}
	#endif

	/* Define this, if the CPU may take advantage of cache aligment. Is enabled
	* for all ARM CPUs. */
	#ifdef CPU_ARM
	#define HAVE_CPU_CACHE_ALIGN
	#endif

	/* Calculate CACHEALIGN_SIZE from CACHEALIGN_BITS */
	#ifdef CACHEALIGN_SIZE
	/* undefine, if defined. always calculate from CACHEALIGN_BITS */
	#undef CACHEALIGN_SIZE
	#endif
	#ifdef CACHEALIGN_BITS
	/* CACHEALIGN_SIZE = 2 ^ CACHEALIGN_BITS */
	#define CACHEALIGN_SIZE (1u << CACHEALIGN_BITS)
	#else
	/* FIXME: set to maximum known cache alignment of supported CPUs */
	#define CACHEALIGN_BITS 5
	#define CACHEALIGN_SIZE 32
	#endif

	#ifdef HAVE_CPU_CACHE_ALIGN
	/* Cache alignment attributes and sizes are enabled */
	#define CACHEALIGN_ATTR __attribute__((aligned(CACHEALIGN_SIZE)))
	/* Aligns x up to a CACHEALIGN_SIZE boundary */
	#define CACHEALIGN_UP(x) \
	((typeof (x))ALIGN_UP_P2((uintptr_t)(x), CACHEALIGN_BITS))
	/* Aligns x down to a CACHEALIGN_SIZE boundary */
	#define CACHEALIGN_DOWN(x) \
	((typeof (x))ALIGN_DOWN_P2((uintptr_t)(x), CACHEALIGN_BITS))
	/* Aligns at least to the greater of size x or CACHEALIGN_SIZE */
	#define CACHEALIGN_AT_LEAST_ATTR(x) \
	__attribute__((aligned(CACHEALIGN_UP(x))))
	/* Aligns a buffer pointer and size to proper boundaries */
	#define CACHEALIGN_BUFFER(start, size) \
	ALIGN_BUFFER((start), (size), CACHEALIGN_SIZE)
	#else
	/* Cache alignment attributes and sizes are not enabled */
	#define CACHEALIGN_ATTR
	#define CACHEALIGN_AT_LEAST_ATTR(x) __attribute__((aligned(x)))
	#define CACHEALIGN_UP(x) (x)
	#define CACHEALIGN_DOWN(x) (x)
	/* Make no adjustments */
	#define CACHEALIGN_BUFFER(start, size)
	#endif

	/* Define MEM_ALIGN_ATTR which may be used to align e.g. buffers for faster
	* access. */
	#if defined(CPU_ARM)
	/* Use ARMs cache alignment. */
	#define MEM_ALIGN_ATTR CACHEALIGN_ATTR
	#define MEM_ALIGN_SIZE CACHEALIGN_SIZE
	#elif defined(CPU_COLDFIRE)
	/* Use fixed alignment of 16 bytes. Speed up only for 'movem' in DRAM. */
	#define MEM_ALIGN_ATTR __attribute__((aligned(16)))
	#define MEM_ALIGN_SIZE 16
	#else
	/* Do nothing. */
	#define MEM_ALIGN_ATTR
	/* Align pointer size */
	#define MEM_ALIGN_SIZE sizeof(intptr_t)
	#endif

	#ifdef STORAGE_WANTS_ALIGN
	#define STORAGE_ALIGN_ATTR __attribute__((aligned(CACHEALIGN_SIZE)))
	#define STORAGE_ALIGN_DOWN(x) \
	((typeof (x))ALIGN_DOWN_P2((uintptr_t)(x), CACHEALIGN_BITS))
	/* Pad a size so the buffer can be aligned later */
	#define STORAGE_PAD(x) ((x) + CACHEALIGN_SIZE - 1)
	/* Number of bytes in the last cacheline assuming buffer of size x is aligned */
	#define STORAGE_OVERLAP(x) ((x) & (CACHEALIGN_SIZE - 1))
	#define STORAGE_ALIGN_BUFFER(start, size) \
	ALIGN_BUFFER((start), (size), CACHEALIGN_SIZE)
	#else
	#define STORAGE_ALIGN_ATTR
	#define STORAGE_ALIGN_DOWN(x) (x)
	#define STORAGE_PAD(x) (x)
	#define STORAGE_OVERLAP(x) 0
	#define STORAGE_ALIGN_BUFFER(start, size)
	#endif

	/* Double-cast to avoid 'dereferencing type-punned pointer will
	* break strict aliasing rules' B.S. */
	#define PUN_PTR(type, p) ((type)(intptr_t)(p))

	#endif /* __SYSTEM_H__ */