?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Android: Fix a problem where entered Rockbox multiple times (with multiple instances...
[maemo-rb.git] / apps / debug_menu.c
blobc0a476dc10c433e9aef58ba83f0f55eacc13c93c
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 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
464 #ifdef CPU_PP
465 static int perfcheck(void)
466 {
467 int result;
468
469 asm (
470 "mrs r2, CPSR \n"
471 "orr r0, r2, #0xc0 \n" /* disable IRQ and FIQ */
472 "msr CPSR_c, r0 \n"
473 "mov %[res], #0 \n"
474 "ldr r0, [%[timr]] \n"
475 "add r0, r0, %[tmo] \n"
476 "1: \n"
477 "add %[res], %[res], #1 \n"
478 "ldr r1, [%[timr]] \n"
479 "cmp r1, r0 \n"
480 "bmi 1b \n"
481 "msr CPSR_c, r2 \n" /* reset IRQ and FIQ state */
482 :
483 [res]"=&r"(result)
484 :
485 [timr]"r"(&USEC_TIMER),
486 [tmo]"r"(
487 #if CONFIG_CPU == PP5002
488 16000
489 #else /* PP5020/5022/5024 */
490 10226
491 #endif
492 )
493 :
494 "r0", "r1", "r2"
495 );
496 return result;
497 }
498 #endif
499
500 #ifdef HAVE_LCD_BITMAP
501 static bool dbg_hw_info(void)
502 {
503 #if CONFIG_CPU == SH7034
504 int bitmask = HW_MASK;
505 int rom_version = ROM_VERSION;
506 unsigned manu, id; /* flash IDs */
507 bool got_id; /* flag if we managed to get the flash IDs */
508 unsigned rom_crc = 0xffffffff; /* CRC32 of the boot ROM */
509 bool has_bootrom; /* flag for boot ROM present */
510 int oldmode; /* saved memory guard mode */
511
512 oldmode = system_memory_guard(MEMGUARD_NONE); /* disable memory guard */
513
514 /* get flash ROM type */
515 got_id = dbg_flash_id(&manu, &id, 0x5555, 0x2AAA); /* try SST, Atmel, NexFlash */
516 if (!got_id)
517 got_id = dbg_flash_id(&manu, &id, 0x555, 0x2AA); /* try AMD, Macronix */
518
519 /* check if the boot ROM area is a flash mirror */
520 has_bootrom = (memcmp((char*)0, (char*)0x02000000, 64*1024) != 0);
521 if (has_bootrom) /* if ROM and Flash different */
522 {
523 /* calculate CRC16 checksum of boot ROM */
524 rom_crc = crc_32((unsigned char*)0x0000, 64*1024, 0xffffffff);
525 }
526
527 system_memory_guard(oldmode); /* re-enable memory guard */
528
529 lcd_setfont(FONT_SYSFIXED);
530 lcd_clear_display();
531
532 lcd_puts(0, 0, "[Hardware info]");
533
534 lcd_putsf(0, 1, "ROM: %d.%02d", rom_version/100, rom_version%100);
535
536 lcd_putsf(0, 2, "Mask: 0x%04x", bitmask);
537
538 if (got_id)
539 lcd_putsf(0, 3, "Flash: M=%02x D=%02x", manu, id);
540 else
541 lcd_puts(0, 3, "Flash: M=?? D=??"); /* unknown, sorry */
542
543 if (has_bootrom)
544 {
545 if (rom_crc == 0x56DBA4EE) /* known Version 1 */
546 lcd_puts(0, 4, "Boot ROM: V1");
547 else
548 lcd_putsf(0, 4, "ROMcrc: 0x%08x", rom_crc);
549 }
550 else
551 {
552 lcd_puts(0, 4, "Boot ROM: none");
553 }
554
555 lcd_update();
556
557 while (!(action_userabort(TIMEOUT_BLOCK)));
558
559 #elif CONFIG_CPU == MCF5249 || CONFIG_CPU == MCF5250
560 unsigned manu, id; /* flash IDs */
561 int got_id; /* flag if we managed to get the flash IDs */
562 int oldmode; /* saved memory guard mode */
563 int line = 0;
564
565 oldmode = system_memory_guard(MEMGUARD_NONE); /* disable memory guard */
566
567 /* get flash ROM type */
568 got_id = dbg_flash_id(&manu, &id, 0x5555, 0x2AAA); /* try SST, Atmel, NexFlash */
569 if (!got_id)
570 got_id = dbg_flash_id(&manu, &id, 0x555, 0x2AA); /* try AMD, Macronix */
571
572 system_memory_guard(oldmode); /* re-enable memory guard */
573
574 lcd_setfont(FONT_SYSFIXED);
575 lcd_clear_display();
576
577 lcd_puts(0, line++, "[Hardware info]");
578
579 if (got_id)
580 lcd_putsf(0, line++, "Flash: M=%04x D=%04x", manu, id);
581 else
582 lcd_puts(0, line++, "Flash: M=???? D=????"); /* unknown, sorry */
583
584 #ifdef IAUDIO_X5
585 {
586 struct ds2411_id id;
587
588 lcd_puts(0, ++line, "Serial Number:");
589
590 got_id = ds2411_read_id(&id);
591
592 if (got_id == DS2411_OK)
593 {
594 lcd_putsf(0, ++line, " FC=%02x", (unsigned)id.family_code);
595 lcd_putsf(0, ++line, " ID=%02X %02X %02X %02X %02X %02X",
596 (unsigned)id.uid[0], (unsigned)id.uid[1], (unsigned)id.uid[2],
597 (unsigned)id.uid[3], (unsigned)id.uid[4], (unsigned)id.uid[5]);
598 lcd_putsf(0, ++line, " CRC=%02X", (unsigned)id.crc);
599 }
600 else
601 {
602 lcd_putsf(0, ++line, "READ ERR=%d", got_id);
603 }
604 }
605 #endif
606
607 lcd_update();
608
609 while (!(action_userabort(TIMEOUT_BLOCK)));
610
611 #elif defined(CPU_PP502x)
612 int line = 0;
613 char pp_version[] = { (PP_VER2 >> 24) & 0xff, (PP_VER2 >> 16) & 0xff,
614 (PP_VER2 >> 8) & 0xff, (PP_VER2) & 0xff,
615 (PP_VER1 >> 24) & 0xff, (PP_VER1 >> 16) & 0xff,
616 (PP_VER1 >> 8) & 0xff, (PP_VER1) & 0xff, '\0' };
617
618 lcd_setfont(FONT_SYSFIXED);
619 lcd_clear_display();
620
621 lcd_puts(0, line++, "[Hardware info]");
622
623 #ifdef IPOD_ARCH
624 lcd_putsf(0, line++, "HW rev: 0x%08lx", IPOD_HW_REVISION);
625 #endif
626
627 #ifdef IPOD_COLOR
628 extern int lcd_type; /* Defined in lcd-colornano.c */
629
630 lcd_putsf(0, line++, "LCD type: %d", lcd_type);
631 #endif
632
633 lcd_putsf(0, line++, "PP version: %s", pp_version);
634
635 lcd_putsf(0, line++, "Est. clock (kHz): %d", perfcheck());
636
637 lcd_update();
638
639 while (!(action_userabort(TIMEOUT_BLOCK)));
640
641 #elif CONFIG_CPU == PP5002
642 int line = 0;
643 char pp_version[] = { (PP_VER4 >> 8) & 0xff, PP_VER4 & 0xff,
644 (PP_VER3 >> 8) & 0xff, PP_VER3 & 0xff,
645 (PP_VER2 >> 8) & 0xff, PP_VER2 & 0xff,
646 (PP_VER1 >> 8) & 0xff, PP_VER1 & 0xff, '\0' };
647
648
649 lcd_setfont(FONT_SYSFIXED);
650 lcd_clear_display();
651
652 lcd_puts(0, line++, "[Hardware info]");
653
654 #ifdef IPOD_ARCH
655 lcd_putsf(0, line++, "HW rev: 0x%08lx", IPOD_HW_REVISION);
656 #endif
657
658 lcd_putsf(0, line++, "PP version: %s", pp_version);
659
660 lcd_putsf(0, line++, "Est. clock (kHz): %d", perfcheck());
661
662 lcd_update();
663
664 while (!(action_userabort(TIMEOUT_BLOCK)));
665
666 #else
667 /* Define this function in your target tree */
668 return __dbg_hw_info();
669 #endif /* CONFIG_CPU */
670 lcd_setfont(FONT_UI);
671 return false;
672 }
673 #else /* !HAVE_LCD_BITMAP */
674 static bool dbg_hw_info(void)
675 {
676 int button;
677 int currval = 0;
678 int rom_version = ROM_VERSION;
679 unsigned manu, id; /* flash IDs */
680 bool got_id; /* flag if we managed to get the flash IDs */
681 unsigned rom_crc = 0xffffffff; /* CRC32 of the boot ROM */
682 bool has_bootrom; /* flag for boot ROM present */
683 int oldmode; /* saved memory guard mode */
684
685 oldmode = system_memory_guard(MEMGUARD_NONE); /* disable memory guard */
686
687 /* get flash ROM type */
688 got_id = dbg_flash_id(&manu, &id, 0x5555, 0x2AAA); /* try SST, Atmel, NexFlash */
689 if (!got_id)
690 got_id = dbg_flash_id(&manu, &id, 0x555, 0x2AA); /* try AMD, Macronix */
691
692 /* check if the boot ROM area is a flash mirror */
693 has_bootrom = (memcmp((char*)0, (char*)0x02000000, 64*1024) != 0);
694 if (has_bootrom) /* if ROM and Flash different */
695 {
696 /* calculate CRC16 checksum of boot ROM */
697 rom_crc = crc_32((unsigned char*)0x0000, 64*1024, 0xffffffff);
698 }
699
700 system_memory_guard(oldmode); /* re-enable memory guard */
701
702 lcd_clear_display();
703
704 lcd_puts(0, 0, "[HW Info]");
705 while(1)
706 {
707 switch(currval)
708 {
709 case 0:
710 lcd_putsf(0, 1, "ROM: %d.%02d",
711 rom_version/100, rom_version%100);
712 break;
713 case 1:
714 if (got_id)
715 lcd_putsf(0, 1, "Flash:%02x,%02x", manu, id);
716 else
717 lcd_puts(0, 1, "Flash:??,??"); /* unknown, sorry */
718 break;
719 case 2:
720 if (has_bootrom)
721 {
722 if (rom_crc == 0x56DBA4EE) /* known Version 1 */
723 lcd_puts(0, 1, "BootROM: V1");
724 else if (rom_crc == 0x358099E8)
725 lcd_puts(0, 1, "BootROM: V2");
726 /* alternative boot ROM found in one single player so far */
727 else
728 lcd_putsf(0, 1, "R: %08x", rom_crc);
729 }
730 else
731 lcd_puts(0, 1, "BootROM: no");
732 }
733
734 lcd_update();
735
736 button = get_action(CONTEXT_SETTINGS,TIMEOUT_BLOCK);
737
738 switch(button)
739 {
740 case ACTION_STD_CANCEL:
741 return false;
742
743 case ACTION_SETTINGS_DEC:
744 currval--;
745 if(currval < 0)
746 currval = 2;
747 break;
748
749 case ACTION_SETTINGS_INC:
750 currval++;
751 if(currval > 2)
752 currval = 0;
753 break;
754 }
755 }
756 return false;
757 }
758 #endif /* !HAVE_LCD_BITMAP */
759 #endif /* PLATFORM_NATIVE */
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 int button;
1266 int adc_battery_voltage;
1267 int currval = 0;
1268
1269 lcd_clear_display();
1270
1271 while(1)
1272 {
1273 if (currval == 0) {
1274 lcd_putsf(0, 0, "PADR: %04x", (unsigned short)PADR);
1275 } else if (currval == 1) {
1276 lcd_putsf(0, 0, "PBDR: %04x", (unsigned short)PBDR);
1277 } else {
1278 int idx = currval - 2; /* idx < 7 */
1279 lcd_putsf(0, 0, "AN%d: %03x", idx, adc_read(idx));
1280 }
1281
1282 battery_read_info(&adc_battery_voltage, NULL);
1283 lcd_putsf(0, 1, "Batt: %d.%03dV", adc_battery_voltage / 1000,
1284 adc_battery_voltage % 1000);
1285 lcd_update();
1286
1287 button = get_action(CONTEXT_SETTINGS,HZ/5);
1288
1289 switch(button)
1290 {
1291 case ACTION_STD_CANCEL:
1292 return false;
1293
1294 case ACTION_SETTINGS_DEC:
1295 currval--;
1296 if(currval < 0)
1297 currval = 9;
1298 break;
1299
1300 case ACTION_SETTINGS_INC:
1301 currval++;
1302 if(currval > 9)
1303 currval = 0;
1304 break;
1305 }
1306 }
1307 return false;
1308 }
1309 #endif /* !HAVE_LCD_BITMAP */
1310 #endif /* PLATFORM_NATIVE */
1311
1312 #if (CONFIG_RTC == RTC_PCF50605) && (CONFIG_PLATFORM & PLATFORM_NATIVE)
1313 static bool dbg_pcf(void)
1314 {
1315 int line;
1316
1317 #ifdef HAVE_LCD_BITMAP
1318 lcd_setfont(FONT_SYSFIXED);
1319 #endif
1320 lcd_clear_display();
1321
1322 while(1)
1323 {
1324 line = 0;
1325
1326 lcd_putsf(0, line++, "DCDC1: %02x", pcf50605_read(0x1b));
1327 lcd_putsf(0, line++, "DCDC2: %02x", pcf50605_read(0x1c));
1328 lcd_putsf(0, line++, "DCDC3: %02x", pcf50605_read(0x1d));
1329 lcd_putsf(0, line++, "DCDC4: %02x", pcf50605_read(0x1e));
1330 lcd_putsf(0, line++, "DCDEC1: %02x", pcf50605_read(0x1f));
1331 lcd_putsf(0, line++, "DCDEC2: %02x", pcf50605_read(0x20));
1332 lcd_putsf(0, line++, "DCUDC1: %02x", pcf50605_read(0x21));
1333 lcd_putsf(0, line++, "DCUDC2: %02x", pcf50605_read(0x22));
1334 lcd_putsf(0, line++, "IOREGC: %02x", pcf50605_read(0x23));
1335 lcd_putsf(0, line++, "D1REGC: %02x", pcf50605_read(0x24));
1336 lcd_putsf(0, line++, "D2REGC: %02x", pcf50605_read(0x25));
1337 lcd_putsf(0, line++, "D3REGC: %02x", pcf50605_read(0x26));
1338 lcd_putsf(0, line++, "LPREG1: %02x", pcf50605_read(0x27));
1339 lcd_update();
1340 if (button_get_w_tmo(HZ/10) == (DEBUG_CANCEL|BUTTON_REL))
1341 {
1342 lcd_setfont(FONT_UI);
1343 return false;
1344 }
1345 }
1346
1347 lcd_setfont(FONT_UI);
1348 return false;
1349 }
1350 #endif
1351
1352 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1353 static bool dbg_cpufreq(void)
1354 {
1355 int line;
1356 int button;
1357
1358 #ifdef HAVE_LCD_BITMAP
1359 lcd_setfont(FONT_SYSFIXED);
1360 #endif
1361 lcd_clear_display();
1362
1363 while(1)
1364 {
1365 line = 0;
1366
1367 lcd_putsf(0, line++, "Frequency: %ld", FREQ);
1368 lcd_putsf(0, line++, "boost_counter: %d", get_cpu_boost_counter());
1369
1370 lcd_update();
1371 button = get_action(CONTEXT_STD,HZ/10);
1372
1373 switch(button)
1374 {
1375 case ACTION_STD_PREV:
1376 cpu_boost(true);
1377 break;
1378
1379 case ACTION_STD_NEXT:
1380 cpu_boost(false);
1381 break;
1382
1383 case ACTION_STD_OK:
1384 while (get_cpu_boost_counter() > 0)
1385 cpu_boost(false);
1386 set_cpu_frequency(CPUFREQ_DEFAULT);
1387 break;
1388
1389 case ACTION_STD_CANCEL:
1390 lcd_setfont(FONT_UI);
1391 return false;
1392 }
1393 }
1394 lcd_setfont(FONT_UI);
1395 return false;
1396 }
1397 #endif /* HAVE_ADJUSTABLE_CPU_FREQ */
1398
1399 #if defined(HAVE_TSC2100) && (CONFIG_PLATFORM & PLATFORM_NATIVE)
1400 #include "tsc2100.h"
1401 static char *itob(int n, int len)
1402 {
1403 static char binary[64];
1404 int i,j;
1405 for (i=1, j=0;i<=len;i++)
1406 {
1407 binary[j++] = n&(1<<(len-i))?'1':'0';
1408 if (i%4 == 0)
1409 binary[j++] = ' ';
1410 }
1411 binary[j] = '\0';
1412 return binary;
1413 }
1414
1415 static const char* tsc2100_debug_getname(int selected_item, void * data,
1416 char *buffer, size_t buffer_len)
1417 {
1418 int *page = (int*)data;
1419 bool reserved = false;
1420 switch (*page)
1421 {
1422 case 0:
1423 if ((selected_item > 0x0a) ||
1424 (selected_item == 0x04) ||
1425 (selected_item == 0x08))
1426 reserved = true;
1427 break;
1428 case 1:
1429 if ((selected_item > 0x05) ||
1430 (selected_item == 0x02))
1431 reserved = true;
1432 break;
1433 case 2:
1434 if (selected_item > 0x1e)
1435 reserved = true;
1436 break;
1437 }
1438 if (reserved)
1439 snprintf(buffer, buffer_len, "%02x: RESERVED", selected_item);
1440 else
1441 snprintf(buffer, buffer_len, "%02x: %s", selected_item,
1442 itob(tsc2100_readreg(*page, selected_item)&0xffff,16));
1443 return buffer;
1444 }
1445 static int tsc2100debug_action_callback(int action, struct gui_synclist *lists)
1446 {
1447 int *page = (int*)lists->data;
1448 if (action == ACTION_STD_OK)
1449 {
1450 *page = (*page+1)%3;
1451 snprintf(lists->title, 32,
1452 "tsc2100 registers - Page %d", *page);
1453 return ACTION_REDRAW;
1454 }
1455 return action;
1456 }
1457 static bool tsc2100_debug(void)
1458 {
1459 int page = 0;
1460 char title[32] = "tsc2100 registers - Page 0";
1461 struct simplelist_info info;
1462 simplelist_info_init(&info, title, 32, &page);
1463 info.timeout = HZ/100;
1464 info.get_name = tsc2100_debug_getname;
1465 info.action_callback= tsc2100debug_action_callback;
1466 return simplelist_show_list(&info);
1467 }
1468 #endif
1469 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
1470 #ifdef HAVE_LCD_BITMAP
1471 /*
1472 * view_battery() shows a automatically scaled graph of the battery voltage
1473 * over time. Usable for estimating battery life / charging rate.
1474 * The power_history array is updated in power_thread of powermgmt.c.
1475 */
1476
1477 #define BAT_LAST_VAL MIN(LCD_WIDTH, POWER_HISTORY_LEN)
1478 #define BAT_YSPACE (LCD_HEIGHT - 20)
1479
1480
1481 static bool view_battery(void)
1482 {
1483 int view = 0;
1484 int i, x, y, y1, y2, grid, graph;
1485 unsigned short maxv, minv;
1486
1487 lcd_setfont(FONT_SYSFIXED);
1488
1489 while(1)
1490 {
1491 lcd_clear_display();
1492 switch (view) {
1493 case 0: /* voltage history graph */
1494 /* Find maximum and minimum voltage for scaling */
1495 minv = power_history[0];
1496 maxv = minv + 1;
1497 for (i = 1; i < BAT_LAST_VAL && power_history[i]; i++) {
1498 if (power_history[i] > maxv)
1499 maxv = power_history[i];
1500 if (power_history[i] < minv)
1501 minv = power_history[i];
1502 }
1503
1504 /* adjust grid scale */
1505 if ((maxv - minv) > 50)
1506 grid = 50;
1507 else
1508 grid = 5;
1509
1510 /* print header */
1511 lcd_putsf(0, 0, "battery %d.%03dV", power_history[0] / 1000,
1512 power_history[0] % 1000);
1513 lcd_putsf(0, 1, "%d.%03d-%d.%03dV (%2dmV)",
1514 minv / 1000, minv % 1000, maxv / 1000, maxv % 1000,
1515 grid);
1516
1517 i = 1;
1518 while ((y = (minv - (minv % grid)+i*grid)) < maxv)
1519 {
1520 graph = ((y-minv)*BAT_YSPACE)/(maxv-minv);
1521 graph = LCD_HEIGHT-1 - graph;
1522
1523 /* draw dotted horizontal grid line */
1524 for (x=0; x<LCD_WIDTH;x=x+2)
1525 lcd_drawpixel(x,graph);
1526
1527 i++;
1528 }
1529
1530 x = 0;
1531 /* draw plot of power history
1532 * skip empty entries
1533 */
1534 for (i = BAT_LAST_VAL - 1; i > 0; i--)
1535 {
1536 if (power_history[i] && power_history[i-1])
1537 {
1538 y1 = (power_history[i] - minv) * BAT_YSPACE /
1539 (maxv - minv);
1540 y1 = MIN(MAX(LCD_HEIGHT-1 - y1, 20),
1541 LCD_HEIGHT-1);
1542 y2 = (power_history[i-1] - minv) * BAT_YSPACE /
1543 (maxv - minv);
1544 y2 = MIN(MAX(LCD_HEIGHT-1 - y2, 20),
1545 LCD_HEIGHT-1);
1546
1547 lcd_set_drawmode(DRMODE_SOLID);
1548
1549 /* make line thicker */
1550 lcd_drawline(((x*LCD_WIDTH)/(BAT_LAST_VAL)),
1551 y1,
1552 (((x+1)*LCD_WIDTH)/(BAT_LAST_VAL)),
1553 y2);
1554 lcd_drawline(((x*LCD_WIDTH)/(BAT_LAST_VAL))+1,
1555 y1+1,
1556 (((x+1)*LCD_WIDTH)/(BAT_LAST_VAL))+1,
1557 y2+1);
1558 x++;
1559 }
1560 }
1561 break;
1562
1563 case 1: /* status: */
1564 #if CONFIG_CHARGING >= CHARGING_MONITOR
1565 lcd_putsf(0, 0, "Pwr status: %s",
1566 charging_state() ? "charging" : "discharging");
1567 #else
1568 lcd_puts(0, 0, "Power status:");
1569 #endif
1570 battery_read_info(&y, NULL);
1571 lcd_putsf(0, 1, "Battery: %d.%03d V", y / 1000, y % 1000);
1572 #ifdef ADC_EXT_POWER
1573 y = (adc_read(ADC_EXT_POWER) * EXT_SCALE_FACTOR) / 1000;
1574 lcd_putsf(0, 2, "External: %d.%03d V", y / 1000, y % 1000);
1575 #endif
1576 #if CONFIG_CHARGING
1577 #if defined ARCHOS_RECORDER
1578 lcd_putsf(0, 3, "Chgr: %s %s",
1579 charger_inserted() ? "present" : "absent",
1580 charger_enabled() ? "on" : "off");
1581 lcd_putsf(0, 5, "short delta: %d", short_delta);
1582 lcd_putsf(0, 6, "long delta: %d", long_delta);
1583 lcd_puts(0, 7, power_message);
1584 lcd_putsf(0, 8, "USB Inserted: %s",
1585 usb_inserted() ? "yes" : "no");
1586 #elif defined IPOD_NANO || defined IPOD_VIDEO
1587 int usb_pwr = (GPIOL_INPUT_VAL & 0x10)?true:false;
1588 int ext_pwr = (GPIOL_INPUT_VAL & 0x08)?false:true;
1589 int dock = (GPIOA_INPUT_VAL & 0x10)?true:false;
1590 int charging = (GPIOB_INPUT_VAL & 0x01)?false:true;
1591 int headphone= (GPIOA_INPUT_VAL & 0x80)?true:false;
1592
1593 lcd_putsf(0, 3, "USB pwr: %s",
1594 usb_pwr ? "present" : "absent");
1595 lcd_putsf(0, 4, "EXT pwr: %s",
1596 ext_pwr ? "present" : "absent");
1597 lcd_putsf(0, 5, "Battery: %s",
1598 charging ? "charging" : (usb_pwr||ext_pwr) ? "charged" : "discharging");
1599 lcd_putsf(0, 6, "Dock mode: %s",
1600 dock ? "enabled" : "disabled");
1601 lcd_putsf(0, 7, "Headphone: %s",
1602 headphone ? "connected" : "disconnected");
1603 #ifdef IPOD_VIDEO
1604 if(probed_ramsize == 64)
1605 x = (adc_read(ADC_4066_ISTAT) * 2400) / (1024 * 2);
1606 else
1607 x = (adc_read(ADC_4066_ISTAT) * 2400) / (1024 * 3);
1608 lcd_putsf(0, 8, "Ibat: %d mA", x);
1609 lcd_putsf(0, 9, "Vbat * Ibat: %d mW", x * y / 1000);
1610 #endif
1611 #elif defined TOSHIBA_GIGABEAT_S
1612 int line = 3;
1613 unsigned int st;
1614
1615 static const unsigned char * const chrgstate_strings[] =
1616 {
1617 "Disabled",
1618 "Error",
1619 "Discharging",
1620 "Precharge",
1621 "Constant Voltage",
1622 "Constant Current",
1623 "<unknown>",
1624 };
1625
1626 lcd_putsf(0, line++, "Charger: %s",
1627 charger_inserted() ? "present" : "absent");
1628
1629 st = power_input_status() &
1630 (POWER_INPUT_CHARGER | POWER_INPUT_BATTERY);
1631 lcd_putsf(0, line++, "%s%s",
1632 (st & POWER_INPUT_MAIN_CHARGER) ? " Main" : "",
1633 (st & POWER_INPUT_USB_CHARGER) ? " USB" : "");
1634
1635 y = ARRAYLEN(chrgstate_strings) - 1;
1636
1637 switch (charge_state)
1638 {
1639 case CHARGE_STATE_DISABLED: y--;
1640 case CHARGE_STATE_ERROR: y--;
1641 case DISCHARGING: y--;
1642 case TRICKLE: y--;
1643 case TOPOFF: y--;
1644 case CHARGING: y--;
1645 default:;
1646 }
1647
1648 lcd_putsf(0, line++, "State: %s", chrgstate_strings[y]);
1649
1650 lcd_putsf(0, line++, "Battery Switch: %s",
1651 (st & POWER_INPUT_BATTERY) ? "On" : "Off");
1652
1653 y = chrgraw_adc_voltage();
1654 lcd_putsf(0, line++, "CHRGRAW: %d.%03d V",
1655 y / 1000, y % 1000);
1656
1657 y = application_supply_adc_voltage();
1658 lcd_putsf(0, line++, "BP : %d.%03d V",
1659 y / 1000, y % 1000);
1660
1661 y = battery_adc_charge_current();
1662 if (y < 0) x = '-', y = -y;
1663 else x = ' ';
1664 lcd_putsf(0, line++, "CHRGISN:%c%d mA", x, y);
1665
1666 y = cccv_regulator_dissipation();
1667 lcd_putsf(0, line++, "P CCCV : %d mW", y);
1668
1669 y = battery_charge_current();
1670 if (y < 0) x = '-', y = -y;
1671 else x = ' ';
1672 lcd_putsf(0, line++, "I Charge:%c%d mA", x, y);
1673
1674 y = battery_adc_temp();
1675
1676 if (y != INT_MIN) {
1677 lcd_putsf(0, line++, "T Battery: %dC (%dF)", y,
1678 (9*y + 160) / 5);
1679 } else {
1680 /* Conversion disabled */
1681 lcd_puts(0, line++, "T Battery: ?");
1682 }
1683
1684 #elif defined(SANSA_E200) || defined(SANSA_C200) || CONFIG_CPU == AS3525 || \
1685 CONFIG_CPU == AS3525v2
1686 static const char * const chrgstate_strings[] =
1687 {
1688 [CHARGE_STATE_DISABLED - CHARGE_STATE_DISABLED]= "Disabled",
1689 [CHARGE_STATE_ERROR - CHARGE_STATE_DISABLED] = "Error",
1690 [DISCHARGING - CHARGE_STATE_DISABLED] = "Discharging",
1691 [CHARGING - CHARGE_STATE_DISABLED] = "Charging",
1692 };
1693 const char *str = NULL;
1694
1695 lcd_putsf(0, 3, "Charger: %s",
1696 charger_inserted() ? "present" : "absent");
1697
1698 y = charge_state - CHARGE_STATE_DISABLED;
1699 if ((unsigned)y < ARRAYLEN(chrgstate_strings))
1700 str = chrgstate_strings[y];
1701
1702 lcd_putsf(0, 4, "State: %s",
1703 str ? str : "<unknown>");
1704
1705 lcd_putsf(0, 5, "CHARGER: %02X", ascodec_read_charger());
1706 #elif defined(IPOD_NANO2G)
1707 y = pmu_read_battery_voltage();
1708 lcd_putsf(17, 1, "RAW: %d.%03d V", y / 1000, y % 1000);
1709 y = pmu_read_battery_current();
1710 lcd_putsf(0, 2, "Battery current: %d mA", y);
1711 lcd_putsf(0, 3, "PWRCON: %8x", PWRCON);
1712 lcd_putsf(0, 4, "PWRCONEXT: %8x", PWRCONEXT);
1713 x = pmu_read(0x1b) & 0xf;
1714 y = pmu_read(0x1a) * 25 + 625;
1715 lcd_putsf(0, 5, "AUTO: %x / %d mV", x, y);
1716 x = pmu_read(0x1f) & 0xf;
1717 y = pmu_read(0x1e) * 25 + 625;
1718 lcd_putsf(0, 6, "DOWN1: %x / %d mV", x, y);
1719 x = pmu_read(0x23) & 0xf;
1720 y = pmu_read(0x22) * 25 + 625;
1721 lcd_putsf(0, 7, "DOWN2: %x / %d mV", x, y);
1722 x = pmu_read(0x27) & 0xf;
1723 y = pmu_read(0x26) * 100 + 900;
1724 lcd_putsf(0, 8, "MEMLDO: %x / %d mV", x, y);
1725 for (i = 0; i < 6; i++)
1726 {
1727 x = pmu_read(0x2e + (i << 1)) & 0xf;
1728 y = pmu_read(0x2d + (i << 1)) * 100 + 900;
1729 lcd_putsf(0, 9 + i, "LDO%d: %x / %d mV", i + 1, x, y);
1730 }
1731 lcd_putsf(0, 15, "CLKCON: %8x", CLKCON);
1732 lcd_putsf(17, 15, "PLL0: %6x", PLL0PMS);
1733 #else
1734 lcd_putsf(0, 3, "Charger: %s",
1735 charger_inserted() ? "present" : "absent");
1736 #endif /* target type */
1737 #endif /* CONFIG_CHARGING */
1738 break;
1739
1740 case 2: /* voltage deltas: */
1741 lcd_puts(0, 0, "Voltage deltas:");
1742
1743 for (i = 0; i <= 6; i++) {
1744 y = power_history[i] - power_history[i+1];
1745 lcd_putsf(0, i+1, "-%d min: %s%d.%03d V", i,
1746 (y < 0) ? "-" : "", ((y < 0) ? y * -1 : y) / 1000,
1747 ((y < 0) ? y * -1 : y ) % 1000);
1748 }
1749 break;
1750
1751 case 3: /* remaining time estimation: */
1752
1753 #ifdef ARCHOS_RECORDER
1754 lcd_putsf(0, 0, "charge_state: %d", charge_state);
1755
1756 lcd_putsf(0, 1, "Cycle time: %d m", powermgmt_last_cycle_startstop_min);
1757
1758 lcd_putsf(0, 2, "Lvl@cyc st: %d%%", powermgmt_last_cycle_level);
1759
1760 lcd_putsf(0, 3, "P=%2d I=%2d", pid_p, pid_i);
1761
1762 lcd_putsf(0, 4, "Trickle sec: %d/60", trickle_sec);
1763 #endif /* ARCHOS_RECORDER */
1764
1765 lcd_putsf(0, 5, "Last PwrHist: %d.%03dV",
1766 power_history[0] / 1000,
1767 power_history[0] % 1000);
1768
1769 lcd_putsf(0, 6, "battery level: %d%%", battery_level());
1770
1771 lcd_putsf(0, 7, "Est. remain: %d m", battery_time());
1772 break;
1773 }
1774
1775 lcd_update();
1776
1777 switch(get_action(CONTEXT_STD,HZ/2))
1778 {
1779 case ACTION_STD_PREV:
1780 if (view)
1781 view--;
1782 break;
1783
1784 case ACTION_STD_NEXT:
1785 if (view < 3)
1786 view++;
1787 break;
1788
1789 case ACTION_STD_CANCEL:
1790 lcd_setfont(FONT_UI);
1791 return false;
1792 }
1793 }
1794 lcd_setfont(FONT_UI);
1795 return false;
1796 }
1797
1798 #endif /* HAVE_LCD_BITMAP */
1799 #endif
1800
1801 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
1802 #if (CONFIG_STORAGE & STORAGE_MMC) || (CONFIG_STORAGE & STORAGE_SD)
1803
1804 #if (CONFIG_STORAGE & STORAGE_MMC)
1805 #define CARDTYPE "MMC"
1806 #elif (CONFIG_STORAGE & STORAGE_SD)
1807 #define CARDTYPE "microSD"
1808 #endif
1809
1810 static int disk_callback(int btn, struct gui_synclist *lists)
1811 {
1812 tCardInfo *card;
1813 int *cardnum = (int*)lists->data;
1814 unsigned char card_name[6];
1815 unsigned char pbuf[32];
1816 char *title = lists->title;
1817 static const unsigned char i_vmin[] = { 0, 1, 5, 10, 25, 35, 60, 100 };
1818 static const unsigned char i_vmax[] = { 1, 5, 10, 25, 35, 45, 80, 200 };
1819 static const unsigned char * const kbit_units[] = { "kBit/s", "MBit/s", "GBit/s" };
1820 static const unsigned char * const nsec_units[] = { "ns", "µs", "ms" };
1821 #if (CONFIG_STORAGE & STORAGE_MMC)
1822 static const char * const mmc_spec_vers[] = { "1.0-1.2", "1.4", "2.0-2.2",
1823 "3.1-3.31", "4.0" };
1824 #endif
1825
1826 if ((btn == ACTION_STD_OK) || (btn == SYS_FS_CHANGED) || (btn == ACTION_REDRAW))
1827 {
1828 #ifdef HAVE_HOTSWAP
1829 if (btn == ACTION_STD_OK)
1830 {
1831 *cardnum ^= 0x1; /* change cards */
1832 }
1833 #endif
1834
1835 simplelist_set_line_count(0);
1836
1837 card = card_get_info(*cardnum);
1838
1839 if (card->initialized > 0)
1840 {
1841 unsigned i;
1842 for (i=0; i<sizeof(card_name); i++)
1843 {
1844 card_name[i] = card_extract_bits(card->cid, (103-8*i), 8);
1845 }
1846 strlcpy(card_name, card_name, sizeof(card_name));
1847 simplelist_addline(SIMPLELIST_ADD_LINE,
1848 "%s Rev %d.%d", card_name,
1849 (int) card_extract_bits(card->cid, 63, 4),
1850 (int) card_extract_bits(card->cid, 59, 4));
1851 simplelist_addline(SIMPLELIST_ADD_LINE,
1852 "Prod: %d/%d",
1853 #if (CONFIG_STORAGE & STORAGE_SD)
1854 (int) card_extract_bits(card->cid, 11, 4),
1855 (int) card_extract_bits(card->cid, 19, 8) + 2000
1856 #elif (CONFIG_STORAGE & STORAGE_MMC)
1857 (int) card_extract_bits(card->cid, 15, 4),
1858 (int) card_extract_bits(card->cid, 11, 4) + 1997
1859 #endif
1860 );
1861 simplelist_addline(SIMPLELIST_ADD_LINE,
1862 #if (CONFIG_STORAGE & STORAGE_SD)
1863 "Ser#: 0x%08lx",
1864 card_extract_bits(card->cid, 55, 32)
1865 #elif (CONFIG_STORAGE & STORAGE_MMC)
1866 "Ser#: 0x%04lx",
1867 card_extract_bits(card->cid, 47, 16)
1868 #endif
1869 );
1870
1871 simplelist_addline(SIMPLELIST_ADD_LINE, "M=%02x, "
1872 #if (CONFIG_STORAGE & STORAGE_SD)
1873 "O=%c%c",
1874 (int) card_extract_bits(card->cid, 127, 8),
1875 card_extract_bits(card->cid, 119, 8),
1876 card_extract_bits(card->cid, 111, 8)
1877 #elif (CONFIG_STORAGE & STORAGE_MMC)
1878 "O=%04x",
1879 (int) card_extract_bits(card->cid, 127, 8),
1880 (int) card_extract_bits(card->cid, 119, 16)
1881 #endif
1882 );
1883
1884 #if (CONFIG_STORAGE & STORAGE_MMC)
1885 int temp = card_extract_bits(card->csd, 125, 4);
1886 simplelist_addline(SIMPLELIST_ADD_LINE,
1887 "MMC v%s", temp < 5 ?
1888 mmc_spec_vers[temp] : "?.?");
1889 #endif
1890 simplelist_addline(SIMPLELIST_ADD_LINE,
1891 "Blocks: 0x%08lx", card->numblocks);
1892 output_dyn_value(pbuf, sizeof pbuf, card->speed / 1000,
1893 kbit_units, false);
1894 simplelist_addline(SIMPLELIST_ADD_LINE,
1895 "Speed: %s", pbuf);
1896 output_dyn_value(pbuf, sizeof pbuf, card->taac,
1897 nsec_units, false);
1898 simplelist_addline(SIMPLELIST_ADD_LINE,
1899 "Taac: %s", pbuf);
1900 simplelist_addline(SIMPLELIST_ADD_LINE,
1901 "Nsac: %d clk", card->nsac);
1902 simplelist_addline(SIMPLELIST_ADD_LINE,
1903 "R2W: *%d", card->r2w_factor);
1904 simplelist_addline(SIMPLELIST_ADD_LINE,
1905 "IRmax: %d..%d mA",
1906 i_vmin[card_extract_bits(card->csd, 61, 3)],
1907 i_vmax[card_extract_bits(card->csd, 58, 3)]);
1908 simplelist_addline(SIMPLELIST_ADD_LINE,
1909 "IWmax: %d..%d mA",
1910 i_vmin[card_extract_bits(card->csd, 55, 3)],
1911 i_vmax[card_extract_bits(card->csd, 52, 3)]);
1912 }
1913 else if (card->initialized == 0)
1914 {
1915 simplelist_addline(SIMPLELIST_ADD_LINE, "Not Found!");
1916 }
1917 #if (CONFIG_STORAGE & STORAGE_SD)
1918 else /* card->initialized < 0 */
1919 {
1920 simplelist_addline(SIMPLELIST_ADD_LINE, "Init Error! (%d)", card->initialized);
1921 }
1922 #endif
1923 snprintf(title, 16, "[" CARDTYPE " %d]", *cardnum);
1924 gui_synclist_set_title(lists, title, Icon_NOICON);
1925 gui_synclist_set_nb_items(lists, simplelist_get_line_count());
1926 gui_synclist_select_item(lists, 0);
1927 btn = ACTION_REDRAW;
1928 }
1929 return btn;
1930 }
1931 #elif (CONFIG_STORAGE & STORAGE_ATA)
1932 static int disk_callback(int btn, struct gui_synclist *lists)
1933 {
1934 (void)lists;
1935 int i;
1936 char buf[128];
1937 unsigned short* identify_info = ata_get_identify();
1938 bool timing_info_present = false;
1939 (void)btn;
1940
1941 simplelist_set_line_count(0);
1942
1943 for (i=0; i < 20; i++)
1944 ((unsigned short*)buf)[i]=htobe16(identify_info[i+27]);
1945 buf[40]=0;
1946 /* kill trailing space */
1947 for (i=39; i && buf[i]==' '; i--)
1948 buf[i] = 0;
1949 simplelist_addline(SIMPLELIST_ADD_LINE, "Model: %s", buf);
1950 for (i=0; i < 4; i++)
1951 ((unsigned short*)buf)[i]=htobe16(identify_info[i+23]);
1952 buf[8]=0;
1953 simplelist_addline(SIMPLELIST_ADD_LINE,
1954 "Firmware: %s", buf);
1955 snprintf(buf, sizeof buf, "%ld MB",
1956 ((unsigned long)identify_info[61] << 16 |
1957 (unsigned long)identify_info[60]) / 2048 );
1958 simplelist_addline(SIMPLELIST_ADD_LINE,
1959 "Size: %s", buf);
1960 unsigned long free;
1961 fat_size( IF_MV2(0,) NULL, &free );
1962 simplelist_addline(SIMPLELIST_ADD_LINE,
1963 "Free: %ld MB", free / 1024);
1964 simplelist_addline(SIMPLELIST_ADD_LINE,
1965 "Spinup time: %d ms", storage_spinup_time() * (1000/HZ));
1966 i = identify_info[83] & (1<<3);
1967 simplelist_addline(SIMPLELIST_ADD_LINE,
1968 "Power mgmt: %s", i ? "enabled" : "unsupported");
1969 i = identify_info[83] & (1<<9);
1970 simplelist_addline(SIMPLELIST_ADD_LINE,
1971 "Noise mgmt: %s", i ? "enabled" : "unsupported");
1972 i = identify_info[82] & (1<<6);
1973 simplelist_addline(SIMPLELIST_ADD_LINE,
1974 "Read-ahead: %s", i ? "enabled" : "unsupported");
1975 timing_info_present = identify_info[53] & (1<<1);
1976 if(timing_info_present) {
1977 char pio3[2], pio4[2];pio3[1] = 0;
1978 pio4[1] = 0;
1979 pio3[0] = (identify_info[64] & (1<<0)) ? '3' : 0;
1980 pio4[0] = (identify_info[64] & (1<<1)) ? '4' : 0;
1981 simplelist_addline(SIMPLELIST_ADD_LINE,
1982 "PIO modes: 0 1 2 %s %s", pio3, pio4);
1983 }
1984 else {
1985 simplelist_addline(SIMPLELIST_ADD_LINE,
1986 "No PIO mode info");
1987 }
1988 timing_info_present = identify_info[53] & (1<<1);
1989 if(timing_info_present) {
1990 simplelist_addline(SIMPLELIST_ADD_LINE,
1991 "Cycle times %dns/%dns",
1992 identify_info[67],
1993 identify_info[68] );
1994 } else {
1995 simplelist_addline(SIMPLELIST_ADD_LINE,
1996 "No timing info");
1997 }
1998 int sector_size = 512;
1999 if((identify_info[106] & 0xe000) == 0x6000)
2000 sector_size *= BIT_N(identify_info[106] & 0x000f);
2001 simplelist_addline(SIMPLELIST_ADD_LINE,
2002 "Physical sector size: %d", sector_size);
2003 #ifdef HAVE_ATA_DMA
2004 if (identify_info[63] & (1<<0)) {
2005 char mdma0[2], mdma1[2], mdma2[2];
2006 mdma0[1] = mdma1[1] = mdma2[1] = 0;
2007 mdma0[0] = (identify_info[63] & (1<<0)) ? '0' : 0;
2008 mdma1[0] = (identify_info[63] & (1<<1)) ? '1' : 0;
2009 mdma2[0] = (identify_info[63] & (1<<2)) ? '2' : 0;
2010 simplelist_addline(SIMPLELIST_ADD_LINE,
2011 "MDMA modes: %s %s %s", mdma0, mdma1, mdma2);
2012 simplelist_addline(SIMPLELIST_ADD_LINE,
2013 "MDMA Cycle times %dns/%dns",
2014 identify_info[65],
2015 identify_info[66] );
2016 }
2017 else {
2018 simplelist_addline(SIMPLELIST_ADD_LINE,
2019 "No MDMA mode info");
2020 }
2021 if (identify_info[53] & (1<<2)) {
2022 char udma0[2], udma1[2], udma2[2], udma3[2], udma4[2], udma5[2], udma6[2];
2023 udma0[1] = udma1[1] = udma2[1] = udma3[1] = udma4[1] = udma5[1] = udma6[1] = 0;
2024 udma0[0] = (identify_info[88] & (1<<0)) ? '0' : 0;
2025 udma1[0] = (identify_info[88] & (1<<1)) ? '1' : 0;
2026 udma2[0] = (identify_info[88] & (1<<2)) ? '2' : 0;
2027 udma3[0] = (identify_info[88] & (1<<3)) ? '3' : 0;
2028 udma4[0] = (identify_info[88] & (1<<4)) ? '4' : 0;
2029 udma5[0] = (identify_info[88] & (1<<5)) ? '5' : 0;
2030 udma6[0] = (identify_info[88] & (1<<6)) ? '6' : 0;
2031 simplelist_addline(SIMPLELIST_ADD_LINE,
2032 "UDMA modes: %s %s %s %s %s %s %s", udma0, udma1, udma2,
2033 udma3, udma4, udma5, udma6);
2034 }
2035 else {
2036 simplelist_addline(SIMPLELIST_ADD_LINE,
2037 "No UDMA mode info");
2038 }
2039 #endif /* HAVE_ATA_DMA */
2040 timing_info_present = identify_info[53] & (1<<1);
2041 if(timing_info_present) {
2042 i = identify_info[49] & (1<<11);
2043 simplelist_addline(SIMPLELIST_ADD_LINE,
2044 "IORDY support: %s", i ? "yes" : "no");
2045 i = identify_info[49] & (1<<10);
2046 simplelist_addline(SIMPLELIST_ADD_LINE,
2047 "IORDY disable: %s", i ? "yes" : "no");
2048 } else {
2049 simplelist_addline(SIMPLELIST_ADD_LINE,
2050 "No timing info");
2051 }
2052 simplelist_addline(SIMPLELIST_ADD_LINE,
2053 "Cluster size: %d bytes", fat_get_cluster_size(IF_MV(0)));
2054 #ifdef HAVE_ATA_DMA
2055 i = ata_get_dma_mode();
2056 if (i == 0) {
2057 simplelist_addline(SIMPLELIST_ADD_LINE,
2058 "DMA not enabled");
2059 } else {
2060 simplelist_addline(SIMPLELIST_ADD_LINE,
2061 "DMA mode: %s %c",
2062 (i & 0x40) ? "UDMA" : "MDMA",
2063 '0' + (i & 7));
2064 }
2065 #endif /* HAVE_ATA_DMA */
2066 return btn;
2067 }
2068 #else /* No SD, MMC or ATA */
2069 static int disk_callback(int btn, struct gui_synclist *lists)
2070 {
2071 (void)btn;
2072 (void)lists;
2073 struct storage_info info;
2074 storage_get_info(0,&info);
2075 simplelist_addline(SIMPLELIST_ADD_LINE, "Vendor: %s", info.vendor);
2076 simplelist_addline(SIMPLELIST_ADD_LINE, "Model: %s", info.product);
2077 simplelist_addline(SIMPLELIST_ADD_LINE, "Firmware: %s", info.revision);
2078 simplelist_addline(SIMPLELIST_ADD_LINE,
2079 "Size: %ld MB", info.num_sectors*(info.sector_size/512)/2024);
2080 unsigned long free;
2081 fat_size( IF_MV2(0,) NULL, &free );
2082 simplelist_addline(SIMPLELIST_ADD_LINE,
2083 "Free: %ld MB", free / 1024);
2084 simplelist_addline(SIMPLELIST_ADD_LINE,
2085 "Cluster size: %d bytes", fat_get_cluster_size(IF_MV(0)));
2086 return btn;
2087 }
2088 #endif
2089
2090 #if (CONFIG_STORAGE & STORAGE_ATA)
2091 static bool dbg_identify_info(void)
2092 {
2093 int fd = creat("/identify_info.bin", 0666);
2094 if(fd >= 0)
2095 {
2096 #ifdef ROCKBOX_LITTLE_ENDIAN
2097 ecwrite(fd, ata_get_identify(), SECTOR_SIZE/2, "s", true);
2098 #else
2099 write(fd, ata_get_identify(), SECTOR_SIZE);
2100 #endif
2101 close(fd);
2102 }
2103 return false;
2104 }
2105 #endif
2106
2107 static bool dbg_disk_info(void)
2108 {
2109 struct simplelist_info info;
2110 simplelist_info_init(&info, "Disk Info", 1, NULL);
2111 #if (CONFIG_STORAGE & STORAGE_MMC) || (CONFIG_STORAGE & STORAGE_SD)
2112 char title[16];
2113 int card = 0;
2114 info.callback_data = (void*)&card;
2115 info.title = title;
2116 #endif
2117 info.action_callback = disk_callback;
2118 info.hide_selection = true;
2119 info.scroll_all = true;
2120 return simplelist_show_list(&info);
2121 }
2122 #endif /* PLATFORM_NATIVE */
2123
2124 #ifdef HAVE_DIRCACHE
2125 static int dircache_callback(int btn, struct gui_synclist *lists)
2126 {
2127 (void)btn; (void)lists;
2128 simplelist_set_line_count(0);
2129 simplelist_addline(SIMPLELIST_ADD_LINE, "Cache initialized: %s",
2130 dircache_is_enabled() ? "Yes" : "No");
2131 simplelist_addline(SIMPLELIST_ADD_LINE, "Cache size: %d B",
2132 dircache_get_cache_size());
2133 simplelist_addline(SIMPLELIST_ADD_LINE, "Last size: %d B",
2134 global_status.dircache_size);
2135 simplelist_addline(SIMPLELIST_ADD_LINE, "Limit: %d B",
2136 DIRCACHE_LIMIT);
2137 simplelist_addline(SIMPLELIST_ADD_LINE, "Reserve: %d/%d B",
2138 dircache_get_reserve_used(), DIRCACHE_RESERVE);
2139 simplelist_addline(SIMPLELIST_ADD_LINE, "Scanning took: %d s",
2140 dircache_get_build_ticks() / HZ);
2141 simplelist_addline(SIMPLELIST_ADD_LINE, "Entry count: %d",
2142 dircache_get_entry_count());
2143 return btn;
2144 }
2145
2146 static bool dbg_dircache_info(void)
2147 {
2148 struct simplelist_info info;
2149 simplelist_info_init(&info, "Dircache Info", 7, NULL);
2150 info.action_callback = dircache_callback;
2151 info.hide_selection = true;
2152 info.scroll_all = true;
2153 return simplelist_show_list(&info);
2154 }
2155
2156 #endif /* HAVE_DIRCACHE */
2157
2158 #ifdef HAVE_TAGCACHE
2159 static int database_callback(int btn, struct gui_synclist *lists)
2160 {
2161 (void)lists;
2162 struct tagcache_stat *stat = tagcache_get_stat();
2163 static bool synced = false;
2164
2165 simplelist_set_line_count(0);
2166
2167 simplelist_addline(SIMPLELIST_ADD_LINE, "Initialized: %s",
2168 stat->initialized ? "Yes" : "No");
2169 simplelist_addline(SIMPLELIST_ADD_LINE, "DB Ready: %s",
2170 stat->ready ? "Yes" : "No");
2171 simplelist_addline(SIMPLELIST_ADD_LINE, "RAM Cache: %s",
2172 stat->ramcache ? "Yes" : "No");
2173 simplelist_addline(SIMPLELIST_ADD_LINE, "RAM: %d/%d B",
2174 stat->ramcache_used, stat->ramcache_allocated);
2175 simplelist_addline(SIMPLELIST_ADD_LINE, "Progress: %d%% (%d entries)",
2176 stat->progress, stat->processed_entries);
2177 simplelist_addline(SIMPLELIST_ADD_LINE, "Curfile: %s",
2178 stat->curentry ? stat->curentry : "---");
2179 simplelist_addline(SIMPLELIST_ADD_LINE, "Commit step: %d",
2180 stat->commit_step);
2181 simplelist_addline(SIMPLELIST_ADD_LINE, "Commit delayed: %s",
2182 stat->commit_delayed ? "Yes" : "No");
2183
2184 simplelist_addline(SIMPLELIST_ADD_LINE, "Queue length: %d",
2185 stat->queue_length);
2186
2187 if (synced)
2188 {
2189 synced = false;
2190 tagcache_screensync_event();
2191 }
2192
2193 if (!btn && stat->curentry)
2194 {
2195 synced = true;
2196 return ACTION_REDRAW;
2197 }
2198
2199 if (btn == ACTION_STD_CANCEL)
2200 tagcache_screensync_enable(false);
2201
2202 return btn;
2203 }
2204 static bool dbg_tagcache_info(void)
2205 {
2206 struct simplelist_info info;
2207 simplelist_info_init(&info, "Database Info", 8, NULL);
2208 info.action_callback = database_callback;
2209 info.hide_selection = true;
2210 info.scroll_all = true;
2211
2212 /* Don't do nonblock here, must give enough processing time
2213 for tagcache thread. */
2214 /* info.timeout = TIMEOUT_NOBLOCK; */
2215 info.timeout = 1;
2216 tagcache_screensync_enable(true);
2217 return simplelist_show_list(&info);
2218 }
2219 #endif
2220
2221 #if CONFIG_CPU == SH7034
2222 static bool dbg_save_roms(void)
2223 {
2224 int fd;
2225 int oldmode = system_memory_guard(MEMGUARD_NONE);
2226
2227 fd = creat("/internal_rom_0000-FFFF.bin", 0666);
2228 if(fd >= 0)
2229 {
2230 write(fd, (void *)0, 0x10000);
2231 close(fd);
2232 }
2233
2234 fd = creat("/internal_rom_2000000-203FFFF.bin", 0666);
2235 if(fd >= 0)
2236 {
2237 write(fd, (void *)0x2000000, 0x40000);
2238 close(fd);
2239 }
2240
2241 system_memory_guard(oldmode);
2242 return false;
2243 }
2244 #elif defined CPU_COLDFIRE
2245 static bool dbg_save_roms(void)
2246 {
2247 int fd;
2248 int oldmode = system_memory_guard(MEMGUARD_NONE);
2249
2250 #if defined(IRIVER_H100_SERIES)
2251 fd = creat("/internal_rom_000000-1FFFFF.bin", 0666);
2252 #elif defined(IRIVER_H300_SERIES)
2253 fd = creat("/internal_rom_000000-3FFFFF.bin", 0666);
2254 #elif defined(IAUDIO_X5) || defined(IAUDIO_M5) || defined(IAUDIO_M3)
2255 fd = creat("/internal_rom_000000-3FFFFF.bin", 0666);
2256 #elif defined(MPIO_HD200)
2257 fd = creat("/internal_rom_000000-1FFFFF.bin", 0666);
2258 #endif
2259 if(fd >= 0)
2260 {
2261 write(fd, (void *)0, FLASH_SIZE);
2262 close(fd);
2263 }
2264 system_memory_guard(oldmode);
2265
2266 #ifdef HAVE_EEPROM
2267 fd = creat("/internal_eeprom.bin", 0666);
2268 if (fd >= 0)
2269 {
2270 int old_irq_level;
2271 char buf[EEPROM_SIZE];
2272 int err;
2273
2274 old_irq_level = disable_irq_save();
2275
2276 err = eeprom_24cxx_read(0, buf, sizeof buf);
2277
2278 restore_irq(old_irq_level);
2279
2280 if (err)
2281 splashf(HZ*3, "Eeprom read failure (%d)", err);
2282 else
2283 {
2284 write(fd, buf, sizeof buf);
2285 }
2286
2287 close(fd);
2288 }
2289 #endif
2290
2291 return false;
2292 }
2293 #elif defined(CPU_PP) && !(CONFIG_STORAGE & STORAGE_SD)
2294 static bool dbg_save_roms(void)
2295 {
2296 int fd;
2297
2298 fd = creat("/internal_rom_000000-0FFFFF.bin", 0666);
2299 if(fd >= 0)
2300 {
2301 write(fd, (void *)0x20000000, FLASH_SIZE);
2302 close(fd);
2303 }
2304
2305 return false;
2306 }
2307 #elif CONFIG_CPU == IMX31L
2308 static bool dbg_save_roms(void)
2309 {
2310 int fd;
2311
2312 fd = creat("/flash_rom_A0000000-A01FFFFF.bin", 0666);
2313 if (fd >= 0)
2314 {
2315 write(fd, (void*)0xa0000000, FLASH_SIZE);
2316 close(fd);
2317 }
2318
2319 return false;
2320 }
2321 #elif defined(CPU_TCC780X)
2322 static bool dbg_save_roms(void)
2323 {
2324 int fd;
2325
2326 fd = creat("/eeprom_E0000000-E0001FFF.bin", 0666);
2327 if (fd >= 0)
2328 {
2329 write(fd, (void*)0xe0000000, 0x2000);
2330 close(fd);
2331 }
2332
2333 return false;
2334 }
2335 #endif /* CPU */
2336
2337 #ifndef SIMULATOR
2338 #if CONFIG_TUNER
2339
2340 #ifdef CONFIG_TUNER_MULTI
2341 static int tuner_type = 0;
2342 #define IF_TUNER_TYPE(type) if(tuner_type==type)
2343 #else
2344 #define IF_TUNER_TYPE(type)
2345 #endif
2346
2347 static int radio_callback(int btn, struct gui_synclist *lists)
2348 {
2349 (void)lists;
2350 if (btn == ACTION_STD_CANCEL)
2351 return btn;
2352 simplelist_set_line_count(1);
2353
2354 #if (CONFIG_TUNER & LV24020LP)
2355 simplelist_addline(SIMPLELIST_ADD_LINE,
2356 "CTRL_STAT: %02X", lv24020lp_get(LV24020LP_CTRL_STAT) );
2357 simplelist_addline(SIMPLELIST_ADD_LINE,
2358 "RADIO_STAT: %02X", lv24020lp_get(LV24020LP_REG_STAT) );
2359 simplelist_addline(SIMPLELIST_ADD_LINE,
2360 "MSS_FM: %d kHz", lv24020lp_get(LV24020LP_MSS_FM) );
2361 simplelist_addline(SIMPLELIST_ADD_LINE,
2362 "MSS_IF: %d Hz", lv24020lp_get(LV24020LP_MSS_IF) );
2363 simplelist_addline(SIMPLELIST_ADD_LINE,
2364 "MSS_SD: %d Hz", lv24020lp_get(LV24020LP_MSS_SD) );
2365 simplelist_addline(SIMPLELIST_ADD_LINE,
2366 "if_set: %d Hz", lv24020lp_get(LV24020LP_IF_SET) );
2367 simplelist_addline(SIMPLELIST_ADD_LINE,
2368 "sd_set: %d Hz", lv24020lp_get(LV24020LP_SD_SET) );
2369 #endif /* LV24020LP */
2370 #if (CONFIG_TUNER & S1A0903X01)
2371 simplelist_addline(SIMPLELIST_ADD_LINE,
2372 "Samsung regs: %08X", s1a0903x01_get(RADIO_ALL));
2373 /* This one doesn't return dynamic data atm */
2374 #endif /* S1A0903X01 */
2375 #if (CONFIG_TUNER & TEA5767)
2376 struct tea5767_dbg_info nfo;
2377 tea5767_dbg_info(&nfo);
2378 simplelist_addline(SIMPLELIST_ADD_LINE, "Philips regs:");
2379 simplelist_addline(SIMPLELIST_ADD_LINE,
2380 " Read: %02X %02X %02X %02X %02X",
2381 (unsigned)nfo.read_regs[0], (unsigned)nfo.read_regs[1],
2382 (unsigned)nfo.read_regs[2], (unsigned)nfo.read_regs[3],
2383 (unsigned)nfo.read_regs[4]);
2384 simplelist_addline(SIMPLELIST_ADD_LINE,
2385 " Write: %02X %02X %02X %02X %02X",
2386 (unsigned)nfo.write_regs[0], (unsigned)nfo.write_regs[1],
2387 (unsigned)nfo.write_regs[2], (unsigned)nfo.write_regs[3],
2388 (unsigned)nfo.write_regs[4]);
2389 #endif /* TEA5767 */
2390 #if (CONFIG_TUNER & SI4700)
2391 IF_TUNER_TYPE(SI4700)
2392 {
2393 struct si4700_dbg_info nfo;
2394 int i;
2395 si4700_dbg_info(&nfo);
2396 simplelist_addline(SIMPLELIST_ADD_LINE, "SI4700 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 /* SI4700 */
2403 #if (CONFIG_TUNER & RDA5802)
2404 IF_TUNER_TYPE(RDA5802)
2405 {
2406 struct rda5802_dbg_info nfo;
2407 int i;
2408 rda5802_dbg_info(&nfo);
2409 simplelist_addline(SIMPLELIST_ADD_LINE, "RDA5802 regs:");
2410 for (i = 0; i < 16; i += 4) {
2411 simplelist_addline(SIMPLELIST_ADD_LINE,"%02X: %04X %04X %04X %04X",
2412 i, nfo.regs[i], nfo.regs[i+1], nfo.regs[i+2], nfo.regs[i+3]);
2413 }
2414 }
2415 #endif /* RDA55802 */
2416 return ACTION_REDRAW;
2417 }
2418 static bool dbg_fm_radio(void)
2419 {
2420 struct simplelist_info info;
2421 #ifdef CONFIG_TUNER_MULTI
2422 tuner_type = tuner_detect_type();
2423 #endif
2424 info.scroll_all = true;
2425 simplelist_info_init(&info, "FM Radio", 1, NULL);
2426 simplelist_set_line_count(0);
2427 simplelist_addline(SIMPLELIST_ADD_LINE, "HW detected: %s",
2428 radio_hardware_present() ? "yes" : "no");
2429
2430 info.action_callback = radio_hardware_present()?radio_callback : NULL;
2431 info.hide_selection = true;
2432 return simplelist_show_list(&info);
2433 }
2434 #endif /* CONFIG_TUNER */
2435 #endif /* !SIMULATOR */
2436
2437 #ifdef HAVE_LCD_BITMAP
2438 extern bool do_screendump_instead_of_usb;
2439
2440 static bool dbg_screendump(void)
2441 {
2442 do_screendump_instead_of_usb = !do_screendump_instead_of_usb;
2443 splashf(HZ, "Screendump %s",
2444 do_screendump_instead_of_usb?"enabled":"disabled");
2445 return false;
2446 }
2447 #endif /* HAVE_LCD_BITMAP */
2448
2449 #if CONFIG_CPU == SH7034 || defined(CPU_COLDFIRE)
2450 static bool dbg_set_memory_guard(void)
2451 {
2452 static const struct opt_items names[MAXMEMGUARD] = {
2453 { "None", -1 },
2454 { "Flash ROM writes", -1 },
2455 { "Zero area (all)", -1 }
2456 };
2457 int mode = system_memory_guard(MEMGUARD_KEEP);
2458
2459 set_option( "Catch mem accesses", &mode, INT, names, MAXMEMGUARD, NULL);
2460 system_memory_guard(mode);
2461
2462 return false;
2463 }
2464 #endif /* CONFIG_CPU == SH7034 || defined(CPU_COLDFIRE) */
2465
2466 #if defined(HAVE_EEPROM) && !defined(HAVE_EEPROM_SETTINGS)
2467 static bool dbg_write_eeprom(void)
2468 {
2469 int fd;
2470 int rc;
2471 int old_irq_level;
2472 char buf[EEPROM_SIZE];
2473 int err;
2474
2475 fd = open("/internal_eeprom.bin", O_RDONLY);
2476
2477 if (fd >= 0)
2478 {
2479 rc = read(fd, buf, EEPROM_SIZE);
2480
2481 if(rc == EEPROM_SIZE)
2482 {
2483 old_irq_level = disable_irq_save();
2484
2485 err = eeprom_24cxx_write(0, buf, sizeof buf);
2486 if (err)
2487 splashf(HZ*3, "Eeprom write failure (%d)", err);
2488 else
2489 splash(HZ*3, "Eeprom written successfully");
2490
2491 restore_irq(old_irq_level);
2492 }
2493 else
2494 {
2495 splashf(HZ*3, "File read error (%d)",rc);
2496 }
2497 close(fd);
2498 }
2499 else
2500 {
2501 splash(HZ*3, "Failed to open 'internal_eeprom.bin'");
2502 }
2503
2504 return false;
2505 }
2506 #endif /* defined(HAVE_EEPROM) && !defined(HAVE_EEPROM_SETTINGS) */
2507 #ifdef CPU_BOOST_LOGGING
2508 static bool cpu_boost_log(void)
2509 {
2510 int i = 0,j=0;
2511 int count = cpu_boost_log_getcount();
2512 int lines = LCD_HEIGHT/SYSFONT_HEIGHT;
2513 char *str;
2514 bool done;
2515 lcd_setfont(FONT_SYSFIXED);
2516 str = cpu_boost_log_getlog_first();
2517 while (i < count)
2518 {
2519 lcd_clear_display();
2520 for(j=0; j<lines; j++,i++)
2521 {
2522 if (!str)
2523 str = cpu_boost_log_getlog_next();
2524 if (str)
2525 {
2526 if(strlen(str) > LCD_WIDTH/SYSFONT_WIDTH)
2527 lcd_puts_scroll(0, j, str);
2528 else
2529 lcd_puts(0, j,str);
2530 }
2531 str = NULL;
2532 }
2533 lcd_update();
2534 done = false;
2535 while (!done)
2536 {
2537 switch(get_action(CONTEXT_STD,TIMEOUT_BLOCK))
2538 {
2539 case ACTION_STD_OK:
2540 case ACTION_STD_PREV:
2541 case ACTION_STD_NEXT:
2542 done = true;
2543 break;
2544 case ACTION_STD_CANCEL:
2545 i = count;
2546 done = true;
2547 break;
2548 }
2549 }
2550 }
2551 lcd_stop_scroll();
2552 get_action(CONTEXT_STD,TIMEOUT_BLOCK);
2553 lcd_setfont(FONT_UI);
2554 return false;
2555 }
2556 #endif
2557
2558 #if (defined(HAVE_WHEEL_ACCELERATION) && (CONFIG_KEYPAD==IPOD_4G_PAD) \
2559 && !defined(IPOD_MINI) && !defined(SIMULATOR))
2560 extern bool wheel_is_touched;
2561 extern int old_wheel_value;
2562 extern int new_wheel_value;
2563 extern int wheel_delta;
2564 extern unsigned int accumulated_wheel_delta;
2565 extern unsigned int wheel_velocity;
2566
2567 static bool dbg_scrollwheel(void)
2568 {
2569 unsigned int speed;
2570
2571 lcd_setfont(FONT_SYSFIXED);
2572
2573 while (1)
2574 {
2575 if (action_userabort(HZ/10))
2576 break;
2577
2578 lcd_clear_display();
2579
2580 /* show internal variables of scrollwheel driver */
2581 lcd_putsf(0, 0, "wheel touched: %s", (wheel_is_touched) ? "true" : "false");
2582 lcd_putsf(0, 1, "new position: %2d", new_wheel_value);
2583 lcd_putsf(0, 2, "old position: %2d", old_wheel_value);
2584 lcd_putsf(0, 3, "wheel delta: %2d", wheel_delta);
2585 lcd_putsf(0, 4, "accumulated delta: %2d", accumulated_wheel_delta);
2586 lcd_putsf(0, 5, "velo [deg/s]: %4d", (int)wheel_velocity);
2587
2588 /* show effective accelerated scrollspeed */
2589 speed = button_apply_acceleration( (1<<31)|(1<<24)|wheel_velocity);
2590 lcd_putsf(0, 6, "accel. speed: %4d", speed);
2591
2592 lcd_update();
2593 }
2594 lcd_setfont(FONT_UI);
2595 return false;
2596 }
2597 #endif
2598
2599 #if defined (HAVE_USBSTACK)
2600
2601 #if defined(ROCKBOX_HAS_LOGF) && defined(USB_ENABLE_SERIAL)
2602 static bool toggle_usb_core_driver(int driver, char *msg)
2603 {
2604 bool enabled = !usb_core_driver_enabled(driver);
2605
2606 usb_core_enable_driver(driver,enabled);
2607 splashf(HZ, "%s %s", msg, enabled?"enabled":"disabled");
2608
2609 return false;
2610 }
2611
2612 static bool toggle_usb_serial(void)
2613 {
2614 return toggle_usb_core_driver(USB_DRIVER_SERIAL,"USB Serial");
2615 }
2616 #endif
2617
2618 #endif
2619
2620 #if CONFIG_USBOTG == USBOTG_ISP1583
2621 extern int dbg_usb_num_items(void);
2622 extern const char* dbg_usb_item(int selected_item, void *data,
2623 char *buffer, size_t buffer_len);
2624
2625 static int isp1583_action_callback(int action, struct gui_synclist *lists)
2626 {
2627 (void)lists;
2628 if (action == ACTION_NONE)
2629 action = ACTION_REDRAW;
2630 return action;
2631 }
2632
2633 static bool dbg_isp1583(void)
2634 {
2635 struct simplelist_info isp1583;
2636 isp1583.scroll_all = true;
2637 simplelist_info_init(&isp1583, "ISP1583", dbg_usb_num_items(), NULL);
2638 isp1583.timeout = HZ/100;
2639 isp1583.hide_selection = true;
2640 isp1583.get_name = dbg_usb_item;
2641 isp1583.action_callback = isp1583_action_callback;
2642 return simplelist_show_list(&isp1583);
2643 }
2644 #endif
2645
2646 #if defined(CREATIVE_ZVx) && !defined(SIMULATOR)
2647 extern int pic_dbg_num_items(void);
2648 extern const char* pic_dbg_item(int selected_item, void *data,
2649 char *buffer, size_t buffer_len);
2650
2651 static int pic_action_callback(int action, struct gui_synclist *lists)
2652 {
2653 (void)lists;
2654 if (action == ACTION_NONE)
2655 action = ACTION_REDRAW;
2656 return action;
2657 }
2658
2659 static bool dbg_pic(void)
2660 {
2661 struct simplelist_info pic;
2662 pic.scroll_all = true;
2663 simplelist_info_init(&pic, "PIC", pic_dbg_num_items(), NULL);
2664 pic.timeout = HZ/100;
2665 pic.hide_selection = true;
2666 pic.get_name = pic_dbg_item;
2667 pic.action_callback = pic_action_callback;
2668 return simplelist_show_list(&pic);
2669 }
2670 #endif
2671
2672
2673 /****** The menu *********/
2674 struct the_menu_item {
2675 unsigned char *desc; /* string or ID */
2676 bool (*function) (void); /* return true if USB was connected */
2677 };
2678 static const struct the_menu_item menuitems[] = {
2679 #if CONFIG_CPU == SH7034 || defined(CPU_COLDFIRE) || \
2680 (defined(CPU_PP) && !(CONFIG_STORAGE & STORAGE_SD)) || \
2681 CONFIG_CPU == IMX31L || defined(CPU_TCC780X)
2682 { "Dump ROM contents", dbg_save_roms },
2683 #endif
2684 #if CONFIG_CPU == SH7034 || defined(CPU_COLDFIRE) || defined(CPU_PP) \
2685 || CONFIG_CPU == S3C2440 || CONFIG_CPU == IMX31L || CONFIG_CPU == AS3525 \
2686 || CONFIG_CPU == DM320 || defined(CPU_S5L870X) || CONFIG_CPU == AS3525v2
2687 { "View I/O ports", dbg_ports },
2688 #endif
2689 #if (CONFIG_RTC == RTC_PCF50605) && (CONFIG_PLATFORM & PLATFORM_NATIVE)
2690 { "View PCF registers", dbg_pcf },
2691 #endif
2692 #if defined(HAVE_TSC2100) && (CONFIG_PLATFORM & PLATFORM_NATIVE)
2693 { "TSC2100 debug", tsc2100_debug },
2694 #endif
2695 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
2696 { "CPU frequency", dbg_cpufreq },
2697 #endif
2698 #if defined(IRIVER_H100_SERIES) && !defined(SIMULATOR)
2699 { "S/PDIF analyzer", dbg_spdif },
2700 #endif
2701 #if CONFIG_CPU == SH7034 || defined(CPU_COLDFIRE)
2702 { "Catch mem accesses", dbg_set_memory_guard },
2703 #endif
2704 { "View OS stacks", dbg_os },
2705 #ifdef HAVE_LCD_BITMAP
2706 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
2707 { "View battery", view_battery },
2708 #endif
2709 { "Screendump", dbg_screendump },
2710 #endif
2711 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
2712 { "View HW info", dbg_hw_info },
2713 #endif
2714 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
2715 { "View partitions", dbg_partitions },
2716 #endif
2717 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
2718 { "View disk info", dbg_disk_info },
2719 #if (CONFIG_STORAGE & STORAGE_ATA)
2720 { "Dump ATA identify info", dbg_identify_info},
2721 #endif
2722 #endif
2723 #ifdef HAVE_DIRCACHE
2724 { "View dircache info", dbg_dircache_info },
2725 #endif
2726 #ifdef HAVE_TAGCACHE
2727 { "View database info", dbg_tagcache_info },
2728 #endif
2729 #ifdef HAVE_LCD_BITMAP
2730 #if CONFIG_CODEC == SWCODEC
2731 { "View buffering thread", dbg_buffering_thread },
2732 #elif !defined(SIMULATOR)
2733 { "View audio thread", dbg_audio_thread },
2734 #endif
2735 #ifdef PM_DEBUG
2736 { "pm histogram", peak_meter_histogram},
2737 #endif /* PM_DEBUG */
2738 #endif /* HAVE_LCD_BITMAP */
2739 #ifndef SIMULATOR
2740 #if CONFIG_TUNER
2741 { "FM Radio", dbg_fm_radio },
2742 #endif
2743 #endif
2744 #if defined(HAVE_EEPROM) && !defined(HAVE_EEPROM_SETTINGS)
2745 { "Write back EEPROM", dbg_write_eeprom },
2746 #endif
2747 #if CONFIG_USBOTG == USBOTG_ISP1583
2748 { "View ISP1583 info", dbg_isp1583 },
2749 #endif
2750 #if defined(CREATIVE_ZVx) && !defined(SIMULATOR)
2751 { "View PIC info", dbg_pic },
2752 #endif
2753 #ifdef ROCKBOX_HAS_LOGF
2754 {"Show Log File", logfdisplay },
2755 {"Dump Log File", logfdump },
2756 #endif
2757 #if defined(HAVE_USBSTACK)
2758 #if defined(ROCKBOX_HAS_LOGF) && defined(USB_ENABLE_SERIAL)
2759 {"USB Serial driver (logf)", toggle_usb_serial },
2760 #endif
2761 #endif /* HAVE_USBSTACK */
2762 #ifdef CPU_BOOST_LOGGING
2763 {"cpu_boost log",cpu_boost_log},
2764 #endif
2765 #if (defined(HAVE_WHEEL_ACCELERATION) && (CONFIG_KEYPAD==IPOD_4G_PAD) \
2766 && !defined(IPOD_MINI) && !defined(SIMULATOR))
2767 {"Debug scrollwheel", dbg_scrollwheel },
2768 #endif
2769 };
2770 static int menu_action_callback(int btn, struct gui_synclist *lists)
2771 {
2772 int i;
2773 if (btn == ACTION_STD_OK)
2774 {
2775 FOR_NB_SCREENS(i)
2776 viewportmanager_theme_enable(i, false, NULL);
2777 menuitems[gui_synclist_get_sel_pos(lists)].function();
2778 btn = ACTION_REDRAW;
2779 FOR_NB_SCREENS(i)
2780 viewportmanager_theme_undo(i, false);
2781 }
2782 return btn;
2783 }
2784
2785 static const char* dbg_menu_getname(int item, void * data,
2786 char *buffer, size_t buffer_len)
2787 {
2788 (void)data; (void)buffer; (void)buffer_len;
2789 return menuitems[item].desc;
2790 }
2791
2792 bool debug_menu(void)
2793 {
2794 struct simplelist_info info;
2795
2796 simplelist_info_init(&info, "Debug Menu", ARRAYLEN(menuitems), NULL);
2797 info.action_callback = menu_action_callback;
2798 info.get_name = dbg_menu_getname;
2799 return simplelist_show_list(&info);
2800 }
thomasjfox's rockbox modifications (mameo port)