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