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