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