static int button_read(int *data)
{
int btn = button_read_device(data);
#else
static int button_read(void)
{
int btn = button_read_device();
#endif
int retval;
#ifdef HAVE_LCD_FLIP
if (btn && flipped)
btn = button_flip(btn); /* swap upside down */
#endif /* HAVE_LCD_FLIP */
#ifdef HAVE_TOUCHSCREEN
if (btn & BUTTON_TOUCHSCREEN)
last_touchscreen_touch = current_tick;
#endif
/* Filter the button status. It is only accepted if we get the same
status twice in a row. */
#ifndef HAVE_TOUCHSCREEN
if (btn != last_read)
retval = lastbtn;
else
#endif
retval = btn;
last_read = btn;
return retval;
}
void system_exception_wait(void)
{
backlight_hw_on();
backlight_hw_brightness(DEFAULT_BRIGHTNESS_SETTING);
/* wait until button press and release */
while(button_read_device() != 0) {}
while(button_read_device() == 0) {}
while(button_read_device() != 0) {}
while(button_read_device() == 0) {}
}
void system_exception_wait(void)
{
/* make sure lcd and backlight are on */
lcd_update();
_backlight_on();
_backlight_set_brightness(DEFAULT_BRIGHTNESS_SETTING);
/* wait until button release (if a button is pressed) */
while(button_read_device());
/* then wait until next button press */
while(!button_read_device());
}
void system_exception_wait(void)
{
/* stop hadrware watchdog, IRQs are stopped */
imx233_rtc_enable_watchdog(false);
/* make sure lcd and backlight are on */
lcd_update();
backlight_hw_on();
backlight_hw_brightness(DEFAULT_BRIGHTNESS_SETTING);
/* wait until button release (if a button is pressed) */
#ifdef HAVE_BUTTON_DATA
int data;
while(button_read_device(&data));
/* then wait until next button press */
while(!button_read_device(&data));
#else
while(button_read_device());
/* then wait until next button press */
while(!button_read_device());
#endif
}
void button_debug_screen(void)
{
char product_id[RMI_PRODUCT_ID_LEN];
rmi_read(RMI_PRODUCT_ID, RMI_PRODUCT_ID_LEN, product_id);
int x_max = rmi_read_single(RMI_2D_SENSOR_XMAX_MSB(0)) << 8 | rmi_read_single(RMI_2D_SENSOR_XMAX_LSB(0));
int y_max = rmi_read_single(RMI_2D_SENSOR_YMAX_MSB(0)) << 8 | rmi_read_single(RMI_2D_SENSOR_YMAX_LSB(0));
int func_presence = rmi_read_single(RMI_FUNCTION_PRESENCE(RMI_2D_TOUCHPAD_FUNCTION));
int sensor_prop = rmi_read_single(RMI_2D_SENSOR_PROP2(0));
int sensor_resol = rmi_read_single(RMI_2D_SENSOR_RESOLUTION(0));
int min_dist = rmi_read_single(RMI_2D_MIN_DIST);
int gesture_settings = rmi_read_single(RMI_2D_GESTURE_SETTINGS);
union
{
unsigned char data;
signed char value;
}sensitivity;
rmi_read(RMI_2D_SENSITIVITY_ADJ, 1, &sensitivity.data);
/* Device to screen */
int zone_w = LCD_WIDTH;
int zone_h = (zone_w * y_max + x_max - 1) / x_max;
int zone_x = 0;
int zone_y = LCD_HEIGHT - zone_h;
#define DX2SX(x) (((x) * zone_w ) / x_max)
#define DY2SY(y) (zone_h - ((y) * zone_h ) / y_max)
struct viewport report_vp;
memset(&report_vp, 0, sizeof(report_vp));
report_vp.x = zone_x;
report_vp.y = zone_y;
report_vp.width = zone_w;
report_vp.height = zone_h;
struct viewport gesture_vp;
memset(&gesture_vp, 0, sizeof(gesture_vp));
gesture_vp.x = 0;
gesture_vp.y = zone_y - 80;
gesture_vp.width = LCD_WIDTH;
gesture_vp.height = 80;
while(1)
{
lcd_set_viewport(NULL);
lcd_clear_display();
int btns = button_read_device();
lcd_putsf(0, 0, "button bitmap: %x", btns);
lcd_putsf(0, 1, "RMI: id=%s p=%x s=%x", product_id, func_presence, sensor_prop);
lcd_putsf(0, 2, "xmax=%d ymax=%d res=%d", x_max, y_max, sensor_resol);
lcd_putsf(0, 3, "attn=%d ctl=%x int=%x",
imx233_get_gpio_input_mask(0, 0x08000000) ? 0 : 1,
rmi_read_single(RMI_DEVICE_CONTROL),
rmi_read_single(RMI_INTERRUPT_REQUEST));
lcd_putsf(0, 4, "sensi: %d min_dist: %d", (int)sensitivity.value, min_dist);
lcd_putsf(0, 5, "gesture: %x", gesture_settings);
union
{
unsigned char data[10];
struct
{
struct rmi_2d_absolute_data_t absolute;
struct rmi_2d_relative_data_t relative;
struct rmi_2d_gesture_data_t gesture;
}s;
}u;
int absolute_x = u.s.absolute.x_msb << 8 | u.s.absolute.x_lsb;
int absolute_y = u.s.absolute.y_msb << 8 | u.s.absolute.y_lsb;
int nr_fingers = u.s.absolute.misc & 7;
bool gesture = (u.s.absolute.misc & 8) == 8;
int palm_width = u.s.absolute.misc >> 4;
rmi_read(RMI_DATA_REGISTER(0), 10, u.data);
lcd_putsf(0, 6, "abs: %d %d %d", absolute_x, absolute_y, (int)u.s.absolute.z);
lcd_putsf(0, 7, "rel: %d %d", (int)u.s.relative.x, (int)u.s.relative.y);
lcd_putsf(0, 8, "gesture: %x %x", u.s.gesture.misc, u.s.gesture.flick);
lcd_putsf(0, 9, "misc: w=%d g=%d f=%d", palm_width, gesture, nr_fingers);
lcd_set_viewport(&report_vp);
lcd_set_drawinfo(DRMODE_SOLID, LCD_RGBPACK(0xff, 0, 0), LCD_BLACK);
lcd_drawrect(0, 0, zone_w, zone_h);
if(nr_fingers == 1)
{
lcd_set_drawinfo(DRMODE_SOLID, LCD_RGBPACK(0, 0, 0xff), LCD_BLACK);
lcd_drawline(DX2SX(absolute_x) - u.s.relative.x,
DY2SY(absolute_y) + u.s.relative.y,
DX2SX(absolute_x), DY2SY(absolute_y));
lcd_set_drawinfo(DRMODE_SOLID, LCD_RGBPACK(0, 0xff, 0), LCD_BLACK);
lcd_fillrect(DX2SX(absolute_x) - 1, DY2SY(absolute_y) - 1, 3, 3);
}
lcd_set_viewport(&gesture_vp);
lcd_set_drawinfo(DRMODE_SOLID, LCD_RGBPACK(0xff, 0xff, 0), LCD_BLACK);
if(u.s.gesture.misc & RMI_2D_GEST_MISC_CONFIRMED)
{
switch(u.s.gesture.misc & RMI_2D_GEST_MISC_TAP_CODE_BM)
{
case RMI_2D_GEST_MISC_NO_TAP: break;
case RMI_2D_GEST_MISC_SINGLE_TAP:
lcd_putsf(0, 0, "TAP!");
break;
case RMI_2D_GEST_MISC_DOUBLE_TAP:
lcd_putsf(0, 0, "DOUBLE TAP!");
break;
case RMI_2D_GEST_MISC_TAP_AND_HOLD:
lcd_putsf(0, 0, "TAP & HOLD!");
break;
default: break;
}
if(u.s.gesture.misc & RMI_2D_GEST_MISC_FLICK)
{
lcd_putsf(0, 1, "FLICK!");
int flick_x = u.s.gesture.flick & RMI_2D_GEST_FLICK_X_BM;
int flick_y = (u.s.gesture.flick & RMI_2D_GEST_FLICK_Y_BM) >> RMI_2D_GEST_FLICK_Y_BP;
#define SIGN4EXT(a) \
if(a & 8) a = -((a ^ 0xf) + 1);
SIGN4EXT(flick_x);
SIGN4EXT(flick_y);
int center_x = (LCD_WIDTH * 2) / 3;
int center_y = 40;
lcd_drawline(center_x, center_y, center_x + flick_x * 5, center_y - flick_y * 5);
}
}
lcd_update();
if(btns & BUTTON_POWER)
break;
if(btns & BUTTON_VOL_DOWN || btns & BUTTON_VOL_UP)
{
if(btns & BUTTON_VOL_UP)
sensitivity.value++;
if(btns & BUTTON_VOL_DOWN)
sensitivity.value--;
rmi_write(RMI_2D_SENSITIVITY_ADJ, 1, &sensitivity.data);
}
yield();
}
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);
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
}
void* main(void)
{
char filename[MAX_PATH];
int i;
int btn;
int rc;
int num_partitions;
struct partinfo* pinfo;
#if !(CONFIG_STORAGE & STORAGE_SD)
char buf[256];
unsigned short* identify_info;
#endif
int usb = USB_EXTRACTED;
chksum_crc32gentab ();
system_init();
kernel_init();
#ifdef HAVE_BOOTLOADER_USB_MODE
/* loader must service interrupts */
enable_interrupt(IRQ_FIQ_STATUS);
#endif
lcd_init();
font_init();
show_logo();
adc_init();
#ifdef HAVE_BOOTLOADER_USB_MODE
button_init_device();
#else
button_init();
#endif
#if defined(SANSA_E200) || defined(PHILIPS_SA9200)
i2c_init();
_backlight_on();
#endif
if (button_hold())
{
verbose = true;
lcd_clear_display();
printf("Hold switch on");
printf("Shutting down...");
sleep(HZ);
power_off();
}
btn = button_read_device();
/* Enable bootloader messages if any button is pressed */
#ifdef HAVE_BOOTLOADER_USB_MODE
lcd_clear_display();
if (btn)
verbose = true;
#else
if (btn) {
lcd_clear_display();
verbose = true;
}
#endif
lcd_setfont(FONT_SYSFIXED);
printf("Rockbox boot loader");
printf("Version: " RBVERSION);
printf(MODEL_NAME);
i=storage_init();
#if !(CONFIG_STORAGE & STORAGE_SD)
if (i==0) {
identify_info=ata_get_identify();
/* Show model */
for (i=0; i < 20; i++) {
((unsigned short*)buf)[i]=htobe16(identify_info[i+27]);
}
buf[40]=0;
for (i=39; i && buf[i]==' '; i--) {
buf[i]=0;
}
printf(buf);
} else {
error(EATA, i, true);
}
#endif
disk_init(IF_MV(0));
num_partitions = disk_mount_all();
if (num_partitions<=0)
{
error(EDISK,num_partitions, true);
}
/* Just list the first 2 partitions since we don't have any devices yet
that have more than that */
for(i=0; i<NUM_PARTITIONS; i++)
{
pinfo = disk_partinfo(i);
printf("Partition %d: 0x%02x %ld MB",
i, pinfo->type, pinfo->size / 2048);
}
/* Now that storage is initialized, check for USB connection */
if ((btn & BOOTLOADER_BOOT_OF) == 0)
{
usb_pin_init();
usb = handle_usb(HZ*2);
if (usb == USB_INSERTED)
btn |= BOOTLOADER_BOOT_OF;
}
/* Try loading Rockbox, if that fails, fall back to the OF */
if((btn & BOOTLOADER_BOOT_OF) == 0)
{
printf("Loading Rockbox...");
snprintf(filename,sizeof(filename), BOOTDIR "/%s", BOOTFILE);
rc = load_mi4(loadbuffer, filename, MAX_LOADSIZE);
if (rc <= EFILE_EMPTY)
{
bool old_verbose = verbose;
verbose = true;
printf("Can't load " BOOTFILE ": ");
printf(loader_strerror(rc));
verbose = old_verbose;
btn |= BOOTLOADER_BOOT_OF;
sleep(5*HZ);
}
else
goto main_exit;
}
if(btn & BOOTLOADER_BOOT_OF)
{
/* Load original mi4 firmware in to a memory buffer called loadbuffer.
The rest of the loading is done in crt0.S.
1) First try reading from the hidden partition (on Sansa only).
2) Next try a decrypted mi4 file in /System/OF.mi4
3) Finally, try a raw firmware binary in /System/OF.bin. It should be
a mi4 firmware decrypted and header stripped using mi4code.
*/
printf("Loading original firmware...");
#if (CONFIG_STORAGE & STORAGE_SD)
/* First try a (hidden) firmware partition */
printf("Trying firmware partition");
pinfo = disk_partinfo(1);
if(pinfo->type == PARTITION_TYPE_OS2_HIDDEN_C_DRIVE)
{
rc = load_mi4_part(loadbuffer, pinfo, MAX_LOADSIZE,
usb == USB_INSERTED);
if (rc <= EFILE_EMPTY) {
printf("Can't load from partition");
printf(loader_strerror(rc));
} else {
goto main_exit;
}
} else {
printf("No hidden partition found.");
}
#endif
#if defined(PHILIPS_HDD1630) || defined(PHILIPS_HDD6330) || defined(PHILIPS_SA9200)
printf("Trying /System/OF.ebn");
rc=load_mi4(loadbuffer, "/System/OF.ebn", MAX_LOADSIZE);
if (rc <= EFILE_EMPTY) {
printf("Can't load /System/OF.ebn");
printf(loader_strerror(rc));
} else {
goto main_exit;
}
#endif
printf("Trying /System/OF.mi4");
rc=load_mi4(loadbuffer, "/System/OF.mi4", MAX_LOADSIZE);
if (rc <= EFILE_EMPTY) {
printf("Can't load /System/OF.mi4");
printf(loader_strerror(rc));
} else {
#if defined(SAMSUNG_YH925)
lcd_reset();
#endif
goto main_exit;
}
printf("Trying /System/OF.bin");
rc=load_raw_firmware(loadbuffer, "/System/OF.bin", MAX_LOADSIZE);
if (rc <= EFILE_EMPTY) {
printf("Can't load /System/OF.bin");
printf(loader_strerror(rc));
} else {
#if defined(SAMSUNG_YH925)
lcd_reset();
#endif
goto main_exit;
}
error(0, 0, true);
}
main_exit:
#ifdef HAVE_BOOTLOADER_USB_MODE
storage_close();
system_prepare_fw_start();
#endif
return (void*)loadbuffer;
}
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;
}