firmware/system.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 by Alan Korr
  11  *
  12  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19 #include <stdio.h>
  20 #include "config.h"
  21 #include <stdbool.h>
  22 #include "lcd.h"
  23 #include "font.h"
  24 #include "system.h"
  25 #include "kernel.h"
  26 #include "thread.h"
  27 #include "timer.h"
  28 #include "inttypes.h"
  29 #include "string.h"
  30
  31 #ifndef SIMULATOR
  32 long cpu_frequency NOCACHEBSS_ATTR = CPU_FREQ;
  33 #endif
  34
  35 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
  36 static int boost_counter NOCACHEBSS_ATTR = 0;
  37 static bool cpu_idle NOCACHEBSS_ATTR = false;
  38 #if NUM_CORES > 1
  39 struct spinlock boostctrl_spin NOCACHEBSS_ATTR;
  40 void cpu_boost_init(void)
  41 {
  42     spinlock_init(&boostctrl_spin, SPINLOCK_NO_TASK_SWITCH);
  43 }
  44 #endif
  45
  46 int get_cpu_boost_counter(void)
  47 {
  48     return boost_counter;
  49 }
  50 #ifdef CPU_BOOST_LOGGING
  51 #define MAX_BOOST_LOG 64
  52 static char cpu_boost_calls[MAX_BOOST_LOG][MAX_PATH];
  53 static int cpu_boost_first = 0;
  54 static int cpu_boost_calls_count = 0;
  55 static int cpu_boost_track_message = 0;
  56 int cpu_boost_log_getcount(void)
  57 {
  58     return cpu_boost_calls_count;
  59 }
  60 char * cpu_boost_log_getlog_first(void)
  61 {
  62     char *first;
  63 #if NUM_CORES > 1
  64     spinlock_lock(&boostctrl_spin);
  65 #endif
  66
  67     first = NULL;
  68
  69     if (cpu_boost_calls_count)
  70     {
  71         cpu_boost_track_message = 1;
  72         first = cpu_boost_calls[cpu_boost_first];
  73     }
  74
  75 #if NUM_CORES > 1
  76     spinlock_unlock(&boostctrl_spin);
  77 #endif
  78 }
  79 char * cpu_boost_log_getlog_next(void)
  80 {
  81     int message;
  82     char *next;
  83
  84 #if NUM_CORES > 1
  85     spinlock_lock(&boostctrl_spin);
  86 #endif
  87
  88     message = (cpu_boost_track_message+cpu_boost_first)%MAX_BOOST_LOG;
  89     next = NULL;
  90
  91     if (cpu_boost_track_message < cpu_boost_calls_count)
  92     {
  93         cpu_boost_track_message++;
  94         next = cpu_boost_calls[message];
  95     }
  96
  97 #if NUM_CORES > 1
  98     spinlock_unlock(&boostctrl_spin);
  99 #endif
 100 }
 101 void cpu_boost_(bool on_off, char* location, int line)
 102 {
 103 #if NUM_CORES > 1
 104     spinlock_lock(&boostctrl_spin);
 105 #endif
 106
 107     if (cpu_boost_calls_count == MAX_BOOST_LOG)
 108     {
 109         cpu_boost_first = (cpu_boost_first+1)%MAX_BOOST_LOG;
 110         cpu_boost_calls_count--;
 111         if (cpu_boost_calls_count < 0)
 112             cpu_boost_calls_count = 0;
 113     }
 114     if (cpu_boost_calls_count < MAX_BOOST_LOG)
 115     {
 116         int message = (cpu_boost_first+cpu_boost_calls_count)%MAX_BOOST_LOG;
 117         snprintf(cpu_boost_calls[message], MAX_PATH,
 118                     "%c %s:%d",on_off==true?'B':'U',location,line);
 119         cpu_boost_calls_count++;
 120     }
 121 #else
 122 void cpu_boost(bool on_off)
 123 {
 124 #if NUM_CORES > 1
 125     spinlock_lock(&boostctrl_spin);
 126 #endif
 127
 128 #endif /* CPU_BOOST_LOGGING */
 129     if(on_off)
 130     {
 131         /* Boost the frequency if not already boosted */
 132         if(++boost_counter == 1)
 133             set_cpu_frequency(CPUFREQ_MAX);
 134     }
 135     else
 136     {
 137         /* Lower the frequency if the counter reaches 0 */
 138         if(--boost_counter <= 0)
 139         {
 140             if(cpu_idle)
 141                 set_cpu_frequency(CPUFREQ_DEFAULT);
 142             else
 143                 set_cpu_frequency(CPUFREQ_NORMAL);
 144
 145             /* Safety measure */
 146             if (boost_counter < 0)
 147             {
 148                 boost_counter = 0;
 149             }
 150         }
 151     }
 152
 153 #if NUM_CORES > 1
 154     spinlock_unlock(&boostctrl_spin);
 155 #endif
 156 }
 157
 158 void cpu_idle_mode(bool on_off)
 159 {
 160 #if NUM_CORES > 1
 161     spinlock_lock(&boostctrl_spin);
 162 #endif
 163
 164     cpu_idle = on_off;
 165
 166     /* We need to adjust the frequency immediately if the CPU
 167        isn't boosted */
 168     if(boost_counter == 0)
 169     {
 170         if(cpu_idle)
 171             set_cpu_frequency(CPUFREQ_DEFAULT);
 172         else
 173             set_cpu_frequency(CPUFREQ_NORMAL);
 174     }
 175
 176 #if NUM_CORES > 1
 177     spinlock_unlock(&boostctrl_spin);
 178 #endif
 179 }
 180 #endif /* HAVE_ADJUSTABLE_CPU_FREQ */
 181
 182
 183 #ifdef HAVE_FLASHED_ROCKBOX
 184 static bool detect_flash_header(uint8_t *addr)
 185 {
 186 #ifndef BOOTLOADER
 187     int oldmode = system_memory_guard(MEMGUARD_NONE);
 188 #endif
 189     struct flash_header hdr;
 190     memcpy(&hdr, addr, sizeof(struct flash_header));
 191 #ifndef BOOTLOADER
 192     system_memory_guard(oldmode);
 193 #endif
 194     return hdr.magic == FLASH_MAGIC;
 195 }
 196 #endif
 197
 198 bool detect_flashed_romimage(void)
 199 {
 200 #ifdef HAVE_FLASHED_ROCKBOX
 201     return detect_flash_header((uint8_t *)FLASH_ROMIMAGE_ENTRY);
 202 #else
 203     return false;
 204 #endif /* HAVE_FLASHED_ROCKBOX */
 205 }
 206
 207 bool detect_flashed_ramimage(void)
 208 {
 209 #ifdef HAVE_FLASHED_ROCKBOX
 210     return detect_flash_header((uint8_t *)FLASH_RAMIMAGE_ENTRY);
 211 #else
 212     return false;
 213 #endif /* HAVE_FLASHED_ROCKBOX */
 214 }
 215
 216 bool detect_original_firmware(void)
 217 {
 218     return !(detect_flashed_ramimage() || detect_flashed_romimage());
 219 }
 220
 221 #if defined(CPU_ARM)
 222
 223 static const char* const uiename[] = {
 224     "Undefined instruction",
 225     "Prefetch abort",
 226     "Data abort",
 227     "Divide by zero"
 228 };
 229
 230 /* Unexpected Interrupt or Exception handler. Currently only deals with
 231    exceptions, but will deal with interrupts later.
 232  */
 233 void UIE(unsigned int pc, unsigned int num) __attribute__((noreturn));
 234 void UIE(unsigned int pc, unsigned int num)
 235 {
 236     char str[32];
 237
 238     lcd_clear_display();
 239 #ifdef HAVE_LCD_BITMAP
 240     lcd_setfont(FONT_SYSFIXED);
 241 #endif
 242     lcd_puts(0, 0, uiename[num]);
 243     snprintf(str, sizeof(str), "at %08x" IF_COP(" (%d)"), pc
 244              IF_COP(, CURRENT_CORE));
 245     lcd_puts(0, 1, str);
 246     lcd_update();
 247
 248     while (1)
 249     {
 250         /* TODO: perhaps add button handling in here when we get a polling
 251            driver some day.
 252          */
 253         core_idle();
 254     }
 255 }
 256
 257 #ifndef STUB
 258 /* Needs to be here or gcc won't find it */
 259 void __div0(void) __attribute__((naked));
 260 void __div0(void)
 261 {
 262     asm volatile (
 263         "ldr    r0, [sp] \r\n"
 264         "mov    r1, #3   \r\n"
 265         "b      UIE      \r\n"
 266     );
 267 }
 268 #endif
 269
 270 #endif /* CPU_ARM */
 271