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