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