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