static int boot_menu(void)
{
const char* strings[] = {"Boot Rockbox", "Boot OF", "USB mode", "Reset Rockbox configuration"};
int button, touch, poweroff_repeat = 0;
unsigned int i;
verbose = true;
adc_init();
redraw:
lcd_clear_display();
for(i=0; i<ARRAYLEN(strings); i++)
{
lcd_drawrect(RECT_X, RECT_Y(i), RECT_WIDTH, RECT_HEIGHT);
lcd_putsxy(TEXT_X(i), TEXT_Y(i), strings[i]);
}
lcd_update();
while(1)
{
button = button_get_w_tmo(HZ/4);
if(button & BUTTON_TOUCHSCREEN)
{
touch = button_get_data();
unsigned int x = touch & 0xFFFF, y = touch >> 16;
int found = -1;
for(i=0; i<ARRAYLEN(strings); i++)
{
if(x > RECT_X && x < RECT_X+RECT_WIDTH &&
y > RECT_Y(i) && y < RECT_Y(i)+RECT_HEIGHT)
{
found = i;
break;
}
}
switch(found)
{
case 0:
reset_screen();
boot_rockbox();
break;
case 1:
reset_screen();
boot_of();
break;
case 2:
usb_mode();
break;
case 3:
reset_configuration();
break;
}
if(found != -1)
goto redraw;
}
else if(button & BUTTON_POWER)
void DisplayChannel::destroy_primary_surface()
{
if (screen()) {
#ifdef USE_OGL
if (surfaces_mngr.is_present_canvas(0)) {
Canvas *canvas;
canvas = surfaces_mngr.get_canvas(0);
if (canvas->get_pixmap_type() == CANVAS_TYPE_GL) {
screen()->unset_type_gl();
screen()->untouch_context();
}
}
#endif
reset_screen();
}
AutoRef<DestroyPrimarySurfaceEvent> event(new DestroyPrimarySurfaceEvent(*this));
get_client().push_event(*event);
(*event)->wait();
if (!(*event)->success()) {
THROW("Destroying primary surface failed");
}
}
static void show_splash(int timeout, const char *msg)
{
reset_screen();
lcd_putsxy( (LCD_WIDTH - (SYSFONT_WIDTH * strlen(msg))) / 2,
(LCD_HEIGHT - SYSFONT_HEIGHT) / 2, msg);
lcd_update();
sleep(timeout);
}
void death( char_data* victim, char_data* ch, char* dt )
{
char tmp [ TWO_LINES ];
obj_data* corpse;
content_array* where = victim->array;
char_data* rch;
bool survive;
remove_bit( &victim->status, STAT_BERSERK );
if( ch == NULL )
for( int i = 0; i < *where; i++ )
if( ( rch = character( where->list[i] ) ) != NULL
&& includes( rch->aggressive, victim ) ) {
ch = rch;
break;
}
stop_fight( victim );
clear_queue( victim );
if( !can_die( victim ) )
return;
disburse_exp( victim );
register_death( victim, ch, dt );
clear_queue( victim );
death_cry( victim );
if( survive = !die_forever( victim ) )
raw_kill( victim );
corpse = make_corpse( victim, where );
loot_corpse( corpse, ch, victim );
if( survive )
return;
if( mob( victim ) != NULL ) {
victim->Extract( );
return;
}
sprintf( tmp, "%s's soul is taken by death.", victim->Name( ) );
info( tmp, LEVEL_BUILDER, tmp, IFLAG_DEATHS, 1, victim );
clear_screen( victim );
reset_screen( victim );
send( victim, "Death is surprisingly peaceful.\n\r" );
send( victim, "Good night.\n\r" );
purge( player( victim ) );
}
void fatal( const char *s )
{
reset_screen( );
fprintf( stderr, "\nFatal error: %s (PC = 0x%08lX)\n", s, pc );
#ifdef DEBUG_TERPRE
fprintf( stdout, "\nFatal error: %s (PC = 0x%08lX)\n", s, pc );
#endif
exit( 1 );
} /* fatal */
void DisplayChannel::handle_reset(RedPeer::InMessage *message)
{
if (surfaces_mngr.is_present_canvas(0)) {
Canvas *canvas;
canvas = surfaces_mngr.get_canvas(0);
canvas->clear();
}
_palette_cache.clear();
reset_screen();
}
void show_board(Board* board) {
reset_screen();
int size = get_size(board);
int factor = get_factor(board);
for(int i = 0; i < size; i++) {
display_space(get_space(board, i), i);
if (is_row_transition(i, factor, size)) {
display_row_transition(factor);
}
if (is_cell_transition(i, factor)) {
write_out(cell_transition_message);
}
}
write_out(end_board_message);
}
int cleanupJS(int dummy)
{
#else
( void ) interpret( );
#endif
unload_cache( );
close_story( );
close_script( );
reset_screen( );
exit( EXIT_SUCCESS );
return ( 0 );
} /* main */
//--------------------------------------------------------------------------
// output status message
//
void output_status(int level, char *st)
{
char *p;
static char linebuf[256];
static int cnt = 0;
// skip null strings
if (st[0] == 0)
return;
// check if in verbose mode
if ((level >= LV_ALWAYS) || VERBOSE)
{
// look for embedded \n
for (p = st; *p; p++)
{
if (*p == 0x0A || ((cnt>33) && (*p==' ')) || (*(p + 1) == 0))
{
// zero terminate the line
linebuf[cnt] = 0;
// print it out ???????? replace
#ifndef __MC68K__
printf("%s",linebuf);
#else
WinDrawChars(linebuf,StrLen(linebuf),5,10*current_line++);
#endif
// check if too many lines
if (current_line == MAXLINE)
reset_screen();
cnt = 0;
}
else
linebuf[cnt++] = *p;
}
}
}
void display(board_t *board)
{
int i, j;
static char statemap[][12] = {"\x1B[00m ", "\x1B[34m~", "\x1B[37m+", "\x1B[32mT", "\x1B[31m#", "\x1B[00m."};
assert(board != NULL);
assert(board->height > 0);
assert(board->width > 0);
reset_screen();
for (i = 0; i < board->height; i++) {
for (j = 0; j < board->width; j++) {
switch(board->cells[i][j].type)
{
case CT_GRASS:
printf("%s", statemap[0]);
break;
case CT_WATER:
printf("%s", statemap[1]);
break;
case CT_ROCK:
printf("%s", statemap[2]);
break;
case CT_TREE:
if(board->cells[i][j].data.tree.life == 100)
printf("%s", statemap[3]);
else if(board->cells[i][j].data.tree.life)
printf("%s", statemap[4]);
else
printf("%s", statemap[5]);
break;
default:
break;
}
}
putchar('\n');
}
}
void vga_init(void)
{
reset_screen();
}
int main(void)
{
unsigned char* loadbuffer;
int buffer_size;
int rc;
int(*kernel_entry)(void);
led_init();
clear_leds(LED_ALL);
/* NB: something in system_init() prevents H-JTAG from downloading */
/* system_init(); */
kernel_init();
/* enable_interrupt(IRQ_FIQ_STATUS); */
backlight_init();
lcd_init();
lcd_setfont(FONT_SYSFIXED);
button_init();
dma_init();
uart_init();
uart_init_device(DEBUG_UART_PORT);
/* mini2440_test(); */
/* Show debug messages if button is pressed */
int touch_data;
if(button_read_device(&touch_data) & BUTTON_MENU)
verbose = true;
printf("Rockbox boot loader");
printf("Version " RBVERSION);
rc = storage_init();
if(rc)
{
reset_screen();
error(EATA, rc, true);
}
disk_init(IF_MD(0));
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 <= 0)
error(EBOOTFILE, rc, true);
printf("Loaded firmware %d\n", rc);
/* storage_close(); */
system_prepare_fw_start();
commit_discard_idcache();
kernel_entry = (void*) loadbuffer;
rc = kernel_entry();
/* end stop - should not get here */
led_flash(LED_ALL, LED_NONE);
while (1); /* avoid warning */
}
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
}
/* keyboard_handler()
An Interrupt Handler that is Called When
Key is Pressed on Keyboard
Input : i -- interrupt vector
Output : None
Side Effect : Handle keypress functions
Prints keys Pressed to Screen accordingly
Issue EOI(End Of Interrupt) to unmask keyboard interrupt
*/
void keyboard_handler(int i)
{
/* Grab Key Pressed*/
uint8_t keycode;
keycode = kbd_read_input();
/* Indicate a key has been pressed */
key_press = 1;
int32_t display_terminal= get_displayed_terminal();
/* Print Only Keys Pressed, NOT Key Release
* No Print for CTRL/SHIFT/Backspace/Caps
* Carries out Functionality Instead */
if(keycode <= KEY_RELEASE_VALUE){
/* Condition Key Press */
if (keycode == ALT)
alt_press += 1;
else if(keycode == L_SHIFT || keycode == R_SHIFT)
shift_press += 1;
else if (keycode == CTRL)
ctrl_press += 1;
else if (keycode == CAPS_LOCK)
caps_on = !caps_on;
/* CTRL-L Clear Screen */
else if(keycode == L && ctrl_press > 0)
reset_screen();
/* Backspace */
else if (keycode == BACKSPACE){
/* Don't backspace when reading and at start of buffer*/
if(read_on[display_terminal] == 0 || (index[display_terminal] != 0 && read_on[display_terminal] == 1))
backspace();
update_terminal_buf(BACK,keycode);
}
/* Return Press During Read */
else if (read_on[display_terminal] == 1 && keycode == RETURN){
printf("\n"); // New Line for Return Press
read_return[display_terminal] = 1;
update_terminal_buf(KEYS,keycode);
}
/* ALT-Function Press */
else if(alt_press > 0 && (keycode == F1 || keycode == F2 || keycode == F3)){
switch(keycode){
case F1:
change_terminal(TERMINAL_1);
break;
case F2:
change_terminal(TERMINAL_2);
break;
case F3:
change_terminal(TERMINAL_3);
default:
break;
}
}
/* Caps On */
else if (caps_on == 1){
caps_on_handler(keycode);
}
/* Shift Press */
else if (shift_press > 0){
printf("%c", shift_keys[keycode - 1]);
update_terminal_buf(SHIFT_KEYS, keycode);
}
/* Normal Press */
else{
printf("%c", keys[keycode - 1]);
update_terminal_buf(KEYS, keycode);
}
}
/* Condition Key Releases */
else if (keycode == (ALT + KEY_RELEASE_VALUE))
alt_press -= 1;
else if(keycode == (L_SHIFT + KEY_RELEASE_VALUE) || keycode == (R_SHIFT + KEY_RELEASE_VALUE))
shift_press -= 1;
else if (keycode == (CTRL + KEY_RELEASE_VALUE))
ctrl_press -= 1;
/* Key Press Serviced */
key_press = 0;
send_eoi(KEYBOARD_IRQ);
}
void* main(void)
{
#ifdef TCCBOOT
int rc;
unsigned char* loadbuffer = (unsigned char*)LOAD_ADDRESS;
#endif
system_init();
power_init();
kernel_init();
enable_irq();
lcd_init();
adc_init();
button_init();
backlight_init();
font_init();
lcd_setfont(FONT_SYSFIXED);
show_logo();
_backlight_on();
/* Only load the firmware if TCCBOOT is defined - this ensures SDRAM_START is
available for loading the firmware. Otherwise display the debug screen. */
#ifdef TCCBOOT
printf("Rockbox boot loader");
printf("Version " RBVERSION);
printf("ATA");
rc = storage_init();
if(rc)
{
reset_screen();
error(EATA, rc, true);
}
printf("mount");
rc = disk_mount_all();
if (rc<=0)
{
error(EDISK,rc, true);
}
rc = load_firmware(loadbuffer, BOOTFILE, MAX_LOAD_SIZE);
if (rc <= EFILE_EMPTY)
{
error(EBOOTFILE,rc, true);
}
else
{
int(*kernel_entry)(void) = (void *) loadbuffer;
disable_irq();
rc = kernel_entry();
}
panicf("Boot failed!");
#else
show_debug_screen();
#endif
return 0;
}