firmware/export/system.h

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 by Alan Korr
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 #ifndef __SYSTEM_H__
  23 #define __SYSTEM_H__
  24
  25 #include "cpu.h"
  26 #include "stdbool.h"
  27 #include "kernel.h"
  28
  29 extern void system_reboot (void);
  30 /* Called from any UIE handler and panicf - wait for a key and return
  31  * to reboot system. */
  32 extern void system_exception_wait(void);
  33 extern void system_init(void);
  34
  35 extern long cpu_frequency;
  36
  37 struct flash_header {
  38     unsigned long magic;
  39     unsigned long length;
  40     char version[32];
  41 };
  42
  43 bool detect_flashed_romimage(void);
  44 bool detect_flashed_ramimage(void);
  45 bool detect_original_firmware(void);
  46
  47 #if defined(HAVE_ADJUSTABLE_CPU_FREQ) \
  48         && defined(ROCKBOX_HAS_LOGF) && (NUM_CORES == 1)
  49 #define CPU_BOOST_LOGGING
  50 #endif
  51
  52 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
  53 #if NUM_CORES > 1
  54 extern struct spinlock boostctrl_spin;
  55 #endif
  56 void cpu_boost_init(void);
  57 #define FREQ cpu_frequency
  58 void set_cpu_frequency(long frequency);
  59 #ifdef CPU_BOOST_LOGGING
  60 char * cpu_boost_log_getlog_first(void);
  61 char * cpu_boost_log_getlog_next(void);
  62 int cpu_boost_log_getcount(void);
  63 void cpu_boost_(bool on_off, char* location, int line);
  64 #else
  65 void cpu_boost(bool on_off);
  66 #endif
  67 void cpu_idle_mode(bool on_off);
  68 int get_cpu_boost_counter(void);
  69 #else /* ndef HAVE_ADJUSTABLE_CPU_FREQ */
  70 #ifndef FREQ
  71 #define FREQ CPU_FREQ
  72 #endif
  73 #define set_cpu_frequency(frequency)
  74 #define cpu_boost(on_off)
  75 #define cpu_boost_id(on_off, id)
  76 #define cpu_idle_mode(on_off)
  77 #define get_cpu_boost_counter()
  78 #define get_cpu_boost_tracker()
  79 #endif /* HAVE_ADJUSTABLE_CPU_FREQ */
  80
  81 #ifdef CPU_BOOST_LOGGING
  82 #define cpu_boost(on_off) cpu_boost_(on_off,__FILE__,  __LINE__)
  83 #endif
  84
  85 #define BAUDRATE 9600
  86
  87 #ifndef NULL
  88 #define NULL ((void*)0)
  89 #endif
  90
  91 #ifndef MIN
  92 #define MIN(a, b) (((a)<(b))?(a):(b))
  93 #endif
  94
  95 #ifndef MAX
  96 #define MAX(a, b) (((a)>(b))?(a):(b))
  97 #endif
  98
  99 /* return number of elements in array a */
 100 #define ARRAYLEN(a) (sizeof(a)/sizeof((a)[0]))
 101
 102 /* return p incremented by specified number of bytes */
 103 #define SKIPBYTES(p, count) ((typeof (p))((char *)(p) + (count)))
 104
 105 #define P2_M1(p2)  ((1 << (p2))-1)
 106
 107 /* align up or down to nearest 2^p2 */
 108 #define ALIGN_DOWN_P2(n, p2) ((n) & ~P2_M1(p2))
 109 #define ALIGN_UP_P2(n, p2)   ALIGN_DOWN_P2((n) + P2_M1(p2),p2)
 110
 111 /* align up or down to nearest integer multiple of a */
 112 #define ALIGN_DOWN(n, a)     ((n)/(a)*(a))
 113 #define ALIGN_UP(n, a)       ALIGN_DOWN((n)+((a)-1),a)
 114
 115 /* align start and end of buffer to nearest integer multiple of a */
 116 #define ALIGN_BUFFER(ptr,len,align) \
 117 {\
 118     uintptr_t tmp_ptr1 = (uintptr_t)ptr; \
 119     uintptr_t tmp_ptr2 = tmp_ptr1 + len;\
 120     tmp_ptr1 = ALIGN_UP(tmp_ptr1,align); \
 121     tmp_ptr2 = ALIGN_DOWN(tmp_ptr2,align); \
 122     len = tmp_ptr2 - tmp_ptr1; \
 123     ptr = (typeof(ptr))tmp_ptr1; \
 124 }
 125
 126
 127 /* newer? SDL includes endian.h, So we ignore it */
 128 #if defined(SIMULATOR) || defined(__PCTOOL__)
 129 #undef letoh16
 130 #undef letoh32
 131 #undef htole16
 132 #undef htole32
 133 #undef betoh16
 134 #undef betoh32
 135 #undef htobe16
 136 #undef htobe32
 137 #endif
 138
 139 /* live endianness conversion */
 140 #ifdef ROCKBOX_LITTLE_ENDIAN
 141 #define letoh16(x) (x)
 142 #define letoh32(x) (x)
 143 #define htole16(x) (x)
 144 #define htole32(x) (x)
 145 #define betoh16(x) swap16(x)
 146 #define betoh32(x) swap32(x)
 147 #define htobe16(x) swap16(x)
 148 #define htobe32(x) swap32(x)
 149 #define swap_odd_even_be32(x) (x)
 150 #define swap_odd_even_le32(x) swap_odd_even32(x)
 151 #else
 152 #define letoh16(x) swap16(x)
 153 #define letoh32(x) swap32(x)
 154 #define htole16(x) swap16(x)
 155 #define htole32(x) swap32(x)
 156 #define betoh16(x) (x)
 157 #define betoh32(x) (x)
 158 #define htobe16(x) (x)
 159 #define htobe32(x) (x)
 160 #define swap_odd_even_be32(x) swap_odd_even32(x)
 161 #define swap_odd_even_le32(x) (x)
 162 #endif
 163
 164
 165 /* static endianness conversion */
 166 #define SWAP_16(x) ((typeof(x))(unsigned short)(((unsigned short)(x) >> 8) | \
 167                                                 ((unsigned short)(x) << 8)))
 168
 169 #define SWAP_32(x) ((typeof(x))(unsigned long)( ((unsigned long)(x) >> 24) | \
 170                                                (((unsigned long)(x) & 0xff0000ul) >> 8) | \
 171                                                (((unsigned long)(x) & 0xff00ul) << 8) | \
 172                                                 ((unsigned long)(x) << 24)))
 173
 174 #ifdef ROCKBOX_LITTLE_ENDIAN
 175 #define LE_TO_H16(x) (x)
 176 #define LE_TO_H32(x) (x)
 177 #define H_TO_LE16(x) (x)
 178 #define H_TO_LE32(x) (x)
 179 #define BE_TO_H16(x) SWAP_16(x)
 180 #define BE_TO_H32(x) SWAP_32(x)
 181 #define H_TO_BE16(x) SWAP_16(x)
 182 #define H_TO_BE32(x) SWAP_32(x)
 183 #else
 184 #define LE_TO_H16(x) SWAP_16(x)
 185 #define LE_TO_H32(x) SWAP_32(x)
 186 #define H_TO_LE16(x) SWAP_16(x)
 187 #define H_TO_LE32(x) SWAP_32(x)
 188 #define BE_TO_H16(x) (x)
 189 #define BE_TO_H32(x) (x)
 190 #define H_TO_BE16(x) (x)
 191 #define H_TO_BE32(x) (x)
 192 #endif
 193
 194 /* Get the byte offset of a type's member */
 195 #define OFFSETOF(type, membername) ((off_t)&((type *)0)->membername)
 196
 197 /* Get the type pointer from one of its members */
 198 #define TYPE_FROM_MEMBER(type, memberptr, membername) \
 199     ((type *)((intptr_t)(memberptr) - OFFSETOF(type, membername)))
 200
 201 /* Use to give gcc hints on which branch is most likely taken */
 202 #if defined(__GNUC__) && __GNUC__ >= 3
 203 #define LIKELY(x)   __builtin_expect(!!(x), 1)
 204 #define UNLIKELY(x) __builtin_expect(!!(x), 0)
 205 #else
 206 #define LIKELY(x)   (x)
 207 #define UNLIKELY(x) (x)
 208 #endif
 209
 210 /* returns index of first set bit or 32 if no bits are set */
 211 int find_first_set_bit(uint32_t val);
 212
 213 static inline __attribute__((always_inline))
 214 uint32_t isolate_first_bit(uint32_t val)
 215     { return val & -val; }
 216
 217 /* gcc 3.4 changed the format of the constraints */
 218 #if (__GNUC__ >= 3) && (__GNUC_MINOR__ > 3) || (__GNUC__ >= 4)
 219 #define I_CONSTRAINT "I08"
 220 #else
 221 #define I_CONSTRAINT "I"
 222 #endif
 223
 224 /* Utilize the user break controller to catch invalid memory accesses. */
 225 int system_memory_guard(int newmode);
 226
 227 enum {
 228     MEMGUARD_KEEP = -1,    /* don't change the mode; for reading */
 229     MEMGUARD_NONE = 0,     /* catch nothing */
 230     MEMGUARD_FLASH_WRITES, /* catch writes to area 02 (flash ROM) */
 231     MEMGUARD_ZERO_AREA,    /* catch all accesses to areas 00 and 01 */
 232     MAXMEMGUARD
 233 };
 234
 235 #if !defined(SIMULATOR) && !defined(__PCTOOL__)
 236 #include "system-target.h"
 237 #else /* SIMULATOR */
 238 static inline uint16_t swap16(uint16_t value)
 239     /*
 240       result[15..8] = value[ 7..0];
 241       result[ 7..0] = value[15..8];
 242     */
 243 {
 244     return (value >> 8) | (value << 8);
 245 }
 246
 247 static inline uint32_t swap32(uint32_t value)
 248     /*
 249       result[31..24] = value[ 7.. 0];
 250       result[23..16] = value[15.. 8];
 251       result[15.. 8] = value[23..16];
 252       result[ 7.. 0] = value[31..24];
 253     */
 254 {
 255     uint32_t hi = swap16(value >> 16);
 256     uint32_t lo = swap16(value & 0xffff);
 257     return (lo << 16) | hi;
 258 }
 259
 260 static inline uint32_t swap_odd_even32(uint32_t value)
 261 {
 262     /*
 263       result[31..24],[15.. 8] = value[23..16],[ 7.. 0]
 264       result[23..16],[ 7.. 0] = value[31..24],[15.. 8]
 265     */
 266     uint32_t t = value & 0xff00ff00;
 267     return (t >> 8) | ((t ^ value) << 8);
 268 }
 269
 270 #endif /* !SIMULATOR */
 271
 272 #ifndef BIT_N
 273 #define BIT_N(n) (1U << (n))
 274 #endif
 275
 276 /* Declare this as HIGHEST_IRQ_LEVEL if they don't differ */
 277 #ifndef DISABLE_INTERRUPTS
 278 #define DISABLE_INTERRUPTS  HIGHEST_IRQ_LEVEL
 279 #endif
 280
 281 /* Just define these as empty if not declared */
 282 #ifdef HAVE_CPUCACHE_INVALIDATE
 283 void cpucache_invalidate(void);
 284 #else
 285 static inline void cpucache_invalidate(void)
 286 {
 287 }
 288 #endif
 289
 290 #ifdef HAVE_CPUCACHE_FLUSH
 291 void cpucache_flush(void);
 292 #else
 293 static inline void cpucache_flush(void)
 294 {
 295 }
 296 #endif
 297
 298 #ifndef CACHEALIGN_SIZE /* could be elsewhere for a particular reason */
 299 #ifdef CACHEALIGN_BITS
 300 /* 2^CACHEALIGN_BITS = the byte size */
 301 #define CACHEALIGN_SIZE (1u << CACHEALIGN_BITS)
 302 #else
 303 #define CACHEALIGN_SIZE sizeof(int)
 304 #endif
 305 #endif /* CACHEALIGN_SIZE */
 306
 307 #ifdef PROC_NEEDS_CACHEALIGN
 308 /* Cache alignment attributes and sizes are enabled */
 309
 310 #define CACHEALIGN_ATTR __attribute__((aligned(CACHEALIGN_SIZE)))
 311 /* Aligns x up to a CACHEALIGN_SIZE boundary */
 312 #define CACHEALIGN_UP(x) \
 313     ((typeof (x))ALIGN_UP_P2((uintptr_t)(x), CACHEALIGN_BITS))
 314 /* Aligns x down to a CACHEALIGN_SIZE boundary */
 315 #define CACHEALIGN_DOWN(x) \
 316     ((typeof (x))ALIGN_DOWN_P2((uintptr_t)(x), CACHEALIGN_BITS))
 317 /* Aligns at least to the greater of size x or CACHEALIGN_SIZE */
 318 #define CACHEALIGN_AT_LEAST_ATTR(x) \
 319     __attribute__((aligned(CACHEALIGN_UP(x))))
 320 /* Aligns a buffer pointer and size to proper boundaries */
 321 #define CACHEALIGN_BUFFER(start, size) \
 322     ALIGN_BUFFER((start), (size), CACHEALIGN_SIZE)
 323
 324 #else /* ndef PROC_NEEDS_CACHEALIGN */
 325
 326 /* Cache alignment attributes and sizes are not enabled */
 327 #define CACHEALIGN_ATTR
 328 #define CACHEALIGN_AT_LEAST_ATTR(x) \
 329     __attribute__((aligned(x)))
 330 #define CACHEALIGN_UP(x) (x)
 331 #define CACHEALIGN_DOWN(x) (x)
 332 /* Make no adjustments */
 333 #define CACHEALIGN_BUFFER(start, size)
 334
 335 #endif /* PROC_NEEDS_CACHEALIGN */
 336
 337 #ifdef STORAGE_WANTS_ALIGN
 338 #define STORAGE_ALIGN_DOWN(x) \
 339     ((typeof (x))ALIGN_DOWN_P2((uintptr_t)(x), CACHEALIGN_BITS))
 340 /* Pad a size so the buffer can be aligned later */
 341 #define STORAGE_PAD(x) ((x) + CACHEALIGN_SIZE - 1)
 342 /* Number of bytes in the last cacheline assuming buffer of size x is aligned */
 343 #define STORAGE_OVERLAP(x) ((x) & (CACHEALIGN_SIZE - 1))
 344 #else
 345 #define STORAGE_ALIGN_DOWN(x) (x)
 346 #define STORAGE_PAD(x) (x)
 347 #define STORAGE_OVERLAP(x) 0
 348 #endif
 349
 350 /* Double-cast to avoid 'dereferencing type-punned pointer will
 351  * break strict aliasing rules' B.S. */
 352 #define PUN_PTR(type, p) ((type)(intptr_t)(p))
 353
 354 #endif /* __SYSTEM_H__ */