nihilazo/rockbox
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
139d447c6a
rockbox/bootloader/iriver_h300.c
James Buren 1bc68d5ad7 h1x0/h300: change when the hold switch and failsafe are used 
After reviewing the code awhile I realized that the failsafe and hold
switch have no impact on the boot process when the usb or charger is
connected. That makes no real sense to me. If these are connected then
neither will be used at all. The boot process will never revisit it
either once those other modes end and resume the boot process. It will
just continue to try to boot from disk as if these emergency settings
never existed.

I have decided it makes more sense for them to be evaluated once the
higher priority charge and disk mode have finished their roles. Given
how the code was originally written it seems to be they were not
intended to run prior to these at the very least since the logical
conditions preclude that possibility as they include the inverse of
the conditions that trigger the charge and disk modes.

Change-Id: I0531c97474572c573178f480c239c3c1659f9653
2020-11-15 11:01:53 +00:00

673 lines
16 KiB
C
Raw Blame History

/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2007 by Linus Nielsen Feltzing
*
* 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.
*
****************************************************************************/
#include "config.h"
#include <stdlib.h>
#include <stdio.h>
#include "inttypes.h"
#include "string.h"
#include "cpu.h"
#include "system.h"
#include "lcd.h"
#include "lcd-remote.h"
#include "scroll_engine.h"
#include "../kernel-internal.h"
#include "storage.h"
#include "file_internal.h"
#include "usb.h"
#include "disk.h"
#include "font.h"
#include "adc.h"
#include "backlight.h"
#include "backlight-target.h"
#include "button.h"
#include "panic.h"
#include "power.h"
#include "powermgmt.h"
#include "file.h"
#include "eeprom_settings.h"
#include "rbunicode.h"
#include "pcf50606.h"
#include "common.h"
#include "rb-loader.h"
#include "loader_strerror.h"
#include "isp1362.h"
#include "version.h"
#include <stdarg.h>
/* Maximum allowed firmware image size. 10MB is more than enough */
#define MAX_LOADSIZE (10*1024*1024)
#define DRAM_START 0x31000000
/* From common.c */
extern int line;
extern int remote_line;
static bool recovery_mode = false;
/* Reset the cookie for the crt0 crash check */
inline void __reset_cookie(void)
{
asm(" move.l #0,%d0");
asm(" move.l %d0,0x10017ffc");
}
void start_iriver_fw(void)
{
asm(" move.w #0x2700,%sr");
__reset_cookie();
asm(" movec.l %d0,%vbr");
asm(" move.l 0,%sp");
asm(" lea.l 8,%a0");
asm(" jmp (%a0)");
}
void start_firmware(void)
{
asm(" move.w #0x2700,%sr");
__reset_cookie();
asm(" move.l %0,%%d0" :: "i"(DRAM_START));
asm(" movec.l %d0,%vbr");
asm(" move.l %0,%%sp" :: "m"(*(int *)DRAM_START));
asm(" move.l %0,%%a0" :: "m"(*(int *)(DRAM_START+4)));
asm(" jmp (%a0)");
}
void start_flashed_romimage(void)
{
uint8_t *src = (uint8_t *)FLASH_ROMIMAGE_ENTRY;
uint32_t *reset_vector;
if (!detect_flashed_romimage())
return ;
reset_vector = (uint32_t *)(&src[sizeof(struct flash_header)+sizeof(uint32_t)]);
asm(" move.w #0x2700,%sr");
__reset_cookie();
asm(" move.l %0,%%d0" :: "i"(DRAM_START));
asm(" movec.l %d0,%vbr");
asm(" move.l %0,%%sp" :: "m"(reset_vector[0]));
asm(" move.l %0,%%a0" :: "m"(reset_vector[1]));
asm(" jmp (%a0)");
/* Failure */
power_off();
}
void start_flashed_ramimage(void)
{
struct flash_header hdr;
uint8_t *buf = (uint8_t *)DRAM_START;
uint8_t *src = (uint8_t *)FLASH_RAMIMAGE_ENTRY;
if (!detect_flashed_ramimage())
return;
/* Load firmware from flash */
cpu_boost(true);
memcpy(&hdr, src, sizeof(struct flash_header));
src += sizeof(struct flash_header);
memcpy(buf, src, hdr.length);
cpu_boost(false);
start_firmware();
/* Failure */
power_off();
}
void shutdown(void)
{
printf("Shutting down...");
/* Reset the rockbox crash check. */
firmware_settings.bl_version = 0;
eeprom_settings_store();
/* We need to gracefully spin down the disk to prevent clicks. */
if (ide_powered())
{
/* Make sure ATA has been initialized. */
storage_init();
/* And put the disk into sleep immediately. */
storage_sleepnow();
}
sleep(HZ*2);
/* Backlight OFF */
backlight_hw_off();
remote_backlight_hw_off();
__reset_cookie();
power_off();
}
/* Print the battery voltage (and a warning message). */
void check_battery(void)
{
int battery_voltage, batt_int, batt_frac;
battery_voltage = _battery_voltage();
batt_int = battery_voltage / 1000;
batt_frac = (battery_voltage % 1000) / 10;
printf("Batt: %d.%02dV", batt_int, batt_frac);
if (battery_voltage <= 310)
{
printf("WARNING! BATTERY LOW!!");
sleep(HZ*2);
}
}
void initialize_eeprom(void)
{
if (detect_original_firmware())
return ;
if (!eeprom_settings_init())
{
recovery_mode = true;
return ;
}
/* If bootloader version has not been reset, disk might
* not be intact. */
if (firmware_settings.bl_version || !firmware_settings.disk_clean)
{
firmware_settings.disk_clean = false;
recovery_mode = true;
}
firmware_settings.bl_version = EEPROM_SETTINGS_BL_MINVER;
eeprom_settings_store();
}
void try_flashboot(void)
{
if (!firmware_settings.initialized)
return ;
switch (firmware_settings.bootmethod)
{
case BOOT_DISK:
return;
case BOOT_ROM:
start_flashed_romimage();
break;
case BOOT_RAM:
start_flashed_ramimage();
break;
case BOOT_RECOVERY:
break;
}
recovery_mode = true;
}
void failsafe_menu(void)
{
static const char *options[] =
{
"Boot from disk",
"Boot RAM image",
"Boot ROM image",
"Shutdown"
};
const int FAILSAFE_OPTIONS = sizeof(options) / sizeof(*options);
const long TIMEOUT = 15 * HZ;
long start_tick = current_tick;
int option = 3;
int button;
int defopt = -1;
char buf[32];
int i;
reset_screen();
printf("Bootloader %s", rbversion);
check_battery();
printf("=========================");
line += FAILSAFE_OPTIONS;
printf("");
printf(" [NAVI] to confirm.");
printf(" [REC] to set as default.");
printf("");
if (firmware_settings.initialized)
{
defopt = firmware_settings.bootmethod;
if (defopt < 0 || defopt >= FAILSAFE_OPTIONS)
defopt = option;
}
while (current_tick - start_tick < TIMEOUT)
{
/* Draw the menu. */
line = 3;
for (i = 0; i < FAILSAFE_OPTIONS; i++)
{
char *def = "[DEF]";
char *arrow = "->";
if (i != defopt)
def = "";
if (i != option)
arrow = " ";
printf("%s %s %s", arrow, options[i], def);
}
snprintf(buf, sizeof(buf), "Time left: %lds",
(TIMEOUT - (current_tick - start_tick)) / HZ);
lcd_puts(0, 10, buf);
lcd_update();
button = button_get_w_tmo(HZ);
if (button == BUTTON_NONE || button & SYS_EVENT)
continue ;
start_tick = current_tick;
/* Ignore the ON/PLAY -button because it can cause trouble
with the RTC alarm mod. */
switch (button & ~(BUTTON_ON))
{
case BUTTON_UP:
case BUTTON_RC_REW:
if (option > 0)
option--;
break ;
case BUTTON_DOWN:
case BUTTON_RC_FF:
if (option < FAILSAFE_OPTIONS-1)
option++;
break ;
case BUTTON_SELECT:
case BUTTON_RC_ON:
goto execute;
case BUTTON_REC:
case BUTTON_RC_REC:
if (firmware_settings.initialized)
{
firmware_settings.bootmethod = option;
eeprom_settings_store();
defopt = option;
}
break ;
}
}
execute:
lcd_puts(0, 10, "Executing command...");
lcd_update();
sleep(HZ);
reset_screen();
switch (option)
{
case BOOT_DISK:
return ;
case BOOT_RAM:
start_flashed_ramimage();
printf("Image not found");
break;
case BOOT_ROM:
start_flashed_romimage();
printf("Image not found");
break;
}
shutdown();
}
/* From the pcf50606 driver */
extern unsigned char pcf50606_intregs[3];
void main(void)
{
int i;
int rc;
bool rc_on_button = false;
bool on_button = false;
bool rec_button = false;
bool hold_status = false;
int data;
bool rtc_alarm;
int mask;
bool usb_charge = false;
/* We want to read the buttons as early as possible, before the user
releases the ON button */
/* Set GPIO33, GPIO37, GPIO38 and GPIO52 as general purpose inputs
(The ON and Hold buttons on the main unit and the remote) */
or_l(0x00100062, &GPIO1_FUNCTION);
and_l(~0x00100062, &GPIO1_ENABLE);
data = GPIO1_READ;
if ((data & 0x20) == 0)
on_button = true;
if ((data & 0x40) == 0)
rc_on_button = true;
/* Set the default state of the hard drive power to OFF */
ide_power_enable(false);
power_init();
/* Check the interrupt registers if it was an RTC alarm */
rtc_alarm = (pcf50606_intregs[0] & 0x80)?true:false;
/* Turn off if we believe the start was accidental */
if(!(rtc_alarm || on_button || rc_on_button ||
(usb_detect() == USB_INSERTED) || charger_inserted())) {
__reset_cookie();
power_off();
}
/* get rid of a nasty humming sound during boot */
mask = disable_irq_save();
pcf50606_write(0x3b, 0x00); /* GPOOD2 high Z */
pcf50606_write(0x3b, 0x07); /* GPOOD2 low */
restore_irq(mask);
/* Start with the main backlight OFF. */
backlight_hw_init();
backlight_hw_off();
/* Remote backlight ON */
remote_backlight_hw_on();
system_init();
kernel_init();
/* Set up waitstates for the peripherals */
set_cpu_frequency(0); /* PLL off */
coldfire_set_pllcr_audio_bits(DEFAULT_PLLCR_AUDIO_BITS);
enable_irq();
initialize_eeprom();
isp1362_init();
adc_init();
button_init();
sleep(HZ/50); /* Allow the button driver to check the buttons */
/* Only check remote hold status if remote power button was actually used. */
if (rc_on_button)
{
lcd_remote_init();
if (remote_button_hold())
hold_status = true;
}
/* Check main hold switch status too. */
if (on_button && button_hold())
{
hold_status = true;
}
/* Power on the hard drive early, to speed up the loading. */
if (!hold_status && !recovery_mode)
{
ide_power_enable(true);
if (usb_detect() != USB_INSERTED)
try_flashboot();
}
lcd_init();
if (!rc_on_button)
lcd_remote_init();
font_init();
lcd_setfont(FONT_SYSFIXED);
backlight_init(); /* BUGFIX backlight_init MUST BE AFTER lcd_init */
printf("Rockbox boot loader");
printf("Version %s", rbversion);
rec_button = ((button_status() & BUTTON_REC) == BUTTON_REC)
|| ((button_status() & BUTTON_RC_REC) == BUTTON_RC_REC);
check_battery();
if(rtc_alarm)
printf("RTC alarm detected");
/* Holding REC while starting runs the original firmware */
if (detect_original_firmware() && rec_button)
{
printf("Starting original firmware...");
start_iriver_fw();
}
/* enable usb charging for charge mode and disk mode */
if (usb_detect() == USB_INSERTED)
{
usb_charging_enable(USB_CHARGING_ENABLE);
usb_charge = true;
}
if(charger_inserted())
{
const char charging_msg[] = "Charging...";
const char complete_msg[] = "Charging complete";
const char *msg;
int w, h;
bool blink_toggle = false;
bool request_start = false;
cpu_idle_mode(true);
while(charger_inserted() && !request_start)
{
long button = button_get_w_tmo(HZ);
switch(button)
{
case BUTTON_ON:
request_start = true;
break;
case BUTTON_NONE: /* Timeout */
if(charging_state())
{
/* To be replaced with a nice animation */
blink_toggle = !blink_toggle;
msg = charging_msg;
}
else
{
blink_toggle = true;
msg = complete_msg;
}
font_getstringsize(msg, &w, &h, FONT_SYSFIXED);
reset_screen();
if(blink_toggle)
lcd_putsxy((LCD_WIDTH-w)/2, (LCD_HEIGHT-h)/2, msg);
check_battery();
break;
}
}
if(!request_start)
{
__reset_cookie();
power_off();
}
cpu_idle_mode(false);
}
usb_init();
/* A hack to enter USB mode without using the USB thread */
if(usb_detect() == USB_INSERTED)
{
const char msg[] = "Bootloader USB mode";
int w, h;
font_getstringsize(msg, &w, &h, FONT_SYSFIXED);
reset_screen();
lcd_putsxy((LCD_WIDTH-w)/2, (LCD_HEIGHT-h)/2, msg);
lcd_update();
lcd_remote_puts(0, 3, msg);
lcd_remote_update();
if (firmware_settings.initialized)
{
firmware_settings.disk_clean = false;
eeprom_settings_store();
}
ide_power_enable(true);
storage_enable(false);
sleep(HZ/20);
usb_enable(true);
cpu_idle_mode(true);
while (usb_detect() == USB_INSERTED)
{
/* Print the battery status. */
line = 0;
remote_line = 0;
check_battery();
storage_spin(); /* Prevent the drive from spinning down */
sleep(HZ);
}
cpu_idle_mode(false);
usb_enable(false);
reset_screen();
lcd_update();
}
/* disable usb charging if we enabled it earlier */
if (usb_charge)
{
usb_charging_enable(USB_CHARGING_DISABLE);
usb_charge = false;
}
/* recheck the hold switch status as it may have changed */
hold_status = (button_hold() || remote_button_hold());
/* hold switch shutdown or failsafe recovery mode */
if (hold_status || recovery_mode)
{
if (detect_original_firmware())
{
printf("Hold switch on");
shutdown();
}
failsafe_menu();
}
rc = storage_init();
if(rc)
{
reset_screen();
printf("ATA error: %d", rc);
printf("Insert USB cable and press");
printf("a button");
while(!(button_get(true) & BUTTON_REL));
}
filesystem_init();
rc = disk_mount_all();
if (rc<=0)
{
reset_screen();
printf("No partition found");
while(button_get(true) != SYS_USB_CONNECTED) {};
}
printf("Loading firmware");
i = load_firmware((unsigned char *)DRAM_START, BOOTFILE, MAX_LOADSIZE);
if(i <= EFILE_EMPTY)
printf("Error: %s", loader_strerror(i));
if (i > 0)
start_firmware();
if (!detect_original_firmware())
{
printf("No firmware found on disk");
sleep(HZ*2);
shutdown();
}
else {
sleep(HZ*2);
start_iriver_fw();
}
}
/* These functions are present in the firmware library, but we reimplement
them here because the originals do a lot more than we want */
void screen_dump(void)
{
}
int usb_screen(void)
{
return 0;
}
unsigned short *bidi_l2v(const unsigned char *str, int orientation)
{
static unsigned short utf16_buf[SCROLL_LINE_SIZE];
unsigned short *target;
(void)orientation;
target = utf16_buf;
while (*str)
str = utf8decode(str, target++);
*target = 0;
return utf16_buf;
}
Reference in New Issue View Git Blame Copy Permalink