?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Correct beast manual install instructions in Windows.
[kugel-rb.git] / apps / debug_menu.c
blobf9fb7a3bb7b7367524342f05559131fb4c28f9f6
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
9 *
10 * Copyright (C) 2002 Heikki Hannikainen
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version 2
15 * of the License, or (at your option) any later version.
16 *
17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18 * KIND, either express or implied.
19 *
20 ****************************************************************************/
21
22 #include "config.h"
23 #include <stdlib.h>
24 #include <stdio.h>
25 #include <stdbool.h>
26 #include <string.h>
27 #include "lcd.h"
28 #include "menu.h"
29 #include "debug_menu.h"
30 #include "kernel.h"
31 #include "sprintf.h"
32 #include "structec.h"
33 #include "action.h"
34 #include "debug.h"
35 #include "thread.h"
36 #include "powermgmt.h"
37 #include "system.h"
38 #include "font.h"
39 #include "audio.h"
40 #include "mp3_playback.h"
41 #include "settings.h"
42 #include "list.h"
43 #include "statusbar.h"
44 #include "dir.h"
45 #include "panic.h"
46 #include "screens.h"
47 #include "misc.h"
48 #include "splash.h"
49 #include "dircache.h"
50 #include "viewport.h"
51 #ifdef HAVE_TAGCACHE
52 #include "tagcache.h"
53 #endif
54 #include "lcd-remote.h"
55 #include "crc32.h"
56 #include "logf.h"
57 #ifndef SIMULATOR
58 #include "disk.h"
59 #include "adc.h"
60 #include "power.h"
61 #include "usb.h"
62 #include "rtc.h"
63 #include "storage.h"
64 #include "fat.h"
65 #include "mas.h"
66 #include "eeprom_24cxx.h"
67 #if (CONFIG_STORAGE & STORAGE_MMC) || (CONFIG_STORAGE & STORAGE_SD)
68 #include "hotswap.h"
69 #endif
70 #if (CONFIG_STORAGE & STORAGE_ATA)
71 #include "ata.h"
72 #endif
73 #if CONFIG_TUNER
74 #include "tuner.h"
75 #include "radio.h"
76 #endif
77 #endif
78
79 #ifdef HAVE_LCD_BITMAP
80 #include "scrollbar.h"
81 #include "peakmeter.h"
82 #endif
83 #include "logfdisp.h"
84 #if CONFIG_CODEC == SWCODEC
85 #include "pcmbuf.h"
86 #include "buffering.h"
87 #include "playback.h"
88 #if defined(HAVE_SPDIF_OUT) || defined(HAVE_SPDIF_IN)
89 #include "spdif.h"
90 #endif
91 #endif
92 #ifdef IRIVER_H300_SERIES
93 #include "pcf50606.h" /* for pcf50606_read */
94 #endif
95 #ifdef IAUDIO_X5
96 #include "ds2411.h"
97 #endif
98 #include "hwcompat.h"
99 #include "button.h"
100 #if CONFIG_RTC == RTC_PCF50605
101 #include "pcf50605.h"
102 #endif
103 #include "appevents.h"
104
105 #if CONFIG_CPU == DM320 || CONFIG_CPU == S3C2440 || CONFIG_CPU == TCC7801 \
106 || CONFIG_CPU == IMX31L || CONFIG_CPU == AS3525 || CONFIG_CPU == JZ4732 \
107 || defined(CPU_S5L870X)
108 #include "debug-target.h"
109 #endif
110
111 #if defined(SANSA_E200) || defined(SANSA_C200) || defined(PHILIPS_SA9200) \
112 || defined(SANSA_CLIP) || defined(SANSA_FUZE)
113 #include "ascodec.h"
114 #include "as3514.h"
115 #endif
116
117 #ifdef IPOD_NANO2G
118 #include "pmu-target.h"
119 #endif
120
121 #ifdef HAVE_USBSTACK
122 #include "usb_core.h"
123 #endif
124
125 /*---------------------------------------------------*/
126 /* SPECIAL DEBUG STUFF */
127 /*---------------------------------------------------*/
128 extern struct thread_entry threads[MAXTHREADS];
129
130 static char thread_status_char(unsigned status)
131 {
132 static const char thread_status_chars[THREAD_NUM_STATES+1] =
133 {
134 [0 ... THREAD_NUM_STATES] = '?',
135 [STATE_RUNNING] = 'R',
136 [STATE_BLOCKED] = 'B',
137 [STATE_SLEEPING] = 'S',
138 [STATE_BLOCKED_W_TMO] = 'T',
139 [STATE_FROZEN] = 'F',
140 [STATE_KILLED] = 'K',
141 };
142
143 if (status > THREAD_NUM_STATES)
144 status = THREAD_NUM_STATES;
145
146 return thread_status_chars[status];
147 }
148
149 static const char* threads_getname(int selected_item, void *data,
150 char *buffer, size_t buffer_len)
151 {
152 (void)data;
153 struct thread_entry *thread;
154 char name[32];
155
156 #if NUM_CORES > 1
157 if (selected_item < (int)NUM_CORES)
158 {
159 snprintf(buffer, buffer_len, "Idle (%d): %2d%%", selected_item,
160 idle_stack_usage(selected_item));
161 return buffer;
162 }
163
164 selected_item -= NUM_CORES;
165 #endif
166
167 thread = &threads[selected_item];
168
169 if (thread->state == STATE_KILLED)
170 {
171 snprintf(buffer, buffer_len, "%2d: ---", selected_item);
172 return buffer;
173 }
174
175 thread_get_name(name, 32, thread);
176
177 snprintf(buffer, buffer_len,
178 "%2d: " IF_COP("(%d) ") "%c%c " IF_PRIO("%d %d ") "%2d%% %s",
179 selected_item,
180 IF_COP(thread->core,)
181 #ifdef HAVE_SCHEDULER_BOOSTCTRL
182 (thread->cpu_boost) ? '+' :
183 #endif
184 ((thread->state == STATE_RUNNING) ? '*' : ' '),
185 thread_status_char(thread->state),
186 IF_PRIO(thread->base_priority, thread->priority, )
187 thread_stack_usage(thread), name);
188
189 return buffer;
190 }
191
192 static int dbg_threads_action_callback(int action, struct gui_synclist *lists)
193 {
194 (void)lists;
195 #ifdef ROCKBOX_HAS_LOGF
196 if (action == ACTION_STD_OK)
197 {
198 int selpos = gui_synclist_get_sel_pos(lists);
199 #if NUM_CORES > 1
200 if (selpos >= NUM_CORES)
201 remove_thread(threads[selpos - NUM_CORES].id);
202 #else
203 remove_thread(threads[selpos].id);
204 #endif
205 return ACTION_REDRAW;
206 }
207 #endif /* ROCKBOX_HAS_LOGF */
208 if (action == ACTION_NONE)
209 action = ACTION_REDRAW;
210 return action;
211 }
212 /* Test code!!! */
213 static bool dbg_os(void)
214 {
215 struct simplelist_info info;
216 simplelist_info_init(&info, IF_COP("Core and ") "Stack usage:",
217 #if NUM_CORES == 1
218 MAXTHREADS,
219 #else
220 MAXTHREADS+NUM_CORES,
221 #endif
222 NULL);
223 #ifndef ROCKBOX_HAS_LOGF
224 info.hide_selection = true;
225 info.scroll_all = true;
226 #endif
227 info.action_callback = dbg_threads_action_callback;
228 info.get_name = threads_getname;
229 return simplelist_show_list(&info);
230 }
231
232 #ifdef HAVE_LCD_BITMAP
233 #if CONFIG_CODEC != SWCODEC
234 #ifndef SIMULATOR
235 static bool dbg_audio_thread(void)
236 {
237 struct audio_debug d;
238
239 lcd_setfont(FONT_SYSFIXED);
240
241 while(1)
242 {
243 if (action_userabort(HZ/5))
244 return false;
245
246 audio_get_debugdata(&d);
247
248 lcd_clear_display();
249
250 lcd_putsf(0, 0, "read: %x", d.audiobuf_read);
251 lcd_putsf(0, 1, "write: %x", d.audiobuf_write);
252 lcd_putsf(0, 2, "swap: %x", d.audiobuf_swapwrite);
253 lcd_putsf(0, 3, "playing: %d", d.playing);
254 lcd_putsf(0, 4, "playable: %x", d.playable_space);
255 lcd_putsf(0, 5, "unswapped: %x", d.unswapped_space);
256
257 /* Playable space left */
258 gui_scrollbar_draw(&screens[SCREEN_MAIN],0, 6*8, 112, 4, d.audiobuflen, 0,
259 d.playable_space, HORIZONTAL);
260
261 /* Show the watermark limit */
262 gui_scrollbar_draw(&screens[SCREEN_MAIN],0, 6*8+4, 112, 4, d.audiobuflen, 0,
263 d.low_watermark_level, HORIZONTAL);
264
265 lcd_putsf(0, 7, "wm: %x - %x",
266 d.low_watermark_level, d.lowest_watermark_level);
267
268 lcd_update();
269 }
270 lcd_setfont(FONT_UI);
271 return false;
272 }
273 #endif /* !SIMULATOR */
274 #else /* CONFIG_CODEC == SWCODEC */
275 static unsigned int ticks, boost_ticks, freq_sum;
276
277 static void dbg_audio_task(void)
278 {
279 #ifndef SIMULATOR
280 if(FREQ > CPUFREQ_NORMAL)
281 boost_ticks++;
282 freq_sum += FREQ/1000000; /* in MHz */
283 #endif
284 ticks++;
285 }
286
287 static bool dbg_buffering_thread(void)
288 {
289 int button;
290 int line;
291 bool done = false;
292 size_t bufused;
293 size_t bufsize = pcmbuf_get_bufsize();
294 int pcmbufdescs = pcmbuf_descs();
295 struct buffering_debug d;
296 size_t filebuflen = audio_get_filebuflen();
297 /* This is a size_t, but call it a long so it puts a - when it's bad. */
298
299 ticks = boost_ticks = freq_sum = 0;
300
301 tick_add_task(dbg_audio_task);
302
303 lcd_setfont(FONT_SYSFIXED);
304 while(!done)
305 {
306 button = get_action(CONTEXT_STD,HZ/5);
307 switch(button)
308 {
309 case ACTION_STD_NEXT:
310 audio_next();
311 break;
312 case ACTION_STD_PREV:
313 audio_prev();
314 break;
315 case ACTION_STD_CANCEL:
316 done = true;
317 break;
318 }
319
320 buffering_get_debugdata(&d);
321
322 line = 0;
323 lcd_clear_display();
324
325 bufused = bufsize - pcmbuf_free();
326
327 lcd_putsf(0, line++, "pcm: %6ld/%ld", (long) bufused, (long) bufsize);
328
329 gui_scrollbar_draw(&screens[SCREEN_MAIN],0, line*8, LCD_WIDTH, 6,
330 bufsize, 0, bufused, HORIZONTAL);
331 line++;
332
333 lcd_putsf(0, line++, "alloc: %6ld/%ld", audio_filebufused(),
334 (long) filebuflen);
335
336 #if LCD_HEIGHT > 80
337 gui_scrollbar_draw(&screens[SCREEN_MAIN],0, line*8, LCD_WIDTH, 6,
338 filebuflen, 0, audio_filebufused(), HORIZONTAL);
339 line++;
340
341 lcd_putsf(0, line++, "real: %6ld/%ld", (long)d.buffered_data,
342 (long)filebuflen);
343
344 gui_scrollbar_draw(&screens[SCREEN_MAIN],0, line*8, LCD_WIDTH, 6,
345 filebuflen, 0, (long)d.buffered_data, HORIZONTAL);
346 line++;
347 #endif
348
349 lcd_putsf(0, line++, "usefl: %6ld/%ld", (long)(d.useful_data),
350 (long)filebuflen);
351
352 #if LCD_HEIGHT > 80
353 gui_scrollbar_draw(&screens[SCREEN_MAIN],0, line*8, LCD_WIDTH, 6,
354 filebuflen, 0, d.useful_data, HORIZONTAL);
355 line++;
356 #endif
357
358 lcd_putsf(0, line++, "data_rem: %ld", (long)d.data_rem);
359
360 lcd_putsf(0, line++, "track count: %2d", audio_track_count());
361
362 lcd_putsf(0, line++, "handle count: %d", (int)d.num_handles);
363
364 #ifndef SIMULATOR
365 lcd_putsf(0, line++, "cpu freq: %3dMHz",
366 (int)((FREQ + 500000) / 1000000));
367 #endif
368
369 if (ticks > 0)
370 {
371 int boostquota = boost_ticks * 1000 / ticks; /* in 0.1 % */
372 int avgclock = freq_sum * 10 / ticks; /* in 100 kHz */
373 lcd_putsf(0, line++, "boost:%3d.%d%% (%d.%dMHz)",
374 boostquota/10, boostquota%10, avgclock/10, avgclock%10);
375 }
376
377 lcd_putsf(0, line++, "pcmbufdesc: %2d/%2d",
378 pcmbuf_used_descs(), pcmbufdescs);
379 lcd_putsf(0, line++, "watermark: %6d",
380 (int)(d.watermark));
381
382 lcd_update();
383 }
384
385 tick_remove_task(dbg_audio_task);
386 lcd_setfont(FONT_UI);
387
388 return false;
389 }
390 #endif /* CONFIG_CODEC */
391 #endif /* HAVE_LCD_BITMAP */
392
393
394 #if (CONFIG_CPU == SH7034 || defined(CPU_COLDFIRE))
395 /* Tool function to read the flash manufacturer and type, if available.
396 Only chips which could be reprogrammed in system will return values.
397 (The mode switch addresses vary between flash manufacturers, hence addr1/2) */
398 /* In IRAM to avoid problems when running directly from Flash */
399 static bool dbg_flash_id(unsigned* p_manufacturer, unsigned* p_device,
400 unsigned addr1, unsigned addr2)
401 ICODE_ATTR __attribute__((noinline));
402 static bool dbg_flash_id(unsigned* p_manufacturer, unsigned* p_device,
403 unsigned addr1, unsigned addr2)
404
405 {
406 unsigned not_manu, not_id; /* read values before switching to ID mode */
407 unsigned manu, id; /* read values when in ID mode */
408
409 #if CONFIG_CPU == SH7034
410 volatile unsigned char* flash = (unsigned char*)0x2000000; /* flash mapping */
411 #elif defined(CPU_COLDFIRE)
412 volatile unsigned short* flash = (unsigned short*)0; /* flash mapping */
413 #endif
414 int old_level; /* saved interrupt level */
415
416 not_manu = flash[0]; /* read the normal content */
417 not_id = flash[1]; /* should be 'A' (0x41) and 'R' (0x52) from the "ARCH" marker */
418
419 /* disable interrupts, prevent any stray flash access */
420 old_level = disable_irq_save();
421
422 flash[addr1] = 0xAA; /* enter command mode */
423 flash[addr2] = 0x55;
424 flash[addr1] = 0x90; /* ID command */
425 /* Atmel wants 20ms pause here */
426 /* sleep(HZ/50); no sleeping possible while interrupts are disabled */
427
428 manu = flash[0]; /* read the IDs */
429 id = flash[1];
430
431 flash[0] = 0xF0; /* reset flash (back to normal read mode) */
432 /* Atmel wants 20ms pause here */
433 /* sleep(HZ/50); no sleeping possible while interrupts are disabled */
434
435 restore_irq(old_level); /* enable interrupts again */
436
437 /* I assume success if the obtained values are different from
438 the normal flash content. This is not perfectly bulletproof, they
439 could theoretically be the same by chance, causing us to fail. */
440 if (not_manu != manu || not_id != id) /* a value has changed */
441 {
442 *p_manufacturer = manu; /* return the results */
443 *p_device = id;
444 return true; /* success */
445 }
446 return false; /* fail */
447 }
448 #endif /* (CONFIG_CPU == SH7034 || CPU_COLDFIRE) */
449
450 #ifndef SIMULATOR
451 #ifdef CPU_PP
452 static int perfcheck(void)
453 {
454 int result;
455
456 asm (
457 "mrs r2, CPSR \n"
458 "orr r0, r2, #0xc0 \n" /* disable IRQ and FIQ */
459 "msr CPSR_c, r0 \n"
460 "mov %[res], #0 \n"
461 "ldr r0, [%[timr]] \n"
462 "add r0, r0, %[tmo] \n"
463 "1: \n"
464 "add %[res], %[res], #1 \n"
465 "ldr r1, [%[timr]] \n"
466 "cmp r1, r0 \n"
467 "bmi 1b \n"
468 "msr CPSR_c, r2 \n" /* reset IRQ and FIQ state */
469 :
470 [res]"=&r"(result)
471 :
472 [timr]"r"(&USEC_TIMER),
473 [tmo]"r"(
474 #if CONFIG_CPU == PP5002
475 16000
476 #else /* PP5020/5022/5024 */
477 10226
478 #endif
479 )
480 :
481 "r0", "r1", "r2"
482 );
483 return result;
484 }
485 #endif
486
487 #ifdef HAVE_LCD_BITMAP
488 static bool dbg_hw_info(void)
489 {
490 #if CONFIG_CPU == SH7034
491 int bitmask = HW_MASK;
492 int rom_version = ROM_VERSION;
493 unsigned manu, id; /* flash IDs */
494 bool got_id; /* flag if we managed to get the flash IDs */
495 unsigned rom_crc = 0xffffffff; /* CRC32 of the boot ROM */
496 bool has_bootrom; /* flag for boot ROM present */
497 int oldmode; /* saved memory guard mode */
498
499 oldmode = system_memory_guard(MEMGUARD_NONE); /* disable memory guard */
500
501 /* get flash ROM type */
502 got_id = dbg_flash_id(&manu, &id, 0x5555, 0x2AAA); /* try SST, Atmel, NexFlash */
503 if (!got_id)
504 got_id = dbg_flash_id(&manu, &id, 0x555, 0x2AA); /* try AMD, Macronix */
505
506 /* check if the boot ROM area is a flash mirror */
507 has_bootrom = (memcmp((char*)0, (char*)0x02000000, 64*1024) != 0);
508 if (has_bootrom) /* if ROM and Flash different */
509 {
510 /* calculate CRC16 checksum of boot ROM */
511 rom_crc = crc_32((unsigned char*)0x0000, 64*1024, 0xffffffff);
512 }
513
514 system_memory_guard(oldmode); /* re-enable memory guard */
515
516 lcd_setfont(FONT_SYSFIXED);
517 lcd_clear_display();
518
519 lcd_puts(0, 0, "[Hardware info]");
520
521 lcd_putsf(0, 1, "ROM: %d.%02d", rom_version/100, rom_version%100);
522
523 lcd_putsf(0, 2, "Mask: 0x%04x", bitmask);
524
525 if (got_id)
526 lcd_putsf(0, 3, "Flash: M=%02x D=%02x", manu, id);
527 else
528 lcd_puts(0, 3, "Flash: M=?? D=??"); /* unknown, sorry */
529
530 if (has_bootrom)
531 {
532 if (rom_crc == 0x56DBA4EE) /* known Version 1 */
533 lcd_puts(0, 4, "Boot ROM: V1");
534 else
535 lcd_putsf(0, 4, "ROMcrc: 0x%08x", rom_crc);
536 }
537 else
538 {
539 lcd_puts(0, 4, "Boot ROM: none");
540 }
541
542 lcd_update();
543
544 while (!(action_userabort(TIMEOUT_BLOCK)));
545
546 #elif CONFIG_CPU == MCF5249 || CONFIG_CPU == MCF5250
547 unsigned manu, id; /* flash IDs */
548 int got_id; /* flag if we managed to get the flash IDs */
549 int oldmode; /* saved memory guard mode */
550 int line = 0;
551
552 oldmode = system_memory_guard(MEMGUARD_NONE); /* disable memory guard */
553
554 /* get flash ROM type */
555 got_id = dbg_flash_id(&manu, &id, 0x5555, 0x2AAA); /* try SST, Atmel, NexFlash */
556 if (!got_id)
557 got_id = dbg_flash_id(&manu, &id, 0x555, 0x2AA); /* try AMD, Macronix */
558
559 system_memory_guard(oldmode); /* re-enable memory guard */
560
561 lcd_setfont(FONT_SYSFIXED);
562 lcd_clear_display();
563
564 lcd_puts(0, line++, "[Hardware info]");
565
566 if (got_id)
567 lcd_putsf(0, line++, "Flash: M=%04x D=%04x", manu, id);
568 else
569 lcd_puts(0, line++, "Flash: M=???? D=????"); /* unknown, sorry */
570
571 #ifdef IAUDIO_X5
572 {
573 struct ds2411_id id;
574
575 lcd_puts(0, ++line, "Serial Number:");
576
577 got_id = ds2411_read_id(&id);
578
579 if (got_id == DS2411_OK)
580 {
581 lcd_putsf(0, ++line, " FC=%02x", (unsigned)id.family_code);
582 lcd_putsf(0, ++line, " ID=%02X %02X %02X %02X %02X %02X",
583 (unsigned)id.uid[0], (unsigned)id.uid[1], (unsigned)id.uid[2],
584 (unsigned)id.uid[3], (unsigned)id.uid[4], (unsigned)id.uid[5]);
585 lcd_putsf(0, ++line, " CRC=%02X", (unsigned)id.crc);
586 }
587 else
588 {
589 lcd_putsf(0, ++line, "READ ERR=%d", got_id);
590 }
591 }
592 #endif
593
594 lcd_update();
595
596 while (!(action_userabort(TIMEOUT_BLOCK)));
597
598 #elif defined(CPU_PP502x)
599 int line = 0;
600 char pp_version[] = { (PP_VER2 >> 24) & 0xff, (PP_VER2 >> 16) & 0xff,
601 (PP_VER2 >> 8) & 0xff, (PP_VER2) & 0xff,
602 (PP_VER1 >> 24) & 0xff, (PP_VER1 >> 16) & 0xff,
603 (PP_VER1 >> 8) & 0xff, (PP_VER1) & 0xff, '\0' };
604
605 lcd_setfont(FONT_SYSFIXED);
606 lcd_clear_display();
607
608 lcd_puts(0, line++, "[Hardware info]");
609
610 #ifdef IPOD_ARCH
611 lcd_putsf(0, line++, "HW rev: 0x%08lx", IPOD_HW_REVISION);
612 #endif
613
614 #ifdef IPOD_COLOR
615 extern int lcd_type; /* Defined in lcd-colornano.c */
616
617 lcd_putsf(0, line++, "LCD type: %d", lcd_type);
618 #endif
619
620 lcd_putsf(0, line++, "PP version: %s", pp_version);
621
622 lcd_putsf(0, line++, "Est. clock (kHz): %d", perfcheck());
623
624 lcd_update();
625
626 while (!(action_userabort(TIMEOUT_BLOCK)));
627
628 #elif CONFIG_CPU == PP5002
629 int line = 0;
630 char pp_version[] = { (PP_VER4 >> 8) & 0xff, PP_VER4 & 0xff,
631 (PP_VER3 >> 8) & 0xff, PP_VER3 & 0xff,
632 (PP_VER2 >> 8) & 0xff, PP_VER2 & 0xff,
633 (PP_VER1 >> 8) & 0xff, PP_VER1 & 0xff, '\0' };
634
635
636 lcd_setfont(FONT_SYSFIXED);
637 lcd_clear_display();
638
639 lcd_puts(0, line++, "[Hardware info]");
640
641 #ifdef IPOD_ARCH
642 lcd_putsf(0, line++, "HW rev: 0x%08lx", IPOD_HW_REVISION);
643 #endif
644
645 lcd_putsf(0, line++, "PP version: %s", pp_version);
646
647 lcd_putsf(0, line++, "Est. clock (kHz): %d", perfcheck());
648
649 lcd_update();
650
651 while (!(action_userabort(TIMEOUT_BLOCK)));
652
653 #else
654 /* Define this function in your target tree */
655 return __dbg_hw_info();
656 #endif /* CONFIG_CPU */
657 lcd_setfont(FONT_UI);
658 return false;
659 }
660 #else /* !HAVE_LCD_BITMAP */
661 static bool dbg_hw_info(void)
662 {
663 int button;
664 int currval = 0;
665 int rom_version = ROM_VERSION;
666 unsigned manu, id; /* flash IDs */
667 bool got_id; /* flag if we managed to get the flash IDs */
668 unsigned rom_crc = 0xffffffff; /* CRC32 of the boot ROM */
669 bool has_bootrom; /* flag for boot ROM present */
670 int oldmode; /* saved memory guard mode */
671
672 oldmode = system_memory_guard(MEMGUARD_NONE); /* disable memory guard */
673
674 /* get flash ROM type */
675 got_id = dbg_flash_id(&manu, &id, 0x5555, 0x2AAA); /* try SST, Atmel, NexFlash */
676 if (!got_id)
677 got_id = dbg_flash_id(&manu, &id, 0x555, 0x2AA); /* try AMD, Macronix */
678
679 /* check if the boot ROM area is a flash mirror */
680 has_bootrom = (memcmp((char*)0, (char*)0x02000000, 64*1024) != 0);
681 if (has_bootrom) /* if ROM and Flash different */
682 {
683 /* calculate CRC16 checksum of boot ROM */
684 rom_crc = crc_32((unsigned char*)0x0000, 64*1024, 0xffffffff);
685 }
686
687 system_memory_guard(oldmode); /* re-enable memory guard */
688
689 lcd_clear_display();
690
691 lcd_puts(0, 0, "[HW Info]");
692 while(1)
693 {
694 switch(currval)
695 {
696 case 0:
697 lcd_putsf(0, 1, "ROM: %d.%02d",
698 rom_version/100, rom_version%100);
699 break;
700 case 1:
701 if (got_id)
702 lcd_putsf(0, 1, "Flash:%02x,%02x", manu, id);
703 else
704 lcd_puts(0, 1, "Flash:??,??"); /* unknown, sorry */
705 break;
706 case 2:
707 if (has_bootrom)
708 {
709 if (rom_crc == 0x56DBA4EE) /* known Version 1 */
710 lcd_puts(0, 1, "BootROM: V1");
711 else if (rom_crc == 0x358099E8)
712 lcd_puts(0, 1, "BootROM: V2");
713 /* alternative boot ROM found in one single player so far */
714 else
715 lcd_putsf(0, 1, "R: %08x", rom_crc);
716 }
717 else
718 lcd_puts(0, 1, "BootROM: no");
719 }
720
721 lcd_update();
722
723 button = get_action(CONTEXT_SETTINGS,TIMEOUT_BLOCK);
724
725 switch(button)
726 {
727 case ACTION_STD_CANCEL:
728 return false;
729
730 case ACTION_SETTINGS_DEC:
731 currval--;
732 if(currval < 0)
733 currval = 2;
734 break;
735
736 case ACTION_SETTINGS_INC:
737 currval++;
738 if(currval > 2)
739 currval = 0;
740 break;
741 }
742 }
743 return false;
744 }
745 #endif /* !HAVE_LCD_BITMAP */
746 #endif /* !SIMULATOR */
747
748 #ifndef SIMULATOR
749 static const char* dbg_partitions_getname(int selected_item, void *data,
750 char *buffer, size_t buffer_len)
751 {
752 (void)data;
753 int partition = selected_item/2;
754 struct partinfo* p = disk_partinfo(partition);
755 if (selected_item%2)
756 {
757 snprintf(buffer, buffer_len, " T:%x %ld MB", p->type, p->size / 2048);
758 }
759 else
760 {
761 snprintf(buffer, buffer_len, "P%d: S:%lx", partition, p->start);
762 }
763 return buffer;
764 }
765
766 bool dbg_partitions(void)
767 {
768 struct simplelist_info info;
769 simplelist_info_init(&info, "Partition Info", 4, NULL);
770 info.selection_size = 2;
771 info.hide_selection = true;
772 info.scroll_all = true;
773 info.get_name = dbg_partitions_getname;
774 return simplelist_show_list(&info);
775 }
776 #endif
777
778 #if defined(CPU_COLDFIRE) && defined(HAVE_SPDIF_OUT)
779 static bool dbg_spdif(void)
780 {
781 int line;
782 unsigned int control;
783 int x;
784 char *s;
785 int category;
786 int generation;
787 unsigned int interruptstat;
788 bool valnogood, symbolerr, parityerr;
789 bool done = false;
790 bool spdif_src_on;
791 int spdif_source = spdif_get_output_source(&spdif_src_on);
792 spdif_set_output_source(AUDIO_SRC_SPDIF IF_SPDIF_POWER_(, true));
793
794 lcd_clear_display();
795 lcd_setfont(FONT_SYSFIXED);
796
797 #ifdef HAVE_SPDIF_POWER
798 spdif_power_enable(true); /* We need SPDIF power for both sending & receiving */
799 #endif
800
801 while (!done)
802 {
803 line = 0;
804
805 control = EBU1RCVCCHANNEL1;
806 interruptstat = INTERRUPTSTAT;
807 INTERRUPTCLEAR = 0x03c00000;
808
809 valnogood = (interruptstat & 0x01000000)?true:false;
810 symbolerr = (interruptstat & 0x00800000)?true:false;
811 parityerr = (interruptstat & 0x00400000)?true:false;
812
813 lcd_putsf(0, line++, "Val: %s Sym: %s Par: %s",
814 valnogood?"--":"OK",
815 symbolerr?"--":"OK",
816 parityerr?"--":"OK");
817
818 lcd_putsf(0, line++, "Status word: %08x", (int)control);
819
820 line++;
821
822 x = control >> 31;
823 lcd_putsf(0, line++, "PRO: %d (%s)",
824 x, x?"Professional":"Consumer");
825
826 x = (control >> 30) & 1;
827 lcd_putsf(0, line++, "Audio: %d (%s)",
828 x, x?"Non-PCM":"PCM");
829
830 x = (control >> 29) & 1;
831 lcd_putsf(0, line++, "Copy: %d (%s)",
832 x, x?"Permitted":"Inhibited");
833
834 x = (control >> 27) & 7;
835 switch(x)
836 {
837 case 0:
838 s = "None";
839 break;
840 case 1:
841 s = "50/15us";
842 break;
843 default:
844 s = "Reserved";
845 break;
846 }
847 lcd_putsf(0, line++, "Preemphasis: %d (%s)", x, s);
848
849 x = (control >> 24) & 3;
850 lcd_putsf(0, line++, "Mode: %d", x);
851
852 category = (control >> 17) & 127;
853 switch(category)
854 {
855 case 0x00:
856 s = "General";
857 break;
858 case 0x40:
859 s = "Audio CD";
860 break;
861 default:
862 s = "Unknown";
863 }
864 lcd_putsf(0, line++, "Category: 0x%02x (%s)", category, s);
865
866 x = (control >> 16) & 1;
867 generation = x;
868 if(((category & 0x70) == 0x10) ||
869 ((category & 0x70) == 0x40) ||
870 ((category & 0x78) == 0x38))
871 {
872 generation = !generation;
873 }
874 lcd_putsf(0, line++, "Generation: %d (%s)",
875 x, generation?"Original":"No ind.");
876
877 x = (control >> 12) & 15;
878 lcd_putsf(0, line++, "Source: %d", x);
879
880
881 x = (control >> 8) & 15;
882 switch(x)
883 {
884 case 0:
885 s = "Unspecified";
886 break;
887 case 8:
888 s = "A (Left)";
889 break;
890 case 4:
891 s = "B (Right)";
892 break;
893 default:
894 s = "";
895 break;
896 }
897 lcd_putsf(0, line++, "Channel: %d (%s)", x, s);
898
899 x = (control >> 4) & 15;
900 switch(x)
901 {
902 case 0:
903 s = "44.1kHz";
904 break;
905 case 0x4:
906 s = "48kHz";
907 break;
908 case 0xc:
909 s = "32kHz";
910 break;
911 }
912 lcd_putsf(0, line++, "Frequency: %d (%s)", x, s);
913
914 x = (control >> 2) & 3;
915 lcd_putsf(0, line++, "Clock accuracy: %d", x);
916 line++;
917
918 #ifndef SIMULATOR
919 lcd_putsf(0, line++, "Measured freq: %ldHz",
920 spdif_measure_frequency());
921 #endif
922
923 lcd_update();
924
925 if (action_userabort(HZ/10))
926 break;
927 }
928
929 spdif_set_output_source(spdif_source IF_SPDIF_POWER_(, spdif_src_on));
930
931 #ifdef HAVE_SPDIF_POWER
932 spdif_power_enable(global_settings.spdif_enable);
933 #endif
934
935 lcd_setfont(FONT_UI);
936 return false;
937 }
938 #endif /* CPU_COLDFIRE */
939
940 #ifndef SIMULATOR
941 #ifdef HAVE_LCD_BITMAP
942 /* button definitions */
943 #if (CONFIG_KEYPAD == IRIVER_H100_PAD) || \
944 (CONFIG_KEYPAD == IRIVER_H300_PAD)
945 # define DEBUG_CANCEL BUTTON_OFF
946
947 #elif CONFIG_KEYPAD == RECORDER_PAD
948 # define DEBUG_CANCEL BUTTON_OFF
949
950 #elif CONFIG_KEYPAD == ONDIO_PAD
951 # define DEBUG_CANCEL BUTTON_MENU
952
953 #elif (CONFIG_KEYPAD == IPOD_1G2G_PAD) || \
954 (CONFIG_KEYPAD == IPOD_3G_PAD) || \
955 (CONFIG_KEYPAD == IPOD_4G_PAD)
956 # define DEBUG_CANCEL BUTTON_MENU
957
958 #elif CONFIG_KEYPAD == IRIVER_IFP7XX_PAD
959 # define DEBUG_CANCEL BUTTON_PLAY
960
961 #elif CONFIG_KEYPAD == IAUDIO_X5M5_PAD
962 # define DEBUG_CANCEL BUTTON_REC
963
964 #elif (CONFIG_KEYPAD == IAUDIO_M3_PAD)
965 # define DEBUG_CANCEL BUTTON_RC_REC
966
967 #elif (CONFIG_KEYPAD == IRIVER_H10_PAD)
968 # define DEBUG_CANCEL BUTTON_REW
969
970 #elif (CONFIG_KEYPAD == MROBE100_PAD)
971 # define DEBUG_CANCEL BUTTON_MENU
972
973 #elif (CONFIG_KEYPAD == SANSA_E200_PAD) || \
974 (CONFIG_KEYPAD == SANSA_C200_PAD) || \
975 (CONFIG_KEYPAD == SANSA_FUZE_PAD)
976 # define DEBUG_CANCEL BUTTON_LEFT
977
978 /* This is temporary until the SA9200 touchpad works */
979 #elif (CONFIG_KEYPAD == PHILIPS_SA9200_PAD) || \
980 (CONFIG_KEYPAD == PHILIPS_HDD1630_PAD)
981 # define DEBUG_CANCEL BUTTON_POWER
982
983 #elif (CONFIG_KEYPAD == SAMSUNG_YH_PAD)
984 # define DEBUG_CANCEL BUTTON_PLAY
985
986 #endif /* key definitions */
987
988 /* Test code!!! */
989 bool dbg_ports(void)
990 {
991 #if CONFIG_CPU == SH7034
992 int adc_battery_voltage, adc_battery_level;
993
994 lcd_setfont(FONT_SYSFIXED);
995 lcd_clear_display();
996
997 while(1)
998 {
999 lcd_putsf(0, 0, "PADR: %04x", (unsigned short)PADR);
1000 lcd_putsf(0, 1, "PBDR: %04x", (unsigned short)PBDR);
1001
1002 lcd_putsf(0, 2, "AN0: %03x AN4: %03x", adc_read(0), adc_read(4));
1003 lcd_putsf(0, 3, "AN1: %03x AN5: %03x", adc_read(1), adc_read(5));
1004 lcd_putsf(0, 4, "AN2: %03x AN6: %03x", adc_read(2), adc_read(6));
1005 lcd_putsf(0, 5, "AN3: %03x AN7: %03x", adc_read(3), adc_read(7));
1006
1007 battery_read_info(&adc_battery_voltage, &adc_battery_level);
1008 lcd_putsf(0, 6, "Batt: %d.%03dV %d%% ", adc_battery_voltage / 1000,
1009 adc_battery_voltage % 1000, adc_battery_level);
1010
1011 lcd_update();
1012 if (button_get_w_tmo(HZ/10) == (DEBUG_CANCEL|BUTTON_REL))
1013 {
1014 lcd_setfont(FONT_UI);
1015 return false;
1016 }
1017 }
1018 #elif defined(CPU_COLDFIRE)
1019 unsigned int gpio_out;
1020 unsigned int gpio1_out;
1021 unsigned int gpio_read;
1022 unsigned int gpio1_read;
1023 unsigned int gpio_function;
1024 unsigned int gpio1_function;
1025 unsigned int gpio_enable;
1026 unsigned int gpio1_enable;
1027 int adc_buttons, adc_remote;
1028 int adc_battery_voltage, adc_battery_level;
1029 int line;
1030
1031 lcd_clear_display();
1032 lcd_setfont(FONT_SYSFIXED);
1033
1034 while(1)
1035 {
1036 line = 0;
1037 gpio_read = GPIO_READ;
1038 gpio1_read = GPIO1_READ;
1039 gpio_out = GPIO_OUT;
1040 gpio1_out = GPIO1_OUT;
1041 gpio_function = GPIO_FUNCTION;
1042 gpio1_function = GPIO1_FUNCTION;
1043 gpio_enable = GPIO_ENABLE;
1044 gpio1_enable = GPIO1_ENABLE;
1045
1046 lcd_putsf(0, line++, "GPIO_READ: %08x", gpio_read);
1047 lcd_putsf(0, line++, "GPIO_OUT: %08x", gpio_out);
1048 lcd_putsf(0, line++, "GPIO_FUNC: %08x", gpio_function);
1049 lcd_putsf(0, line++, "GPIO_ENA: %08x", gpio_enable);
1050
1051 lcd_putsf(0, line++, "GPIO1_READ: %08x", gpio1_read);
1052 lcd_putsf(0, line++, "GPIO1_OUT: %08x", gpio1_out);
1053 lcd_putsf(0, line++, "GPIO1_FUNC: %08x", gpio1_function);
1054 lcd_putsf(0, line++, "GPIO1_ENA: %08x", gpio1_enable);
1055
1056 adc_buttons = adc_read(ADC_BUTTONS);
1057 adc_remote = adc_read(ADC_REMOTE);
1058 battery_read_info(&adc_battery_voltage, &adc_battery_level);
1059 #if defined(IAUDIO_X5) || defined(IAUDIO_M5) || defined(IRIVER_H300_SERIES)
1060 lcd_putsf(0, line++, "ADC_BUTTONS (%c): %02x",
1061 button_scan_enabled() ? '+' : '-', adc_buttons);
1062 #else
1063 lcd_putsf(0, line++, "ADC_BUTTONS: %02x", adc_buttons);
1064 #endif
1065 #if defined(IAUDIO_X5) || defined(IAUDIO_M5)
1066 lcd_putsf(0, line++, "ADC_REMOTE (%c): %02x",
1067 remote_detect() ? '+' : '-', adc_remote);
1068 #else
1069 lcd_putsf(0, line++, "ADC_REMOTE: %02x", adc_remote);
1070 #endif
1071 #if defined(IRIVER_H100_SERIES) || defined(IRIVER_H300_SERIES)
1072 lcd_putsf(0, line++, "ADC_REMOTEDETECT: %02x",
1073 adc_read(ADC_REMOTEDETECT));
1074 #endif
1075
1076 lcd_putsf(0, line++, "Batt: %d.%03dV %d%% ", adc_battery_voltage / 1000,
1077 adc_battery_voltage % 1000, adc_battery_level);
1078
1079 #if defined(IRIVER_H100_SERIES) || defined(IRIVER_H300_SERIES)
1080 lcd_putsf(0, line++, "remotetype: %d", remote_type());
1081 #endif
1082
1083 lcd_update();
1084 if (button_get_w_tmo(HZ/10) == (DEBUG_CANCEL|BUTTON_REL))
1085 {
1086 lcd_setfont(FONT_UI);
1087 return false;
1088 }
1089 }
1090
1091 #elif defined(CPU_PP502x)
1092 int line;
1093
1094 lcd_clear_display();
1095 lcd_setfont(FONT_SYSFIXED);
1096
1097 while(1)
1098 {
1099 line = 0;
1100 lcd_puts(0, line++, "GPIO STATES:");
1101 lcd_putsf(0, line++, "A: %02x E: %02x I: %02x",
1102 (unsigned int)GPIOA_INPUT_VAL,
1103 (unsigned int)GPIOE_INPUT_VAL,
1104 (unsigned int)GPIOI_INPUT_VAL);
1105 lcd_putsf(0, line++, "B: %02x F: %02x J: %02x",
1106 (unsigned int)GPIOB_INPUT_VAL,
1107 (unsigned int)GPIOF_INPUT_VAL,
1108 (unsigned int)GPIOJ_INPUT_VAL);
1109 lcd_putsf(0, line++, "C: %02x G: %02x K: %02x",
1110 (unsigned int)GPIOC_INPUT_VAL,
1111 (unsigned int)GPIOG_INPUT_VAL,
1112 (unsigned int)GPIOK_INPUT_VAL);
1113 lcd_putsf(0, line++, "D: %02x H: %02x L: %02x",
1114 (unsigned int)GPIOD_INPUT_VAL,
1115 (unsigned int)GPIOH_INPUT_VAL,
1116 (unsigned int)GPIOL_INPUT_VAL);
1117 line++;
1118 lcd_putsf(0, line++, "GPO32_VAL: %08lx", GPO32_VAL);
1119 lcd_putsf(0, line++, "GPO32_EN: %08lx", GPO32_ENABLE);
1120 lcd_putsf(0, line++, "DEV_EN: %08lx", DEV_EN);
1121 lcd_putsf(0, line++, "DEV_EN2: %08lx", DEV_EN2);
1122 lcd_putsf(0, line++, "DEV_EN3: %08lx", inl(0x60006044)); /* to be verified */
1123 lcd_putsf(0, line++, "DEV_INIT1: %08lx", DEV_INIT1);
1124 lcd_putsf(0, line++, "DEV_INIT2: %08lx", DEV_INIT2);
1125 #ifdef ADC_ACCESSORY
1126 lcd_putsf(0, line++, "ACCESSORY: %d", adc_read(ADC_ACCESSORY));
1127 #endif
1128
1129 #if defined(IPOD_ACCESSORY_PROTOCOL)
1130 extern unsigned char serbuf[];
1131 lcd_putsf(0, line++, "IAP PACKET: %02x %02x %02x %02x %02x %02x %02x %02x",
1132 serbuf[0], serbuf[1], serbuf[2], serbuf[3], serbuf[4], serbuf[5],
1133 serbuf[6], serbuf[7]);
1134 #endif
1135
1136 #if defined(IRIVER_H10) || defined(IRIVER_H10_5GB)
1137 line++;
1138 lcd_putsf(0, line++, "BATT: %03x UNK1: %03x",
1139 adc_read(ADC_BATTERY), adc_read(ADC_UNKNOWN_1));
1140 lcd_putsf(0, line++, "REM: %03x PAD: %03x",
1141 adc_read(ADC_REMOTE), adc_read(ADC_SCROLLPAD));
1142 #elif defined(PHILIPS_HDD1630)
1143 line++;
1144 lcd_putsf(0, line++, "BATT: %03x UNK1: %03x",
1145 adc_read(ADC_BATTERY), adc_read(ADC_UNKNOWN_1));
1146 #elif defined(SANSA_E200) || defined(PHILIPS_SA9200)
1147 lcd_putsf(0, line++, "ADC_BVDD: %4d", adc_read(ADC_BVDD));
1148 lcd_putsf(0, line++, "ADC_RTCSUP: %4d", adc_read(ADC_RTCSUP));
1149 lcd_putsf(0, line++, "ADC_UVDD: %4d", adc_read(ADC_UVDD));
1150 lcd_putsf(0, line++, "ADC_CHG_IN: %4d", adc_read(ADC_CHG_IN));
1151 lcd_putsf(0, line++, "ADC_CVDD: %4d", adc_read(ADC_CVDD));
1152 lcd_putsf(0, line++, "ADC_BATTEMP: %4d", adc_read(ADC_BATTEMP));
1153 lcd_putsf(0, line++, "ADC_MICSUP1: %4d", adc_read(ADC_MICSUP1));
1154 lcd_putsf(0, line++, "ADC_MICSUP2: %4d", adc_read(ADC_MICSUP2));
1155 lcd_putsf(0, line++, "ADC_VBE1: %4d", adc_read(ADC_VBE1));
1156 lcd_putsf(0, line++, "ADC_VBE2: %4d", adc_read(ADC_VBE2));
1157 lcd_putsf(0, line++, "ADC_I_MICSUP1:%4d", adc_read(ADC_I_MICSUP1));
1158 #if !defined(PHILIPS_SA9200)
1159 lcd_putsf(0, line++, "ADC_I_MICSUP2:%4d", adc_read(ADC_I_MICSUP2));
1160 lcd_putsf(0, line++, "ADC_VBAT: %4d", adc_read(ADC_VBAT));
1161 #endif
1162 #endif
1163 lcd_update();
1164 if (button_get_w_tmo(HZ/10) == (DEBUG_CANCEL|BUTTON_REL))
1165 {
1166 lcd_setfont(FONT_UI);
1167 return false;
1168 }
1169 }
1170
1171 #elif CONFIG_CPU == PP5002
1172 int line;
1173
1174 lcd_clear_display();
1175 lcd_setfont(FONT_SYSFIXED);
1176
1177 while(1)
1178 {
1179 line = 0;
1180 lcd_putsf(0, line++, "GPIO_A: %02x GPIO_B: %02x",
1181 (unsigned int)GPIOA_INPUT_VAL, (unsigned int)GPIOB_INPUT_VAL);
1182 lcd_putsf(0, line++, "GPIO_C: %02x GPIO_D: %02x",
1183 (unsigned int)GPIOC_INPUT_VAL, (unsigned int)GPIOD_INPUT_VAL);
1184
1185 lcd_putsf(0, line++, "DEV_EN: %08lx", DEV_EN);
1186 lcd_putsf(0, line++, "CLOCK_ENABLE: %08lx", CLOCK_ENABLE);
1187 lcd_putsf(0, line++, "CLOCK_SOURCE: %08lx", CLOCK_SOURCE);
1188 lcd_putsf(0, line++, "PLL_CONTROL: %08lx", PLL_CONTROL);
1189 lcd_putsf(0, line++, "PLL_DIV: %08lx", PLL_DIV);
1190 lcd_putsf(0, line++, "PLL_MULT: %08lx", PLL_MULT);
1191 lcd_putsf(0, line++, "TIMING1_CTL: %08lx", TIMING1_CTL);
1192 lcd_putsf(0, line++, "TIMING2_CTL: %08lx", TIMING2_CTL);
1193
1194 lcd_update();
1195 if (button_get_w_tmo(HZ/10) == (DEBUG_CANCEL|BUTTON_REL))
1196 {
1197 lcd_setfont(FONT_UI);
1198 return false;
1199 }
1200 }
1201 lcd_setfont(FONT_UI);
1202 #else
1203 return __dbg_ports();
1204 #endif /* CPU */
1205 return false;
1206 }
1207 #else /* !HAVE_LCD_BITMAP */
1208 bool dbg_ports(void)
1209 {
1210 char buf[32];
1211 int button;
1212 int adc_battery_voltage;
1213 int currval = 0;
1214
1215 lcd_clear_display();
1216
1217 while(1)
1218 {
1219 switch(currval)
1220 {
1221 case 0:
1222 snprintf(buf, 32, "PADR: %04x", (unsigned short)PADR);
1223 break;
1224 case 1:
1225 snprintf(buf, 32, "PBDR: %04x", (unsigned short)PBDR);
1226 break;
1227 case 2:
1228 snprintf(buf, 32, "AN0: %03x", adc_read(0));
1229 break;
1230 case 3:
1231 snprintf(buf, 32, "AN1: %03x", adc_read(1));
1232 break;
1233 case 4:
1234 snprintf(buf, 32, "AN2: %03x", adc_read(2));
1235 break;
1236 case 5:
1237 snprintf(buf, 32, "AN3: %03x", adc_read(3));
1238 break;
1239 case 6:
1240 snprintf(buf, 32, "AN4: %03x", adc_read(4));
1241 break;
1242 case 7:
1243 snprintf(buf, 32, "AN5: %03x", adc_read(5));
1244 break;
1245 case 8:
1246 snprintf(buf, 32, "AN6: %03x", adc_read(6));
1247 break;
1248 case 9:
1249 snprintf(buf, 32, "AN7: %03x", adc_read(7));
1250 break;
1251 }
1252 lcd_puts(0, 0, buf);
1253
1254 battery_read_info(&adc_battery_voltage, NULL);
1255 lcd_putsf(0, 1, "Batt: %d.%03dV", adc_battery_voltage / 1000,
1256 adc_battery_voltage % 1000);
1257 lcd_update();
1258
1259 button = get_action(CONTEXT_SETTINGS,HZ/5);
1260
1261 switch(button)
1262 {
1263 case ACTION_STD_CANCEL:
1264 return false;
1265
1266 case ACTION_SETTINGS_DEC:
1267 currval--;
1268 if(currval < 0)
1269 currval = 9;
1270 break;
1271
1272 case ACTION_SETTINGS_INC:
1273 currval++;
1274 if(currval > 9)
1275 currval = 0;
1276 break;
1277 }
1278 }
1279 return false;
1280 }
1281 #endif /* !HAVE_LCD_BITMAP */
1282 #endif /* !SIMULATOR */
1283
1284 #if (CONFIG_RTC == RTC_PCF50605) && !defined(SIMULATOR)
1285 static bool dbg_pcf(void)
1286 {
1287 int line;
1288
1289 #ifdef HAVE_LCD_BITMAP
1290 lcd_setfont(FONT_SYSFIXED);
1291 #endif
1292 lcd_clear_display();
1293
1294 while(1)
1295 {
1296 line = 0;
1297
1298 lcd_putsf(0, line++, "DCDC1: %02x", pcf50605_read(0x1b));
1299 lcd_putsf(0, line++, "DCDC2: %02x", pcf50605_read(0x1c));
1300 lcd_putsf(0, line++, "DCDC3: %02x", pcf50605_read(0x1d));
1301 lcd_putsf(0, line++, "DCDC4: %02x", pcf50605_read(0x1e));
1302 lcd_putsf(0, line++, "DCDEC1: %02x", pcf50605_read(0x1f));
1303 lcd_putsf(0, line++, "DCDEC2: %02x", pcf50605_read(0x20));
1304 lcd_putsf(0, line++, "DCUDC1: %02x", pcf50605_read(0x21));
1305 lcd_putsf(0, line++, "DCUDC2: %02x", pcf50605_read(0x22));
1306 lcd_putsf(0, line++, "IOREGC: %02x", pcf50605_read(0x23));
1307 lcd_putsf(0, line++, "D1REGC: %02x", pcf50605_read(0x24));
1308 lcd_putsf(0, line++, "D2REGC: %02x", pcf50605_read(0x25));
1309 lcd_putsf(0, line++, "D3REGC: %02x", pcf50605_read(0x26));
1310 lcd_putsf(0, line++, "LPREG1: %02x", pcf50605_read(0x27));
1311 lcd_update();
1312 if (button_get_w_tmo(HZ/10) == (DEBUG_CANCEL|BUTTON_REL))
1313 {
1314 lcd_setfont(FONT_UI);
1315 return false;
1316 }
1317 }
1318
1319 lcd_setfont(FONT_UI);
1320 return false;
1321 }
1322 #endif
1323
1324 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1325 static bool dbg_cpufreq(void)
1326 {
1327 int line;
1328 int button;
1329
1330 #ifdef HAVE_LCD_BITMAP
1331 lcd_setfont(FONT_SYSFIXED);
1332 #endif
1333 lcd_clear_display();
1334
1335 while(1)
1336 {
1337 line = 0;
1338
1339 lcd_putsf(0, line++, "Frequency: %ld", FREQ);
1340 lcd_putsf(0, line++, "boost_counter: %d", get_cpu_boost_counter());
1341
1342 lcd_update();
1343 button = get_action(CONTEXT_STD,HZ/10);
1344
1345 switch(button)
1346 {
1347 case ACTION_STD_PREV:
1348 cpu_boost(true);
1349 break;
1350
1351 case ACTION_STD_NEXT:
1352 cpu_boost(false);
1353 break;
1354
1355 case ACTION_STD_OK:
1356 while (get_cpu_boost_counter() > 0)
1357 cpu_boost(false);
1358 set_cpu_frequency(CPUFREQ_DEFAULT);
1359 break;
1360
1361 case ACTION_STD_CANCEL:
1362 lcd_setfont(FONT_UI);
1363 return false;
1364 }
1365 }
1366 lcd_setfont(FONT_UI);
1367 return false;
1368 }
1369 #endif /* HAVE_ADJUSTABLE_CPU_FREQ */
1370
1371 #if defined(HAVE_TSC2100) && !defined(SIMULATOR)
1372 #include "tsc2100.h"
1373 static char *itob(int n, int len)
1374 {
1375 static char binary[64];
1376 int i,j;
1377 for (i=1, j=0;i<=len;i++)
1378 {
1379 binary[j++] = n&(1<<(len-i))?'1':'0';
1380 if (i%4 == 0)
1381 binary[j++] = ' ';
1382 }
1383 binary[j] = '\0';
1384 return binary;
1385 }
1386
1387 static const char* tsc2100_debug_getname(int selected_item, void * data,
1388 char *buffer, size_t buffer_len)
1389 {
1390 int *page = (int*)data;
1391 bool reserved = false;
1392 switch (*page)
1393 {
1394 case 0:
1395 if ((selected_item > 0x0a) ||
1396 (selected_item == 0x04) ||
1397 (selected_item == 0x08))
1398 reserved = true;
1399 break;
1400 case 1:
1401 if ((selected_item > 0x05) ||
1402 (selected_item == 0x02))
1403 reserved = true;
1404 break;
1405 case 2:
1406 if (selected_item > 0x1e)
1407 reserved = true;
1408 break;
1409 }
1410 if (reserved)
1411 snprintf(buffer, buffer_len, "%02x: RESERVED", selected_item);
1412 else
1413 snprintf(buffer, buffer_len, "%02x: %s", selected_item,
1414 itob(tsc2100_readreg(*page, selected_item)&0xffff,16));
1415 return buffer;
1416 }
1417 static int tsc2100debug_action_callback(int action, struct gui_synclist *lists)
1418 {
1419 int *page = (int*)lists->data;
1420 if (action == ACTION_STD_OK)
1421 {
1422 *page = (*page+1)%3;
1423 snprintf(lists->title, 32,
1424 "tsc2100 registers - Page %d", *page);
1425 return ACTION_REDRAW;
1426 }
1427 return action;
1428 }
1429 static bool tsc2100_debug(void)
1430 {
1431 int page = 0;
1432 char title[32] = "tsc2100 registers - Page 0";
1433 struct simplelist_info info;
1434 simplelist_info_init(&info, title, 32, &page);
1435 info.timeout = HZ/100;
1436 info.get_name = tsc2100_debug_getname;
1437 info.action_callback= tsc2100debug_action_callback;
1438 return simplelist_show_list(&info);
1439 }
1440 #endif
1441 #ifndef SIMULATOR
1442 #ifdef HAVE_LCD_BITMAP
1443 /*
1444 * view_battery() shows a automatically scaled graph of the battery voltage
1445 * over time. Usable for estimating battery life / charging rate.
1446 * The power_history array is updated in power_thread of powermgmt.c.
1447 */
1448
1449 #define BAT_LAST_VAL MIN(LCD_WIDTH, POWER_HISTORY_LEN)
1450 #define BAT_YSPACE (LCD_HEIGHT - 20)
1451
1452 static bool view_battery(void)
1453 {
1454 int view = 0;
1455 int i, x, y;
1456 unsigned short maxv, minv;
1457
1458 lcd_setfont(FONT_SYSFIXED);
1459
1460 while(1)
1461 {
1462 lcd_clear_display();
1463 switch (view) {
1464 case 0: /* voltage history graph */
1465 /* Find maximum and minimum voltage for scaling */
1466 minv = power_history[0];
1467 maxv = minv + 1;
1468 for (i = 1; i < BAT_LAST_VAL && power_history[i]; i++) {
1469 if (power_history[i] > maxv)
1470 maxv = power_history[i];
1471 if (power_history[i] < minv)
1472 minv = power_history[i];
1473 }
1474
1475 lcd_putsf(0, 0, "Battery %d.%03d", power_history[0] / 1000,
1476 power_history[0] % 1000);
1477 lcd_putsf(0, 1, "scale %d.%03d-%d.%03dV",
1478 minv / 1000, minv % 1000, maxv / 1000, maxv % 1000);
1479
1480 x = 0;
1481 for (i = BAT_LAST_VAL - 1; i >= 0; i--) {
1482 y = (power_history[i] - minv) * BAT_YSPACE / (maxv - minv);
1483 lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
1484 lcd_vline(x, LCD_HEIGHT-1, 20);
1485 lcd_set_drawmode(DRMODE_SOLID);
1486 lcd_vline(x, LCD_HEIGHT-1,
1487 MIN(MAX(LCD_HEIGHT-1 - y, 20), LCD_HEIGHT-1));
1488 x++;
1489 }
1490
1491 break;
1492
1493 case 1: /* status: */
1494 lcd_puts(0, 0, "Power status:");
1495
1496 battery_read_info(&y, NULL);
1497 lcd_putsf(0, 1, "Battery: %d.%03d V", y / 1000, y % 1000);
1498 #ifdef ADC_EXT_POWER
1499 y = (adc_read(ADC_EXT_POWER) * EXT_SCALE_FACTOR) / 1000;
1500 lcd_putsf(0, 2, "External: %d.%03d V", y / 1000, y % 1000);
1501 #endif
1502 #if CONFIG_CHARGING
1503 #if defined ARCHOS_RECORDER
1504 lcd_putsf(0, 3, "Chgr: %s %s",
1505 charger_inserted() ? "present" : "absent",
1506 charger_enabled() ? "on" : "off");
1507 lcd_putsf(0, 5, "short delta: %d", short_delta);
1508 lcd_putsf(0, 6, "long delta: %d", long_delta);
1509 lcd_puts(0, 7, power_message);
1510 lcd_putsf(0, 8, "USB Inserted: %s",
1511 usb_inserted() ? "yes" : "no");
1512 #elif defined IRIVER_H300_SERIES
1513 lcd_putsf(0, 9, "USB Charging Enabled: %s",
1514 usb_charging_enabled() ? "yes" : "no");
1515 #elif defined IPOD_NANO || defined IPOD_VIDEO
1516 int usb_pwr = (GPIOL_INPUT_VAL & 0x10)?true:false;
1517 int ext_pwr = (GPIOL_INPUT_VAL & 0x08)?false:true;
1518 int dock = (GPIOA_INPUT_VAL & 0x10)?true:false;
1519 int charging = (GPIOB_INPUT_VAL & 0x01)?false:true;
1520 int headphone= (GPIOA_INPUT_VAL & 0x80)?true:false;
1521
1522 lcd_putsf(0, 3, "USB pwr: %s",
1523 usb_pwr ? "present" : "absent");
1524 lcd_putsf(0, 4, "EXT pwr: %s",
1525 ext_pwr ? "present" : "absent");
1526 lcd_putsf(0, 5, "Battery: %s",
1527 charging ? "charging" : (usb_pwr||ext_pwr) ? "charged" : "discharging");
1528 lcd_putsf(0, 6, "Dock mode: %s",
1529 dock ? "enabled" : "disabled");
1530 lcd_putsf(0, 7, "Headphone: %s",
1531 headphone ? "connected" : "disconnected");
1532 #elif defined TOSHIBA_GIGABEAT_S
1533 int line = 3;
1534 unsigned int st;
1535
1536 static const unsigned char * const chrgstate_strings[] =
1537 {
1538 "Disabled",
1539 "Error",
1540 "Discharging",
1541 "Precharge",
1542 "Constant Voltage",
1543 "Constant Current",
1544 "<unknown>",
1545 };
1546
1547 lcd_putsf(0, line++, "Charger: %s",
1548 charger_inserted() ? "present" : "absent");
1549
1550 st = power_input_status() &
1551 (POWER_INPUT_CHARGER | POWER_INPUT_BATTERY);
1552 lcd_putsf(0, line++, "%s%s",
1553 (st & POWER_INPUT_MAIN_CHARGER) ? " Main" : "",
1554 (st & POWER_INPUT_USB_CHARGER) ? " USB" : "");
1555
1556 lcd_putsf(0, line++, "IUSB Max: %d", usb_allowed_current());
1557
1558 y = ARRAYLEN(chrgstate_strings) - 1;
1559
1560 switch (charge_state)
1561 {
1562 case CHARGE_STATE_DISABLED: y--;
1563 case CHARGE_STATE_ERROR: y--;
1564 case DISCHARGING: y--;
1565 case TRICKLE: y--;
1566 case TOPOFF: y--;
1567 case CHARGING: y--;
1568 default:;
1569 }
1570
1571 lcd_putsf(0, line++, "State: %s", chrgstate_strings[y]);
1572
1573 lcd_putsf(0, line++, "Battery Switch: %s",
1574 (st & POWER_INPUT_BATTERY) ? "On" : "Off");
1575
1576 y = chrgraw_adc_voltage();
1577 lcd_putsf(0, line++, "CHRGRAW: %d.%03d V",
1578 y / 1000, y % 1000);
1579
1580 y = application_supply_adc_voltage();
1581 lcd_putsf(0, line++, "BP : %d.%03d V",
1582 y / 1000, y % 1000);
1583
1584 y = battery_adc_charge_current();
1585 if (y < 0) x = '-', y = -y;
1586 else x = ' ';
1587 lcd_putsf(0, line++, "CHRGISN:%c%d mA", x, y);
1588
1589 y = cccv_regulator_dissipation();
1590 lcd_putsf(0, line++, "P CCCV : %d mW", y);
1591
1592 y = battery_charge_current();
1593 if (y < 0) x = '-', y = -y;
1594 else x = ' ';
1595 lcd_putsf(0, line++, "I Charge:%c%d mA", x, y);
1596
1597 y = battery_adc_temp();
1598
1599 if (y != INT_MIN) {
1600 lcd_putsf(0, line++, "T Battery: %dC (%dF)", y,
1601 (9*y + 160) / 5);
1602 } else {
1603 /* Conversion disabled */
1604 lcd_puts(0, line++, "T Battery: ?");
1605 }
1606
1607 #elif defined(SANSA_E200) || defined(SANSA_C200) || defined(SANSA_CLIP) || defined(SANSA_FUZE)
1608 const int first = CHARGE_STATE_DISABLED;
1609 static const char * const chrgstate_strings[] =
1610 {
1611 [CHARGE_STATE_DISABLED-first] = "Disabled",
1612 [CHARGE_STATE_ERROR-first] = "Error",
1613 [DISCHARGING-first] = "Discharging",
1614 [CHARGING-first] = "Charging",
1615 };
1616 const char *str = NULL;
1617
1618 lcd_putsf(0, 3, "Charger: %s",
1619 charger_inserted() ? "present" : "absent");
1620
1621 y = charge_state - first;
1622 if ((unsigned)y < ARRAYLEN(chrgstate_strings))
1623 str = chrgstate_strings[y];
1624
1625 lcd_putsf(0, 4, "State: %s",
1626 str ? str : "<unknown>");
1627
1628 lcd_putsf(0, 5, "CHARGER: %02X",
1629 ascodec_read(AS3514_CHARGER));
1630 #elif defined(IPOD_NANO2G)
1631 y = pmu_read_battery_current();
1632 lcd_putsf(0, 2, "Battery current: %d mA", y);
1633 #else
1634 lcd_putsf(0, 3, "Charger: %s",
1635 charger_inserted() ? "present" : "absent");
1636 #endif /* target type */
1637 #endif /* CONFIG_CHARGING */
1638 break;
1639
1640 case 2: /* voltage deltas: */
1641 lcd_puts(0, 0, "Voltage deltas:");
1642
1643 for (i = 0; i <= 6; i++) {
1644 y = power_history[i] - power_history[i+1];
1645 lcd_putsf(0, i+1, "-%d min: %s%d.%03d V", i,
1646 (y < 0) ? "-" : "", ((y < 0) ? y * -1 : y) / 1000,
1647 ((y < 0) ? y * -1 : y ) % 1000);
1648 }
1649 break;
1650
1651 case 3: /* remaining time estimation: */
1652
1653 #ifdef ARCHOS_RECORDER
1654 lcd_putsf(0, 0, "charge_state: %d", charge_state);
1655
1656 lcd_putsf(0, 1, "Cycle time: %d m", powermgmt_last_cycle_startstop_min);
1657
1658 lcd_putsf(0, 2, "Lvl@cyc st: %d%%", powermgmt_last_cycle_level);
1659
1660 lcd_putsf(0, 3, "P=%2d I=%2d", pid_p, pid_i);
1661
1662 lcd_putsf(0, 4, "Trickle sec: %d/60", trickle_sec);
1663 #endif /* ARCHOS_RECORDER */
1664
1665 lcd_putsf(0, 5, "Last PwrHist: %d.%03dV",
1666 power_history[0] / 1000,
1667 power_history[0] % 1000);
1668
1669 lcd_putsf(0, 6, "battery level: %d%%", battery_level());
1670
1671 lcd_putsf(0, 7, "Est. remain: %d m", battery_time());
1672 break;
1673 }
1674
1675 lcd_update();
1676
1677 switch(get_action(CONTEXT_STD,HZ/2))
1678 {
1679 case ACTION_STD_PREV:
1680 if (view)
1681 view--;
1682 break;
1683
1684 case ACTION_STD_NEXT:
1685 if (view < 3)
1686 view++;
1687 break;
1688
1689 case ACTION_STD_CANCEL:
1690 lcd_setfont(FONT_UI);
1691 return false;
1692 }
1693 }
1694 lcd_setfont(FONT_UI);
1695 return false;
1696 }
1697
1698 #endif /* HAVE_LCD_BITMAP */
1699 #endif
1700
1701 #ifndef SIMULATOR
1702 #if (CONFIG_STORAGE & STORAGE_MMC) || (CONFIG_STORAGE & STORAGE_SD)
1703
1704 #if (CONFIG_STORAGE & STORAGE_MMC)
1705 #define CARDTYPE "MMC"
1706 #elif (CONFIG_STORAGE & STORAGE_SD)
1707 #define CARDTYPE "microSD"
1708 #endif
1709
1710 static int disk_callback(int btn, struct gui_synclist *lists)
1711 {
1712 tCardInfo *card;
1713 int *cardnum = (int*)lists->data;
1714 unsigned char card_name[7];
1715 unsigned char pbuf[32];
1716 char *title = lists->title;
1717 static const unsigned char i_vmin[] = { 0, 1, 5, 10, 25, 35, 60, 100 };
1718 static const unsigned char i_vmax[] = { 1, 5, 10, 25, 35, 45, 80, 200 };
1719 static const unsigned char * const kbit_units[] = { "kBit/s", "MBit/s", "GBit/s" };
1720 static const unsigned char * const nsec_units[] = { "ns", "µs", "ms" };
1721 #if (CONFIG_STORAGE & STORAGE_MMC)
1722 static const char * const mmc_spec_vers[] = { "1.0-1.2", "1.4", "2.0-2.2",
1723 "3.1-3.31", "4.0" };
1724 #endif
1725
1726 if ((btn == ACTION_STD_OK) || (btn == SYS_FS_CHANGED) || (btn == ACTION_REDRAW))
1727 {
1728 #ifdef HAVE_HOTSWAP
1729 if (btn == ACTION_STD_OK)
1730 {
1731 *cardnum ^= 0x1; /* change cards */
1732 }
1733 #endif
1734
1735 simplelist_set_line_count(0);
1736
1737 card = card_get_info(*cardnum);
1738
1739 if (card->initialized > 0)
1740 {
1741 strlcpy(card_name, ((unsigned char*)card->cid) + 3, sizeof(card_name));
1742 simplelist_addline(SIMPLELIST_ADD_LINE,
1743 "%s Rev %d.%d", card_name,
1744 (int) card_extract_bits(card->cid, 55, 4),
1745 (int) card_extract_bits(card->cid, 51, 4));
1746 simplelist_addline(SIMPLELIST_ADD_LINE,
1747 "Prod: %d/%d",
1748 #if (CONFIG_STORAGE & STORAGE_SD)
1749 (int) card_extract_bits(card->cid, 11, 3),
1750 (int) card_extract_bits(card->cid, 19, 8) + 2000
1751 #elif (CONFIG_STORAGE & STORAGE_MMC)
1752 (int) card_extract_bits(card->cid, 15, 4),
1753 (int) card_extract_bits(card->cid, 11, 4) + 1997
1754 #endif
1755 );
1756 simplelist_addline(SIMPLELIST_ADD_LINE,
1757 #if (CONFIG_STORAGE & STORAGE_SD)
1758 "Ser#: 0x%08lx",
1759 card_extract_bits(card->cid, 55, 32)
1760 #elif (CONFIG_STORAGE & STORAGE_MMC)
1761 "Ser#: 0x%04lx",
1762 card_extract_bits(card->cid, 47, 16)
1763 #endif
1764 );
1765
1766 simplelist_addline(SIMPLELIST_ADD_LINE, "M=%02x, "
1767 #if (CONFIG_STORAGE & STORAGE_SD)
1768 "O=%c%c",
1769 (int) card_extract_bits(card->cid, 127, 8),
1770 card_extract_bits(card->cid, 119, 8),
1771 card_extract_bits(card->cid, 111, 8)
1772 #elif (CONFIG_STORAGE & STORAGE_MMC)
1773 "O=%04x",
1774 (int) card_extract_bits(card->cid, 127, 8),
1775 (int) card_extract_bits(card->cid, 119, 16)
1776 #endif
1777 );
1778
1779 #if (CONFIG_STORAGE & STORAGE_MMC)
1780 int temp = card_extract_bits(card->csd, 125, 4);
1781 simplelist_addline(SIMPLELIST_ADD_LINE,
1782 "MMC v%s", temp < 5 ?
1783 mmc_spec_vers[temp] : "?.?");
1784 #endif
1785 simplelist_addline(SIMPLELIST_ADD_LINE,
1786 "Blocks: 0x%08lx", card->numblocks);
1787 output_dyn_value(pbuf, sizeof pbuf, card->speed / 1000,
1788 kbit_units, false);
1789 simplelist_addline(SIMPLELIST_ADD_LINE,
1790 "Speed: %s", pbuf);
1791 output_dyn_value(pbuf, sizeof pbuf, card->taac,
1792 nsec_units, false);
1793 simplelist_addline(SIMPLELIST_ADD_LINE,
1794 "Taac: %s", pbuf);
1795 simplelist_addline(SIMPLELIST_ADD_LINE,
1796 "Nsac: %d clk", card->nsac);
1797 simplelist_addline(SIMPLELIST_ADD_LINE,
1798 "R2W: *%d", card->r2w_factor);
1799 simplelist_addline(SIMPLELIST_ADD_LINE,
1800 "IRmax: %d..%d mA",
1801 i_vmin[card_extract_bits(card->csd, 61, 3)],
1802 i_vmax[card_extract_bits(card->csd, 58, 3)]);
1803 simplelist_addline(SIMPLELIST_ADD_LINE,
1804 "IWmax: %d..%d mA",
1805 i_vmin[card_extract_bits(card->csd, 55, 3)],
1806 i_vmax[card_extract_bits(card->csd, 52, 3)]);
1807 }
1808 else if (card->initialized == 0)
1809 {
1810 simplelist_addline(SIMPLELIST_ADD_LINE, "Not Found!");
1811 }
1812 #if (CONFIG_STORAGE & STORAGE_SD)
1813 else /* card->initialized < 0 */
1814 {
1815 simplelist_addline(SIMPLELIST_ADD_LINE, "Init Error! (%d)", card->initialized);
1816 }
1817 #endif
1818 snprintf(title, 16, "[" CARDTYPE " %d]", *cardnum);
1819 gui_synclist_set_title(lists, title, Icon_NOICON);
1820 gui_synclist_set_nb_items(lists, simplelist_get_line_count());
1821 gui_synclist_select_item(lists, 0);
1822 btn = ACTION_REDRAW;
1823 }
1824 return btn;
1825 }
1826 #elif (CONFIG_STORAGE & STORAGE_ATA)
1827 static int disk_callback(int btn, struct gui_synclist *lists)
1828 {
1829 (void)lists;
1830 int i;
1831 char buf[128];
1832 unsigned short* identify_info = ata_get_identify();
1833 bool timing_info_present = false;
1834 (void)btn;
1835
1836 simplelist_set_line_count(0);
1837
1838 for (i=0; i < 20; i++)
1839 ((unsigned short*)buf)[i]=htobe16(identify_info[i+27]);
1840 buf[40]=0;
1841 /* kill trailing space */
1842 for (i=39; i && buf[i]==' '; i--)
1843 buf[i] = 0;
1844 simplelist_addline(SIMPLELIST_ADD_LINE, "Model: %s", buf);
1845 for (i=0; i < 4; i++)
1846 ((unsigned short*)buf)[i]=htobe16(identify_info[i+23]);
1847 buf[8]=0;
1848 simplelist_addline(SIMPLELIST_ADD_LINE,
1849 "Firmware: %s", buf);
1850 snprintf(buf, sizeof buf, "%ld MB",
1851 ((unsigned long)identify_info[61] << 16 |
1852 (unsigned long)identify_info[60]) / 2048 );
1853 simplelist_addline(SIMPLELIST_ADD_LINE,
1854 "Size: %s", buf);
1855 unsigned long free;
1856 fat_size( IF_MV2(0,) NULL, &free );
1857 simplelist_addline(SIMPLELIST_ADD_LINE,
1858 "Free: %ld MB", free / 1024);
1859 simplelist_addline(SIMPLELIST_ADD_LINE,
1860 "Spinup time: %d ms", storage_spinup_time() * (1000/HZ));
1861 i = identify_info[83] & (1<<3);
1862 simplelist_addline(SIMPLELIST_ADD_LINE,
1863 "Power mgmt: %s", i ? "enabled" : "unsupported");
1864 i = identify_info[83] & (1<<9);
1865 simplelist_addline(SIMPLELIST_ADD_LINE,
1866 "Noise mgmt: %s", i ? "enabled" : "unsupported");
1867 i = identify_info[82] & (1<<6);
1868 simplelist_addline(SIMPLELIST_ADD_LINE,
1869 "Read-ahead: %s", i ? "enabled" : "unsupported");
1870 timing_info_present = identify_info[53] & (1<<1);
1871 if(timing_info_present) {
1872 char pio3[2], pio4[2];pio3[1] = 0;
1873 pio4[1] = 0;
1874 pio3[0] = (identify_info[64] & (1<<0)) ? '3' : 0;
1875 pio4[0] = (identify_info[64] & (1<<1)) ? '4' : 0;
1876 simplelist_addline(SIMPLELIST_ADD_LINE,
1877 "PIO modes: 0 1 2 %s %s", pio3, pio4);
1878 }
1879 else {
1880 simplelist_addline(SIMPLELIST_ADD_LINE,
1881 "No PIO mode info");
1882 }
1883 timing_info_present = identify_info[53] & (1<<1);
1884 if(timing_info_present) {
1885 simplelist_addline(SIMPLELIST_ADD_LINE,
1886 "Cycle times %dns/%dns",
1887 identify_info[67],
1888 identify_info[68] );
1889 } else {
1890 simplelist_addline(SIMPLELIST_ADD_LINE,
1891 "No timing info");
1892 }
1893 #ifdef HAVE_ATA_DMA
1894 if (identify_info[63] & (1<<0)) {
1895 char mdma0[2], mdma1[2], mdma2[2];
1896 mdma0[1] = mdma1[1] = mdma2[1] = 0;
1897 mdma0[0] = (identify_info[63] & (1<<0)) ? '0' : 0;
1898 mdma1[0] = (identify_info[63] & (1<<1)) ? '1' : 0;
1899 mdma2[0] = (identify_info[63] & (1<<2)) ? '2' : 0;
1900 simplelist_addline(SIMPLELIST_ADD_LINE,
1901 "MDMA modes: %s %s %s", mdma0, mdma1, mdma2);
1902 simplelist_addline(SIMPLELIST_ADD_LINE,
1903 "MDMA Cycle times %dns/%dns",
1904 identify_info[65],
1905 identify_info[66] );
1906 }
1907 else {
1908 simplelist_addline(SIMPLELIST_ADD_LINE,
1909 "No MDMA mode info");
1910 }
1911 if (identify_info[53] & (1<<2)) {
1912 char udma0[2], udma1[2], udma2[2], udma3[2], udma4[2], udma5[2], udma6[2];
1913 udma0[1] = udma1[1] = udma2[1] = udma3[1] = udma4[1] = udma5[1] = udma6[1] = 0;
1914 udma0[0] = (identify_info[88] & (1<<0)) ? '0' : 0;
1915 udma1[0] = (identify_info[88] & (1<<1)) ? '1' : 0;
1916 udma2[0] = (identify_info[88] & (1<<2)) ? '2' : 0;
1917 udma3[0] = (identify_info[88] & (1<<3)) ? '3' : 0;
1918 udma4[0] = (identify_info[88] & (1<<4)) ? '4' : 0;
1919 udma5[0] = (identify_info[88] & (1<<5)) ? '5' : 0;
1920 udma6[0] = (identify_info[88] & (1<<6)) ? '6' : 0;
1921 simplelist_addline(SIMPLELIST_ADD_LINE,
1922 "UDMA modes: %s %s %s %s %s %s %s", udma0, udma1, udma2,
1923 udma3, udma4, udma5, udma6);
1924 }
1925 else {
1926 simplelist_addline(SIMPLELIST_ADD_LINE,
1927 "No UDMA mode info");
1928 }
1929 #endif /* HAVE_ATA_DMA */
1930 timing_info_present = identify_info[53] & (1<<1);
1931 if(timing_info_present) {
1932 i = identify_info[49] & (1<<11);
1933 simplelist_addline(SIMPLELIST_ADD_LINE,
1934 "IORDY support: %s", i ? "yes" : "no");
1935 i = identify_info[49] & (1<<10);
1936 simplelist_addline(SIMPLELIST_ADD_LINE,
1937 "IORDY disable: %s", i ? "yes" : "no");
1938 } else {
1939 simplelist_addline(SIMPLELIST_ADD_LINE,
1940 "No timing info");
1941 }
1942 simplelist_addline(SIMPLELIST_ADD_LINE,
1943 "Cluster size: %d bytes", fat_get_cluster_size(IF_MV(0)));
1944 #ifdef HAVE_ATA_DMA
1945 i = ata_get_dma_mode();
1946 if (i == 0) {
1947 simplelist_addline(SIMPLELIST_ADD_LINE,
1948 "DMA not enabled");
1949 } else {
1950 simplelist_addline(SIMPLELIST_ADD_LINE,
1951 "DMA mode: %s %c",
1952 (i & 0x40) ? "UDMA" : "MDMA",
1953 '0' + (i & 7));
1954 }
1955 #endif /* HAVE_ATA_DMA */
1956 return btn;
1957 }
1958 #else /* No SD, MMC or ATA */
1959 static int disk_callback(int btn, struct gui_synclist *lists)
1960 {
1961 (void)btn;
1962 (void)lists;
1963 struct storage_info info;
1964 storage_get_info(0,&info);
1965 simplelist_addline(SIMPLELIST_ADD_LINE, "Vendor: %s", info.vendor);
1966 simplelist_addline(SIMPLELIST_ADD_LINE, "Model: %s", info.product);
1967 simplelist_addline(SIMPLELIST_ADD_LINE, "Firmware: %s", info.revision);
1968 simplelist_addline(SIMPLELIST_ADD_LINE,
1969 "Size: %ld MB", info.num_sectors*(info.sector_size/512)/2024);
1970 unsigned long free;
1971 fat_size( IF_MV2(0,) NULL, &free );
1972 simplelist_addline(SIMPLELIST_ADD_LINE,
1973 "Free: %ld MB", free / 1024);
1974 simplelist_addline(SIMPLELIST_ADD_LINE,
1975 "Cluster size: %d bytes", fat_get_cluster_size(IF_MV(0)));
1976 return btn;
1977 }
1978 #endif
1979
1980 #if (CONFIG_STORAGE & STORAGE_ATA)
1981 static bool dbg_identify_info(void)
1982 {
1983 int fd = creat("/identify_info.bin");
1984 if(fd >= 0)
1985 {
1986 #ifdef ROCKBOX_LITTLE_ENDIAN
1987 ecwrite(fd, ata_get_identify(), SECTOR_SIZE/2, "s", true);
1988 #else
1989 write(fd, ata_get_identify(), SECTOR_SIZE);
1990 #endif
1991 close(fd);
1992 }
1993 return false;
1994 }
1995 #endif
1996
1997 static bool dbg_disk_info(void)
1998 {
1999 struct simplelist_info info;
2000 simplelist_info_init(&info, "Disk Info", 1, NULL);
2001 #if (CONFIG_STORAGE & STORAGE_MMC) || (CONFIG_STORAGE & STORAGE_SD)
2002 char title[16];
2003 int card = 0;
2004 info.callback_data = (void*)&card;
2005 info.title = title;
2006 #endif
2007 info.action_callback = disk_callback;
2008 info.hide_selection = true;
2009 info.scroll_all = true;
2010 return simplelist_show_list(&info);
2011 }
2012 #endif /* !SIMULATOR */
2013
2014 #ifdef HAVE_DIRCACHE
2015 static int dircache_callback(int btn, struct gui_synclist *lists)
2016 {
2017 (void)btn; (void)lists;
2018 simplelist_set_line_count(0);
2019 simplelist_addline(SIMPLELIST_ADD_LINE, "Cache initialized: %s",
2020 dircache_is_enabled() ? "Yes" : "No");
2021 simplelist_addline(SIMPLELIST_ADD_LINE, "Cache size: %d B",
2022 dircache_get_cache_size());
2023 simplelist_addline(SIMPLELIST_ADD_LINE, "Last size: %d B",
2024 global_status.dircache_size);
2025 simplelist_addline(SIMPLELIST_ADD_LINE, "Limit: %d B",
2026 DIRCACHE_LIMIT);
2027 simplelist_addline(SIMPLELIST_ADD_LINE, "Reserve: %d/%d B",
2028 dircache_get_reserve_used(), DIRCACHE_RESERVE);
2029 simplelist_addline(SIMPLELIST_ADD_LINE, "Scanning took: %d s",
2030 dircache_get_build_ticks() / HZ);
2031 simplelist_addline(SIMPLELIST_ADD_LINE, "Entry count: %d",
2032 dircache_get_entry_count());
2033 return btn;
2034 }
2035
2036 static bool dbg_dircache_info(void)
2037 {
2038 struct simplelist_info info;
2039 simplelist_info_init(&info, "Dircache Info", 7, NULL);
2040 info.action_callback = dircache_callback;
2041 info.hide_selection = true;
2042 info.scroll_all = true;
2043 return simplelist_show_list(&info);
2044 }
2045
2046 #endif /* HAVE_DIRCACHE */
2047
2048 #ifdef HAVE_TAGCACHE
2049 static int database_callback(int btn, struct gui_synclist *lists)
2050 {
2051 (void)lists;
2052 struct tagcache_stat *stat = tagcache_get_stat();
2053 static bool synced = false;
2054
2055 simplelist_set_line_count(0);
2056
2057 simplelist_addline(SIMPLELIST_ADD_LINE, "Initialized: %s",
2058 stat->initialized ? "Yes" : "No");
2059 simplelist_addline(SIMPLELIST_ADD_LINE, "DB Ready: %s",
2060 stat->ready ? "Yes" : "No");
2061 simplelist_addline(SIMPLELIST_ADD_LINE, "RAM Cache: %s",
2062 stat->ramcache ? "Yes" : "No");
2063 simplelist_addline(SIMPLELIST_ADD_LINE, "RAM: %d/%d B",
2064 stat->ramcache_used, stat->ramcache_allocated);
2065 simplelist_addline(SIMPLELIST_ADD_LINE, "Progress: %d%% (%d entries)",
2066 stat->progress, stat->processed_entries);
2067 simplelist_addline(SIMPLELIST_ADD_LINE, "Curfile: %s",
2068 stat->curentry ? stat->curentry : "---");
2069 simplelist_addline(SIMPLELIST_ADD_LINE, "Commit step: %d",
2070 stat->commit_step);
2071 simplelist_addline(SIMPLELIST_ADD_LINE, "Commit delayed: %s",
2072 stat->commit_delayed ? "Yes" : "No");
2073
2074 simplelist_addline(SIMPLELIST_ADD_LINE, "Queue length: %d",
2075 stat->queue_length);
2076
2077 if (synced)
2078 {
2079 synced = false;
2080 tagcache_screensync_event();
2081 }
2082
2083 if (!btn && stat->curentry)
2084 {
2085 synced = true;
2086 return ACTION_REDRAW;
2087 }
2088
2089 if (btn == ACTION_STD_CANCEL)
2090 tagcache_screensync_enable(false);
2091
2092 return btn;
2093 }
2094 static bool dbg_tagcache_info(void)
2095 {
2096 struct simplelist_info info;
2097 simplelist_info_init(&info, "Database Info", 8, NULL);
2098 info.action_callback = database_callback;
2099 info.hide_selection = true;
2100 info.scroll_all = true;
2101
2102 /* Don't do nonblock here, must give enough processing time
2103 for tagcache thread. */
2104 /* info.timeout = TIMEOUT_NOBLOCK; */
2105 info.timeout = 1;
2106 tagcache_screensync_enable(true);
2107 return simplelist_show_list(&info);
2108 }
2109 #endif
2110
2111 #if CONFIG_CPU == SH7034
2112 static bool dbg_save_roms(void)
2113 {
2114 int fd;
2115 int oldmode = system_memory_guard(MEMGUARD_NONE);
2116
2117 fd = creat("/internal_rom_0000-FFFF.bin");
2118 if(fd >= 0)
2119 {
2120 write(fd, (void *)0, 0x10000);
2121 close(fd);
2122 }
2123
2124 fd = creat("/internal_rom_2000000-203FFFF.bin");
2125 if(fd >= 0)
2126 {
2127 write(fd, (void *)0x2000000, 0x40000);
2128 close(fd);
2129 }
2130
2131 system_memory_guard(oldmode);
2132 return false;
2133 }
2134 #elif defined CPU_COLDFIRE
2135 static bool dbg_save_roms(void)
2136 {
2137 int fd;
2138 int oldmode = system_memory_guard(MEMGUARD_NONE);
2139
2140 #if defined(IRIVER_H100_SERIES)
2141 fd = creat("/internal_rom_000000-1FFFFF.bin");
2142 #elif defined(IRIVER_H300_SERIES)
2143 fd = creat("/internal_rom_000000-3FFFFF.bin");
2144 #elif defined(IAUDIO_X5) || defined(IAUDIO_M5) || defined(IAUDIO_M3)
2145 fd = creat("/internal_rom_000000-3FFFFF.bin");
2146 #endif
2147 if(fd >= 0)
2148 {
2149 write(fd, (void *)0, FLASH_SIZE);
2150 close(fd);
2151 }
2152 system_memory_guard(oldmode);
2153
2154 #ifdef HAVE_EEPROM
2155 fd = creat("/internal_eeprom.bin");
2156 if (fd >= 0)
2157 {
2158 int old_irq_level;
2159 char buf[EEPROM_SIZE];
2160 int err;
2161
2162 old_irq_level = disable_irq_save();
2163
2164 err = eeprom_24cxx_read(0, buf, sizeof buf);
2165
2166 restore_irq(old_irq_level);
2167
2168 if (err)
2169 splashf(HZ*3, "Eeprom read failure (%d)", err);
2170 else
2171 {
2172 write(fd, buf, sizeof buf);
2173 }
2174
2175 close(fd);
2176 }
2177 #endif
2178
2179 return false;
2180 }
2181 #elif defined(CPU_PP) && !(CONFIG_STORAGE & STORAGE_SD)
2182 static bool dbg_save_roms(void)
2183 {
2184 int fd;
2185
2186 fd = creat("/internal_rom_000000-0FFFFF.bin");
2187 if(fd >= 0)
2188 {
2189 write(fd, (void *)0x20000000, FLASH_SIZE);
2190 close(fd);
2191 }
2192
2193 return false;
2194 }
2195 #elif CONFIG_CPU == IMX31L
2196 static bool dbg_save_roms(void)
2197 {
2198 int fd;
2199
2200 fd = creat("/flash_rom_A0000000-A01FFFFF.bin");
2201 if (fd >= 0)
2202 {
2203 write(fd, (void*)0xa0000000, FLASH_SIZE);
2204 close(fd);
2205 }
2206
2207 return false;
2208 }
2209 #elif defined(CPU_TCC780X)
2210 static bool dbg_save_roms(void)
2211 {
2212 int fd;
2213
2214 fd = creat("/eeprom_E0000000-E0001FFF.bin");
2215 if (fd >= 0)
2216 {
2217 write(fd, (void*)0xe0000000, 0x2000);
2218 close(fd);
2219 }
2220
2221 return false;
2222 }
2223 #endif /* CPU */
2224
2225 #ifndef SIMULATOR
2226 #if CONFIG_TUNER
2227 static int radio_callback(int btn, struct gui_synclist *lists)
2228 {
2229 (void)lists;
2230 if (btn == ACTION_STD_CANCEL)
2231 return btn;
2232 simplelist_set_line_count(1);
2233
2234 #if (CONFIG_TUNER & LV24020LP)
2235 simplelist_addline(SIMPLELIST_ADD_LINE,
2236 "CTRL_STAT: %02X", lv24020lp_get(LV24020LP_CTRL_STAT) );
2237 simplelist_addline(SIMPLELIST_ADD_LINE,
2238 "RADIO_STAT: %02X", lv24020lp_get(LV24020LP_REG_STAT) );
2239 simplelist_addline(SIMPLELIST_ADD_LINE,
2240 "MSS_FM: %d kHz", lv24020lp_get(LV24020LP_MSS_FM) );
2241 simplelist_addline(SIMPLELIST_ADD_LINE,
2242 "MSS_IF: %d Hz", lv24020lp_get(LV24020LP_MSS_IF) );
2243 simplelist_addline(SIMPLELIST_ADD_LINE,
2244 "MSS_SD: %d Hz", lv24020lp_get(LV24020LP_MSS_SD) );
2245 simplelist_addline(SIMPLELIST_ADD_LINE,
2246 "if_set: %d Hz", lv24020lp_get(LV24020LP_IF_SET) );
2247 simplelist_addline(SIMPLELIST_ADD_LINE,
2248 "sd_set: %d Hz", lv24020lp_get(LV24020LP_SD_SET) );
2249 #endif /* LV24020LP */
2250 #if (CONFIG_TUNER & S1A0903X01)
2251 simplelist_addline(SIMPLELIST_ADD_LINE,
2252 "Samsung regs: %08X", s1a0903x01_get(RADIO_ALL));
2253 /* This one doesn't return dynamic data atm */
2254 #endif /* S1A0903X01 */
2255 #if (CONFIG_TUNER & TEA5767)
2256 struct tea5767_dbg_info nfo;
2257 tea5767_dbg_info(&nfo);
2258 simplelist_addline(SIMPLELIST_ADD_LINE, "Philips regs:");
2259 simplelist_addline(SIMPLELIST_ADD_LINE,
2260 " Read: %02X %02X %02X %02X %02X",
2261 (unsigned)nfo.read_regs[0], (unsigned)nfo.read_regs[1],
2262 (unsigned)nfo.read_regs[2], (unsigned)nfo.read_regs[3],
2263 (unsigned)nfo.read_regs[4]);
2264 simplelist_addline(SIMPLELIST_ADD_LINE,
2265 " Write: %02X %02X %02X %02X %02X",
2266 (unsigned)nfo.write_regs[0], (unsigned)nfo.write_regs[1],
2267 (unsigned)nfo.write_regs[2], (unsigned)nfo.write_regs[3],
2268 (unsigned)nfo.write_regs[4]);
2269 #endif /* TEA5767 */
2270 #if (CONFIG_TUNER & SI4700)
2271 struct si4700_dbg_info nfo;
2272 si4700_dbg_info(&nfo);
2273 simplelist_addline(SIMPLELIST_ADD_LINE, "SI4700 regs:");
2274 /* Registers */
2275 simplelist_addline(SIMPLELIST_ADD_LINE,
2276 "%04X %04X %04X %04X",
2277 (unsigned)nfo.regs[0], (unsigned)nfo.regs[1],
2278 (unsigned)nfo.regs[2], (unsigned)nfo.regs[3]);
2279 simplelist_addline(SIMPLELIST_ADD_LINE,
2280 "%04X %04X %04X %04X",
2281 (unsigned)nfo.regs[4], (unsigned)nfo.regs[5],
2282 (unsigned)nfo.regs[6], (unsigned)nfo.regs[7]);
2283 simplelist_addline(SIMPLELIST_ADD_LINE,
2284 "%04X %04X %04X %04X",
2285 (unsigned)nfo.regs[8], (unsigned)nfo.regs[9],
2286 (unsigned)nfo.regs[10], (unsigned)nfo.regs[11]);
2287 simplelist_addline(SIMPLELIST_ADD_LINE,
2288 "%04X %04X %04X %04X",
2289 (unsigned)nfo.regs[12], (unsigned)nfo.regs[13],
2290 (unsigned)nfo.regs[14], (unsigned)nfo.regs[15]);
2291 #endif /* SI4700 */
2292 return ACTION_REDRAW;
2293 }
2294 static bool dbg_fm_radio(void)
2295 {
2296 struct simplelist_info info;
2297 info.scroll_all = true;
2298 simplelist_info_init(&info, "FM Radio", 1, NULL);
2299 simplelist_set_line_count(0);
2300 simplelist_addline(SIMPLELIST_ADD_LINE, "HW detected: %s",
2301 radio_hardware_present() ? "yes" : "no");
2302
2303 info.action_callback = radio_hardware_present()?radio_callback : NULL;
2304 info.hide_selection = true;
2305 return simplelist_show_list(&info);
2306 }
2307 #endif /* CONFIG_TUNER */
2308 #endif /* !SIMULATOR */
2309
2310 #ifdef HAVE_LCD_BITMAP
2311 extern bool do_screendump_instead_of_usb;
2312
2313 static bool dbg_screendump(void)
2314 {
2315 do_screendump_instead_of_usb = !do_screendump_instead_of_usb;
2316 splashf(HZ, "Screendump %s",
2317 do_screendump_instead_of_usb?"enabled":"disabled");
2318 return false;
2319 }
2320 #endif /* HAVE_LCD_BITMAP */
2321
2322 #if CONFIG_CPU == SH7034 || defined(CPU_COLDFIRE)
2323 static bool dbg_set_memory_guard(void)
2324 {
2325 static const struct opt_items names[MAXMEMGUARD] = {
2326 { "None", -1 },
2327 { "Flash ROM writes", -1 },
2328 { "Zero area (all)", -1 }
2329 };
2330 int mode = system_memory_guard(MEMGUARD_KEEP);
2331
2332 set_option( "Catch mem accesses", &mode, INT, names, MAXMEMGUARD, NULL);
2333 system_memory_guard(mode);
2334
2335 return false;
2336 }
2337 #endif /* CONFIG_CPU == SH7034 || defined(CPU_COLDFIRE) */
2338
2339 #if defined(HAVE_EEPROM) && !defined(HAVE_EEPROM_SETTINGS)
2340 static bool dbg_write_eeprom(void)
2341 {
2342 int fd;
2343 int rc;
2344 int old_irq_level;
2345 char buf[EEPROM_SIZE];
2346 int err;
2347
2348 fd = open("/internal_eeprom.bin", O_RDONLY);
2349
2350 if (fd >= 0)
2351 {
2352 rc = read(fd, buf, EEPROM_SIZE);
2353
2354 if(rc == EEPROM_SIZE)
2355 {
2356 old_irq_level = disable_irq_save();
2357
2358 err = eeprom_24cxx_write(0, buf, sizeof buf);
2359 if (err)
2360 splashf(HZ*3, "Eeprom write failure (%d)", err);
2361 else
2362 splash(HZ*3, "Eeprom written successfully");
2363
2364 restore_irq(old_irq_level);
2365 }
2366 else
2367 {
2368 splashf(HZ*3, "File read error (%d)",rc);
2369 }
2370 close(fd);
2371 }
2372 else
2373 {
2374 splash(HZ*3, "Failed to open 'internal_eeprom.bin'");
2375 }
2376
2377 return false;
2378 }
2379 #endif /* defined(HAVE_EEPROM) && !defined(HAVE_EEPROM_SETTINGS) */
2380 #ifdef CPU_BOOST_LOGGING
2381 static bool cpu_boost_log(void)
2382 {
2383 int i = 0,j=0;
2384 int count = cpu_boost_log_getcount();
2385 int lines = LCD_HEIGHT/SYSFONT_HEIGHT;
2386 char *str;
2387 bool done;
2388 lcd_setfont(FONT_SYSFIXED);
2389 str = cpu_boost_log_getlog_first();
2390 while (i < count)
2391 {
2392 lcd_clear_display();
2393 for(j=0; j<lines; j++,i++)
2394 {
2395 if (!str)
2396 str = cpu_boost_log_getlog_next();
2397 if (str)
2398 {
2399 if(strlen(str) > LCD_WIDTH/SYSFONT_WIDTH)
2400 lcd_puts_scroll(0, j, str);
2401 else
2402 lcd_puts(0, j,str);
2403 }
2404 str = NULL;
2405 }
2406 lcd_update();
2407 done = false;
2408 while (!done)
2409 {
2410 switch(get_action(CONTEXT_STD,TIMEOUT_BLOCK))
2411 {
2412 case ACTION_STD_OK:
2413 case ACTION_STD_PREV:
2414 case ACTION_STD_NEXT:
2415 done = true;
2416 break;
2417 case ACTION_STD_CANCEL:
2418 i = count;
2419 done = true;
2420 break;
2421 }
2422 }
2423 }
2424 get_action(CONTEXT_STD,TIMEOUT_BLOCK);
2425 lcd_setfont(FONT_UI);
2426 return false;
2427 }
2428 #endif
2429
2430 #if (defined(HAVE_WHEEL_ACCELERATION) && (CONFIG_KEYPAD==IPOD_4G_PAD) && !defined(SIMULATOR))
2431 extern bool wheel_is_touched;
2432 extern int old_wheel_value;
2433 extern int new_wheel_value;
2434 extern int wheel_delta;
2435 extern unsigned int accumulated_wheel_delta;
2436 extern unsigned int wheel_velocity;
2437
2438 static bool dbg_scrollwheel(void)
2439 {
2440 unsigned int speed;
2441
2442 lcd_setfont(FONT_SYSFIXED);
2443
2444 while (1)
2445 {
2446 if (action_userabort(HZ/10))
2447 break;
2448
2449 lcd_clear_display();
2450
2451 /* show internal variables of scrollwheel driver */
2452 lcd_putsf(0, 0, "wheel touched: %s", (wheel_is_touched) ? "true" : "false");
2453 lcd_putsf(0, 1, "new position: %2d", new_wheel_value);
2454 lcd_putsf(0, 2, "old position: %2d", old_wheel_value);
2455 lcd_putsf(0, 3, "wheel delta: %2d", wheel_delta);
2456 lcd_putsf(0, 4, "accumulated delta: %2d", accumulated_wheel_delta);
2457 lcd_putsf(0, 5, "velo [deg/s]: %4d", (int)wheel_velocity);
2458
2459 /* show effective accelerated scrollspeed */
2460 speed = button_apply_acceleration( (1<<31)|(1<<24)|wheel_velocity);
2461 lcd_putsf(0, 6, "accel. speed: %4d", speed);
2462
2463 lcd_update();
2464 }
2465 lcd_setfont(FONT_UI);
2466 return false;
2467 }
2468 #endif
2469
2470 #if defined (HAVE_USBSTACK)
2471
2472 #if defined(ROCKBOX_HAS_LOGF) && defined(USB_ENABLE_SERIAL)
2473 static bool toggle_usb_core_driver(int driver, char *msg)
2474 {
2475 bool enabled = !usb_core_driver_enabled(driver);
2476
2477 usb_core_enable_driver(driver,enabled);
2478 splashf(HZ, "%s %s", msg, enabled?"enabled":"disabled");
2479
2480 return false;
2481 }
2482
2483 static bool toggle_usb_serial(void)
2484 {
2485 return toggle_usb_core_driver(USB_DRIVER_SERIAL,"USB Serial");
2486 }
2487 #endif
2488
2489 #endif
2490
2491 #if CONFIG_USBOTG == USBOTG_ISP1583
2492 extern int dbg_usb_num_items(void);
2493 extern const char* dbg_usb_item(int selected_item, void *data,
2494 char *buffer, size_t buffer_len);
2495
2496 static int isp1583_action_callback(int action, struct gui_synclist *lists)
2497 {
2498 (void)lists;
2499 if (action == ACTION_NONE)
2500 action = ACTION_REDRAW;
2501 return action;
2502 }
2503
2504 static bool dbg_isp1583(void)
2505 {
2506 struct simplelist_info isp1583;
2507 isp1583.scroll_all = true;
2508 simplelist_info_init(&isp1583, "ISP1583", dbg_usb_num_items(), NULL);
2509 isp1583.timeout = HZ/100;
2510 isp1583.hide_selection = true;
2511 isp1583.get_name = dbg_usb_item;
2512 isp1583.action_callback = isp1583_action_callback;
2513 return simplelist_show_list(&isp1583);
2514 }
2515 #endif
2516
2517 #if defined(CREATIVE_ZVx) && !defined(SIMULATOR)
2518 extern int pic_dbg_num_items(void);
2519 extern const char* pic_dbg_item(int selected_item, void *data,
2520 char *buffer, size_t buffer_len);
2521
2522 static int pic_action_callback(int action, struct gui_synclist *lists)
2523 {
2524 (void)lists;
2525 if (action == ACTION_NONE)
2526 action = ACTION_REDRAW;
2527 return action;
2528 }
2529
2530 static bool dbg_pic(void)
2531 {
2532 struct simplelist_info pic;
2533 pic.scroll_all = true;
2534 simplelist_info_init(&pic, "PIC", pic_dbg_num_items(), NULL);
2535 pic.timeout = HZ/100;
2536 pic.hide_selection = true;
2537 pic.get_name = pic_dbg_item;
2538 pic.action_callback = pic_action_callback;
2539 return simplelist_show_list(&pic);
2540 }
2541 #endif
2542
2543
2544 /****** The menu *********/
2545 struct the_menu_item {
2546 unsigned char *desc; /* string or ID */
2547 bool (*function) (void); /* return true if USB was connected */
2548 };
2549 static const struct the_menu_item menuitems[] = {
2550 #if CONFIG_CPU == SH7034 || defined(CPU_COLDFIRE) || \
2551 (defined(CPU_PP) && !(CONFIG_STORAGE & STORAGE_SD)) || \
2552 CONFIG_CPU == IMX31L || defined(CPU_TCC780X)
2553 { "Dump ROM contents", dbg_save_roms },
2554 #endif
2555 #if CONFIG_CPU == SH7034 || defined(CPU_COLDFIRE) || defined(CPU_PP) \
2556 || CONFIG_CPU == S3C2440 || CONFIG_CPU == IMX31L || CONFIG_CPU == AS3525 \
2557 || CONFIG_CPU == DM320 || defined(CPU_S5L870X)
2558 { "View I/O ports", dbg_ports },
2559 #endif
2560 #if (CONFIG_RTC == RTC_PCF50605) && !defined(SIMULATOR)
2561 { "View PCF registers", dbg_pcf },
2562 #endif
2563 #if defined(HAVE_TSC2100) && !defined(SIMULATOR)
2564 { "TSC2100 debug", tsc2100_debug },
2565 #endif
2566 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
2567 { "CPU frequency", dbg_cpufreq },
2568 #endif
2569 #if defined(IRIVER_H100_SERIES) && !defined(SIMULATOR)
2570 { "S/PDIF analyzer", dbg_spdif },
2571 #endif
2572 #if CONFIG_CPU == SH7034 || defined(CPU_COLDFIRE)
2573 { "Catch mem accesses", dbg_set_memory_guard },
2574 #endif
2575 { "View OS stacks", dbg_os },
2576 #ifdef HAVE_LCD_BITMAP
2577 #ifndef SIMULATOR
2578 { "View battery", view_battery },
2579 #endif
2580 { "Screendump", dbg_screendump },
2581 #endif
2582 #ifndef SIMULATOR
2583 { "View HW info", dbg_hw_info },
2584 #endif
2585 #ifndef SIMULATOR
2586 { "View partitions", dbg_partitions },
2587 #endif
2588 #ifndef SIMULATOR
2589 { "View disk info", dbg_disk_info },
2590 #if (CONFIG_STORAGE & STORAGE_ATA)
2591 { "Dump ATA identify info", dbg_identify_info},
2592 #endif
2593 #endif
2594 #ifdef HAVE_DIRCACHE
2595 { "View dircache info", dbg_dircache_info },
2596 #endif
2597 #ifdef HAVE_TAGCACHE
2598 { "View database info", dbg_tagcache_info },
2599 #endif
2600 #ifdef HAVE_LCD_BITMAP
2601 #if CONFIG_CODEC == SWCODEC
2602 { "View buffering thread", dbg_buffering_thread },
2603 #elif !defined(SIMULATOR)
2604 { "View audio thread", dbg_audio_thread },
2605 #endif
2606 #ifdef PM_DEBUG
2607 { "pm histogram", peak_meter_histogram},
2608 #endif /* PM_DEBUG */
2609 #endif /* HAVE_LCD_BITMAP */
2610 #ifndef SIMULATOR
2611 #if CONFIG_TUNER
2612 { "FM Radio", dbg_fm_radio },
2613 #endif
2614 #endif
2615 #if defined(HAVE_EEPROM) && !defined(HAVE_EEPROM_SETTINGS)
2616 { "Write back EEPROM", dbg_write_eeprom },
2617 #endif
2618 #if CONFIG_USBOTG == USBOTG_ISP1583
2619 { "View ISP1583 info", dbg_isp1583 },
2620 #endif
2621 #if defined(CREATIVE_ZVx) && !defined(SIMULATOR)
2622 { "View PIC info", dbg_pic },
2623 #endif
2624 #ifdef ROCKBOX_HAS_LOGF
2625 {"logf", logfdisplay },
2626 {"logfdump", logfdump },
2627 #endif
2628 #if defined(HAVE_USBSTACK)
2629 #if defined(ROCKBOX_HAS_LOGF) && defined(USB_ENABLE_SERIAL)
2630 {"USB Serial driver (logf)", toggle_usb_serial },
2631 #endif
2632 #endif /* HAVE_USBSTACK */
2633 #ifdef CPU_BOOST_LOGGING
2634 {"cpu_boost log",cpu_boost_log},
2635 #endif
2636 #if (defined(HAVE_WHEEL_ACCELERATION) && (CONFIG_KEYPAD==IPOD_4G_PAD) && !defined(SIMULATOR))
2637 {"Debug scrollwheel", dbg_scrollwheel },
2638 #endif
2639 };
2640 static int menu_action_callback(int btn, struct gui_synclist *lists)
2641 {
2642 if (btn == ACTION_STD_OK)
2643 {
2644 int oldbars = viewportmanager_set_statusbar(VP_SB_HIDE_ALL);
2645 menuitems[gui_synclist_get_sel_pos(lists)].function();
2646 btn = ACTION_REDRAW;
2647 send_event(GUI_EVENT_REFRESH, NULL);
2648 viewportmanager_set_statusbar(oldbars);
2649 }
2650 return btn;
2651 }
2652
2653 static const char* dbg_menu_getname(int item, void * data,
2654 char *buffer, size_t buffer_len)
2655 {
2656 (void)data; (void)buffer; (void)buffer_len;
2657 return menuitems[item].desc;
2658 }
2659
2660 bool debug_menu(void)
2661 {
2662 struct simplelist_info info;
2663
2664 simplelist_info_init(&info, "Debug Menu", ARRAYLEN(menuitems), NULL);
2665 info.action_callback = menu_action_callback;
2666 info.get_name = dbg_menu_getname;
2667 return simplelist_show_list(&info);
2668 }
My public Rockbox git repo