bootloader/ipod.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2005 by Dave Chapman
  11  *
  12  * Based on Rockbox iriver bootloader by Linus Nielsen Feltzing
  13  * and the ipodlinux bootloader by Daniel Palffy and Bernard Leach
  14  *
  15  * This program is free software; you can redistribute it and/or
  16  * modify it under the terms of the GNU General Public License
  17  * as published by the Free Software Foundation; either version 2
  18  * of the License, or (at your option) any later version.
  19  *
  20  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  21  * KIND, either express or implied.
  22  *
  23  ****************************************************************************/
  24 #include "config.h"
  25
  26 #include <stdlib.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include <stdarg.h>
  30 #include "cpu.h"
  31 #include "system.h"
  32 #include "lcd.h"
  33 #include "kernel.h"
  34 #include "thread.h"
  35 #include "ata.h"
  36 #include "fat.h"
  37 #include "disk.h"
  38 #include "font.h"
  39 #include "adc.h"
  40 #include "backlight.h"
  41 #include "panic.h"
  42 #include "power.h"
  43 #include "file.h"
  44 #include "common.h"
  45 #include "hwcompat.h"
  46 #include "usb.h"
  47
  48 #define XSC(X) #X
  49 #define SC(X) XSC(X)
  50
  51 /* Maximum allowed firmware image size. The largest known current
  52    (December 2006) firmware is about 7.5MB (Apple's firmware for the ipod video)
  53    so we set this to 8MB. */
  54 #define MAX_LOADSIZE (8*1024*1024)
  55
  56 /* A buffer to load the Linux kernel or Rockbox into */
  57 unsigned char *loadbuffer = (unsigned char *)DRAM_START;
  58
  59 /* Bootloader version */
  60 char version[] = APPSVERSION;
  61
  62 #if CONFIG_KEYPAD == IPOD_4G_PAD && !defined(IPOD_MINI)
  63 /* check if number of seconds has past */
  64 int timer_check(int clock_start, unsigned int usecs)
  65 {
  66     if ((USEC_TIMER - clock_start) >= usecs) {
  67         return 1;
  68     } else {
  69         return 0;
  70     }
  71 }
  72
  73 static void ser_opto_keypad_cfg(int val)
  74 {
  75     int start_time;
  76
  77     GPIOB_ENABLE &=~ 0x80;
  78
  79     outl(inl(0x7000c104) | 0xc000000, 0x7000c104);
  80     outl(val, 0x7000c120);
  81     outl(inl(0x7000c100) | 0x80000000, 0x7000c100);
  82
  83     GPIOB_OUTPUT_VAL &=~ 0x10;
  84     GPIOB_OUTPUT_EN  |=  0x10;
  85
  86     start_time = USEC_TIMER;
  87     do {
  88         if ((inl(0x7000c104) & 0x80000000) == 0) {
  89             break;
  90         }
  91     } while (timer_check(start_time, 1500) != 0);
  92
  93     outl(inl(0x7000c100) & ~0x80000000, 0x7000c100);
  94
  95     GPIOB_ENABLE     |= 0x80;
  96     GPIOB_OUTPUT_VAL |= 0x10;
  97     GPIOB_OUTPUT_EN  &=~0x10;
  98
  99     outl(inl(0x7000c104) | 0xc000000, 0x7000c104);
 100     outl(inl(0x7000c100) | 0x60000000, 0x7000c100);
 101 }
 102
 103 int opto_keypad_read(void)
 104 {
 105     int loop_cnt, had_io = 0;
 106
 107     for (loop_cnt = 5; loop_cnt != 0;)
 108     {
 109         int key_pressed = 0;
 110         int start_time;
 111         unsigned int key_pad_val;
 112
 113         ser_opto_keypad_cfg(0x8000023a);
 114
 115         start_time = USEC_TIMER;
 116         do {
 117             if (inl(0x7000c104) & 0x4000000) {
 118                 had_io = 1;
 119                 break;
 120             }
 121
 122             if (had_io != 0) {
 123                 break;
 124             }
 125         } while (timer_check(start_time, 1500) != 0);
 126
 127         key_pad_val = inl(0x7000c140);
 128         if ((key_pad_val & ~0x7fff0000) != 0x8000023a) {
 129             loop_cnt--;
 130         } else {
 131             key_pad_val = (key_pad_val << 11) >> 27;
 132             key_pressed = 1;
 133         }
 134
 135         outl(inl(0x7000c100) | 0x60000000, 0x7000c100);
 136         outl(inl(0x7000c104) | 0xc000000, 0x7000c104);
 137
 138         if (key_pressed != 0) {
 139             return key_pad_val ^ 0x1f;
 140         }
 141     }
 142
 143     return 0;
 144 }
 145 #endif
 146
 147 static int key_pressed(void)
 148 {
 149     unsigned char state;
 150
 151 #if CONFIG_KEYPAD == IPOD_4G_PAD
 152 #ifdef IPOD_MINI /* mini 1G only */
 153     state = GPIOA_INPUT_VAL & 0x3f;
 154     if ((state & 0x10) == 0) return BUTTON_LEFT;
 155     if ((state & 0x2) == 0) return BUTTON_MENU;
 156     if ((state & 0x4) == 0) return BUTTON_PLAY;
 157     if ((state & 0x8) == 0) return BUTTON_RIGHT;
 158 #else
 159     state = opto_keypad_read();
 160     if ((state & 0x4) == 0) return BUTTON_LEFT;
 161     if ((state & 0x10) == 0) return BUTTON_MENU;
 162     if ((state & 0x8) == 0) return BUTTON_PLAY;
 163     if ((state & 0x2) == 0) return BUTTON_RIGHT;
 164 #endif
 165 #elif (CONFIG_KEYPAD == IPOD_3G_PAD) || (CONFIG_KEYPAD == IPOD_1G2G_PAD)
 166     state = GPIOA_INPUT_VAL;
 167     if ((state & 0x08) == 0) return BUTTON_LEFT;
 168     if ((state & 0x10) == 0) return BUTTON_MENU;
 169     if ((state & 0x04) == 0) return BUTTON_PLAY;
 170     if ((state & 0x01) == 0) return BUTTON_RIGHT;
 171 #endif
 172     return 0;
 173 }
 174
 175 bool button_hold(void)
 176 {
 177 #if CONFIG_KEYPAD == IPOD_1G2G_PAD
 178     return (GPIOA_INPUT_VAL & 0x20);
 179 #else
 180     return !(GPIOA_INPUT_VAL & 0x20);
 181 #endif
 182 }
 183
 184 void fatal_error(void)
 185 {
 186     extern int line;
 187     bool holdstatus=false;
 188
 189     /* System font is 6 pixels wide */
 190 #if defined(IPOD_1G2G) || defined(IPOD_3G)
 191     printf("Insert Firewire cable, or");
 192     printf("hold MENU+PLAY to reboot");
 193     printf("then REW+FF for disk mode");
 194 #elif LCD_WIDTH >= (30*6)
 195     printf("Insert USB cable, or");
 196     printf("hold MENU+SELECT to reboot");
 197     printf("then SELECT+PLAY for disk mode");
 198 #else
 199     printf("Insert USB cable, or");
 200     printf("hold MENU+SELECT to");
 201     printf("reboot then SELECT+PLAY");
 202     printf("for disk mode");
 203 #endif
 204     lcd_update();
 205
 206     usb_init();
 207     while (1) {
 208         if (button_hold() != holdstatus) {
 209             if (button_hold()) {
 210                 holdstatus=true;
 211                 lcd_puts(0, line, "Hold switch on!");
 212             } else {
 213                 holdstatus=false;
 214                 lcd_puts(0, line, "               ");
 215             }
 216             lcd_update();
 217         }
 218         if (usb_detect() == USB_INSERTED) {
 219             ata_sleepnow(); /* Immediately spindown the disk. */
 220             sleep(HZ*2);
 221 #if CONFIG_CPU == PP5020
 222             memcpy((void *)0x40017f00, "diskmode\0\0hotstuff\0\0\1", 21);
 223 #elif CONFIG_CPU == PP5022
 224             memcpy((void *)0x4001ff00, "diskmode\0\0hotstuff\0\0\1", 21);
 225 #elif CONFIG_CPU == PP5002
 226             memcpy((void *)0x40017f00, "diskmodehotstuff\1", 17);
 227 #endif /* CONFIG_CPU */
 228             system_reboot(); /* Reboot */
 229         }
 230         udelay(100000); /* 100ms */
 231     }
 232
 233 }
 234
 235 /* The bootloader is started from the OSOS image on the firmware
 236  * partition. There are several ways it can be installed there:
 237  * appended to the Apple firmware, on its own, or appended to
 238  * Rockbox itself. The Apple ROM loader loads the entire OSOS
 239  * image to DRAM_START, whatever it contains. If the bootloader
 240  * is appended to another image then it will've modified the
 241  * entry point in the OSOS header such that the ROM will call the
 242  * bootloader rather than the main image.
 243  *
 244  * So, once the bootloader has control:
 245  *
 246  * 1) If the hold switch is on, or the menu button is being held,
 247  *    try to boot the Apple firmware.
 248  *   1a) First, it looks for apple_os.ipod on the FAT32 partition,
 249  *       in .rockbox or the root directory. If found it loads that
 250  *       without further checking and runs it.
 251  *   1b) Next, it checks to see if the OSOS image already loaded
 252  *       into RAM is in fact the Apple firmware with the bootloader
 253  *       appended. It looks at DRAM_START+0x20 for the string
 254  *       "portalplayer", and if it's there, just jumps back to
 255  *       DRAM_START where the entry point was before the bootloader
 256  *       was appended.
 257  *   1c) If neither of those worked, it displays an error and dies.
 258  *
 259  * 2) If the play button is being held, try to boot Linux. It looks
 260  *    for linux.bin in the root directory, and if it's not there,
 261  *    it displays an error and dies.
 262  *
 263  * 3) Otherwise, try to boot Rockbox.
 264  *   3a) First, it looks for rockbox.ipod on the FAT32 partition,
 265  *       in .rockbox or the root directory. If found it loads that
 266  *       without further checking and runs it.
 267  *   3b) Next, it checks to see if the OSOS image already loaded
 268  *       into RAM is in fact Rockbox with the bootloader appended.
 269  *       It looks at DRAM_START+0x20 for the string "Rockbox\1"
 270  *       (which is inserted there in crt0-pp.S), and if it's there,
 271  *       just humps back to DRAM_START where the entry point was
 272  *       before the bootloader was appended.
 273  *   3c) If neither of those worked, it displays an error and dies.
 274  *
 275  * The result is that any of the three install configurations work,
 276  * and that images of apple_os.ipod or rockbox.ipod on the FAT32
 277  * partition take priority over the contents of OSOS (this avoids
 278  * upgrades failing to work if OSOS is not updated).
 279  *
 280  * Loading from OSOS is somewhat faster than loading from FAT32,
 281  * because the Apple ROM doesn't have to deal with filesystems or
 282  * fragmentation, and is already loading from OSOS anyway. Thus,
 283  * the fastest boot configuration that still allows dual booting
 284  * is to install Rockbox into OSOS with the bootloader appended
 285  * (and delete/rename rockbox.ipod from the FAT32 partition).
 286  *
 287  * It is of course faster to just install Rockbox to OSOS alone,
 288  * but then it's impossible to boot the Apple firmware.
 289  */
 290
 291 void* main(void)
 292 {
 293     char buf[256];
 294     int i;
 295     int btn;
 296     int rc;
 297     bool haveramos;
 298     bool button_was_held;
 299     struct partinfo* pinfo;
 300     unsigned short* identify_info;
 301
 302     /* Check the button hold status as soon as possible - to
 303        give the user maximum chance to turn it off in order to
 304        reset the settings in rockbox. */
 305     button_was_held = button_hold();
 306
 307     system_init();
 308     kernel_init();
 309
 310 #ifndef HAVE_BACKLIGHT_INVERSION
 311     backlight_init(); /* Turns on the backlight */
 312 #endif
 313
 314     lcd_init();
 315     font_init();
 316
 317 #ifdef HAVE_LCD_COLOR
 318     lcd_set_foreground(LCD_WHITE);
 319     lcd_set_background(LCD_BLACK);
 320     lcd_clear_display();
 321 #endif
 322
 323 #if 0
 324     /* ADC and button drivers are not yet implemented */
 325     adc_init();
 326     button_init();
 327 #endif
 328
 329     btn=key_pressed();
 330
 331     /* Enable bootloader messages */
 332     if (btn==BUTTON_RIGHT)
 333         verbose = true;
 334
 335     lcd_setfont(FONT_SYSFIXED);
 336
 337     printf("Rockbox boot loader");
 338     printf("Version: %s", version);
 339     printf("IPOD version: 0x%08x", IPOD_HW_REVISION);
 340
 341     i=ata_init();
 342     if (i==0) {
 343       identify_info=ata_get_identify();
 344       /* Show model */
 345       for (i=0; i < 20; i++) {
 346         ((unsigned short*)buf)[i]=htobe16(identify_info[i+27]);
 347       }
 348       buf[40]=0;
 349       for (i=39; i && buf[i]==' '; i--) {
 350         buf[i]=0;
 351       }
 352       printf(buf);
 353     } else {
 354       printf("ATA: %d", i);
 355     }
 356
 357     disk_init();
 358     rc = disk_mount_all();
 359     if (rc<=0)
 360     {
 361         printf("No partition found");
 362         fatal_error();
 363     }
 364
 365     pinfo = disk_partinfo(1);
 366     printf("Partition 1: 0x%02x %ld sectors",
 367            pinfo->type, pinfo->size);
 368
 369     if (button_was_held || (btn==BUTTON_MENU)) {
 370         /* If either the hold switch was on, or the Menu button was held, then
 371            try the Apple firmware */
 372
 373         printf("Loading original firmware...");
 374
 375         /* First try an apple_os.ipod file on the FAT32 partition
 376            (either in .rockbox or the root)
 377          */
 378
 379         rc=load_firmware(loadbuffer, "apple_os.ipod", MAX_LOADSIZE);
 380
 381         if (rc == EOK) {
 382             printf("apple_os.ipod loaded.");
 383             return (void*)DRAM_START;
 384         } else if (rc == EFILE_NOT_FOUND) {
 385             /* If apple_os.ipod doesn't exist, then check if there is an Apple
 386                firmware image in RAM  */
 387             haveramos = (memcmp((void*)(DRAM_START+0x20),"portalplayer",12)==0);
 388             if (haveramos) {
 389                 /* We have a copy of the retailos in RAM, lets just run it. */
 390                 return (void*)DRAM_START;
 391             }
 392         } else if (rc < EFILE_NOT_FOUND) {
 393             printf("Error!");
 394             printf("Can't load apple_os.ipod:");
 395             printf(strerror(rc));
 396         }
 397
 398         /* Everything failed - just loop forever */
 399         printf("No RetailOS detected");
 400
 401     } else if (btn==BUTTON_PLAY) {
 402         printf("Loading Linux...");
 403         rc=load_raw_firmware(loadbuffer, "/linux.bin", MAX_LOADSIZE);
 404         if (rc < EOK) {
 405             printf("Error!");
 406             printf("Can't load linux.bin:");
 407             printf(strerror(rc));
 408         } else {
 409             return (void*)DRAM_START;
 410         }
 411     } else {
 412         printf("Loading Rockbox...");
 413         rc=load_firmware(loadbuffer, BOOTFILE, MAX_LOADSIZE);
 414         if (rc == EOK) {
 415             printf("Rockbox loaded.");
 416             return (void*)DRAM_START;
 417         } else if (rc == EFILE_NOT_FOUND) {
 418             /* if rockbox.ipod doesn't exist, then check if there is a Rockbox
 419                image in RAM  */
 420             haveramos = (memcmp((void*)(DRAM_START+0x20),"Rockbox\1",8)==0);
 421             if (haveramos) {
 422                 /* We have a copy of Rockbox in RAM, lets just run it. */
 423                 return (void*)DRAM_START;
 424             }
 425         }
 426
 427         printf("Error!");
 428         printf("Can't load " BOOTFILE ": ");
 429         printf(strerror(rc));
 430     }
 431
 432     /* If we get to here, then we haven't been able to load any firmware */
 433     fatal_error();
 434
 435     /* We never get here, but keep gcc happy */
 436     return (void*)0;
 437 }