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