diff -ub -r rockbox-060219/apps/misc.c rockbox-jsl060214/apps/misc.c --- rockbox-060219/apps/misc.c Mon Jan 23 06:00:35 2006 +++ rockbox-jsl060214/apps/misc.c Sat Feb 18 02:56:22 2006 @@ -54,6 +54,10 @@ #include "icons.h" #endif /* End HAVE_LCD_BITMAP */ +#if defined(HAVE_RECORDING) && (CONFIG_CODEC == SWCODEC) +#include "pcm_record.h" +#endif + /* Format a large-range value for output, using the appropriate unit so that * the displayed value is in the range 1 <= display < 1000 (1024 for "binary" * units) if possible, and 3 significant digits are shown. If a buffer is @@ -462,11 +466,27 @@ if(!charger_inserted()) #endif { +#if defined(HAVE_RECORDING) && (CONFIG_CODEC == SWCODEC) + if (pcm_rec_status() & AUDIO_STATUS_RECORD) { + audio_stop_recording(); + gui_syncsplash(2*HZ, true, "Stopping Recording!"); + sleep(2*HZ); + } +#endif + if (!battery_level_safe()) + gui_syncsplash(3*HZ, true, "RECHARGE! Battery empty! %s", + str(LANG_SHUTTINGDOWN)); + else if (battery_level() < 10) + gui_syncsplash(3*HZ, true, "WARNING! Low Battery. %s", + str(LANG_SHUTTINGDOWN)); + else { lcd_clear_display(); gui_syncsplash(0, true, str(LANG_SHUTTINGDOWN)); + } if (callback != NULL) callback(parameter); + if (battery_level() > 9) /* do not save settings on low battery */ system_flush(); shutdown_hw(); diff -ub -r rockbox-060219/firmware/export/powermgmt.h rockbox-jsl060214/firmware/export/powermgmt.h --- rockbox-060219/firmware/export/powermgmt.h Thu Jan 26 06:00:32 2006 +++ rockbox-jsl060214/firmware/export/powermgmt.h Sat Feb 18 02:56:22 2006 @@ -113,14 +113,27 @@ # define CURRENT_NORMAL 95 /* average, nearly proportional to 1/U */ # define CURRENT_USB 1 /* host powered in USB mode; avoid zero-div */ # define CURRENT_BACKLIGHT 0 /* no backlight */ + #else /* Values for HD based jukeboxes */ -# ifdef IRIVER_H100_SERIES -# define CURRENT_NORMAL 80 -# else +#ifdef IRIVER_H100_SERIES +# define CURRENT_NORMAL 80 /* 20h playback on 1600mAh battery */ +# define CURRENT_BACKLIGHT 23 /* from IriverBattery twiki page */ +# define CURRENT_SPDIF_OUT 10 /* optical SPDIF output on */ +#else # define CURRENT_NORMAL 145 /* usual current in mA when using the AJB including some disk/backlight/... activity */ -# endif /* not IRIVER_H100_SERIES */ -# define CURRENT_USB 500 /* usual current in mA in USB mode */ -# define CURRENT_BACKLIGHT 30 /* additional current when backlight is always on */ +# define CURRENT_BACKLIGHT 30 /* additional current when backlight always on */ +#endif /* not IRIVER_H100_SERIES */ +#define CURRENT_USB 500 /* usual current in mA in USB mode */ +#ifdef IRIVER_H100_SERIES +# define CURRENT_RECORD 80 /* additional current while recording */ +#elif defined(IRIVER_H300_SERIES) +# define CURRENT_RECORD 100 +#elif defined(HAVE_RECORDING) +# define CURRENT_RECORD 10 +#endif +#ifdef HAVE_REMOTE_LCD +# define CURRENT_REMOTE 8 /* add. current when H100-remote connected */ +#endif # define CURRENT_MIN_CHG 70 /* minimum charge current */ # define MIN_CHG_V 8500 /* at 8.5v charger voltage get CURRENT_MIN_CHG */ @@ -140,10 +153,10 @@ #endif /* SIMULATOR */ -/* Returns battery level in percent */ -int battery_level(void); +/* Returns battery status */ +int battery_level(void); /* percent */ int battery_time(void); /* minutes */ - +int battery_adc_voltage(void); /* voltage from ADC in centivolts */ unsigned int battery_voltage(void); /* filtered batt. voltage in centivolts */ /* Tells if the battery level is safe for disk writes */ diff -ub -r rockbox-060219/firmware/powermgmt.c rockbox-jsl060214/firmware/powermgmt.c --- rockbox-060219/firmware/powermgmt.c Sat Feb 4 06:00:43 2006 +++ rockbox-jsl060214/firmware/powermgmt.c Sat Feb 18 03:07:10 2006 @@ -49,6 +49,9 @@ #ifdef HAVE_LCD_BITMAP #include "font.h" #endif +#if defined(HAVE_RECORDING) && (CONFIG_CODEC == SWCODEC) +#include "pcm_record.h" +#endif #include "logf.h" #include "lcd-remote.h" @@ -69,7 +72,6 @@ #define DEBUG_STACK 0 #endif -static int shutdown_timeout = 0; #ifdef SIMULATOR /***********************************************************/ @@ -115,32 +117,45 @@ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 30, 45, 60 }; -static const unsigned int battery_level_dangerous[BATTERY_TYPES_COUNT] = +static const short battery_level_dangerous[BATTERY_TYPES_COUNT] = { -#if CONFIG_BATTERY == BATT_LIION2200 /* FM Recorder, LiIon */ +#if CONFIG_BATTERY == BATT_LIION2200 /* FM Recorder: LiIon */ 280 -#elif CONFIG_BATTERY == BATT_3AAA /* Ondio */ - 310, 345 /* alkaline, NiHM */ -#elif CONFIG_BATTERY == BATT_LIPOL1300 /* iRiver H1x0 */ +#elif CONFIG_BATTERY == BATT_3AAA /* Ondio: Alkaline, NiHM */ + 310, 345 +#elif CONFIG_BATTERY == BATT_LIPOL1300 /* iRiver Hxxx: LiPolymer */ 339 -#else /* Player/recorder, NiMH */ +#else /* Player/recorder: NiMH */ 475 #endif }; +static const short battery_level_shutoff[BATTERY_TYPES_COUNT] = +{ +#if CONFIG_BATTERY == BATT_LIION2200 /* FM Recorder */ + 258 +#elif CONFIG_BATTERY == BATT_3AAA /* Ondio */ + 270, 280 +#elif CONFIG_BATTERY == BATT_LIPOL1300 /* iRiver Hxxx */ + 296 +#else /* Player/recorder */ + 440 +#endif +}; + +/* voltages [centivolt] of 0%, 10%, ... 100% when charging disabled */ static const short percent_to_volt_discharge[BATTERY_TYPES_COUNT][11] = -/* voltages (centivolt) of 0%, 10%, ... 100% when charging disabled */ { #if CONFIG_BATTERY == BATT_LIION2200 /* measured values */ { 260, 285, 295, 303, 311, 320, 330, 345, 360, 380, 400 } #elif CONFIG_BATTERY == BATT_3AAA /* measured values */ - { 280, 325, 341, 353, 364, 374, 385, 395, 409, 427, 475 }, /* alkaline */ + { 280, 325, 341, 353, 364, 374, 385, 395, 409, 427, 475 }, /* Alkaline */ { 310, 355, 363, 369, 372, 374, 376, 378, 380, 386, 405 } /* NiMH */ #elif CONFIG_BATTERY == BATT_LIPOL1300 /* Below 337 the backlight starts flickering during HD access */ - { 337, 358, 365, 369, 372, 377, 383, 389, 397, 406, 413 } + { 336, 365, 370, 374, 378, 382, 387, 393, 400, 408, 416 } #else /* NiMH */ /* original values were taken directly after charging, but it should show 100% after turning off the device for some hours, too */ @@ -152,11 +167,12 @@ #ifdef HAVE_CHARGING charger_input_state_type charger_input_state IDATA_ATTR; -/* voltages (centivolt) of 0%, 10%, ... 100% when charging enabled */ +/* voltages [centivolt] of 0%, 10%, ... 100% when charging enabled */ static const short percent_to_volt_charge[11] = { #if CONFIG_BATTERY == BATT_LIPOL1300 - 340, 349, 358, 367, 376, 385, 394, 403, 408, 413, 418 /* Estimated */ + /* values measured over one full charging cycle */ + 354, 386, 393, 398, 400, 402, 404, 408, 413, 418, 423 /* LiPo */ #else /* values guessed, see http://www.seattlerobotics.org/encoder/200210/LiIon2.pdf until someone @@ -197,23 +213,31 @@ * Average battery voltage and charger voltage, filtered via a digital * exponential filter. */ -static unsigned int battery_centivolts;/* filtered battery voltage, centvolts */ static unsigned int avgbat; /* average battery voltage (filtering) */ +static int battery_centivolts; /* filtered battery voltage, centvolts */ +#ifdef HAVE_CHARGE_CTRL #define BATT_AVE_SAMPLES 32 /* filter constant / @ 2Hz sample rate */ +#elif CONFIG_BATTERY == BATT_LIPOL1300 +#define BATT_AVE_SAMPLES 128 /* slow filter for iriver */ +#else +#define BATT_AVE_SAMPLES 64 /* medium filter constant for all others */ +#endif /* battery level (0-100%) of this minute, updated once per minute */ -static int battery_percent = -1; -static int battery_capacity = BATTERY_CAPACITY_MIN; /* default value, mAH */ +static int battery_percent; +static int battery_capacity = BATTERY_CAPACITY_MIN; /* default value [mAh] */ static int battery_type = 0; /* Power history: power_history[0] is the newest sample */ unsigned short power_history[POWER_HISTORY_LEN]; -static char power_stack[DEFAULT_STACK_SIZE + DEBUG_STACK]; +static char power_stack[DEFAULT_STACK_SIZE/2 + DEBUG_STACK]; static const char power_thread_name[] = "power"; +static int shutdown_timeout = 0; static int poweroff_timeout = 0; -static int powermgmt_est_runningtime_min = -1; +static int powermgmt_est_runningtime_min; +static bool low_battery = false; static bool sleeptimer_active = false; static long sleeptimer_endtick; @@ -223,11 +247,6 @@ static void battery_status_update(void); static int runcurrent(void); -unsigned int battery_voltage(void) -{ - return battery_centivolts; -} - void reset_poweroff_timer(void) { last_event_tick = current_tick; @@ -258,12 +277,24 @@ return powermgmt_est_runningtime_min; } -/* Returns battery level in percent */ +/* Returns battery level [percent] */ int battery_level(void) { return battery_percent; } +/* Returns filtered battery voltage [centivolts] */ +unsigned int battery_voltage(void) +{ + return battery_centivolts; +} + +/* Returns battery voltage from ADC [centivolts] */ +int battery_adc_voltage(void) +{ + return (adc_read(ADC_UNREG_POWER) * BATTERY_SCALE_FACTOR + 5000) / 10000; +} + /* Tells if the battery level is safe for disk writes */ bool battery_level_safe(void) { @@ -295,8 +326,7 @@ return 0; } -/* look into the percent_to_volt_* table and get a realistic battery level - percentage */ +/* look into the percent_to_volt_* table and get a realistic battery level */ static int voltage_to_percent(int voltage, const short* table) { if (voltage <= table[0]) @@ -322,7 +352,33 @@ { int level; -#if defined(HAVE_CHARGE_CTRL) || defined(HAVE_CHARGE_STATE) +#if CONFIG_BATTERY == BATT_LIPOL1300 + if (charger_input_state == NO_CHARGER) { + /* discharging. calculate new battery level and average with last */ + level = voltage_to_percent(battery_centivolts, + percent_to_volt_discharge[battery_type]); + if (level != (battery_percent - 1)) + level = (level + battery_percent + 1) / 2; + } + else if (charger_input_state == CHARGER_UNPLUGGED) { + /* just unplugged. adjust filtered values */ + battery_centivolts -= percent_to_volt_charge[battery_percent/10] - + percent_to_volt_discharge[0][battery_percent/10]; + avgbat = battery_centivolts * 10000 * BATT_AVE_SAMPLES; + level = battery_percent; + } + else if (charger_input_state == CHARGER_PLUGGED) { + /* just plugged in. adjust battery values */ + battery_centivolts += percent_to_volt_charge[battery_percent/10] - + percent_to_volt_discharge[0][battery_percent/10]; + avgbat = battery_centivolts * 10000 * BATT_AVE_SAMPLES; + level = 11 * battery_percent / 10; + } + else { /* charging. calculate new battery level */ + level = voltage_to_percent(battery_centivolts, + percent_to_volt_charge); + } +#elif defined(HAVE_CHARGE_CTRL) || defined(HAVE_CHARGE_STATE) if (charge_state == DISCHARGING) { level = voltage_to_percent(battery_centivolts, percent_to_volt_discharge[battery_type]); @@ -332,7 +388,7 @@ level = MIN(voltage_to_percent(battery_centivolts, percent_to_volt_charge), 99); } - else { /* in topoff/trickle charge, the battery is by definition 100% full */ + else { /* in topoff/trickle charge, battery is by definition 100% full */ level = 100; } #else @@ -341,35 +397,71 @@ percent_to_volt_discharge[battery_type]); #endif -#ifndef HAVE_MMC /* this adjustment is only needed for HD based */ - if (battery_percent == -1) { /* first run of this procedure */ - /* The battery voltage is usually a little lower directly after - turning on, because the disk was used heavily. Raise it by 5. % */ - level = (level > 95) ? 100 : level + 5; - } -#endif - battery_percent = level; /* calculate estimated remaining running time */ /* discharging: remaining running time */ /* charging: remaining charging time */ #ifdef HAVE_CHARGE_CTRL if (charge_state == CHARGING) { - powermgmt_est_runningtime_min = (100 - level) * battery_capacity / 100 - * 60 / (CURRENT_MAX_CHG - runcurrent()); + powermgmt_est_runningtime_min = (100 - level) * battery_capacity * 60 + / 100 / (CURRENT_MAX_CHG - runcurrent()); + } + else +#elif CONFIG_BATTERY == BATT_LIPOL1300 + if (charger_inserted()) { +#ifdef IRIVER_H300_SERIES + /* H300_SERIES use CURRENT_MAX_CHG for basic charge time (80%) + * plus 100 min top off charge time */ + powermgmt_est_runningtime_min = ((100-level) * battery_capacity * 80 + /100 / CURRENT_MAX_CHG) + 100; +#else + /* H100_SERIES scaled for 160 min basic charge time (80%) on + * 1600 mAh battery plus 100 min top off charge time */ + powermgmt_est_runningtime_min = ((100 - level) * battery_capacity + / 993) + 100; +#endif + level = (level * 80) / 100; + if (level > 72) { /* > 91% */ + int i = POWER_HISTORY_LEN; + int d = 1; +#ifdef HAVE_CHARGE_STATE + if (charge_state == DISCHARGING) + d = -2; +#endif + while ((i > 2) && (d > 0)) /* search zero or neg. delta */ + d = power_history[0] - power_history[--i]; + if ((((d == 0) && (i > 6)) || (d == -1)) && (i < 107)) { + /* top off charging */ + level = MIN(80 + (i*19 / 102), 99); /* show 81% .. 99% */ + powermgmt_est_runningtime_min = MAX(106 - i, 0); + } + else if ((d < 0) || (i > 118)) { + /* charging finished */ + level = 100; + powermgmt_est_runningtime_min = battery_capacity * 60 + / runcurrent(); + } + } } else #endif { - powermgmt_est_runningtime_min = level * battery_capacity / 100 - * 60 / runcurrent(); + if (battery_centivolts > (percent_to_volt_discharge[0][0] - 2)) + powermgmt_est_runningtime_min = (level + battery_percent) * 60 * + battery_capacity / 200 / runcurrent(); + else + powermgmt_est_runningtime_min = (battery_centivolts - + battery_level_shutoff[0]) / 2; } + + battery_percent = level; } /* * We shut off in the following cases: * 1) The unit is idle, not playing music * 2) The unit is playing music, but is paused + * 3) The battery level has reached shutdown limit * * We do not shut off in the following cases: * 1) The USB is connected @@ -391,6 +483,31 @@ } #endif + /* For low battery condition do some power-save stuff */ + if (battery_percent < 9) { + if (!low_battery) { + low_battery = true; +#if CONFIG_BACKLIGHT == BL_IRIVER_H100 + backlight_set_fade_in(0); + backlight_set_fade_out(0); +#endif + backlight_set_timeout(2); +#ifdef HAVE_REMOTE_LCD + remote_backlight_set_timeout(2); +#endif + } + } else { + low_battery = false; + } + + /* switch off unit if battery level is too low for reliable operation */ + if(battery_centivolts < battery_level_shutoff[battery_type]) { + if(!shutdown_timeout) { + backlight_on(); + sys_poweroff(); + } + } + if(timeout && #ifdef CONFIG_TUNER (!radio_powered()) && @@ -433,9 +550,7 @@ } } -/* - * Estimate how much current we are drawing just to run. - */ +/* Estimate how much current we are drawing */ static int runcurrent(void) { int current; @@ -461,6 +576,30 @@ current += CURRENT_BACKLIGHT; #endif +#if defined(HAVE_RECORDING) +#if CONFIG_CODEC == SWCODEC + unsigned int audio_stat = pcm_rec_status(); +#else + int audio_stat = audio_status(); +#endif + if (audio_stat & AUDIO_STATUS_RECORD) + current += CURRENT_RECORD; +#endif + +#ifdef HAVE_SPDIF_POWER +#ifdef SPDIF_POWER_INVERTED + if (GPIO1_OUT & 0x01000000) +#else + if (!(GPIO1_OUT & 0x01000000)) +#endif + current += CURRENT_SPDIF_OUT; +#endif + +#ifdef HAVE_REMOTE_LCD + if ((GPIO_READ & 0x40000000) == 0) + current += CURRENT_REMOTE; +#endif + return(current); } @@ -497,20 +636,7 @@ * loop (including the subroutines), and end up back here where we * transition to the appropriate steady state charger on/off state. */ - if(charger_inserted()) { - switch(charger_input_state) { - case NO_CHARGER: - case CHARGER_UNPLUGGED: - charger_input_state = CHARGER_PLUGGED; - return; - case CHARGER_PLUGGED: - queue_broadcast(SYS_CHARGER_CONNECTED, NULL); - charger_input_state = CHARGER; - break; - case CHARGER: - break; - } - } else { /* charger not inserted */ + if(!charger_inserted()) { switch(charger_input_state) { case NO_CHARGER: break; @@ -523,14 +649,28 @@ charger_input_state = CHARGER_UNPLUGGED; return; } + } else { /* charger inserted */ + switch(charger_input_state) { + case CHARGER: + break; + case CHARGER_PLUGGED: + queue_broadcast(SYS_CHARGER_CONNECTED, NULL); + charger_input_state = CHARGER; + break; + case CHARGER_UNPLUGGED: + case NO_CHARGER: + charger_input_state = CHARGER_PLUGGED; + return; } -#endif + } +#endif /* HAVE CHARGING */ + #ifdef HAVE_CHARGE_STATE switch (charger_input_state) { - case CHARGER_UNPLUGGED: - charge_state = DISCHARGING; case NO_CHARGER: break; + case CHARGER_UNPLUGGED: + charge_state = DISCHARGING; case CHARGER_PLUGGED: case CHARGER: if (charging_state()) { @@ -540,7 +680,6 @@ } break; } - #endif /* HAVE_CHARGE_STATE */ small_ticks = MIN(HZ/2, ticks); @@ -570,17 +709,29 @@ /* * battery_centivolts is the centivolt-scaled filtered battery value. */ - battery_centivolts = avgbat / BATT_AVE_SAMPLES / 10000; - + battery_centivolts = (avgbat / BATT_AVE_SAMPLES + 5000) / 10000; + } + else if (battery_percent < 7) { + /* If battery is low, observe voltage during disk activity. + * Shut down if battery is below shutoff level. + */ + battery_centivolts = (battery_adc_voltage() + + battery_centivolts + 1) / 2; + if (!shutdown_timeout && + (battery_centivolts < battery_level_shutoff[battery_type])) + sys_poweroff(); + else + avgbat = avgbat - (avgbat / BATT_AVE_SAMPLES) + + battery_centivolts * 10000; } + #if defined(DEBUG_FILE) && defined(HAVE_CHARGE_CTRL) /* * If we have a lot of pending writes or if the disk is spining, * fsync the debug log file. */ - if((wrcount > 10) || - ((wrcount > 0) && ata_disk_is_active())) { + if((wrcount > 10) || ((wrcount > 0) && ata_disk_is_active())) { fsync(fd); wrcount = 0; } @@ -608,10 +759,36 @@ /* initialize the voltages for the exponential filter */ - avgbat = adc_read(ADC_UNREG_POWER) * BATTERY_SCALE_FACTOR * - BATT_AVE_SAMPLES; + avgbat = adc_read(ADC_UNREG_POWER) * BATTERY_SCALE_FACTOR + 15000; + +#ifndef HAVE_MMC /* this adjustment is only needed for HD based */ + /* The battery voltage is usually a little lower directly after + turning on, because the disk was used heavily. Raise it by 5% */ +#ifdef HAVE_CHARGING + if(!charger_inserted()) /* only if charger not connected */ +#endif + avgbat += (percent_to_volt_discharge[battery_type][6] - + percent_to_volt_discharge[battery_type][5]) * 5000; +#endif /* not HAVE_MMC */ + + avgbat = avgbat * BATT_AVE_SAMPLES; battery_centivolts = avgbat / BATT_AVE_SAMPLES / 10000; +#ifdef HAVE_CHARGING + if(charger_inserted()) { + battery_percent = voltage_to_percent(battery_centivolts, + percent_to_volt_charge); +#if CONFIG_BATTERY == BATT_LIPOL1300 + charger_input_state = CHARGER; +#endif + } else +#endif + { battery_percent = voltage_to_percent(battery_centivolts, + percent_to_volt_discharge[battery_type]); + battery_percent += (battery_percent < 100); + } + + #if defined(DEBUG_FILE) && defined(HAVE_CHARGE_CTRL) fd = -1; wrcount = 0; @@ -911,8 +1088,8 @@ { logf("sys_poweroff()"); /* If the main thread fails to shut down the system, we will force a - power off after an 8 second timeout */ - shutdown_timeout = HZ*8; + power off after an 10 second timeout */ + shutdown_timeout = HZ*10; queue_post(&button_queue, SYS_POWEROFF, NULL); } @@ -927,27 +1104,39 @@ fd = -1; } #endif + audio_stop(); + + if(battery_percent > 9) { /* do not save on low battery */ #ifdef HAVE_LCD_BITMAP glyph_cache_save(); #endif ata_flush(); + } + if(ata_disk_is_active()) ata_spindown(1); - while(ata_disk_is_active()) - sleep(HZ/10); + backlight_off(); +#ifdef HAVE_REMOTE_LCD + remote_backlight_off(); +#endif mp3_shutdown(); #ifdef HAVE_UDA1380 uda1380_close(); #elif defined(HAVE_TLV320) tlv320_close(); #endif - backlight_off(); + + /* If HD is still active we try to wait for spindown, otherwise the + shutdown_timeout in power_thread_sleep will force a power off */ + while(ata_disk_is_active()) + sleep(HZ/10); + lcd_set_contrast(0); #ifdef HAVE_REMOTE_LCD - remote_backlight_off(); lcd_remote_set_contrast(0); #endif + power_off(); #endif /* #ifndef SIMULATOR */ } Only in rockbox-jsl060214/firmware: powermgmt.c.orig Only in rockbox-jsl060214/firmware: powermgmt.c.rej Only in rockbox-060219: flash Only in rockbox-jsl060214/fonts: .DS_Store Only in rockbox-060219/fonts: 00-Starmap_r400-8.bdf Only in rockbox-060219/fonts: 5x7.bdf Only in rockbox-060219/fonts: 5x8.bdf Only in rockbox-060219/fonts: 6+12x13.bdf Only in rockbox-060219/fonts: 6x10.bdf Only in rockbox-060219/fonts: 6x12.bdf Only in rockbox-060219/fonts: 6x13.bdf Only in rockbox-060219/fonts: 6x13B.bdf Only in rockbox-060219/fonts: 6x9.bdf Only in rockbox-060219/fonts: 8x13B.bdf Only in rockbox-060219/fonts: Hebrew-Bold.bdf Only in rockbox-060219/fonts: Hebrew-Large.bdf Only in rockbox-060219/fonts: Hebrew-Medium.bdf Only in rockbox-060219/fonts: Hebrew-Small.bdf Only in rockbox-060219/fonts: Tiny-Prop-5.bdf Only in rockbox-060219/fonts: Tiny-Prop-6.bdf Only in rockbox-060219/fonts: alt8x8.bdf Only in rockbox-060219/fonts: atadore.bdf Only in rockbox-060219/fonts: atari-small.bdf Only in rockbox-060219/fonts: chicago12.bdf Only in rockbox-060219/fonts: clR6x8-8859-2.bdf Only in rockbox-060219/fonts: courB08.bdf Only in rockbox-060219/fonts: courB14.bdf Only in rockbox-060219/fonts: helvR12.bdf Only in rockbox-060219/fonts: jackash-16.bdf Only in rockbox-060219/fonts: namil-8.bdf Only in rockbox-060219/fonts: nimbus-12.bdf Only in rockbox-060219/fonts: nimbus-14.bdf Only in rockbox-060219/fonts: timR08.bdf Only in rockbox-060219/fonts: unifont.bdf Only in rockbox-060219/fonts: uwe_prop.bdf Only in rockbox-060219/fonts: win_crox0c.bdf Only in rockbox-060219/fonts: win_crox1c.bdf Only in rockbox-060219/fonts: win_crox2c.bdf Only in rockbox-060219/fonts: win_crox3c.bdf Only in rockbox-060219/fonts: win_crox4h.bdf Only in rockbox-060219/fonts: win_crox5t.bdf Only in rockbox-060219/fonts: win_crox6hbo.bdf Only in rockbox-060219/fonts: xtal-14.bdf Only in rockbox-060219: gdb Only in rockbox-jsl060214/tools: bmp2rb Only in rockbox-jsl060214/tools: codepages Only in rockbox-jsl060214/tools: convbdf Only in rockbox-jsl060214/tools: descramble Only in rockbox-jsl060214/tools: descramble.o Only in rockbox-jsl060214/tools: iriver.o Only in rockbox-jsl060214/tools: mkboot Only in rockbox-jsl060214/tools: rdf2binary Only in rockbox-jsl060214/tools: scramble Only in rockbox-jsl060214/tools: scramble.o Only in rockbox-060219: uisimulator Only in rockbox-060219: wps