static void cmd_handler (void)
{
/* Handle commands and filenames */
if (ieee_data.ieeeflags & COMMAND_RECVD) {
# ifdef HAVE_HOTPLUG
/* This seems to be a nice point to handle card changes */
if (disk_state != DISK_OK) {
set_busy_led(1);
/* If the disk was changed the buffer contents are useless */
if (disk_state == DISK_CHANGED || disk_state == DISK_REMOVED) {
free_multiple_buffers(FMB_ALL);
change_init();
filesystem_init(0);
} else {
/* Disk state indicated an error, try to recover by initialising */
filesystem_init(1);
}
update_leds();
}
# endif
if (ieee_data.secondary_address == 0x0f) {
parse_doscommand(); /* Command channel */
} else {
datacrc = 0xffff; /* Filename in command buffer */
file_open(ieee_data.secondary_address);
}
command_length = 0;
ieee_data.ieeeflags &= (uint8_t) ~COMMAND_RECVD;
} /* COMMAND_RECVD */
/* We're done, clean up unused buffers */
free_multiple_buffers(FMB_UNSTICKY);
d64_bam_commit();
}
void main(void)
{
unsigned char* loadbuffer;
int buffer_size;
int rc;
int(*kernel_entry)(void);
/* Make sure interrupts are disabled */
set_irq_level(IRQ_DISABLED);
set_fiq_status(FIQ_DISABLED);
system_init();
kernel_init();
/* Now enable interrupts */
set_irq_level(IRQ_ENABLED);
set_fiq_status(FIQ_ENABLED);
lcd_init();
backlight_init();
font_init();
button_init();
usb_init();
power_init();
// enable_irq();
// enable_fiq();
adc_init();
lcd_setfont(FONT_SYSFIXED);
/* Show debug messages if button is pressed */
// if(button_read_device())
verbose = true;
printf("Rockbox boot loader");
printf("Version %s", rbversion);
/* Enter USB mode without USB thread */
if(usb_detect() == USB_INSERTED)
{
const char msg[] = "Bootloader USB mode";
reset_screen();
lcd_putsxy( (LCD_WIDTH - (SYSFONT_WIDTH * strlen(msg))) / 2,
(LCD_HEIGHT - SYSFONT_HEIGHT) / 2, msg);
lcd_update();
ide_power_enable(true);
storage_enable(false);
sleep(HZ/20);
usb_enable(true);
while (usb_detect() == USB_INSERTED)
{
storage_spin(); /* Prevent the drive from spinning down */
sleep(HZ);
}
usb_enable(false);
reset_screen();
lcd_update();
}
sleep(50);
printf("ATA");
rc = storage_init();
if(rc)
{
reset_screen();
error(EATA, rc, true);
}
printf("filesystem");
filesystem_init();
printf("mount");
rc = disk_mount_all();
if (rc<=0)
{
error(EDISK,rc, true);
}
printf("Loading firmware");
loadbuffer = (unsigned char*) 0x00900000;
buffer_size = (unsigned char*)0x01900000 - loadbuffer;
rc = load_firmware(loadbuffer, BOOTFILE, buffer_size);
if(rc <= EFILE_EMPTY)
error(EBOOTFILE, rc, true);
kernel_entry = (void*) loadbuffer;
rc = kernel_entry();
/* Should not get here! */
return rc;
}
void main(void)
{
unsigned char* loadbuffer;
int buffer_size;
int rc;
int(*kernel_entry)(void);
system_init();
kernel_init(); /* Need the kernel to sleep */
enable_interrupt(IRQ_FIQ_STATUS);
lcd_init();
backlight_init();
button_init();
font_init();
adc_init();
lcd_setfont(FONT_SYSFIXED);
/* These checks should only run if the bootloader is flashed */
if(GSTATUS3&0x02)
{
GSTATUS3&=0xFFFFFFFD;
if(!(GPGDAT&BUTTON_POWER) && charger_inserted())
{
while(!(GPGDAT&BUTTON_POWER) && charger_inserted())
{
char msg[20];
if(charging_state())
{
snprintf(msg,sizeof(msg),"Charging");
}
else
{
snprintf(msg,sizeof(msg),"Charge Complete");
}
reset_screen();
lcd_putsxy( (LCD_WIDTH - (SYSFONT_WIDTH * strlen(msg))) / 2,
(LCD_HEIGHT - SYSFONT_HEIGHT) / 2, msg);
lcd_update();
#if defined(HAVE_RTC_ALARM)
/* Check if the alarm went off while charging */
if(rtc_check_alarm_flag())
{
GSTATUS3=1; /* Normally this is set in crt0.s */
break;
}
#endif
}
if(!(GPGDAT&BUTTON_POWER)
#if defined(HAVE_RTC_ALARM)
&& !GSTATUS3
#endif
)
{
shutdown();
}
}
if(button_hold())
{
const char msg[] = "HOLD is enabled";
reset_screen();
lcd_putsxy( (LCD_WIDTH - (SYSFONT_WIDTH * strlen(msg))) / 2,
(LCD_HEIGHT - SYSFONT_HEIGHT) / 2, msg);
lcd_update();
sleep(2*HZ);
shutdown();
}
}
power_init();
usb_init();
/* Enter USB mode without USB thread */
if(usb_detect() == USB_INSERTED)
{
const char msg[] = "Bootloader USB mode";
reset_screen();
lcd_putsxy( (LCD_WIDTH - (SYSFONT_WIDTH * strlen(msg))) / 2,
(LCD_HEIGHT - SYSFONT_HEIGHT) / 2, msg);
lcd_update();
storage_enable(false);
sleep(HZ/20);
usb_enable(true);
while (usb_detect() == USB_INSERTED)
sleep(HZ);
usb_enable(false);
reset_screen();
lcd_update();
}
reset_screen();
/* Show debug messages if button is pressed */
if(button_read_device()&BUTTON_A)
verbose = true;
printf("Rockbox boot loader");
printf("Version %s", rbversion);
sleep(50); /* ATA seems to error without this pause */
rc = storage_init();
if(rc)
{
reset_screen();
error(EATA, rc, true);
}
filesystem_init();
rc = disk_mount_all();
if (rc<=0)
{
error(EDISK, rc, true);
}
printf("Loading firmware");
/* Flush out anything pending first */
commit_discard_idcache();
loadbuffer = (unsigned char*) 0x31000000;
buffer_size = (unsigned char*)0x31400000 - loadbuffer;
rc = load_firmware(loadbuffer, BOOTFILE, buffer_size);
if(rc <= EFILE_EMPTY)
error(EBOOTFILE, rc, true);
storage_close();
system_prepare_fw_start();
commit_discard_idcache();
kernel_entry = (void*) loadbuffer;
rc = kernel_entry();
#if 0
/* Halt */
while (1)
core_idle();
#else
/* Return and restart */
#endif
}
int main(void) {
/* Early system initialisation */
early_board_init();
system_init_early();
leds_init();
set_busy_led(1);
set_dirty_led(0);
/* Due to an erratum in the LPC17xx chips anything that may change */
/* peripheral clock scalers must come before system_init_late() */
uart_init();
#ifndef SPI_LATE_INIT
spi_init(SPI_SPEED_SLOW);
#endif
timer_init();
i2c_init();
/* Second part of system initialisation, switches to full speed on ARM */
system_init_late();
enable_interrupts();
/* Prompt software name and version string */
uart_puts_P(PSTR("\r\nNODISKEMU " VERSION "\r\n"));
/* Internal-only initialisation, called here because it's faster */
buffers_init();
buttons_init();
/* Anything that does something which needs the system clock */
/* should be placed after system_init_late() */
rtc_init(); // accesses I2C
disk_init(); // accesses card
read_configuration(); // restores configuration, may change device address
filesystem_init(0);
// FIXME: change_init();
#ifdef CONFIG_REMOTE_DISPLAY
/* at this point all buffers should be free, */
/* so just use the data area of the first to build the string */
uint8_t *strbuf = buffers[0].data;
ustrcpy_P(strbuf, versionstr);
ustrcpy_P(strbuf+ustrlen(strbuf), longverstr);
if (display_init(ustrlen(strbuf), strbuf)) {
display_address(device_address);
display_current_part(0);
}
#endif
set_busy_led(0);
#if defined(HAVE_SD)
/* card switch diagnostic aid - hold down PREV button to use */
if (menu_system_enabled && get_key_press(KEY_PREV))
board_diagnose();
#endif
if (menu_system_enabled)
lcd_splashscreen();
bus_interface_init();
bus_init();
read_configuration();
late_board_init();
for (;;) {
if (menu_system_enabled)
lcd_refresh();
else {
lcd_clear();
lcd_printf("#%d", device_address);
}
/* Unit number may depend on hardware and stored settings */
/* so present it here at last */
printf("#%02d\r\n", device_address);
bus_mainloop();
bus_interface_init();
bus_init(); // needs delay, inits device address with HW settings
}
}
void web_server_init(void) {
filesystem_init();
http_server_init(80, process_POST, tag_expand);
}
int main(int argc, char *argv[]) {
configuration_parse(&argc, &argv);
return filesystem_init(argc, argv, &fuse_initialised, &fuse_destroyed);
}
void* main(void)
{
int i;
int btn;
int num_partitions;
int crc32;
char sector[512];
struct partinfo pinfo;
system_init();
kernel_init();
lcd_init();
font_init();
button_init();
i2c_init();
backlight_hw_on();
lcd_set_foreground(LCD_WHITE);
lcd_set_background(LCD_BLACK);
lcd_clear_display();
btn = button_read_device();
verbose = true;
lcd_setfont(FONT_SYSFIXED);
printf("Rockbox e200R installer");
printf("Version: %s", rbversion);
printf(MODEL_NAME);
printf("");
i=storage_init();
filesystem_init();
num_partitions = disk_mount_all();
if (num_partitions<=0)
{
error(EDISK, num_partitions, true);
}
disk_partinfo(1, &pinfo);
#if 0 /* not needed in release builds */
printf("--- Partition info ---");
printf("start: %x", pinfo.start);
printf("size: %x", pinfo.size);
printf("type: %x", pinfo.type);
printf("reading: %x", (START_SECTOR_OF_ROM + ROMSECTOR_TO_HACK)*512);
#endif
storage_read_sectors(pinfo.start + START_SECTOR_OF_ROM + ROMSECTOR_TO_HACK,
1 , sector);
crc32 = chksum_crc32 (sector, 512);
#if 0 /* not needed in release builds */
printf("--- Hack Status ---");
printf("Sector checksum: %x", crc32);
#endif
if (crc32 == PATCHED_CRC32)
{
/* Bootloader already patched */
printf("Already unlocked");
printf("Proceed to Step 2");
} else if ((crc32 == KNOWN_CRC32) &&
!memcmp(§or[HACK_OFFSET], knownBytes,
sizeof(knownBytes)/sizeof(*knownBytes)))
{
/* E200R bootloader detected - patch it */
memcpy(§or[HACK_OFFSET], changedBytes,
sizeof(changedBytes)/sizeof(*changedBytes));
storage_write_sectors(
pinfo.start + START_SECTOR_OF_ROM + ROMSECTOR_TO_HACK,
1 , sector);
printf("Firmware unlocked");
printf("Proceed to Step 2");
} else if (is_e200(crc32))
{
printf("Vanilla E200 detected!");
printf("Please install using");
printf("Sansapatcher");
}
else
{
printf("Unknown bootloader");
printf("Rockbox installer cannot");
printf("continue");
}
/* Turn button lights off */
GPIOG_OUTPUT_VAL &=~0x80;
printf("");
if (button_hold())
printf("Release Hold and");
printf("Press any key to shutdown");
while(button_read_device() == BUTTON_NONE);
power_off();
return NULL;
}
