?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Rockbox Utility: add missing folder to deployment script.
[maemo-rb.git] / apps / debug_menu.c
blob8e1abdd1616a1e24de4b780f39fc50ef60cb62fa
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 "lang.h"
29 #include "menu.h"
30 #include "debug_menu.h"
31 #include "kernel.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 "shortcuts.h"
50 #include "dircache.h"
51 #include "viewport.h"
52 #ifdef HAVE_TAGCACHE
53 #include "tagcache.h"
54 #endif
55 #include "lcd-remote.h"
56 #include "crc32.h"
57 #include "logf.h"
58 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
59 #include "disk.h"
60 #include "adc.h"
61 #include "usb.h"
62 #include "rtc.h"
63 #include "storage.h"
64 #include "fat.h"
65 #include "eeprom_24cxx.h"
66 #if (CONFIG_STORAGE & STORAGE_MMC) || (CONFIG_STORAGE & STORAGE_SD)
67 #include "sdmmc.h"
68 #endif
69 #if (CONFIG_STORAGE & STORAGE_ATA)
70 #include "ata.h"
71 #endif
72 #if CONFIG_TUNER
73 #include "tuner.h"
74 #include "radio.h"
75 #endif
76 #endif
77 #include "power.h"
78
79 #ifdef HAVE_LCD_BITMAP
80 #include "scrollbar.h"
81 #include "peakmeter.h"
82 #endif
83 #include "logfdisp.h"
84 #include "core_alloc.h"
85 #if CONFIG_CODEC == SWCODEC
86 #include "pcmbuf.h"
87 #include "buffering.h"
88 #include "playback.h"
89 #if defined(HAVE_SPDIF_OUT) || defined(HAVE_SPDIF_IN)
90 #include "spdif.h"
91 #endif
92 #endif
93 #ifdef IRIVER_H300_SERIES
94 #include "pcf50606.h" /* for pcf50606_read */
95 #endif
96 #ifdef IAUDIO_X5
97 #include "ds2411.h"
98 #endif
99 #include "hwcompat.h"
100 #include "button.h"
101 #if CONFIG_RTC == RTC_PCF50605
102 #include "pcf50605.h"
103 #endif
104 #include "appevents.h"
105 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
106 #include "debug-target.h"
107 #endif
108
109 #if defined(SANSA_E200) || defined(SANSA_C200) || defined(PHILIPS_SA9200) \
110 || (CONFIG_CPU == AS3525 && defined(CONFIG_CHARGING)) \
111 || CONFIG_CPU == AS3525v2
112 #include "ascodec.h"
113 #include "as3514.h"
114 #endif
115
116 #ifdef IPOD_NANO2G
117 #include "pmu-target.h"
118 #endif
119
120 #ifdef HAVE_USBSTACK
121 #include "usb_core.h"
122 #endif
123
124 #if defined(IPOD_ACCESSORY_PROTOCOL)
125 #include "iap.h"
126 #endif
127
128 /*---------------------------------------------------*/
129 /* SPECIAL DEBUG STUFF */
130 /*---------------------------------------------------*/
131 extern struct thread_entry threads[MAXTHREADS];
132
133 static char thread_status_char(unsigned status)
134 {
135 static const char thread_status_chars[THREAD_NUM_STATES+1] =
136 {
137 [0 ... THREAD_NUM_STATES] = '?',
138 [STATE_RUNNING] = 'R',
139 [STATE_BLOCKED] = 'B',
140 [STATE_SLEEPING] = 'S',
141 [STATE_BLOCKED_W_TMO] = 'T',
142 [STATE_FROZEN] = 'F',
143 [STATE_KILLED] = 'K',
144 };
145
146 if (status > THREAD_NUM_STATES)
147 status = THREAD_NUM_STATES;
148
149 return thread_status_chars[status];
150 }
151
152 static const char* threads_getname(int selected_item, void *data,
153 char *buffer, size_t buffer_len)
154 {
155 (void)data;
156 struct thread_entry *thread;
157 char name[32];
158
159 #if NUM_CORES > 1
160 if (selected_item < (int)NUM_CORES)
161 {
162 snprintf(buffer, buffer_len, "Idle (%d): %2d%%", selected_item,
163 idle_stack_usage(selected_item));
164 return buffer;
165 }
166
167 selected_item -= NUM_CORES;
168 #endif
169
170 thread = &threads[selected_item];
171
172 if (thread->state == STATE_KILLED)
173 {
174 snprintf(buffer, buffer_len, "%2d: ---", selected_item);
175 return buffer;
176 }
177
178 thread_get_name(name, 32, thread);
179
180 snprintf(buffer, buffer_len,
181 "%2d: " IF_COP("(%d) ") "%c%c " IF_PRIO("%d %d ") "%2d%% %s",
182 selected_item,
183 IF_COP(thread->core,)
184 #ifdef HAVE_SCHEDULER_BOOSTCTRL
185 (thread->cpu_boost) ? '+' :
186 #endif
187 ((thread->state == STATE_RUNNING) ? '*' : ' '),
188 thread_status_char(thread->state),
189 IF_PRIO(thread->base_priority, thread->priority, )
190 thread_stack_usage(thread), name);
191
192 return buffer;
193 }
194
195 static int dbg_threads_action_callback(int action, struct gui_synclist *lists)
196 {
197 (void)lists;
198 #ifdef ROCKBOX_HAS_LOGF
199 if (action == ACTION_STD_OK)
200 {
201 int selpos = gui_synclist_get_sel_pos(lists);
202 #if NUM_CORES > 1
203 if (selpos >= NUM_CORES)
204 remove_thread(threads[selpos - NUM_CORES].id);
205 #else
206 remove_thread(threads[selpos].id);
207 #endif
208 return ACTION_REDRAW;
209 }
210 #endif /* ROCKBOX_HAS_LOGF */
211 if (action == ACTION_NONE)
212 action = ACTION_REDRAW;
213 return action;
214 }
215 /* Test code!!! */
216 static bool dbg_os(void)
217 {
218 struct simplelist_info info;
219 simplelist_info_init(&info, IF_COP("Core and ") "Stack usage:",
220 #if NUM_CORES == 1
221 MAXTHREADS,
222 #else
223 MAXTHREADS+NUM_CORES,
224 #endif
225 NULL);
226 #ifndef ROCKBOX_HAS_LOGF
227 info.hide_selection = true;
228 info.scroll_all = true;
229 #endif
230 info.action_callback = dbg_threads_action_callback;
231 info.get_name = threads_getname;
232 return simplelist_show_list(&info);
233 }
234
235 #ifdef __linux__
236 #include "cpuinfo-linux.h"
237
238 #define MAX_STATES 16
239 static struct time_state states[MAX_STATES];
240
241 static const char* get_cpuinfo(int selected_item, void *data,
242 char *buffer, size_t buffer_len)
243 {
244 (void)data;(void)buffer_len;
245 const char* text;
246 long time, diff;
247 struct cpuusage us;
248 static struct cpuusage last_us;
249 int state_count = *(int*)data;
250
251 if (cpuusage_linux(&us) != 0)
252 return NULL;
253
254 switch(selected_item)
255 {
256 case 0:
257 diff = abs(last_us.usage - us.usage);
258 sprintf(buffer, "Usage: %ld.%02ld%% (%c %ld.%02ld)",
259 us.usage/100, us.usage%100,
260 (us.usage >= last_us.usage) ? '+':'-',
261 diff/100, diff%100);
262 last_us.usage = us.usage;
263 return buffer;
264 case 1:
265 text = "User";
266 time = us.utime;
267 diff = us.utime - last_us.utime;
268 last_us.utime = us.utime;
269 break;
270 case 2:
271 text = "Sys";
272 time = us.stime;
273 diff = us.stime - last_us.stime;
274 last_us.stime = us.stime;
275 break;
276 case 3:
277 text = "Real";
278 time = us.rtime;
279 diff = us.rtime - last_us.rtime;
280 last_us.rtime = us.rtime;
281 break;
282 case 4:
283 return "*** Per CPU freq stats ***";
284 default:
285 {
286 int cpu = (selected_item - 5) / (state_count + 1);
287 int cpu_line = (selected_item - 5) % (state_count + 1);
288 int freq1 = frequency_linux(cpu, false);
289 int freq2 = frequency_linux(cpu, true);
290 if (cpu_line == 0)
291 {
292 sprintf(buffer, " CPU%d: Cur/Scal freq: %d/%d MHz", cpu,
293 freq1 > 0 ? freq1/1000 : -1,
294 freq2 > 0 ? freq2/1000 : -1);
295 }
296 else
297 {
298 cpustatetimes_linux(cpu, states, ARRAYLEN(states));
299 snprintf(buffer, buffer_len, " %ld %ld",
300 states[cpu_line-1].frequency,
301 states[cpu_line-1].time);
302 }
303 return buffer;
304 }
305 }
306 sprintf(buffer, "%s: %ld.%02lds (+ %ld.%02ld)", text,
307 time / us.hz, time % us.hz,
308 diff / us.hz, diff % us.hz);
309 return buffer;
310 }
311
312 static int cpuinfo_cb(int action, struct gui_synclist *lists)
313 {
314 (void)lists;
315 if (action == ACTION_NONE)
316 action = ACTION_REDRAW;
317 return action;
318 }
319
320 static bool dbg_cpuinfo(void)
321 {
322 struct simplelist_info info;
323 int cpu_count = MAX(cpucount_linux(), 1);
324 int state_count = cpustatetimes_linux(0, states, ARRAYLEN(states));
325 printf("%s(): %d %d\n", __func__, cpu_count, state_count);
326 simplelist_info_init(&info, "CPU info:", 5 + cpu_count*(state_count+1), &state_count);
327 info.get_name = get_cpuinfo;
328 info.action_callback = cpuinfo_cb;
329 info.timeout = HZ;
330 info.hide_selection = true;
331 info.scroll_all = true;
332 return simplelist_show_list(&info);
333 }
334
335 #endif
336
337 #ifdef HAVE_LCD_BITMAP
338 #if CONFIG_CODEC != SWCODEC
339 #ifndef SIMULATOR
340 static bool dbg_audio_thread(void)
341 {
342 struct audio_debug d;
343
344 lcd_setfont(FONT_SYSFIXED);
345
346 while(1)
347 {
348 if (action_userabort(HZ/5))
349 return false;
350
351 audio_get_debugdata(&d);
352
353 lcd_clear_display();
354
355 lcd_putsf(0, 0, "read: %x", d.audiobuf_read);
356 lcd_putsf(0, 1, "write: %x", d.audiobuf_write);
357 lcd_putsf(0, 2, "swap: %x", d.audiobuf_swapwrite);
358 lcd_putsf(0, 3, "playing: %d", d.playing);
359 lcd_putsf(0, 4, "playable: %x", d.playable_space);
360 lcd_putsf(0, 5, "unswapped: %x", d.unswapped_space);
361
362 /* Playable space left */
363 gui_scrollbar_draw(&screens[SCREEN_MAIN],0, 6*8, 112, 4, d.audiobuflen, 0,
364 d.playable_space, HORIZONTAL);
365
366 /* Show the watermark limit */
367 gui_scrollbar_draw(&screens[SCREEN_MAIN],0, 6*8+4, 112, 4, d.audiobuflen, 0,
368 d.low_watermark_level, HORIZONTAL);
369
370 lcd_putsf(0, 7, "wm: %x - %x",
371 d.low_watermark_level, d.lowest_watermark_level);
372
373 lcd_update();
374 }
375 lcd_setfont(FONT_UI);
376 return false;
377 }
378 #endif /* !SIMULATOR */
379 #else /* CONFIG_CODEC == SWCODEC */
380 static unsigned int ticks, freq_sum;
381 #ifndef CPU_MULTI_FREQUENCY
382 static unsigned int boost_ticks;
383 #endif
384
385 static void dbg_audio_task(void)
386 {
387 #ifdef CPUFREQ_NORMAL
388 #ifndef CPU_MULTI_FREQUENCY
389 if(FREQ > CPUFREQ_NORMAL)
390 boost_ticks++;
391 #endif
392 freq_sum += FREQ/1000000; /* in MHz */
393 #endif
394 ticks++;
395 }
396
397 static bool dbg_buffering_thread(void)
398 {
399 int button;
400 int line;
401 bool done = false;
402 size_t bufused;
403 size_t bufsize = pcmbuf_get_bufsize();
404 int pcmbufdescs = pcmbuf_descs();
405 struct buffering_debug d;
406 size_t filebuflen = audio_get_filebuflen();
407 /* This is a size_t, but call it a long so it puts a - when it's bad. */
408
409 #ifndef CPU_MULTI_FREQUENCY
410 boost_ticks = 0;
411 #endif
412 ticks = freq_sum = 0;
413
414 tick_add_task(dbg_audio_task);
415
416 FOR_NB_SCREENS(i)
417 screens[i].setfont(FONT_SYSFIXED);
418
419 while(!done)
420 {
421 button = get_action(CONTEXT_STD,HZ/5);
422 switch(button)
423 {
424 case ACTION_STD_NEXT:
425 audio_next();
426 break;
427 case ACTION_STD_PREV:
428 audio_prev();
429 break;
430 case ACTION_STD_CANCEL:
431 done = true;
432 break;
433 }
434
435 buffering_get_debugdata(&d);
436 bufused = bufsize - pcmbuf_free();
437
438 FOR_NB_SCREENS(i)
439 {
440 line = 0;
441 screens[i].clear_display();
442
443
444 screens[i].putsf(0, line++, "pcm: %6ld/%ld", (long) bufused, (long) bufsize);
445
446 gui_scrollbar_draw(&screens[i],0, line*8, screens[i].lcdwidth, 6,
447 bufsize, 0, bufused, HORIZONTAL);
448 line++;
449
450 screens[i].putsf(0, line++, "alloc: %6ld/%ld", audio_filebufused(),
451 (long) filebuflen);
452
453 #if LCD_HEIGHT > 80 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_HEIGHT > 80)
454 if (screens[i].lcdheight > 80)
455 {
456 gui_scrollbar_draw(&screens[i],0, line*8, screens[i].lcdwidth, 6,
457 filebuflen, 0, audio_filebufused(), HORIZONTAL);
458 line++;
459
460 screens[i].putsf(0, line++, "real: %6ld/%ld", (long)d.buffered_data,
461 (long)filebuflen);
462
463 gui_scrollbar_draw(&screens[i],0, line*8, screens[i].lcdwidth, 6,
464 filebuflen, 0, (long)d.buffered_data, HORIZONTAL);
465 line++;
466 }
467 #endif
468
469 screens[i].putsf(0, line++, "usefl: %6ld/%ld", (long)(d.useful_data),
470 (long)filebuflen);
471
472 #if LCD_HEIGHT > 80 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_HEIGHT > 80)
473 if (screens[i].lcdheight > 80)
474 {
475 gui_scrollbar_draw(&screens[i],0, line*8, screens[i].lcdwidth, 6,
476 filebuflen, 0, d.useful_data, HORIZONTAL);
477 line++;
478 }
479 #endif
480
481 screens[i].putsf(0, line++, "data_rem: %ld", (long)d.data_rem);
482
483 screens[i].putsf(0, line++, "track count: %2d", audio_track_count());
484
485 screens[i].putsf(0, line++, "handle count: %d", (int)d.num_handles);
486
487 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
488 screens[i].putsf(0, line++, "cpu freq: %3dMHz",
489 (int)((FREQ + 500000) / 1000000));
490 #endif
491
492 if (ticks > 0)
493 {
494 int avgclock = freq_sum * 10 / ticks; /* in 100 kHz */
495 #ifdef CPU_MULTI_FREQUENCY
496 int boostquota = (avgclock * 100 - CPUFREQ_NORMAL/1000) /
497 ((CPUFREQ_MAX - CPUFREQ_NORMAL) / 1000000); /* in 0.1 % */
498 #else
499 int boostquota = boost_ticks * 1000 / ticks; /* in 0.1 % */
500 #endif
501 screens[i].putsf(0, line++, "boost:%3d.%d%% (%d.%dMHz)",
502 boostquota/10, boostquota%10, avgclock/10, avgclock%10);
503 }
504
505 screens[i].putsf(0, line++, "pcmbufdesc: %2d/%2d",
506 pcmbuf_used_descs(), pcmbufdescs);
507 screens[i].putsf(0, line++, "watermark: %6d",
508 (int)(d.watermark));
509
510 screens[i].update();
511 }
512 }
513
514 tick_remove_task(dbg_audio_task);
515
516 FOR_NB_SCREENS(i)
517 screens[i].setfont(FONT_UI);
518
519 return false;
520 }
521 #endif /* CONFIG_CODEC */
522 #endif /* HAVE_LCD_BITMAP */
523
524 static const char* bf_getname(int selected_item, void *data,
525 char *buffer, size_t buffer_len)
526 {
527 (void)data;
528 core_print_block_at(selected_item, buffer, buffer_len);
529 return buffer;
530 }
531
532 static int bf_action_cb(int action, struct gui_synclist* list)
533 {
534 if (action == ACTION_STD_OK)
535 {
536 if (gui_synclist_get_sel_pos(list) == 0 && core_test_free())
537 {
538 splash(HZ, "Freed test handle. New alloc should trigger compact");
539 }
540 else
541 {
542 splash(HZ/1, "Attempting a 64k allocation");
543 int handle = core_alloc("test", 64<<10);
544 splash(HZ/2, (handle > 0) ? "Success":"Fail");
545 /* for some reason simplelist doesn't allow adding items here if
546 * info.get_name is given, so use normal list api */
547 gui_synclist_set_nb_items(list, core_get_num_blocks());
548 if (handle > 0)
549 core_free(handle);
550 }
551 action = ACTION_REDRAW;
552 }
553 else if (action == ACTION_NONE)
554 action = ACTION_REDRAW;
555 return action;
556 }
557
558 static bool dbg_buflib_allocs(void)
559 {
560 struct simplelist_info info;
561 simplelist_info_init(&info, "mem allocs", core_get_num_blocks(), NULL);
562 info.get_name = bf_getname;
563 info.action_callback = bf_action_cb;
564 info.timeout = TIMEOUT_BLOCK;
565 return simplelist_show_list(&info);
566 }
567
568 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
569 static const char* dbg_partitions_getname(int selected_item, void *data,
570 char *buffer, size_t buffer_len)
571 {
572 (void)data;
573 int partition = selected_item/2;
574 struct partinfo* p = disk_partinfo(partition);
575 if (selected_item%2)
576 {
577 snprintf(buffer, buffer_len, " T:%x %ld MB", p->type, p->size / ( 2048 / ( SECTOR_SIZE / 512 )));
578 }
579 else
580 {
581 snprintf(buffer, buffer_len, "P%d: S:%lx", partition, p->start);
582 }
583 return buffer;
584 }
585
586 static bool dbg_partitions(void)
587 {
588 struct simplelist_info info;
589 simplelist_info_init(&info, "Partition Info", 4, NULL);
590 info.selection_size = 2;
591 info.hide_selection = true;
592 info.scroll_all = true;
593 info.get_name = dbg_partitions_getname;
594 return simplelist_show_list(&info);
595 }
596 #endif /* PLATFORM_NATIVE */
597
598 #if defined(CPU_COLDFIRE) && defined(HAVE_SPDIF_OUT)
599 static bool dbg_spdif(void)
600 {
601 int line;
602 unsigned int control;
603 int x;
604 char *s;
605 int category;
606 int generation;
607 unsigned int interruptstat;
608 bool valnogood, symbolerr, parityerr;
609 bool done = false;
610 bool spdif_src_on;
611 int spdif_source = spdif_get_output_source(&spdif_src_on);
612 spdif_set_output_source(AUDIO_SRC_SPDIF IF_SPDIF_POWER_(, true));
613
614 lcd_clear_display();
615 lcd_setfont(FONT_SYSFIXED);
616
617 #ifdef HAVE_SPDIF_POWER
618 spdif_power_enable(true); /* We need SPDIF power for both sending & receiving */
619 #endif
620
621 while (!done)
622 {
623 line = 0;
624
625 control = EBU1RCVCCHANNEL1;
626 interruptstat = INTERRUPTSTAT;
627 INTERRUPTCLEAR = 0x03c00000;
628
629 valnogood = (interruptstat & 0x01000000)?true:false;
630 symbolerr = (interruptstat & 0x00800000)?true:false;
631 parityerr = (interruptstat & 0x00400000)?true:false;
632
633 lcd_putsf(0, line++, "Val: %s Sym: %s Par: %s",
634 valnogood?"--":"OK",
635 symbolerr?"--":"OK",
636 parityerr?"--":"OK");
637
638 lcd_putsf(0, line++, "Status word: %08x", (int)control);
639
640 line++;
641
642 x = control >> 31;
643 lcd_putsf(0, line++, "PRO: %d (%s)",
644 x, x?"Professional":"Consumer");
645
646 x = (control >> 30) & 1;
647 lcd_putsf(0, line++, "Audio: %d (%s)",
648 x, x?"Non-PCM":"PCM");
649
650 x = (control >> 29) & 1;
651 lcd_putsf(0, line++, "Copy: %d (%s)",
652 x, x?"Permitted":"Inhibited");
653
654 x = (control >> 27) & 7;
655 switch(x)
656 {
657 case 0:
658 s = "None";
659 break;
660 case 1:
661 s = "50/15us";
662 break;
663 default:
664 s = "Reserved";
665 break;
666 }
667 lcd_putsf(0, line++, "Preemphasis: %d (%s)", x, s);
668
669 x = (control >> 24) & 3;
670 lcd_putsf(0, line++, "Mode: %d", x);
671
672 category = (control >> 17) & 127;
673 switch(category)
674 {
675 case 0x00:
676 s = "General";
677 break;
678 case 0x40:
679 s = "Audio CD";
680 break;
681 default:
682 s = "Unknown";
683 }
684 lcd_putsf(0, line++, "Category: 0x%02x (%s)", category, s);
685
686 x = (control >> 16) & 1;
687 generation = x;
688 if(((category & 0x70) == 0x10) ||
689 ((category & 0x70) == 0x40) ||
690 ((category & 0x78) == 0x38))
691 {
692 generation = !generation;
693 }
694 lcd_putsf(0, line++, "Generation: %d (%s)",
695 x, generation?"Original":"No ind.");
696
697 x = (control >> 12) & 15;
698 lcd_putsf(0, line++, "Source: %d", x);
699
700
701 x = (control >> 8) & 15;
702 switch(x)
703 {
704 case 0:
705 s = "Unspecified";
706 break;
707 case 8:
708 s = "A (Left)";
709 break;
710 case 4:
711 s = "B (Right)";
712 break;
713 default:
714 s = "";
715 break;
716 }
717 lcd_putsf(0, line++, "Channel: %d (%s)", x, s);
718
719 x = (control >> 4) & 15;
720 switch(x)
721 {
722 case 0:
723 s = "44.1kHz";
724 break;
725 case 0x4:
726 s = "48kHz";
727 break;
728 case 0xc:
729 s = "32kHz";
730 break;
731 }
732 lcd_putsf(0, line++, "Frequency: %d (%s)", x, s);
733
734 x = (control >> 2) & 3;
735 lcd_putsf(0, line++, "Clock accuracy: %d", x);
736 line++;
737
738 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
739 lcd_putsf(0, line++, "Measured freq: %ldHz",
740 spdif_measure_frequency());
741 #endif
742
743 lcd_update();
744
745 if (action_userabort(HZ/10))
746 break;
747 }
748
749 spdif_set_output_source(spdif_source IF_SPDIF_POWER_(, spdif_src_on));
750
751 #ifdef HAVE_SPDIF_POWER
752 spdif_power_enable(global_settings.spdif_enable);
753 #endif
754
755 lcd_setfont(FONT_UI);
756 return false;
757 }
758 #endif /* CPU_COLDFIRE */
759
760 #if (CONFIG_RTC == RTC_PCF50605) && (CONFIG_PLATFORM & PLATFORM_NATIVE)
761 static bool dbg_pcf(void)
762 {
763 int line;
764
765 #ifdef HAVE_LCD_BITMAP
766 lcd_setfont(FONT_SYSFIXED);
767 #endif
768 lcd_clear_display();
769
770 while(1)
771 {
772 line = 0;
773
774 lcd_putsf(0, line++, "DCDC1: %02x", pcf50605_read(0x1b));
775 lcd_putsf(0, line++, "DCDC2: %02x", pcf50605_read(0x1c));
776 lcd_putsf(0, line++, "DCDC3: %02x", pcf50605_read(0x1d));
777 lcd_putsf(0, line++, "DCDC4: %02x", pcf50605_read(0x1e));
778 lcd_putsf(0, line++, "DCDEC1: %02x", pcf50605_read(0x1f));
779 lcd_putsf(0, line++, "DCDEC2: %02x", pcf50605_read(0x20));
780 lcd_putsf(0, line++, "DCUDC1: %02x", pcf50605_read(0x21));
781 lcd_putsf(0, line++, "DCUDC2: %02x", pcf50605_read(0x22));
782 lcd_putsf(0, line++, "IOREGC: %02x", pcf50605_read(0x23));
783 lcd_putsf(0, line++, "D1REGC: %02x", pcf50605_read(0x24));
784 lcd_putsf(0, line++, "D2REGC: %02x", pcf50605_read(0x25));
785 lcd_putsf(0, line++, "D3REGC: %02x", pcf50605_read(0x26));
786 lcd_putsf(0, line++, "LPREG1: %02x", pcf50605_read(0x27));
787 lcd_update();
788 if (action_userabort(HZ/10))
789 {
790 lcd_setfont(FONT_UI);
791 return false;
792 }
793 }
794
795 lcd_setfont(FONT_UI);
796 return false;
797 }
798 #endif
799
800 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
801 static bool dbg_cpufreq(void)
802 {
803 int line;
804 int button;
805
806 #ifdef HAVE_LCD_BITMAP
807 lcd_setfont(FONT_SYSFIXED);
808 #endif
809 lcd_clear_display();
810
811 while(1)
812 {
813 line = 0;
814
815 lcd_putsf(0, line++, "Frequency: %ld", FREQ);
816 lcd_putsf(0, line++, "boost_counter: %d", get_cpu_boost_counter());
817
818 lcd_update();
819 button = get_action(CONTEXT_STD,HZ/10);
820
821 switch(button)
822 {
823 case ACTION_STD_PREV:
824 cpu_boost(true);
825 break;
826
827 case ACTION_STD_NEXT:
828 cpu_boost(false);
829 break;
830
831 case ACTION_STD_OK:
832 while (get_cpu_boost_counter() > 0)
833 cpu_boost(false);
834 set_cpu_frequency(CPUFREQ_DEFAULT);
835 break;
836
837 case ACTION_STD_CANCEL:
838 lcd_setfont(FONT_UI);
839 return false;
840 }
841 }
842 lcd_setfont(FONT_UI);
843 return false;
844 }
845 #endif /* HAVE_ADJUSTABLE_CPU_FREQ */
846
847 #if defined(HAVE_TSC2100) && (CONFIG_PLATFORM & PLATFORM_NATIVE)
848 #include "tsc2100.h"
849 static const char* tsc2100_debug_getname(int selected_item, void * data,
850 char *buffer, size_t buffer_len)
851 {
852 int *page = (int*)data;
853 bool reserved = false;
854 switch (*page)
855 {
856 case 0:
857 if ((selected_item > 0x0a) ||
858 (selected_item == 0x04) ||
859 (selected_item == 0x08))
860 reserved = true;
861 break;
862 case 1:
863 if ((selected_item > 0x05) ||
864 (selected_item == 0x02))
865 reserved = true;
866 break;
867 case 2:
868 if (selected_item > 0x1e)
869 reserved = true;
870 break;
871 }
872 if (reserved)
873 snprintf(buffer, buffer_len, "%02x: RSVD", selected_item);
874 else
875 snprintf(buffer, buffer_len, "%02x: %04x", selected_item,
876 tsc2100_readreg(*page, selected_item)&0xffff);
877 return buffer;
878 }
879 static int tsc2100debug_action_callback(int action, struct gui_synclist *lists)
880 {
881 int *page = (int*)lists->data;
882 if (action == ACTION_STD_OK)
883 {
884 *page = (*page+1)%3;
885 snprintf(lists->title, 32,
886 "tsc2100 registers - Page %d", *page);
887 return ACTION_REDRAW;
888 }
889 return action;
890 }
891 static bool tsc2100_debug(void)
892 {
893 int page = 0;
894 char title[32] = "tsc2100 registers - Page 0";
895 struct simplelist_info info;
896 simplelist_info_init(&info, title, 32, &page);
897 info.timeout = HZ/100;
898 info.get_name = tsc2100_debug_getname;
899 info.action_callback= tsc2100debug_action_callback;
900 return simplelist_show_list(&info);
901 }
902 #endif
903 #if (CONFIG_BATTERY_MEASURE != 0) && defined(HAVE_LCD_BITMAP) && !defined(SIMULATOR)
904 /*
905 * view_battery() shows a automatically scaled graph of the battery voltage
906 * over time. Usable for estimating battery life / charging rate.
907 * The power_history array is updated in power_thread of powermgmt.c.
908 */
909
910 #define BAT_LAST_VAL MIN(LCD_WIDTH, POWER_HISTORY_LEN)
911 #define BAT_TSPACE 20
912 #define BAT_YSPACE (LCD_HEIGHT - BAT_TSPACE)
913
914
915 static bool view_battery(void)
916 {
917 int view = 0;
918 int i, x, y, z, y1, y2, grid, graph;
919 unsigned short maxv, minv;
920
921 lcd_setfont(FONT_SYSFIXED);
922
923 while(1)
924 {
925 lcd_clear_display();
926 switch (view) {
927 case 0: /* voltage history graph */
928 /* Find maximum and minimum voltage for scaling */
929 minv = power_history[0];
930 maxv = minv + 1;
931 for (i = 1; i < BAT_LAST_VAL && power_history[i]; i++) {
932 if (power_history[i] > maxv)
933 maxv = power_history[i];
934 if (power_history[i] < minv)
935 minv = power_history[i];
936 }
937 /* print header */
938 #if (CONFIG_BATTERY_MEASURE & VOLTAGE_MEASURE)
939 /* adjust grid scale */
940 if ((maxv - minv) > 50)
941 grid = 50;
942 else
943 grid = 5;
944
945 lcd_putsf(0, 0, "battery %d.%03dV", power_history[0] / 1000,
946 power_history[0] % 1000);
947 lcd_putsf(0, 1, "%d.%03d-%d.%03dV (%2dmV)",
948 minv / 1000, minv % 1000, maxv / 1000, maxv % 1000,
949 grid);
950 #elif (CONFIG_BATTERY_MEASURE & PERCENTAGE_MEASURE)
951 /* adjust grid scale */
952 if ((maxv - minv) > 10)
953 grid = 10;
954 else
955 grid = 1;
956 lcd_putsf(0, 0, "battery %d%%", power_history[0]);
957 lcd_putsf(0, 1, "%d%%-%d%% (%d %%)", minv, maxv, grid);
958 #endif
959
960 i = 1;
961 while ((y = (minv - (minv % grid)+i*grid)) < maxv)
962 {
963 graph = ((y-minv)*BAT_YSPACE)/(maxv-minv);
964 graph = LCD_HEIGHT-1 - graph;
965
966 /* draw dotted horizontal grid line */
967 for (x=0; x<LCD_WIDTH;x=x+2)
968 lcd_drawpixel(x,graph);
969
970 i++;
971 }
972
973 x = 0;
974 /* draw plot of power history
975 * skip empty entries
976 */
977 for (i = BAT_LAST_VAL - 1; i > 0; i--)
978 {
979 if (power_history[i] && power_history[i-1])
980 {
981 y1 = (power_history[i] - minv) * BAT_YSPACE /
982 (maxv - minv);
983 y1 = MIN(MAX(LCD_HEIGHT-1 - y1, BAT_TSPACE),
984 LCD_HEIGHT-1);
985 y2 = (power_history[i-1] - minv) * BAT_YSPACE /
986 (maxv - minv);
987 y2 = MIN(MAX(LCD_HEIGHT-1 - y2, BAT_TSPACE),
988 LCD_HEIGHT-1);
989
990 lcd_set_drawmode(DRMODE_SOLID);
991
992 /* make line thicker */
993 lcd_drawline(((x*LCD_WIDTH)/(BAT_LAST_VAL)),
994 y1,
995 (((x+1)*LCD_WIDTH)/(BAT_LAST_VAL)),
996 y2);
997 lcd_drawline(((x*LCD_WIDTH)/(BAT_LAST_VAL))+1,
998 y1+1,
999 (((x+1)*LCD_WIDTH)/(BAT_LAST_VAL))+1,
1000 y2+1);
1001 x++;
1002 }
1003 }
1004 break;
1005
1006 case 1: /* status: */
1007 #if CONFIG_CHARGING >= CHARGING_MONITOR
1008 lcd_putsf(0, 0, "Pwr status: %s",
1009 charging_state() ? "charging" : "discharging");
1010 #else
1011 lcd_puts(0, 0, "Power status: unknown");
1012 #endif
1013 battery_read_info(&y, &z);
1014 if (y > 0)
1015 lcd_putsf(0, 1, "Battery: %d.%03d V (%d %%)", y / 1000, y % 1000, z);
1016 else if (z > 0)
1017 lcd_putsf(0, 1, "Battery: %d %%", z);
1018 #ifdef ADC_EXT_POWER
1019 y = (adc_read(ADC_EXT_POWER) * EXT_SCALE_FACTOR) / 1000;
1020 lcd_putsf(0, 2, "External: %d.%03d V", y / 1000, y % 1000);
1021 #endif
1022 #if CONFIG_CHARGING
1023 #if defined ARCHOS_RECORDER
1024 lcd_putsf(0, 3, "Chgr: %s %s",
1025 charger_inserted() ? "present" : "absent",
1026 charger_enabled() ? "on" : "off");
1027 lcd_putsf(0, 5, "short delta: %d", short_delta);
1028 lcd_putsf(0, 6, "long delta: %d", long_delta);
1029 lcd_puts(0, 7, power_message);
1030 lcd_putsf(0, 8, "USB Inserted: %s",
1031 usb_inserted() ? "yes" : "no");
1032 #elif defined IPOD_NANO || defined IPOD_VIDEO
1033 int usb_pwr = (GPIOL_INPUT_VAL & 0x10)?true:false;
1034 int ext_pwr = (GPIOL_INPUT_VAL & 0x08)?false:true;
1035 int dock = (GPIOA_INPUT_VAL & 0x10)?true:false;
1036 int charging = (GPIOB_INPUT_VAL & 0x01)?false:true;
1037 int headphone= (GPIOA_INPUT_VAL & 0x80)?true:false;
1038
1039 lcd_putsf(0, 3, "USB pwr: %s",
1040 usb_pwr ? "present" : "absent");
1041 lcd_putsf(0, 4, "EXT pwr: %s",
1042 ext_pwr ? "present" : "absent");
1043 lcd_putsf(0, 5, "Battery: %s",
1044 charging ? "charging" : (usb_pwr||ext_pwr) ? "charged" : "discharging");
1045 lcd_putsf(0, 6, "Dock mode: %s",
1046 dock ? "enabled" : "disabled");
1047 lcd_putsf(0, 7, "Headphone: %s",
1048 headphone ? "connected" : "disconnected");
1049 #ifdef IPOD_VIDEO
1050 if(probed_ramsize == 64)
1051 x = (adc_read(ADC_4066_ISTAT) * 2400) / (1024 * 2);
1052 else
1053 #endif
1054 x = (adc_read(ADC_4066_ISTAT) * 2400) / (1024 * 3);
1055 lcd_putsf(0, 8, "Ibat: %d mA", x);
1056 lcd_putsf(0, 9, "Vbat * Ibat: %d mW", x * y / 1000);
1057 #elif defined TOSHIBA_GIGABEAT_S
1058 int line = 3;
1059 unsigned int st;
1060
1061 static const unsigned char * const chrgstate_strings[] =
1062 {
1063 "Disabled",
1064 "Error",
1065 "Discharging",
1066 "Precharge",
1067 "Constant Voltage",
1068 "Constant Current",
1069 "<unknown>",
1070 };
1071
1072 lcd_putsf(0, line++, "Charger: %s",
1073 charger_inserted() ? "present" : "absent");
1074
1075 st = power_input_status() &
1076 (POWER_INPUT_CHARGER | POWER_INPUT_BATTERY);
1077 lcd_putsf(0, line++, "%s%s",
1078 (st & POWER_INPUT_MAIN_CHARGER) ? " Main" : "",
1079 (st & POWER_INPUT_USB_CHARGER) ? " USB" : "");
1080
1081 y = ARRAYLEN(chrgstate_strings) - 1;
1082
1083 switch (charge_state)
1084 {
1085 case CHARGE_STATE_DISABLED: y--;
1086 case CHARGE_STATE_ERROR: y--;
1087 case DISCHARGING: y--;
1088 case TRICKLE: y--;
1089 case TOPOFF: y--;
1090 case CHARGING: y--;
1091 default:;
1092 }
1093
1094 lcd_putsf(0, line++, "State: %s", chrgstate_strings[y]);
1095
1096 lcd_putsf(0, line++, "Battery Switch: %s",
1097 (st & POWER_INPUT_BATTERY) ? "On" : "Off");
1098
1099 y = chrgraw_adc_voltage();
1100 lcd_putsf(0, line++, "CHRGRAW: %d.%03d V",
1101 y / 1000, y % 1000);
1102
1103 y = application_supply_adc_voltage();
1104 lcd_putsf(0, line++, "BP : %d.%03d V",
1105 y / 1000, y % 1000);
1106
1107 y = battery_adc_charge_current();
1108 if (y < 0) x = '-', y = -y;
1109 else x = ' ';
1110 lcd_putsf(0, line++, "CHRGISN:%c%d mA", x, y);
1111
1112 y = cccv_regulator_dissipation();
1113 lcd_putsf(0, line++, "P CCCV : %d mW", y);
1114
1115 y = battery_charge_current();
1116 if (y < 0) x = '-', y = -y;
1117 else x = ' ';
1118 lcd_putsf(0, line++, "I Charge:%c%d mA", x, y);
1119
1120 y = battery_adc_temp();
1121
1122 if (y != INT_MIN) {
1123 lcd_putsf(0, line++, "T Battery: %dC (%dF)", y,
1124 (9*y + 160) / 5);
1125 } else {
1126 /* Conversion disabled */
1127 lcd_puts(0, line++, "T Battery: ?");
1128 }
1129
1130 #elif defined(SANSA_E200) || defined(SANSA_C200) || CONFIG_CPU == AS3525 || \
1131 CONFIG_CPU == AS3525v2
1132 static const char * const chrgstate_strings[] =
1133 {
1134 [CHARGE_STATE_DISABLED - CHARGE_STATE_DISABLED]= "Disabled",
1135 [CHARGE_STATE_ERROR - CHARGE_STATE_DISABLED] = "Error",
1136 [DISCHARGING - CHARGE_STATE_DISABLED] = "Discharging",
1137 [CHARGING - CHARGE_STATE_DISABLED] = "Charging",
1138 };
1139 const char *str = NULL;
1140
1141 lcd_putsf(0, 3, "Charger: %s",
1142 charger_inserted() ? "present" : "absent");
1143
1144 y = charge_state - CHARGE_STATE_DISABLED;
1145 if ((unsigned)y < ARRAYLEN(chrgstate_strings))
1146 str = chrgstate_strings[y];
1147
1148 lcd_putsf(0, 4, "State: %s",
1149 str ? str : "<unknown>");
1150
1151 lcd_putsf(0, 5, "CHARGER: %02X", ascodec_read_charger());
1152 #elif defined(IPOD_NANO2G)
1153 y = pmu_read_battery_voltage();
1154 lcd_putsf(17, 1, "RAW: %d.%03d V", y / 1000, y % 1000);
1155 y = pmu_read_battery_current();
1156 lcd_putsf(0, 2, "Battery current: %d mA", y);
1157 lcd_putsf(0, 3, "PWRCON: %08x %08x", PWRCON, PWRCONEXT);
1158 lcd_putsf(0, 4, "CLKCON: %08x %03x %03x", CLKCON, CLKCON2, CLKCON3);
1159 lcd_putsf(0, 5, "PLL: %06x %06x %06x", PLL0PMS, PLL1PMS, PLL2PMS);
1160 x = pmu_read(0x1b) & 0xf;
1161 y = pmu_read(0x1a) * 25 + 625;
1162 lcd_putsf(0, 6, "AUTO: %x / %d mV", x, y);
1163 x = pmu_read(0x1f) & 0xf;
1164 y = pmu_read(0x1e) * 25 + 625;
1165 lcd_putsf(0, 7, "DOWN1: %x / %d mV", x, y);
1166 x = pmu_read(0x23) & 0xf;
1167 y = pmu_read(0x22) * 25 + 625;
1168 lcd_putsf(0, 8, "DOWN2: %x / %d mV", x, y);
1169 x = pmu_read(0x27) & 0xf;
1170 y = pmu_read(0x26) * 100 + 900;
1171 lcd_putsf(0, 9, "MEMLDO: %x / %d mV", x, y);
1172 for (i = 0; i < 6; i++)
1173 {
1174 x = pmu_read(0x2e + (i << 1)) & 0xf;
1175 y = pmu_read(0x2d + (i << 1)) * 100 + 900;
1176 lcd_putsf(0, 10 + i, "LDO%d: %x / %d mV", i + 1, x, y);
1177 }
1178 #else
1179 lcd_putsf(0, 3, "Charger: %s",
1180 charger_inserted() ? "present" : "absent");
1181 #endif /* target type */
1182 #endif /* CONFIG_CHARGING */
1183 break;
1184 case 2: /* voltage deltas: */
1185 #if (CONFIG_BATTERY_MEASURE & VOLTAGE_MEASURE)
1186 lcd_puts(0, 0, "Voltage deltas:");
1187 for (i = 0; i < POWER_HISTORY_LEN-1; i++) {
1188 y = power_history[i] - power_history[i+1];
1189 lcd_putsf(0, i+1, "-%d min: %c%d.%03d V", i,
1190 (y < 0) ? '-' : ' ', ((y < 0) ? y * -1 : y) / 1000,
1191 ((y < 0) ? y * -1 : y ) % 1000);
1192 }
1193 #elif (CONFIG_BATTERY_MEASURE & PERCENTAGE_MEASURE)
1194 lcd_puts(0, 0, "Percentage deltas:");
1195 for (i = 0; i < POWER_HISTORY_LEN-1; i++) {
1196 y = power_history[i] - power_history[i+1];
1197 lcd_putsf(0, i+1, "-%d min: %c%d%%", i,
1198 (y < 0) ? '-' : ' ', ((y < 0) ? y * -1 : y));
1199 }
1200 #endif
1201 break;
1202
1203 case 3: /* remaining time estimation: */
1204
1205 #ifdef ARCHOS_RECORDER
1206 lcd_putsf(0, 0, "charge_state: %d", charge_state);
1207
1208 lcd_putsf(0, 1, "Cycle time: %d m", powermgmt_last_cycle_startstop_min);
1209
1210 lcd_putsf(0, 2, "Lvl@cyc st: %d%%", powermgmt_last_cycle_level);
1211
1212 lcd_putsf(0, 3, "P=%2d I=%2d", pid_p, pid_i);
1213
1214 lcd_putsf(0, 4, "Trickle sec: %d/60", trickle_sec);
1215 #endif /* ARCHOS_RECORDER */
1216
1217 #if (CONFIG_BATTERY_MEASURE & VOLTAGE_MEASURE)
1218 lcd_putsf(0, 5, "Last PwrHist: %d.%03dV",
1219 power_history[0] / 1000,
1220 power_history[0] % 1000);
1221 #endif
1222
1223 lcd_putsf(0, 6, "battery level: %d%%", battery_level());
1224
1225 int time_left = battery_time();
1226 if (time_left >= 0)
1227 lcd_putsf(0, 7, "Est. remain: %d m", time_left);
1228 else
1229 lcd_puts(0, 7, "Estimation n/a");
1230 break;
1231 }
1232
1233 lcd_update();
1234
1235 switch(get_action(CONTEXT_STD,HZ/2))
1236 {
1237 case ACTION_STD_PREV:
1238 if (view)
1239 view--;
1240 break;
1241
1242 case ACTION_STD_NEXT:
1243 if (view < 3)
1244 view++;
1245 break;
1246
1247 case ACTION_STD_CANCEL:
1248 lcd_setfont(FONT_UI);
1249 return false;
1250 }
1251 }
1252 lcd_setfont(FONT_UI);
1253 return false;
1254 }
1255
1256 #endif /* (CONFIG_BATTERY_MEASURE != 0) && HAVE_LCD_BITMAP */
1257
1258 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
1259 #if (CONFIG_STORAGE & STORAGE_MMC) || (CONFIG_STORAGE & STORAGE_SD)
1260
1261 #if (CONFIG_STORAGE & STORAGE_MMC)
1262 #define CARDTYPE "MMC"
1263 #elif (CONFIG_STORAGE & STORAGE_SD)
1264 #define CARDTYPE "microSD"
1265 #endif
1266
1267 static int disk_callback(int btn, struct gui_synclist *lists)
1268 {
1269 tCardInfo *card;
1270 int *cardnum = (int*)lists->data;
1271 unsigned char card_name[6];
1272 unsigned char pbuf[32];
1273 char *title = lists->title;
1274 static const unsigned char i_vmin[] = { 0, 1, 5, 10, 25, 35, 60, 100 };
1275 static const unsigned char i_vmax[] = { 1, 5, 10, 25, 35, 45, 80, 200 };
1276 static const unsigned char * const kbit_units[] = { "kBit/s", "MBit/s", "GBit/s" };
1277 static const unsigned char * const nsec_units[] = { "ns", "µs", "ms" };
1278 #if (CONFIG_STORAGE & STORAGE_MMC)
1279 static const char * const mmc_spec_vers[] = { "1.0-1.2", "1.4", "2.0-2.2",
1280 "3.1-3.31", "4.0" };
1281 #endif
1282
1283 if ((btn == ACTION_STD_OK) || (btn == SYS_FS_CHANGED) || (btn == ACTION_REDRAW))
1284 {
1285 #ifdef HAVE_HOTSWAP
1286 if (btn == ACTION_STD_OK)
1287 {
1288 *cardnum ^= 0x1; /* change cards */
1289 }
1290 #endif
1291
1292 simplelist_set_line_count(0);
1293
1294 card = card_get_info(*cardnum);
1295
1296 if (card->initialized > 0)
1297 {
1298 unsigned i;
1299 for (i=0; i<sizeof(card_name); i++)
1300 {
1301 card_name[i] = card_extract_bits(card->cid, (103-8*i), 8);
1302 }
1303 strlcpy(card_name, card_name, sizeof(card_name));
1304 simplelist_addline(SIMPLELIST_ADD_LINE,
1305 "%s Rev %d.%d", card_name,
1306 (int) card_extract_bits(card->cid, 63, 4),
1307 (int) card_extract_bits(card->cid, 59, 4));
1308 simplelist_addline(SIMPLELIST_ADD_LINE,
1309 "Prod: %d/%d",
1310 #if (CONFIG_STORAGE & STORAGE_SD)
1311 (int) card_extract_bits(card->cid, 11, 4),
1312 (int) card_extract_bits(card->cid, 19, 8) + 2000
1313 #elif (CONFIG_STORAGE & STORAGE_MMC)
1314 (int) card_extract_bits(card->cid, 15, 4),
1315 (int) card_extract_bits(card->cid, 11, 4) + 1997
1316 #endif
1317 );
1318 simplelist_addline(SIMPLELIST_ADD_LINE,
1319 #if (CONFIG_STORAGE & STORAGE_SD)
1320 "Ser#: 0x%08lx",
1321 card_extract_bits(card->cid, 55, 32)
1322 #elif (CONFIG_STORAGE & STORAGE_MMC)
1323 "Ser#: 0x%04lx",
1324 card_extract_bits(card->cid, 47, 16)
1325 #endif
1326 );
1327
1328 simplelist_addline(SIMPLELIST_ADD_LINE, "M=%02x, "
1329 #if (CONFIG_STORAGE & STORAGE_SD)
1330 "O=%c%c",
1331 (int) card_extract_bits(card->cid, 127, 8),
1332 card_extract_bits(card->cid, 119, 8),
1333 card_extract_bits(card->cid, 111, 8)
1334 #elif (CONFIG_STORAGE & STORAGE_MMC)
1335 "O=%04x",
1336 (int) card_extract_bits(card->cid, 127, 8),
1337 (int) card_extract_bits(card->cid, 119, 16)
1338 #endif
1339 );
1340
1341 #if (CONFIG_STORAGE & STORAGE_MMC)
1342 int temp = card_extract_bits(card->csd, 125, 4);
1343 simplelist_addline(SIMPLELIST_ADD_LINE,
1344 "MMC v%s", temp < 5 ?
1345 mmc_spec_vers[temp] : "?.?");
1346 #endif
1347 simplelist_addline(SIMPLELIST_ADD_LINE,
1348 "Blocks: 0x%08lx", card->numblocks);
1349 output_dyn_value(pbuf, sizeof pbuf, card->speed / 1000,
1350 kbit_units, false);
1351 simplelist_addline(SIMPLELIST_ADD_LINE,
1352 "Speed: %s", pbuf);
1353 output_dyn_value(pbuf, sizeof pbuf, card->taac,
1354 nsec_units, false);
1355 simplelist_addline(SIMPLELIST_ADD_LINE,
1356 "Taac: %s", pbuf);
1357 simplelist_addline(SIMPLELIST_ADD_LINE,
1358 "Nsac: %d clk", card->nsac);
1359 simplelist_addline(SIMPLELIST_ADD_LINE,
1360 "R2W: *%d", card->r2w_factor);
1361 #if (CONFIG_STORAGE & STORAGE_SD)
1362 int csd_structure = card_extract_bits(card->csd, 127, 2);
1363 if (csd_structure == 0) /* CSD version 1.0 */
1364 #endif
1365 {
1366 simplelist_addline(SIMPLELIST_ADD_LINE,
1367 "IRmax: %d..%d mA",
1368 i_vmin[card_extract_bits(card->csd, 61, 3)],
1369 i_vmax[card_extract_bits(card->csd, 58, 3)]);
1370 simplelist_addline(SIMPLELIST_ADD_LINE,
1371 "IWmax: %d..%d mA",
1372 i_vmin[card_extract_bits(card->csd, 55, 3)],
1373 i_vmax[card_extract_bits(card->csd, 52, 3)]);
1374 }
1375 }
1376 else if (card->initialized == 0)
1377 {
1378 simplelist_addline(SIMPLELIST_ADD_LINE, "Not Found!");
1379 }
1380 #if (CONFIG_STORAGE & STORAGE_SD)
1381 else /* card->initialized < 0 */
1382 {
1383 simplelist_addline(SIMPLELIST_ADD_LINE, "Init Error! (%d)", card->initialized);
1384 }
1385 #endif
1386 snprintf(title, 16, "[" CARDTYPE " %d]", *cardnum);
1387 gui_synclist_set_title(lists, title, Icon_NOICON);
1388 gui_synclist_set_nb_items(lists, simplelist_get_line_count());
1389 gui_synclist_select_item(lists, 0);
1390 btn = ACTION_REDRAW;
1391 }
1392 return btn;
1393 }
1394 #elif (CONFIG_STORAGE & STORAGE_ATA)
1395 static int disk_callback(int btn, struct gui_synclist *lists)
1396 {
1397 (void)lists;
1398 int i;
1399 char buf[128];
1400 unsigned short* identify_info = ata_get_identify();
1401 bool timing_info_present = false;
1402 (void)btn;
1403
1404 simplelist_set_line_count(0);
1405
1406 for (i=0; i < 20; i++)
1407 ((unsigned short*)buf)[i]=htobe16(identify_info[i+27]);
1408 buf[40]=0;
1409 /* kill trailing space */
1410 for (i=39; i && buf[i]==' '; i--)
1411 buf[i] = 0;
1412 simplelist_addline(SIMPLELIST_ADD_LINE, "Model: %s", buf);
1413 for (i=0; i < 4; i++)
1414 ((unsigned short*)buf)[i]=htobe16(identify_info[i+23]);
1415 buf[8]=0;
1416 simplelist_addline(SIMPLELIST_ADD_LINE,
1417 "Firmware: %s", buf);
1418 snprintf(buf, sizeof buf, "%ld MB",
1419 ((unsigned long)identify_info[61] << 16 |
1420 (unsigned long)identify_info[60]) / 2048 );
1421 simplelist_addline(SIMPLELIST_ADD_LINE,
1422 "Size: %s", buf);
1423 unsigned long free;
1424 fat_size( IF_MV2(0,) NULL, &free );
1425 simplelist_addline(SIMPLELIST_ADD_LINE,
1426 "Free: %ld MB", free / 1024);
1427 simplelist_addline(SIMPLELIST_ADD_LINE,
1428 "Spinup time: %d ms", storage_spinup_time() * (1000/HZ));
1429 i = identify_info[83] & (1<<3);
1430 simplelist_addline(SIMPLELIST_ADD_LINE,
1431 "Power mgmt: %s", i ? "enabled" : "unsupported");
1432 i = identify_info[83] & (1<<9);
1433 simplelist_addline(SIMPLELIST_ADD_LINE,
1434 "Noise mgmt: %s", i ? "enabled" : "unsupported");
1435 i = identify_info[82] & (1<<6);
1436 simplelist_addline(SIMPLELIST_ADD_LINE,
1437 "Read-ahead: %s", i ? "enabled" : "unsupported");
1438 timing_info_present = identify_info[53] & (1<<1);
1439 if(timing_info_present) {
1440 char pio3[2], pio4[2];pio3[1] = 0;
1441 pio4[1] = 0;
1442 pio3[0] = (identify_info[64] & (1<<0)) ? '3' : 0;
1443 pio4[0] = (identify_info[64] & (1<<1)) ? '4' : 0;
1444 simplelist_addline(SIMPLELIST_ADD_LINE,
1445 "PIO modes: 0 1 2 %s %s", pio3, pio4);
1446 }
1447 else {
1448 simplelist_addline(SIMPLELIST_ADD_LINE,
1449 "No PIO mode info");
1450 }
1451 timing_info_present = identify_info[53] & (1<<1);
1452 if(timing_info_present) {
1453 simplelist_addline(SIMPLELIST_ADD_LINE,
1454 "Cycle times %dns/%dns",
1455 identify_info[67],
1456 identify_info[68] );
1457 } else {
1458 simplelist_addline(SIMPLELIST_ADD_LINE,
1459 "No timing info");
1460 }
1461 int sector_size = 512;
1462 if((identify_info[106] & 0xe000) == 0x6000)
1463 sector_size *= BIT_N(identify_info[106] & 0x000f);
1464 simplelist_addline(SIMPLELIST_ADD_LINE,
1465 "Physical sector size: %d", sector_size);
1466 #ifdef HAVE_ATA_DMA
1467 if (identify_info[63] & (1<<0)) {
1468 char mdma0[2], mdma1[2], mdma2[2];
1469 mdma0[1] = mdma1[1] = mdma2[1] = 0;
1470 mdma0[0] = (identify_info[63] & (1<<0)) ? '0' : 0;
1471 mdma1[0] = (identify_info[63] & (1<<1)) ? '1' : 0;
1472 mdma2[0] = (identify_info[63] & (1<<2)) ? '2' : 0;
1473 simplelist_addline(SIMPLELIST_ADD_LINE,
1474 "MDMA modes: %s %s %s", mdma0, mdma1, mdma2);
1475 simplelist_addline(SIMPLELIST_ADD_LINE,
1476 "MDMA Cycle times %dns/%dns",
1477 identify_info[65],
1478 identify_info[66] );
1479 }
1480 else {
1481 simplelist_addline(SIMPLELIST_ADD_LINE,
1482 "No MDMA mode info");
1483 }
1484 if (identify_info[53] & (1<<2)) {
1485 char udma0[2], udma1[2], udma2[2], udma3[2], udma4[2], udma5[2], udma6[2];
1486 udma0[1] = udma1[1] = udma2[1] = udma3[1] = udma4[1] = udma5[1] = udma6[1] = 0;
1487 udma0[0] = (identify_info[88] & (1<<0)) ? '0' : 0;
1488 udma1[0] = (identify_info[88] & (1<<1)) ? '1' : 0;
1489 udma2[0] = (identify_info[88] & (1<<2)) ? '2' : 0;
1490 udma3[0] = (identify_info[88] & (1<<3)) ? '3' : 0;
1491 udma4[0] = (identify_info[88] & (1<<4)) ? '4' : 0;
1492 udma5[0] = (identify_info[88] & (1<<5)) ? '5' : 0;
1493 udma6[0] = (identify_info[88] & (1<<6)) ? '6' : 0;
1494 simplelist_addline(SIMPLELIST_ADD_LINE,
1495 "UDMA modes: %s %s %s %s %s %s %s", udma0, udma1, udma2,
1496 udma3, udma4, udma5, udma6);
1497 }
1498 else {
1499 simplelist_addline(SIMPLELIST_ADD_LINE,
1500 "No UDMA mode info");
1501 }
1502 #endif /* HAVE_ATA_DMA */
1503 timing_info_present = identify_info[53] & (1<<1);
1504 if(timing_info_present) {
1505 i = identify_info[49] & (1<<11);
1506 simplelist_addline(SIMPLELIST_ADD_LINE,
1507 "IORDY support: %s", i ? "yes" : "no");
1508 i = identify_info[49] & (1<<10);
1509 simplelist_addline(SIMPLELIST_ADD_LINE,
1510 "IORDY disable: %s", i ? "yes" : "no");
1511 } else {
1512 simplelist_addline(SIMPLELIST_ADD_LINE,
1513 "No timing info");
1514 }
1515 simplelist_addline(SIMPLELIST_ADD_LINE,
1516 "Cluster size: %d bytes", fat_get_cluster_size(IF_MV(0)));
1517 #ifdef HAVE_ATA_DMA
1518 i = ata_get_dma_mode();
1519 if (i == 0) {
1520 simplelist_addline(SIMPLELIST_ADD_LINE,
1521 "DMA not enabled");
1522 } else {
1523 simplelist_addline(SIMPLELIST_ADD_LINE,
1524 "DMA mode: %s %c",
1525 (i & 0x40) ? "UDMA" : "MDMA",
1526 '0' + (i & 7));
1527 }
1528 #endif /* HAVE_ATA_DMA */
1529 return btn;
1530 }
1531 #else /* No SD, MMC or ATA */
1532 static int disk_callback(int btn, struct gui_synclist *lists)
1533 {
1534 (void)lists;
1535 struct storage_info info;
1536 storage_get_info(0,&info);
1537 simplelist_addline(SIMPLELIST_ADD_LINE, "Vendor: %s", info.vendor);
1538 simplelist_addline(SIMPLELIST_ADD_LINE, "Model: %s", info.product);
1539 simplelist_addline(SIMPLELIST_ADD_LINE, "Firmware: %s", info.revision);
1540 simplelist_addline(SIMPLELIST_ADD_LINE,
1541 "Size: %ld MB", info.num_sectors*(info.sector_size/512)/2024);
1542 unsigned long free;
1543 fat_size( IF_MV2(0,) NULL, &free );
1544 simplelist_addline(SIMPLELIST_ADD_LINE,
1545 "Free: %ld MB", free / 1024);
1546 simplelist_addline(SIMPLELIST_ADD_LINE,
1547 "Cluster size: %d bytes", fat_get_cluster_size(IF_MV(0)));
1548 return btn;
1549 }
1550 #endif
1551
1552 #if (CONFIG_STORAGE & STORAGE_ATA)
1553 static bool dbg_identify_info(void)
1554 {
1555 int fd = creat("/identify_info.bin", 0666);
1556 if(fd >= 0)
1557 {
1558 #ifdef ROCKBOX_LITTLE_ENDIAN
1559 ecwrite(fd, ata_get_identify(), SECTOR_SIZE/2, "s", true);
1560 #else
1561 write(fd, ata_get_identify(), SECTOR_SIZE);
1562 #endif
1563 close(fd);
1564 }
1565 return false;
1566 }
1567 #endif
1568
1569 static bool dbg_disk_info(void)
1570 {
1571 struct simplelist_info info;
1572 simplelist_info_init(&info, "Disk Info", 1, NULL);
1573 #if (CONFIG_STORAGE & STORAGE_MMC) || (CONFIG_STORAGE & STORAGE_SD)
1574 char title[16];
1575 int card = 0;
1576 info.callback_data = (void*)&card;
1577 info.title = title;
1578 #endif
1579 info.action_callback = disk_callback;
1580 info.hide_selection = true;
1581 info.scroll_all = true;
1582 return simplelist_show_list(&info);
1583 }
1584 #endif /* PLATFORM_NATIVE */
1585
1586 #ifdef HAVE_DIRCACHE
1587 static int dircache_callback(int btn, struct gui_synclist *lists)
1588 {
1589 (void)lists;
1590 simplelist_set_line_count(0);
1591 simplelist_addline(SIMPLELIST_ADD_LINE, "Cache initialized: %s",
1592 dircache_is_enabled() ? "Yes" : "No");
1593 simplelist_addline(SIMPLELIST_ADD_LINE, "Cache size: %d B",
1594 dircache_get_cache_size());
1595 simplelist_addline(SIMPLELIST_ADD_LINE, "Last size: %d B",
1596 global_status.dircache_size);
1597 simplelist_addline(SIMPLELIST_ADD_LINE, "Limit: %d B",
1598 DIRCACHE_LIMIT);
1599 simplelist_addline(SIMPLELIST_ADD_LINE, "Reserve: %d/%d B",
1600 dircache_get_reserve_used(), DIRCACHE_RESERVE);
1601 simplelist_addline(SIMPLELIST_ADD_LINE, "Scanning took: %d s",
1602 dircache_get_build_ticks() / HZ);
1603 simplelist_addline(SIMPLELIST_ADD_LINE, "Entry count: %d",
1604 dircache_get_entry_count());
1605 return btn;
1606 }
1607
1608 static bool dbg_dircache_info(void)
1609 {
1610 struct simplelist_info info;
1611 simplelist_info_init(&info, "Dircache Info", 7, NULL);
1612 info.action_callback = dircache_callback;
1613 info.hide_selection = true;
1614 info.scroll_all = true;
1615 return simplelist_show_list(&info);
1616 }
1617
1618 #endif /* HAVE_DIRCACHE */
1619
1620 #ifdef HAVE_TAGCACHE
1621 static int database_callback(int btn, struct gui_synclist *lists)
1622 {
1623 (void)lists;
1624 struct tagcache_stat *stat = tagcache_get_stat();
1625 static bool synced = false;
1626
1627 simplelist_set_line_count(0);
1628
1629 simplelist_addline(SIMPLELIST_ADD_LINE, "Initialized: %s",
1630 stat->initialized ? "Yes" : "No");
1631 simplelist_addline(SIMPLELIST_ADD_LINE, "DB Ready: %s",
1632 stat->ready ? "Yes" : "No");
1633 simplelist_addline(SIMPLELIST_ADD_LINE, "RAM Cache: %s",
1634 stat->ramcache ? "Yes" : "No");
1635 simplelist_addline(SIMPLELIST_ADD_LINE, "RAM: %d/%d B",
1636 stat->ramcache_used, stat->ramcache_allocated);
1637 simplelist_addline(SIMPLELIST_ADD_LINE, "Progress: %d%% (%d entries)",
1638 stat->progress, stat->processed_entries);
1639 simplelist_addline(SIMPLELIST_ADD_LINE, "Curfile: %s",
1640 stat->curentry ? stat->curentry : "---");
1641 simplelist_addline(SIMPLELIST_ADD_LINE, "Commit step: %d",
1642 stat->commit_step);
1643 simplelist_addline(SIMPLELIST_ADD_LINE, "Commit delayed: %s",
1644 stat->commit_delayed ? "Yes" : "No");
1645
1646 simplelist_addline(SIMPLELIST_ADD_LINE, "Queue length: %d",
1647 stat->queue_length);
1648
1649 if (synced)
1650 {
1651 synced = false;
1652 tagcache_screensync_event();
1653 }
1654
1655 if (!btn && stat->curentry)
1656 {
1657 synced = true;
1658 return ACTION_REDRAW;
1659 }
1660
1661 if (btn == ACTION_STD_CANCEL)
1662 tagcache_screensync_enable(false);
1663
1664 return btn;
1665 }
1666 static bool dbg_tagcache_info(void)
1667 {
1668 struct simplelist_info info;
1669 simplelist_info_init(&info, "Database Info", 8, NULL);
1670 info.action_callback = database_callback;
1671 info.hide_selection = true;
1672 info.scroll_all = true;
1673
1674 /* Don't do nonblock here, must give enough processing time
1675 for tagcache thread. */
1676 /* info.timeout = TIMEOUT_NOBLOCK; */
1677 info.timeout = 1;
1678 tagcache_screensync_enable(true);
1679 return simplelist_show_list(&info);
1680 }
1681 #endif
1682
1683 #if CONFIG_CPU == SH7034
1684 static bool dbg_save_roms(void)
1685 {
1686 int fd;
1687 int oldmode = system_memory_guard(MEMGUARD_NONE);
1688
1689 fd = creat("/internal_rom_0000-FFFF.bin", 0666);
1690 if(fd >= 0)
1691 {
1692 write(fd, (void *)0, 0x10000);
1693 close(fd);
1694 }
1695
1696 fd = creat("/internal_rom_2000000-203FFFF.bin", 0666);
1697 if(fd >= 0)
1698 {
1699 write(fd, (void *)0x2000000, 0x40000);
1700 close(fd);
1701 }
1702
1703 system_memory_guard(oldmode);
1704 return false;
1705 }
1706 #elif defined CPU_COLDFIRE
1707 static bool dbg_save_roms(void)
1708 {
1709 int fd;
1710 int oldmode = system_memory_guard(MEMGUARD_NONE);
1711
1712 #if defined(IRIVER_H100_SERIES)
1713 fd = creat("/internal_rom_000000-1FFFFF.bin", 0666);
1714 #elif defined(IRIVER_H300_SERIES)
1715 fd = creat("/internal_rom_000000-3FFFFF.bin", 0666);
1716 #elif defined(IAUDIO_X5) || defined(IAUDIO_M5) || defined(IAUDIO_M3)
1717 fd = creat("/internal_rom_000000-3FFFFF.bin", 0666);
1718 #elif defined(MPIO_HD200) || defined(MPIO_HD300)
1719 fd = creat("/internal_rom_000000-1FFFFF.bin", 0666);
1720 #endif
1721 if(fd >= 0)
1722 {
1723 write(fd, (void *)0, FLASH_SIZE);
1724 close(fd);
1725 }
1726 system_memory_guard(oldmode);
1727
1728 #ifdef HAVE_EEPROM
1729 fd = creat("/internal_eeprom.bin", 0666);
1730 if (fd >= 0)
1731 {
1732 int old_irq_level;
1733 char buf[EEPROM_SIZE];
1734 int err;
1735
1736 old_irq_level = disable_irq_save();
1737
1738 err = eeprom_24cxx_read(0, buf, sizeof buf);
1739
1740 restore_irq(old_irq_level);
1741
1742 if (err)
1743 splashf(HZ*3, "Eeprom read failure (%d)", err);
1744 else
1745 {
1746 write(fd, buf, sizeof buf);
1747 }
1748
1749 close(fd);
1750 }
1751 #endif
1752
1753 return false;
1754 }
1755 #elif defined(CPU_PP) && !(CONFIG_STORAGE & STORAGE_SD)
1756 static bool dbg_save_roms(void)
1757 {
1758 int fd = creat("/internal_rom_000000-0FFFFF.bin", 0666);
1759 if(fd >= 0)
1760 {
1761 write(fd, (void *)0x20000000, FLASH_SIZE);
1762 close(fd);
1763 }
1764
1765 return false;
1766 }
1767 #elif CONFIG_CPU == IMX31L
1768 static bool dbg_save_roms(void)
1769 {
1770 int fd = creat("/flash_rom_A0000000-A01FFFFF.bin", 0666);
1771 if (fd >= 0)
1772 {
1773 write(fd, (void*)0xa0000000, FLASH_SIZE);
1774 close(fd);
1775 }
1776
1777 return false;
1778 }
1779 #elif defined(CPU_TCC780X)
1780 static bool dbg_save_roms(void)
1781 {
1782 int fd = creat("/eeprom_E0000000-E0001FFF.bin", 0666);
1783 if (fd >= 0)
1784 {
1785 write(fd, (void*)0xe0000000, 0x2000);
1786 close(fd);
1787 }
1788
1789 return false;
1790 }
1791 #endif /* CPU */
1792
1793 #ifndef SIMULATOR
1794 #if CONFIG_TUNER
1795
1796 #ifdef CONFIG_TUNER_MULTI
1797 static int tuner_type = 0;
1798 #define IF_TUNER_TYPE(type) if(tuner_type==type)
1799 #else
1800 #define IF_TUNER_TYPE(type)
1801 #endif
1802
1803 static int radio_callback(int btn, struct gui_synclist *lists)
1804 {
1805 (void)lists;
1806 if (btn == ACTION_STD_CANCEL)
1807 return btn;
1808 simplelist_set_line_count(1);
1809
1810 #if (CONFIG_TUNER & LV24020LP)
1811 simplelist_addline(SIMPLELIST_ADD_LINE,
1812 "CTRL_STAT: %02X", lv24020lp_get(LV24020LP_CTRL_STAT) );
1813 simplelist_addline(SIMPLELIST_ADD_LINE,
1814 "RADIO_STAT: %02X", lv24020lp_get(LV24020LP_REG_STAT) );
1815 simplelist_addline(SIMPLELIST_ADD_LINE,
1816 "MSS_FM: %d kHz", lv24020lp_get(LV24020LP_MSS_FM) );
1817 simplelist_addline(SIMPLELIST_ADD_LINE,
1818 "MSS_IF: %d Hz", lv24020lp_get(LV24020LP_MSS_IF) );
1819 simplelist_addline(SIMPLELIST_ADD_LINE,
1820 "MSS_SD: %d Hz", lv24020lp_get(LV24020LP_MSS_SD) );
1821 simplelist_addline(SIMPLELIST_ADD_LINE,
1822 "if_set: %d Hz", lv24020lp_get(LV24020LP_IF_SET) );
1823 simplelist_addline(SIMPLELIST_ADD_LINE,
1824 "sd_set: %d Hz", lv24020lp_get(LV24020LP_SD_SET) );
1825 #endif /* LV24020LP */
1826 #if (CONFIG_TUNER & S1A0903X01)
1827 simplelist_addline(SIMPLELIST_ADD_LINE,
1828 "Samsung regs: %08X", s1a0903x01_get(RADIO_ALL));
1829 /* This one doesn't return dynamic data atm */
1830 #endif /* S1A0903X01 */
1831 #if (CONFIG_TUNER & TEA5767)
1832 struct tea5767_dbg_info nfo;
1833 tea5767_dbg_info(&nfo);
1834 simplelist_addline(SIMPLELIST_ADD_LINE, "Philips regs:");
1835 simplelist_addline(SIMPLELIST_ADD_LINE,
1836 " Read: %02X %02X %02X %02X %02X",
1837 (unsigned)nfo.read_regs[0], (unsigned)nfo.read_regs[1],
1838 (unsigned)nfo.read_regs[2], (unsigned)nfo.read_regs[3],
1839 (unsigned)nfo.read_regs[4]);
1840 simplelist_addline(SIMPLELIST_ADD_LINE,
1841 " Write: %02X %02X %02X %02X %02X",
1842 (unsigned)nfo.write_regs[0], (unsigned)nfo.write_regs[1],
1843 (unsigned)nfo.write_regs[2], (unsigned)nfo.write_regs[3],
1844 (unsigned)nfo.write_regs[4]);
1845 #endif /* TEA5767 */
1846 #if (CONFIG_TUNER & SI4700)
1847 IF_TUNER_TYPE(SI4700)
1848 {
1849 struct si4700_dbg_info nfo;
1850 si4700_dbg_info(&nfo);
1851 simplelist_addline(SIMPLELIST_ADD_LINE, "SI4700 regs:");
1852 for (int i = 0; i < 16; i += 4) {
1853 simplelist_addline(SIMPLELIST_ADD_LINE,"%02X: %04X %04X %04X %04X",
1854 i, nfo.regs[i], nfo.regs[i+1], nfo.regs[i+2], nfo.regs[i+3]);
1855 }
1856 #ifdef HAVE_RDS_CAP
1857 simplelist_addline(SIMPLELIST_ADD_LINE, "");
1858 simplelist_addline(SIMPLELIST_ADD_LINE, "RDS Info:");
1859 simplelist_addline(SIMPLELIST_ADD_LINE,
1860 si4700_get_rds_info(RADIO_RDS_NAME));
1861
1862 simplelist_addline(SIMPLELIST_ADD_LINE,
1863 si4700_get_rds_info(RADIO_RDS_TEXT));
1864 #endif
1865 }
1866 #endif /* SI4700 */
1867 #if (CONFIG_TUNER & RDA5802)
1868 IF_TUNER_TYPE(RDA5802)
1869 {
1870 struct rda5802_dbg_info nfo;
1871 rda5802_dbg_info(&nfo);
1872 simplelist_addline(SIMPLELIST_ADD_LINE, "RDA5802 regs:");
1873 for (int i = 0; i < 16; i += 4) {
1874 simplelist_addline(SIMPLELIST_ADD_LINE,"%02X: %04X %04X %04X %04X",
1875 i, nfo.regs[i], nfo.regs[i+1], nfo.regs[i+2], nfo.regs[i+3]);
1876 }
1877 }
1878 #endif /* RDA55802 */
1879 return ACTION_REDRAW;
1880 }
1881 static bool dbg_fm_radio(void)
1882 {
1883 struct simplelist_info info;
1884 #ifdef CONFIG_TUNER_MULTI
1885 tuner_type = tuner_detect_type();
1886 #endif
1887 info.scroll_all = true;
1888 simplelist_info_init(&info, "FM Radio", 1, NULL);
1889 simplelist_set_line_count(0);
1890 simplelist_addline(SIMPLELIST_ADD_LINE, "HW detected: %s",
1891 radio_hardware_present() ? "yes" : "no");
1892
1893 info.action_callback = radio_hardware_present()?radio_callback : NULL;
1894 info.hide_selection = true;
1895 return simplelist_show_list(&info);
1896 }
1897 #endif /* CONFIG_TUNER */
1898 #endif /* !SIMULATOR */
1899
1900 #if defined(HAVE_LCD_BITMAP) && !defined(APPLICATION)
1901 extern bool do_screendump_instead_of_usb;
1902
1903 static bool dbg_screendump(void)
1904 {
1905 do_screendump_instead_of_usb = !do_screendump_instead_of_usb;
1906 splashf(HZ, "Screendump %sabled", do_screendump_instead_of_usb?"en":"dis");
1907 return false;
1908 }
1909 #endif /* HAVE_LCD_BITMAP */
1910
1911 extern bool write_metadata_log;
1912
1913 static bool dbg_metadatalog(void)
1914 {
1915 write_metadata_log = !write_metadata_log;
1916 splashf(HZ, "Metadata log %sabled", write_metadata_log ? "en" : "dis");
1917 return false;
1918 }
1919
1920 #if CONFIG_CPU == SH7034 || defined(CPU_COLDFIRE)
1921 static bool dbg_set_memory_guard(void)
1922 {
1923 static const struct opt_items names[MAXMEMGUARD] = {
1924 { "None", -1 },
1925 { "Flash ROM writes", -1 },
1926 { "Zero area (all)", -1 }
1927 };
1928 int mode = system_memory_guard(MEMGUARD_KEEP);
1929
1930 set_option( "Catch mem accesses", &mode, INT, names, MAXMEMGUARD, NULL);
1931 system_memory_guard(mode);
1932
1933 return false;
1934 }
1935 #endif /* CONFIG_CPU == SH7034 || defined(CPU_COLDFIRE) */
1936
1937 #if defined(HAVE_EEPROM) && !defined(HAVE_EEPROM_SETTINGS)
1938 static bool dbg_write_eeprom(void)
1939 {
1940 int fd = open("/internal_eeprom.bin", O_RDONLY);
1941
1942 if (fd >= 0)
1943 {
1944 char buf[EEPROM_SIZE];
1945 int rc = read(fd, buf, EEPROM_SIZE);
1946
1947 if(rc == EEPROM_SIZE)
1948 {
1949 int old_irq_level = disable_irq_save();
1950
1951 int err = eeprom_24cxx_write(0, buf, sizeof buf);
1952 if (err)
1953 splashf(HZ*3, "Eeprom write failure (%d)", err);
1954 else
1955 splash(HZ*3, "Eeprom written successfully");
1956
1957 restore_irq(old_irq_level);
1958 }
1959 else
1960 {
1961 splashf(HZ*3, "File read error (%d)",rc);
1962 }
1963 close(fd);
1964 }
1965 else
1966 {
1967 splash(HZ*3, "Failed to open 'internal_eeprom.bin'");
1968 }
1969
1970 return false;
1971 }
1972 #endif /* defined(HAVE_EEPROM) && !defined(HAVE_EEPROM_SETTINGS) */
1973 #ifdef CPU_BOOST_LOGGING
1974 static bool cpu_boost_log(void)
1975 {
1976 int count = cpu_boost_log_getcount();
1977 char *str = cpu_boost_log_getlog_first();
1978 bool done;
1979 lcd_setfont(FONT_SYSFIXED);
1980 for (int i = 0; i < count ;)
1981 {
1982 lcd_clear_display();
1983 for(int j=0; j<LCD_HEIGHT/SYSFONT_HEIGHT; j++,i++)
1984 {
1985 if (!str)
1986 str = cpu_boost_log_getlog_next();
1987 if (str)
1988 {
1989 if(strlen(str) > LCD_WIDTH/SYSFONT_WIDTH)
1990 lcd_puts_scroll(0, j, str);
1991 else
1992 lcd_puts(0, j,str);
1993 }
1994 str = NULL;
1995 }
1996 lcd_update();
1997 done = false;
1998 while (!done)
1999 {
2000 switch(get_action(CONTEXT_STD,TIMEOUT_BLOCK))
2001 {
2002 case ACTION_STD_OK:
2003 case ACTION_STD_PREV:
2004 case ACTION_STD_NEXT:
2005 done = true;
2006 break;
2007 case ACTION_STD_CANCEL:
2008 i = count;
2009 done = true;
2010 break;
2011 }
2012 }
2013 }
2014 lcd_stop_scroll();
2015 get_action(CONTEXT_STD,TIMEOUT_BLOCK);
2016 lcd_setfont(FONT_UI);
2017 return false;
2018 }
2019 #endif
2020
2021 #if (defined(HAVE_WHEEL_ACCELERATION) && (CONFIG_KEYPAD==IPOD_4G_PAD) \
2022 && !defined(IPOD_MINI) && !defined(SIMULATOR))
2023 extern bool wheel_is_touched;
2024 extern int old_wheel_value;
2025 extern int new_wheel_value;
2026 extern int wheel_delta;
2027 extern unsigned int accumulated_wheel_delta;
2028 extern unsigned int wheel_velocity;
2029
2030 static bool dbg_scrollwheel(void)
2031 {
2032 lcd_setfont(FONT_SYSFIXED);
2033
2034 while (1)
2035 {
2036 if (action_userabort(HZ/10))
2037 break;
2038
2039 lcd_clear_display();
2040
2041 /* show internal variables of scrollwheel driver */
2042 lcd_putsf(0, 0, "wheel touched: %s", (wheel_is_touched) ? "true" : "false");
2043 lcd_putsf(0, 1, "new position: %2d", new_wheel_value);
2044 lcd_putsf(0, 2, "old position: %2d", old_wheel_value);
2045 lcd_putsf(0, 3, "wheel delta: %2d", wheel_delta);
2046 lcd_putsf(0, 4, "accumulated delta: %2d", accumulated_wheel_delta);
2047 lcd_putsf(0, 5, "velo [deg/s]: %4d", (int)wheel_velocity);
2048
2049 /* show effective accelerated scrollspeed */
2050 lcd_putsf(0, 6, "accel. speed: %4d",
2051 button_apply_acceleration((1<<31)|(1<<24)|wheel_velocity) );
2052
2053 lcd_update();
2054 }
2055 lcd_setfont(FONT_UI);
2056 return false;
2057 }
2058 #endif
2059
2060 #ifdef HAVE_USBSTACK
2061 #if defined(ROCKBOX_HAS_LOGF) && defined(USB_ENABLE_SERIAL)
2062 static bool toggle_usb_serial(void)
2063 {
2064 bool enabled = !usb_core_driver_enabled(USB_DRIVER_SERIAL);
2065
2066 usb_core_enable_driver(USB_DRIVER_SERIAL, enabled);
2067 splashf(HZ, "USB Serial %sabled", enabled ? "en" : "dis");
2068
2069 return false;
2070 }
2071 #endif
2072 #endif
2073
2074 #if CONFIG_USBOTG == USBOTG_ISP1583
2075 extern int dbg_usb_num_items(void);
2076 extern const char* dbg_usb_item(int selected_item, void *data,
2077 char *buffer, size_t buffer_len);
2078
2079 static int isp1583_action_callback(int action, struct gui_synclist *lists)
2080 {
2081 (void)lists;
2082 if (action == ACTION_NONE)
2083 action = ACTION_REDRAW;
2084 return action;
2085 }
2086
2087 static bool dbg_isp1583(void)
2088 {
2089 struct simplelist_info isp1583;
2090 isp1583.scroll_all = true;
2091 simplelist_info_init(&isp1583, "ISP1583", dbg_usb_num_items(), NULL);
2092 isp1583.timeout = HZ/100;
2093 isp1583.hide_selection = true;
2094 isp1583.get_name = dbg_usb_item;
2095 isp1583.action_callback = isp1583_action_callback;
2096 return simplelist_show_list(&isp1583);
2097 }
2098 #endif
2099
2100 #if defined(CREATIVE_ZVx) && !defined(SIMULATOR)
2101 extern int pic_dbg_num_items(void);
2102 extern const char* pic_dbg_item(int selected_item, void *data,
2103 char *buffer, size_t buffer_len);
2104
2105 static int pic_action_callback(int action, struct gui_synclist *lists)
2106 {
2107 (void)lists;
2108 if (action == ACTION_NONE)
2109 action = ACTION_REDRAW;
2110 return action;
2111 }
2112
2113 static bool dbg_pic(void)
2114 {
2115 struct simplelist_info pic;
2116 pic.scroll_all = true;
2117 simplelist_info_init(&pic, "PIC", pic_dbg_num_items(), NULL);
2118 pic.timeout = HZ/100;
2119 pic.hide_selection = true;
2120 pic.get_name = pic_dbg_item;
2121 pic.action_callback = pic_action_callback;
2122 return simplelist_show_list(&pic);
2123 }
2124 #endif
2125
2126
2127 /****** The menu *********/
2128 static const struct {
2129 unsigned char *desc; /* string or ID */
2130 bool (*function) (void); /* return true if USB was connected */
2131 } menuitems[] = {
2132 #if CONFIG_CPU == SH7034 || defined(CPU_COLDFIRE) || \
2133 (defined(CPU_PP) && !(CONFIG_STORAGE & STORAGE_SD)) || \
2134 CONFIG_CPU == IMX31L || defined(CPU_TCC780X)
2135 { "Dump ROM contents", dbg_save_roms },
2136 #endif
2137 #if CONFIG_CPU == SH7034 || defined(CPU_COLDFIRE) || defined(CPU_PP) \
2138 || CONFIG_CPU == S3C2440 || CONFIG_CPU == IMX31L || CONFIG_CPU == AS3525 \
2139 || CONFIG_CPU == DM320 || defined(CPU_S5L870X) || CONFIG_CPU == AS3525v2 \
2140 || CONFIG_CPU == RK27XX
2141 { "View I/O ports", dbg_ports },
2142 #endif
2143 #if (CONFIG_RTC == RTC_PCF50605) && (CONFIG_PLATFORM & PLATFORM_NATIVE)
2144 { "View PCF registers", dbg_pcf },
2145 #endif
2146 #if defined(HAVE_TSC2100) && (CONFIG_PLATFORM & PLATFORM_NATIVE)
2147 { "TSC2100 debug", tsc2100_debug },
2148 #endif
2149 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
2150 { "CPU frequency", dbg_cpufreq },
2151 #endif
2152 #if CONFIG_CPU == IMX31L
2153 { "DVFS/DPTC", __dbg_dvfs_dptc },
2154 #endif
2155 #if defined(IRIVER_H100_SERIES) && !defined(SIMULATOR)
2156 { "S/PDIF analyzer", dbg_spdif },
2157 #endif
2158 #if CONFIG_CPU == SH7034 || defined(CPU_COLDFIRE)
2159 { "Catch mem accesses", dbg_set_memory_guard },
2160 #endif
2161 { "View OS stacks", dbg_os },
2162 #ifdef __linux__
2163 { "View CPU stats", dbg_cpuinfo },
2164 #endif
2165 #ifdef HAVE_LCD_BITMAP
2166 #if (CONFIG_BATTERY_MEASURE != 0) && !defined(SIMULATOR)
2167 { "View battery", view_battery },
2168 #endif
2169 #ifndef APPLICATION
2170 { "Screendump", dbg_screendump },
2171 #endif
2172 #endif
2173 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
2174 { "View HW info", dbg_hw_info },
2175 #endif
2176 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
2177 { "View partitions", dbg_partitions },
2178 #endif
2179 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
2180 { "View disk info", dbg_disk_info },
2181 #if (CONFIG_STORAGE & STORAGE_ATA)
2182 { "Dump ATA identify info", dbg_identify_info},
2183 #endif
2184 #endif
2185 { "Metadata log", dbg_metadatalog },
2186 #ifdef HAVE_DIRCACHE
2187 { "View dircache info", dbg_dircache_info },
2188 #endif
2189 #ifdef HAVE_TAGCACHE
2190 { "View database info", dbg_tagcache_info },
2191 #endif
2192 #ifdef HAVE_LCD_BITMAP
2193 #if CONFIG_CODEC == SWCODEC
2194 { "View buffering thread", dbg_buffering_thread },
2195 #elif !defined(SIMULATOR)
2196 { "View audio thread", dbg_audio_thread },
2197 #endif
2198 #ifdef PM_DEBUG
2199 { "pm histogram", peak_meter_histogram},
2200 #endif /* PM_DEBUG */
2201 #endif /* HAVE_LCD_BITMAP */
2202 { "View buflib allocs", dbg_buflib_allocs },
2203 #ifndef SIMULATOR
2204 #if CONFIG_TUNER
2205 { "FM Radio", dbg_fm_radio },
2206 #endif
2207 #endif
2208 #if defined(HAVE_EEPROM) && !defined(HAVE_EEPROM_SETTINGS)
2209 { "Write back EEPROM", dbg_write_eeprom },
2210 #endif
2211 #if CONFIG_USBOTG == USBOTG_ISP1583
2212 { "View ISP1583 info", dbg_isp1583 },
2213 #endif
2214 #if defined(CREATIVE_ZVx) && !defined(SIMULATOR)
2215 { "View PIC info", dbg_pic },
2216 #endif
2217 #ifdef ROCKBOX_HAS_LOGF
2218 {"Show Log File", logfdisplay },
2219 {"Dump Log File", logfdump },
2220 #endif
2221 #if defined(HAVE_USBSTACK)
2222 #if defined(ROCKBOX_HAS_LOGF) && defined(USB_ENABLE_SERIAL)
2223 {"USB Serial driver (logf)", toggle_usb_serial },
2224 #endif
2225 #endif /* HAVE_USBSTACK */
2226 #ifdef CPU_BOOST_LOGGING
2227 {"cpu_boost log",cpu_boost_log},
2228 #endif
2229 #if (defined(HAVE_WHEEL_ACCELERATION) && (CONFIG_KEYPAD==IPOD_4G_PAD) \
2230 && !defined(IPOD_MINI) && !defined(SIMULATOR))
2231 {"Debug scrollwheel", dbg_scrollwheel },
2232 #endif
2233 };
2234
2235 static int menu_action_callback(int btn, struct gui_synclist *lists)
2236 {
2237 int selection = gui_synclist_get_sel_pos(lists);
2238 if (btn == ACTION_STD_OK)
2239 {
2240 FOR_NB_SCREENS(i)
2241 viewportmanager_theme_enable(i, false, NULL);
2242 menuitems[selection].function();
2243 btn = ACTION_REDRAW;
2244 FOR_NB_SCREENS(i)
2245 viewportmanager_theme_undo(i, false);
2246 }
2247 else if (btn == ACTION_STD_CONTEXT)
2248 {
2249 MENUITEM_STRINGLIST(menu_items, "Debug Menu", NULL, ID2P(LANG_ADD_TO_FAVES));
2250 if (do_menu(&menu_items, NULL, NULL, false) == 0)
2251 shortcuts_add(SHORTCUT_DEBUGITEM, menuitems[selection].desc);
2252 return ACTION_STD_CANCEL;
2253 }
2254 return btn;
2255 }
2256
2257 static const char* menu_get_name(int item, void * data,
2258 char *buffer, size_t buffer_len)
2259 {
2260 (void)data; (void)buffer; (void)buffer_len;
2261 return menuitems[item].desc;
2262 }
2263
2264 bool debug_menu(void)
2265 {
2266 struct simplelist_info info;
2267
2268 simplelist_info_init(&info, "Debug Menu", ARRAYLEN(menuitems), NULL);
2269 info.action_callback = menu_action_callback;
2270 info.get_name = menu_get_name;
2271 return simplelist_show_list(&info);
2272 }
2273
2274 bool run_debug_screen(char* screen)
2275 {
2276 for (unsigned i=0; i<ARRAYLEN(menuitems); i++)
2277 if (!strcmp(screen, menuitems[i].desc))
2278 {
2279 FOR_NB_SCREENS(j)
2280 viewportmanager_theme_enable(j, false, NULL);
2281 menuitems[i].function();
2282 FOR_NB_SCREENS(j)
2283 viewportmanager_theme_undo(j, false);
2284 return true;
2285 }
2286
2287 return false;
2288 }
thomasjfox's rockbox modifications (mameo port)