firmware/rolo.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 Randy D. Wood
  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 #include "config.h"
  23 #include "lcd.h"
  24 #include "lcd-remote.h"
  25 #include "thread.h"
  26 #include "kernel.h"
  27 #include "sprintf.h"
  28 #include "button.h"
  29 #include "file.h"
  30 #include "audio.h"
  31 #include "system.h"
  32 #include "i2c.h"
  33 #include "adc.h"
  34 #include "string.h"
  35 #include "buffer.h"
  36 #include "rolo.h"
  37
  38 #ifdef MI4_FORMAT
  39 #include "crc32-mi4.h"
  40 #undef FIRMWARE_OFFSET_FILE_CRC
  41 #undef FIRMWARE_OFFSET_FILE_DATA
  42 #define FIRMWARE_OFFSET_FILE_CRC     0xC
  43 #define FIRMWARE_OFFSET_FILE_DATA    0x200
  44 #endif
  45
  46 #if !defined(IRIVER_IFP7XX_SERIES) && \
  47     (CONFIG_CPU != PP5002)
  48 /* FIX: this doesn't work on iFP, 3rd Gen ipods */
  49
  50 #define IRQ0_EDGE_TRIGGER 0x80
  51
  52 #ifdef CPU_PP
  53 /* Handle the COP properly - it needs to jump to a function outside SDRAM while
  54  * the new firmware is being loaded, and then jump to the start of SDRAM
  55  * TODO: Use the mailboxes built into the PP processor for this
  56  */
  57
  58 #if NUM_CORES > 1
  59 volatile unsigned char IDATA_ATTR cpu_message = 0;
  60 volatile unsigned char IDATA_ATTR cpu_reply = 0;
  61 extern int cop_idlestackbegin[];
  62
  63 void rolo_restart_cop(void) ICODE_ATTR;
  64 void rolo_restart_cop(void)
  65 {
  66     if (CURRENT_CORE == CPU)
  67     {
  68         /* There should be free thread slots aplenty */
  69         create_thread(rolo_restart_cop, cop_idlestackbegin, IDLE_STACK_SIZE,
  70                       0, "rolo COP" IF_PRIO(, PRIORITY_REALTIME)
  71                       IF_COP(, COP));
  72         return;
  73     }
  74
  75     COP_INT_DIS = -1;
  76
  77     /* Invalidate cache */
  78     invalidate_icache();
  79
  80     /* Disable cache */
  81     CACHE_CTL = CACHE_CTL_DISABLE;
  82
  83     /* Tell the main core that we're ready to reload */
  84     cpu_reply = 1;
  85
  86     /* Wait while RoLo loads the image into SDRAM */
  87     /* TODO: Accept checksum failure gracefully */
  88     while(cpu_message != 1);
  89
  90     /* Acknowledge the CPU and then reload */
  91     cpu_reply = 2;
  92
  93     asm volatile(
  94         "mov   r0, #0x10000000   \n"
  95         "mov   pc, r0            \n"
  96     );
  97 }
  98 #endif /* NUM_CORES > 1 */
  99 #endif /* CPU_PP */
 100
 101 static void rolo_error(const char *text)
 102 {
 103     lcd_clear_display();
 104     lcd_puts(0, 0, "ROLO error:");
 105     lcd_puts_scroll(0, 1, text);
 106     lcd_update();
 107     button_get(true);
 108     button_get(true);
 109     button_get(true);
 110     lcd_stop_scroll();
 111 }
 112
 113 #if CONFIG_CPU == SH7034 || CONFIG_CPU == IMX31L
 114 /* these are in assembler file "descramble.S" for SH7034 */
 115 extern unsigned short descramble(const unsigned char* source,
 116                                  unsigned char* dest, int length);
 117 /* this is in firmware/target/arm/imx31/rolo_restart.S for IMX31 */
 118 extern void rolo_restart(const unsigned char* source, unsigned char* dest,
 119                          int length);
 120 #else
 121
 122 /* explicitly put this code in iram, ICODE_ATTR is defined to be null for some
 123    targets that are low on iram, like the gigabeat F/X */
 124 void rolo_restart(const unsigned char* source, unsigned char* dest,
 125                   long length) __attribute__ ((section(".icode")));
 126 void rolo_restart(const unsigned char* source, unsigned char* dest,
 127                   long length)
 128 {
 129     long i;
 130     unsigned char* localdest = dest;
 131
 132     /* This is the equivalent of a call to memcpy() but this must be done from
 133        iram to avoid overwriting itself and we don't want to depend on memcpy()
 134        always being in iram */
 135     for(i = 0;i < length;i++)
 136         *localdest++ = *source++;
 137
 138 #if defined(CPU_COLDFIRE)
 139     asm (
 140         "movec.l %0,%%vbr    \n"
 141         "move.l  (%0)+,%%sp  \n"
 142         "move.l  (%0),%0     \n"
 143         "jmp     (%0)        \n"
 144         : : "a"(dest)
 145     );
 146 #elif defined(CPU_PP502x)
 147     CPU_INT_DIS = -1;
 148
 149     /* Flush cache */
 150     flush_icache();
 151
 152     /* Disable cache */
 153     CACHE_CTL = CACHE_CTL_DISABLE;
 154
 155     /* Reset the memory mapping registers to zero */
 156     {
 157         volatile unsigned long *mmap_reg;
 158         for (mmap_reg = &MMAP_FIRST; mmap_reg <= &MMAP_LAST; mmap_reg++)
 159             *mmap_reg = 0;
 160     }
 161
 162 #if NUM_CORES > 1
 163     /* Tell the COP it's safe to continue rebooting */
 164     cpu_message = 1;
 165
 166     /* Wait for the COP to tell us it is rebooting */
 167     while(cpu_reply != 2);
 168 #endif
 169
 170     asm volatile(
 171         "mov   r0, #0x10000000   \n"
 172         "mov   pc, r0            \n"
 173     );
 174
 175 #elif defined(CPU_TCC780X) || (CONFIG_CPU == S3C2440)
 176     /* Flush and invalidate caches */
 177     invalidate_icache();
 178
 179     asm volatile(
 180         "mov   pc, %0            \n"
 181         : : "r"(dest)
 182     );
 183 #endif
 184 }
 185 #endif
 186
 187 /* This is assigned in the linker control file */
 188 extern unsigned long loadaddress;
 189
 190 /***************************************************************************
 191  *
 192  * Name: rolo_load_app(char *filename,int scrambled)
 193  * Filename must be a fully defined filename including the path and extension
 194  *
 195  ***************************************************************************/
 196 int rolo_load(const char* filename)
 197 {
 198     int fd;
 199     long length;
 200 #if defined(CPU_COLDFIRE) || defined(CPU_ARM)
 201 #if !defined(MI4_FORMAT)
 202     int i;
 203 #endif
 204     unsigned long checksum,file_checksum;
 205 #else
 206     long file_length;
 207     unsigned short checksum,file_checksum;
 208 #endif
 209     unsigned char* ramstart = (void*)&loadaddress;
 210
 211     lcd_clear_display();
 212     lcd_puts(0, 0, "ROLO...");
 213     lcd_puts(0, 1, "Loading");
 214     lcd_update();
 215 #ifdef HAVE_REMOTE_LCD
 216     lcd_remote_clear_display();
 217     lcd_remote_puts(0, 0, "ROLO...");
 218     lcd_remote_puts(0, 1, "Loading");
 219     lcd_remote_update();
 220 #endif
 221
 222     audio_stop();
 223
 224     fd = open(filename, O_RDONLY);
 225     if(-1 == fd) {
 226         rolo_error("File not found");
 227         return -1;
 228     }
 229
 230     length = filesize(fd) - FIRMWARE_OFFSET_FILE_DATA;
 231
 232 #if defined(CPU_COLDFIRE) || defined(CPU_PP) || (CONFIG_CPU==DM320) \
 233     || defined(CPU_TCC780X) || (CONFIG_CPU==IMX31L) || (CONFIG_CPU == S3C2440) \
 234     || (CONFIG_CPU==AS3525)
 235     /* Read and save checksum */
 236     lseek(fd, FIRMWARE_OFFSET_FILE_CRC, SEEK_SET);
 237     if (read(fd, &file_checksum, 4) != 4) {
 238         rolo_error("Error Reading checksum");
 239         return -1;
 240     }
 241
 242 #if !defined(MI4_FORMAT)
 243     /* Rockbox checksums are big-endian */
 244     file_checksum = betoh32(file_checksum);
 245 #endif
 246
 247 #if defined(CPU_PP) && NUM_CORES > 1
 248     lcd_puts(0, 2, "Waiting for coprocessor...");
 249     lcd_update();
 250     rolo_restart_cop();
 251     /* Wait for COP to be in safe code */
 252     while(cpu_reply != 1);
 253     lcd_puts(0, 2, "                          ");
 254     lcd_update();
 255 #endif
 256
 257     lseek(fd, FIRMWARE_OFFSET_FILE_DATA, SEEK_SET);
 258
 259     if (read(fd, audiobuf, length) != length) {
 260         rolo_error("Error Reading File");
 261         return -1;
 262     }
 263
 264 #ifdef MI4_FORMAT
 265     /* Check CRC32 to see if we have a valid file */
 266     chksum_crc32gentab();
 267     checksum = chksum_crc32 (audiobuf, length);
 268 #else
 269     checksum = MODEL_NUMBER;
 270
 271     for(i = 0;i < length;i++) {
 272         checksum += audiobuf[i];
 273     }
 274 #endif
 275
 276     /* Verify checksum against file header */
 277     if (checksum != file_checksum) {
 278         rolo_error("Checksum Error");
 279         return -1;
 280     }
 281
 282     lcd_puts(0, 1, "Executing");
 283     lcd_update();
 284 #ifdef HAVE_REMOTE_LCD
 285     lcd_remote_puts(0, 1, "Executing");
 286     lcd_remote_update();
 287 #endif
 288     adc_close();
 289
 290 #ifdef CPU_ARM
 291     /* Should do these together since some ARM version should never have
 292      * FIQ disabled and not IRQ (imx31 errata). */
 293     disable_interrupt(IRQ_FIQ_STATUS);
 294 #else
 295     /* Some targets have a higher disable level than HIGEST_IRQ_LEVEL */
 296     set_irq_level(DISABLE_INTERRUPTS);
 297 #endif
 298
 299 #elif CONFIG_CPU == SH7034
 300     /* Read file length from header and compare to real file length */
 301     lseek(fd, FIRMWARE_OFFSET_FILE_LENGTH, SEEK_SET);
 302     if(read(fd, &file_length, 4) != 4) {
 303         rolo_error("Error Reading File Length");
 304         return -1;
 305     }
 306     if (length != file_length) {
 307         rolo_error("File length mismatch");
 308         return -1;
 309     }
 310
 311     /* Read and save checksum */
 312     lseek(fd, FIRMWARE_OFFSET_FILE_CRC, SEEK_SET);
 313     if (read(fd, &file_checksum, 2) != 2) {
 314         rolo_error("Error Reading checksum");
 315         return -1;
 316     }
 317     lseek(fd, FIRMWARE_OFFSET_FILE_DATA, SEEK_SET);
 318
 319     /* verify that file can be read and descrambled */
 320     if ((audiobuf + (2*length)+4) >= audiobufend) {
 321         rolo_error("Not enough room to load file");
 322         return -1;
 323     }
 324
 325     if (read(fd, &audiobuf[length], length) != (int)length) {
 326         rolo_error("Error Reading File");
 327         return -1;
 328     }
 329
 330     lcd_puts(0, 1, "Descramble");
 331     lcd_update();
 332
 333     checksum = descramble(audiobuf + length, audiobuf, length);
 334
 335     /* Verify checksum against file header */
 336     if (checksum != file_checksum) {
 337         rolo_error("Checksum Error");
 338         return -1;
 339     }
 340
 341     lcd_puts(0, 1, "Executing     ");
 342     lcd_update();
 343
 344     set_irq_level(HIGHEST_IRQ_LEVEL);
 345
 346     /* Calling these 2 initialization routines was necessary to get the
 347        the origional Archos version of the firmware to load and execute. */
 348     system_init();           /* Initialize system for restart */
 349     i2c_init();              /* Init i2c bus - it seems like a good idea */
 350     ICR = IRQ0_EDGE_TRIGGER; /* Make IRQ0 edge triggered */
 351     TSTR = 0xE0;             /* disable all timers */
 352     /* model-specific de-init, needed when flashed */
 353     /* Especially the Archos software is picky about this */
 354 #if defined(ARCHOS_RECORDER) || defined(ARCHOS_RECORDERV2) || \
 355     defined(ARCHOS_FMRECORDER)
 356     PAIOR = 0x0FA0;
 357 #endif
 358 #endif
 359     rolo_restart(audiobuf, ramstart, length);
 360
 361     return 0; /* this is never reached */
 362     (void)checksum; (void)file_checksum;
 363 }
 364 #else  /* !defined(IRIVER_IFP7XX_SERIES) */
 365 int rolo_load(const char* filename)
 366 {
 367     /* dummy */
 368     (void)filename;
 369     return 0;
 370 }
 371
 372 #endif /* !defined(IRIVER_IFP7XX_SERIES) */