?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Make TTS options actually work (fix variable name).
[kugel-rb.git] / apps / debug_menu.c
blobdd16a4ef4c920f84b9b38e9a84a9e9a07c785e1d
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 (CONFIG_KEYPAD == PHILIPS_HDD6330_PAD)
982 # define DEBUG_CANCEL BUTTON_POWER
983
984 #elif (CONFIG_KEYPAD == SAMSUNG_YH_PAD)
985 # define DEBUG_CANCEL BUTTON_PLAY
986
987 #endif /* key definitions */
988
989 /* Test code!!! */
990 bool dbg_ports(void)
991 {
992 #if CONFIG_CPU == SH7034
993 int adc_battery_voltage, adc_battery_level;
994
995 lcd_setfont(FONT_SYSFIXED);
996 lcd_clear_display();
997
998 while(1)
999 {
1000 lcd_putsf(0, 0, "PADR: %04x", (unsigned short)PADR);
1001 lcd_putsf(0, 1, "PBDR: %04x", (unsigned short)PBDR);
1002
1003 lcd_putsf(0, 2, "AN0: %03x AN4: %03x", adc_read(0), adc_read(4));
1004 lcd_putsf(0, 3, "AN1: %03x AN5: %03x", adc_read(1), adc_read(5));
1005 lcd_putsf(0, 4, "AN2: %03x AN6: %03x", adc_read(2), adc_read(6));
1006 lcd_putsf(0, 5, "AN3: %03x AN7: %03x", adc_read(3), adc_read(7));
1007
1008 battery_read_info(&adc_battery_voltage, &adc_battery_level);
1009 lcd_putsf(0, 6, "Batt: %d.%03dV %d%% ", adc_battery_voltage / 1000,
1010 adc_battery_voltage % 1000, adc_battery_level);
1011
1012 lcd_update();
1013 if (button_get_w_tmo(HZ/10) == (DEBUG_CANCEL|BUTTON_REL))
1014 {
1015 lcd_setfont(FONT_UI);
1016 return false;
1017 }
1018 }
1019 #elif defined(CPU_COLDFIRE)
1020 unsigned int gpio_out;
1021 unsigned int gpio1_out;
1022 unsigned int gpio_read;
1023 unsigned int gpio1_read;
1024 unsigned int gpio_function;
1025 unsigned int gpio1_function;
1026 unsigned int gpio_enable;
1027 unsigned int gpio1_enable;
1028 int adc_buttons, adc_remote;
1029 int adc_battery_voltage, adc_battery_level;
1030 int line;
1031
1032 lcd_clear_display();
1033 lcd_setfont(FONT_SYSFIXED);
1034
1035 while(1)
1036 {
1037 line = 0;
1038 gpio_read = GPIO_READ;
1039 gpio1_read = GPIO1_READ;
1040 gpio_out = GPIO_OUT;
1041 gpio1_out = GPIO1_OUT;
1042 gpio_function = GPIO_FUNCTION;
1043 gpio1_function = GPIO1_FUNCTION;
1044 gpio_enable = GPIO_ENABLE;
1045 gpio1_enable = GPIO1_ENABLE;
1046
1047 lcd_putsf(0, line++, "GPIO_READ: %08x", gpio_read);
1048 lcd_putsf(0, line++, "GPIO_OUT: %08x", gpio_out);
1049 lcd_putsf(0, line++, "GPIO_FUNC: %08x", gpio_function);
1050 lcd_putsf(0, line++, "GPIO_ENA: %08x", gpio_enable);
1051
1052 lcd_putsf(0, line++, "GPIO1_READ: %08x", gpio1_read);
1053 lcd_putsf(0, line++, "GPIO1_OUT: %08x", gpio1_out);
1054 lcd_putsf(0, line++, "GPIO1_FUNC: %08x", gpio1_function);
1055 lcd_putsf(0, line++, "GPIO1_ENA: %08x", gpio1_enable);
1056
1057 adc_buttons = adc_read(ADC_BUTTONS);
1058 adc_remote = adc_read(ADC_REMOTE);
1059 battery_read_info(&adc_battery_voltage, &adc_battery_level);
1060 #if defined(IAUDIO_X5) || defined(IAUDIO_M5) || defined(IRIVER_H300_SERIES)
1061 lcd_putsf(0, line++, "ADC_BUTTONS (%c): %02x",
1062 button_scan_enabled() ? '+' : '-', adc_buttons);
1063 #else
1064 lcd_putsf(0, line++, "ADC_BUTTONS: %02x", adc_buttons);
1065 #endif
1066 #if defined(IAUDIO_X5) || defined(IAUDIO_M5)
1067 lcd_putsf(0, line++, "ADC_REMOTE (%c): %02x",
1068 remote_detect() ? '+' : '-', adc_remote);
1069 #else
1070 lcd_putsf(0, line++, "ADC_REMOTE: %02x", adc_remote);
1071 #endif
1072 #if defined(IRIVER_H100_SERIES) || defined(IRIVER_H300_SERIES)
1073 lcd_putsf(0, line++, "ADC_REMOTEDETECT: %02x",
1074 adc_read(ADC_REMOTEDETECT));
1075 #endif
1076
1077 lcd_putsf(0, line++, "Batt: %d.%03dV %d%% ", adc_battery_voltage / 1000,
1078 adc_battery_voltage % 1000, adc_battery_level);
1079
1080 #if defined(IRIVER_H100_SERIES) || defined(IRIVER_H300_SERIES)
1081 lcd_putsf(0, line++, "remotetype: %d", remote_type());
1082 #endif
1083
1084 lcd_update();
1085 if (button_get_w_tmo(HZ/10) == (DEBUG_CANCEL|BUTTON_REL))
1086 {
1087 lcd_setfont(FONT_UI);
1088 return false;
1089 }
1090 }
1091
1092 #elif defined(CPU_PP502x)
1093 int line;
1094
1095 lcd_clear_display();
1096 lcd_setfont(FONT_SYSFIXED);
1097
1098 while(1)
1099 {
1100 line = 0;
1101 lcd_puts(0, line++, "GPIO STATES:");
1102 lcd_putsf(0, line++, "A: %02x E: %02x I: %02x",
1103 (unsigned int)GPIOA_INPUT_VAL,
1104 (unsigned int)GPIOE_INPUT_VAL,
1105 (unsigned int)GPIOI_INPUT_VAL);
1106 lcd_putsf(0, line++, "B: %02x F: %02x J: %02x",
1107 (unsigned int)GPIOB_INPUT_VAL,
1108 (unsigned int)GPIOF_INPUT_VAL,
1109 (unsigned int)GPIOJ_INPUT_VAL);
1110 lcd_putsf(0, line++, "C: %02x G: %02x K: %02x",
1111 (unsigned int)GPIOC_INPUT_VAL,
1112 (unsigned int)GPIOG_INPUT_VAL,
1113 (unsigned int)GPIOK_INPUT_VAL);
1114 lcd_putsf(0, line++, "D: %02x H: %02x L: %02x",
1115 (unsigned int)GPIOD_INPUT_VAL,
1116 (unsigned int)GPIOH_INPUT_VAL,
1117 (unsigned int)GPIOL_INPUT_VAL);
1118 line++;
1119 lcd_putsf(0, line++, "GPO32_VAL: %08lx", GPO32_VAL);
1120 lcd_putsf(0, line++, "GPO32_EN: %08lx", GPO32_ENABLE);
1121 lcd_putsf(0, line++, "DEV_EN: %08lx", DEV_EN);
1122 lcd_putsf(0, line++, "DEV_EN2: %08lx", DEV_EN2);
1123 lcd_putsf(0, line++, "DEV_EN3: %08lx", inl(0x60006044)); /* to be verified */
1124 lcd_putsf(0, line++, "DEV_INIT1: %08lx", DEV_INIT1);
1125 lcd_putsf(0, line++, "DEV_INIT2: %08lx", DEV_INIT2);
1126 #ifdef ADC_ACCESSORY
1127 lcd_putsf(0, line++, "ACCESSORY: %d", adc_read(ADC_ACCESSORY));
1128 #endif
1129 #ifdef IPOD_VIDEO
1130 lcd_putsf(0, line++, "4066_ISTAT: %d", adc_read(ADC_4066_ISTAT));
1131 #endif
1132
1133 #if defined(IPOD_ACCESSORY_PROTOCOL)
1134 extern unsigned char serbuf[];
1135 lcd_putsf(0, line++, "IAP PACKET: %02x %02x %02x %02x %02x %02x %02x %02x",
1136 serbuf[0], serbuf[1], serbuf[2], serbuf[3], serbuf[4], serbuf[5],
1137 serbuf[6], serbuf[7]);
1138 #endif
1139
1140 #if defined(IRIVER_H10) || defined(IRIVER_H10_5GB)
1141 line++;
1142 lcd_putsf(0, line++, "BATT: %03x UNK1: %03x",
1143 adc_read(ADC_BATTERY), adc_read(ADC_UNKNOWN_1));
1144 lcd_putsf(0, line++, "REM: %03x PAD: %03x",
1145 adc_read(ADC_REMOTE), adc_read(ADC_SCROLLPAD));
1146 #elif defined(PHILIPS_HDD1630) || defined(PHILIPS_HDD6330)
1147 line++;
1148 lcd_putsf(0, line++, "BATT: %03x UNK1: %03x",
1149 adc_read(ADC_BATTERY), adc_read(ADC_UNKNOWN_1));
1150 #elif defined(SANSA_E200) || defined(PHILIPS_SA9200)
1151 lcd_putsf(0, line++, "ADC_BVDD: %4d", adc_read(ADC_BVDD));
1152 lcd_putsf(0, line++, "ADC_RTCSUP: %4d", adc_read(ADC_RTCSUP));
1153 lcd_putsf(0, line++, "ADC_UVDD: %4d", adc_read(ADC_UVDD));
1154 lcd_putsf(0, line++, "ADC_CHG_IN: %4d", adc_read(ADC_CHG_IN));
1155 lcd_putsf(0, line++, "ADC_CVDD: %4d", adc_read(ADC_CVDD));
1156 lcd_putsf(0, line++, "ADC_BATTEMP: %4d", adc_read(ADC_BATTEMP));
1157 lcd_putsf(0, line++, "ADC_MICSUP1: %4d", adc_read(ADC_MICSUP1));
1158 lcd_putsf(0, line++, "ADC_MICSUP2: %4d", adc_read(ADC_MICSUP2));
1159 lcd_putsf(0, line++, "ADC_VBE1: %4d", adc_read(ADC_VBE1));
1160 lcd_putsf(0, line++, "ADC_VBE2: %4d", adc_read(ADC_VBE2));
1161 lcd_putsf(0, line++, "ADC_I_MICSUP1:%4d", adc_read(ADC_I_MICSUP1));
1162 #if !defined(PHILIPS_SA9200)
1163 lcd_putsf(0, line++, "ADC_I_MICSUP2:%4d", adc_read(ADC_I_MICSUP2));
1164 lcd_putsf(0, line++, "ADC_VBAT: %4d", adc_read(ADC_VBAT));
1165 #endif
1166 #endif
1167 lcd_update();
1168 if (button_get_w_tmo(HZ/10) == (DEBUG_CANCEL|BUTTON_REL))
1169 {
1170 lcd_setfont(FONT_UI);
1171 return false;
1172 }
1173 }
1174
1175 #elif CONFIG_CPU == PP5002
1176 int line;
1177
1178 lcd_clear_display();
1179 lcd_setfont(FONT_SYSFIXED);
1180
1181 while(1)
1182 {
1183 line = 0;
1184 lcd_putsf(0, line++, "GPIO_A: %02x GPIO_B: %02x",
1185 (unsigned int)GPIOA_INPUT_VAL, (unsigned int)GPIOB_INPUT_VAL);
1186 lcd_putsf(0, line++, "GPIO_C: %02x GPIO_D: %02x",
1187 (unsigned int)GPIOC_INPUT_VAL, (unsigned int)GPIOD_INPUT_VAL);
1188
1189 lcd_putsf(0, line++, "DEV_EN: %08lx", DEV_EN);
1190 lcd_putsf(0, line++, "CLOCK_ENABLE: %08lx", CLOCK_ENABLE);
1191 lcd_putsf(0, line++, "CLOCK_SOURCE: %08lx", CLOCK_SOURCE);
1192 lcd_putsf(0, line++, "PLL_CONTROL: %08lx", PLL_CONTROL);
1193 lcd_putsf(0, line++, "PLL_DIV: %08lx", PLL_DIV);
1194 lcd_putsf(0, line++, "PLL_MULT: %08lx", PLL_MULT);
1195 lcd_putsf(0, line++, "TIMING1_CTL: %08lx", TIMING1_CTL);
1196 lcd_putsf(0, line++, "TIMING2_CTL: %08lx", TIMING2_CTL);
1197
1198 lcd_update();
1199 if (button_get_w_tmo(HZ/10) == (DEBUG_CANCEL|BUTTON_REL))
1200 {
1201 lcd_setfont(FONT_UI);
1202 return false;
1203 }
1204 }
1205 lcd_setfont(FONT_UI);
1206 #else
1207 return __dbg_ports();
1208 #endif /* CPU */
1209 return false;
1210 }
1211 #else /* !HAVE_LCD_BITMAP */
1212 bool dbg_ports(void)
1213 {
1214 char buf[32];
1215 int button;
1216 int adc_battery_voltage;
1217 int currval = 0;
1218
1219 lcd_clear_display();
1220
1221 while(1)
1222 {
1223 switch(currval)
1224 {
1225 case 0:
1226 snprintf(buf, 32, "PADR: %04x", (unsigned short)PADR);
1227 break;
1228 case 1:
1229 snprintf(buf, 32, "PBDR: %04x", (unsigned short)PBDR);
1230 break;
1231 case 2:
1232 snprintf(buf, 32, "AN0: %03x", adc_read(0));
1233 break;
1234 case 3:
1235 snprintf(buf, 32, "AN1: %03x", adc_read(1));
1236 break;
1237 case 4:
1238 snprintf(buf, 32, "AN2: %03x", adc_read(2));
1239 break;
1240 case 5:
1241 snprintf(buf, 32, "AN3: %03x", adc_read(3));
1242 break;
1243 case 6:
1244 snprintf(buf, 32, "AN4: %03x", adc_read(4));
1245 break;
1246 case 7:
1247 snprintf(buf, 32, "AN5: %03x", adc_read(5));
1248 break;
1249 case 8:
1250 snprintf(buf, 32, "AN6: %03x", adc_read(6));
1251 break;
1252 case 9:
1253 snprintf(buf, 32, "AN7: %03x", adc_read(7));
1254 break;
1255 }
1256 lcd_puts(0, 0, buf);
1257
1258 battery_read_info(&adc_battery_voltage, NULL);
1259 lcd_putsf(0, 1, "Batt: %d.%03dV", adc_battery_voltage / 1000,
1260 adc_battery_voltage % 1000);
1261 lcd_update();
1262
1263 button = get_action(CONTEXT_SETTINGS,HZ/5);
1264
1265 switch(button)
1266 {
1267 case ACTION_STD_CANCEL:
1268 return false;
1269
1270 case ACTION_SETTINGS_DEC:
1271 currval--;
1272 if(currval < 0)
1273 currval = 9;
1274 break;
1275
1276 case ACTION_SETTINGS_INC:
1277 currval++;
1278 if(currval > 9)
1279 currval = 0;
1280 break;
1281 }
1282 }
1283 return false;
1284 }
1285 #endif /* !HAVE_LCD_BITMAP */
1286 #endif /* !SIMULATOR */
1287
1288 #if (CONFIG_RTC == RTC_PCF50605) && !defined(SIMULATOR)
1289 static bool dbg_pcf(void)
1290 {
1291 int line;
1292
1293 #ifdef HAVE_LCD_BITMAP
1294 lcd_setfont(FONT_SYSFIXED);
1295 #endif
1296 lcd_clear_display();
1297
1298 while(1)
1299 {
1300 line = 0;
1301
1302 lcd_putsf(0, line++, "DCDC1: %02x", pcf50605_read(0x1b));
1303 lcd_putsf(0, line++, "DCDC2: %02x", pcf50605_read(0x1c));
1304 lcd_putsf(0, line++, "DCDC3: %02x", pcf50605_read(0x1d));
1305 lcd_putsf(0, line++, "DCDC4: %02x", pcf50605_read(0x1e));
1306 lcd_putsf(0, line++, "DCDEC1: %02x", pcf50605_read(0x1f));
1307 lcd_putsf(0, line++, "DCDEC2: %02x", pcf50605_read(0x20));
1308 lcd_putsf(0, line++, "DCUDC1: %02x", pcf50605_read(0x21));
1309 lcd_putsf(0, line++, "DCUDC2: %02x", pcf50605_read(0x22));
1310 lcd_putsf(0, line++, "IOREGC: %02x", pcf50605_read(0x23));
1311 lcd_putsf(0, line++, "D1REGC: %02x", pcf50605_read(0x24));
1312 lcd_putsf(0, line++, "D2REGC: %02x", pcf50605_read(0x25));
1313 lcd_putsf(0, line++, "D3REGC: %02x", pcf50605_read(0x26));
1314 lcd_putsf(0, line++, "LPREG1: %02x", pcf50605_read(0x27));
1315 lcd_update();
1316 if (button_get_w_tmo(HZ/10) == (DEBUG_CANCEL|BUTTON_REL))
1317 {
1318 lcd_setfont(FONT_UI);
1319 return false;
1320 }
1321 }
1322
1323 lcd_setfont(FONT_UI);
1324 return false;
1325 }
1326 #endif
1327
1328 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1329 static bool dbg_cpufreq(void)
1330 {
1331 int line;
1332 int button;
1333
1334 #ifdef HAVE_LCD_BITMAP
1335 lcd_setfont(FONT_SYSFIXED);
1336 #endif
1337 lcd_clear_display();
1338
1339 while(1)
1340 {
1341 line = 0;
1342
1343 lcd_putsf(0, line++, "Frequency: %ld", FREQ);
1344 lcd_putsf(0, line++, "boost_counter: %d", get_cpu_boost_counter());
1345
1346 lcd_update();
1347 button = get_action(CONTEXT_STD,HZ/10);
1348
1349 switch(button)
1350 {
1351 case ACTION_STD_PREV:
1352 cpu_boost(true);
1353 break;
1354
1355 case ACTION_STD_NEXT:
1356 cpu_boost(false);
1357 break;
1358
1359 case ACTION_STD_OK:
1360 while (get_cpu_boost_counter() > 0)
1361 cpu_boost(false);
1362 set_cpu_frequency(CPUFREQ_DEFAULT);
1363 break;
1364
1365 case ACTION_STD_CANCEL:
1366 lcd_setfont(FONT_UI);
1367 return false;
1368 }
1369 }
1370 lcd_setfont(FONT_UI);
1371 return false;
1372 }
1373 #endif /* HAVE_ADJUSTABLE_CPU_FREQ */
1374
1375 #if defined(HAVE_TSC2100) && !defined(SIMULATOR)
1376 #include "tsc2100.h"
1377 static char *itob(int n, int len)
1378 {
1379 static char binary[64];
1380 int i,j;
1381 for (i=1, j=0;i<=len;i++)
1382 {
1383 binary[j++] = n&(1<<(len-i))?'1':'0';
1384 if (i%4 == 0)
1385 binary[j++] = ' ';
1386 }
1387 binary[j] = '\0';
1388 return binary;
1389 }
1390
1391 static const char* tsc2100_debug_getname(int selected_item, void * data,
1392 char *buffer, size_t buffer_len)
1393 {
1394 int *page = (int*)data;
1395 bool reserved = false;
1396 switch (*page)
1397 {
1398 case 0:
1399 if ((selected_item > 0x0a) ||
1400 (selected_item == 0x04) ||
1401 (selected_item == 0x08))
1402 reserved = true;
1403 break;
1404 case 1:
1405 if ((selected_item > 0x05) ||
1406 (selected_item == 0x02))
1407 reserved = true;
1408 break;
1409 case 2:
1410 if (selected_item > 0x1e)
1411 reserved = true;
1412 break;
1413 }
1414 if (reserved)
1415 snprintf(buffer, buffer_len, "%02x: RESERVED", selected_item);
1416 else
1417 snprintf(buffer, buffer_len, "%02x: %s", selected_item,
1418 itob(tsc2100_readreg(*page, selected_item)&0xffff,16));
1419 return buffer;
1420 }
1421 static int tsc2100debug_action_callback(int action, struct gui_synclist *lists)
1422 {
1423 int *page = (int*)lists->data;
1424 if (action == ACTION_STD_OK)
1425 {
1426 *page = (*page+1)%3;
1427 snprintf(lists->title, 32,
1428 "tsc2100 registers - Page %d", *page);
1429 return ACTION_REDRAW;
1430 }
1431 return action;
1432 }
1433 static bool tsc2100_debug(void)
1434 {
1435 int page = 0;
1436 char title[32] = "tsc2100 registers - Page 0";
1437 struct simplelist_info info;
1438 simplelist_info_init(&info, title, 32, &page);
1439 info.timeout = HZ/100;
1440 info.get_name = tsc2100_debug_getname;
1441 info.action_callback= tsc2100debug_action_callback;
1442 return simplelist_show_list(&info);
1443 }
1444 #endif
1445 #ifndef SIMULATOR
1446 #ifdef HAVE_LCD_BITMAP
1447 /*
1448 * view_battery() shows a automatically scaled graph of the battery voltage
1449 * over time. Usable for estimating battery life / charging rate.
1450 * The power_history array is updated in power_thread of powermgmt.c.
1451 */
1452
1453 #define BAT_LAST_VAL MIN(LCD_WIDTH, POWER_HISTORY_LEN)
1454 #define BAT_YSPACE (LCD_HEIGHT - 20)
1455
1456 static bool view_battery(void)
1457 {
1458 int view = 0;
1459 int i, x, y;
1460 unsigned short maxv, minv;
1461
1462 lcd_setfont(FONT_SYSFIXED);
1463
1464 while(1)
1465 {
1466 lcd_clear_display();
1467 switch (view) {
1468 case 0: /* voltage history graph */
1469 /* Find maximum and minimum voltage for scaling */
1470 minv = power_history[0];
1471 maxv = minv + 1;
1472 for (i = 1; i < BAT_LAST_VAL && power_history[i]; i++) {
1473 if (power_history[i] > maxv)
1474 maxv = power_history[i];
1475 if (power_history[i] < minv)
1476 minv = power_history[i];
1477 }
1478
1479 lcd_putsf(0, 0, "Battery %d.%03d", power_history[0] / 1000,
1480 power_history[0] % 1000);
1481 lcd_putsf(0, 1, "scale %d.%03d-%d.%03dV",
1482 minv / 1000, minv % 1000, maxv / 1000, maxv % 1000);
1483
1484 x = 0;
1485 for (i = BAT_LAST_VAL - 1; i >= 0; i--) {
1486 y = (power_history[i] - minv) * BAT_YSPACE / (maxv - minv);
1487 lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
1488 lcd_vline(x, LCD_HEIGHT-1, 20);
1489 lcd_set_drawmode(DRMODE_SOLID);
1490 lcd_vline(x, LCD_HEIGHT-1,
1491 MIN(MAX(LCD_HEIGHT-1 - y, 20), LCD_HEIGHT-1));
1492 x++;
1493 }
1494
1495 break;
1496
1497 case 1: /* status: */
1498 lcd_puts(0, 0, "Power status:");
1499
1500 battery_read_info(&y, NULL);
1501 lcd_putsf(0, 1, "Battery: %d.%03d V", y / 1000, y % 1000);
1502 #ifdef ADC_EXT_POWER
1503 y = (adc_read(ADC_EXT_POWER) * EXT_SCALE_FACTOR) / 1000;
1504 lcd_putsf(0, 2, "External: %d.%03d V", y / 1000, y % 1000);
1505 #endif
1506 #if CONFIG_CHARGING
1507 #if defined ARCHOS_RECORDER
1508 lcd_putsf(0, 3, "Chgr: %s %s",
1509 charger_inserted() ? "present" : "absent",
1510 charger_enabled() ? "on" : "off");
1511 lcd_putsf(0, 5, "short delta: %d", short_delta);
1512 lcd_putsf(0, 6, "long delta: %d", long_delta);
1513 lcd_puts(0, 7, power_message);
1514 lcd_putsf(0, 8, "USB Inserted: %s",
1515 usb_inserted() ? "yes" : "no");
1516 #elif defined IRIVER_H300_SERIES
1517 lcd_putsf(0, 9, "USB Charging Enabled: %s",
1518 usb_charging_enabled() ? "yes" : "no");
1519 #elif defined IPOD_NANO || defined IPOD_VIDEO
1520 int usb_pwr = (GPIOL_INPUT_VAL & 0x10)?true:false;
1521 int ext_pwr = (GPIOL_INPUT_VAL & 0x08)?false:true;
1522 int dock = (GPIOA_INPUT_VAL & 0x10)?true:false;
1523 int charging = (GPIOB_INPUT_VAL & 0x01)?false:true;
1524 int headphone= (GPIOA_INPUT_VAL & 0x80)?true:false;
1525
1526 lcd_putsf(0, 3, "USB pwr: %s",
1527 usb_pwr ? "present" : "absent");
1528 lcd_putsf(0, 4, "EXT pwr: %s",
1529 ext_pwr ? "present" : "absent");
1530 lcd_putsf(0, 5, "Battery: %s",
1531 charging ? "charging" : (usb_pwr||ext_pwr) ? "charged" : "discharging");
1532 lcd_putsf(0, 6, "Dock mode: %s",
1533 dock ? "enabled" : "disabled");
1534 lcd_putsf(0, 7, "Headphone: %s",
1535 headphone ? "connected" : "disconnected");
1536 #ifdef IPOD_VIDEO
1537 x = (adc_read(ADC_4066_ISTAT) * 2400) /
1538 #if MEM == 64
1539 (1024 * 2);
1540 #else
1541 (1024 * 3);
1542 #endif
1543 lcd_putsf(0, 8, "Ibat: %d mA", x);
1544 lcd_putsf(0, 9, "Vbat * Ibat: %d mW", x * y / 1000);
1545 #endif
1546 #elif defined TOSHIBA_GIGABEAT_S
1547 int line = 3;
1548 unsigned int st;
1549
1550 static const unsigned char * const chrgstate_strings[] =
1551 {
1552 "Disabled",
1553 "Error",
1554 "Discharging",
1555 "Precharge",
1556 "Constant Voltage",
1557 "Constant Current",
1558 "<unknown>",
1559 };
1560
1561 lcd_putsf(0, line++, "Charger: %s",
1562 charger_inserted() ? "present" : "absent");
1563
1564 st = power_input_status() &
1565 (POWER_INPUT_CHARGER | POWER_INPUT_BATTERY);
1566 lcd_putsf(0, line++, "%s%s",
1567 (st & POWER_INPUT_MAIN_CHARGER) ? " Main" : "",
1568 (st & POWER_INPUT_USB_CHARGER) ? " USB" : "");
1569
1570 lcd_putsf(0, line++, "IUSB Max: %d", usb_allowed_current());
1571
1572 y = ARRAYLEN(chrgstate_strings) - 1;
1573
1574 switch (charge_state)
1575 {
1576 case CHARGE_STATE_DISABLED: y--;
1577 case CHARGE_STATE_ERROR: y--;
1578 case DISCHARGING: y--;
1579 case TRICKLE: y--;
1580 case TOPOFF: y--;
1581 case CHARGING: y--;
1582 default:;
1583 }
1584
1585 lcd_putsf(0, line++, "State: %s", chrgstate_strings[y]);
1586
1587 lcd_putsf(0, line++, "Battery Switch: %s",
1588 (st & POWER_INPUT_BATTERY) ? "On" : "Off");
1589
1590 y = chrgraw_adc_voltage();
1591 lcd_putsf(0, line++, "CHRGRAW: %d.%03d V",
1592 y / 1000, y % 1000);
1593
1594 y = application_supply_adc_voltage();
1595 lcd_putsf(0, line++, "BP : %d.%03d V",
1596 y / 1000, y % 1000);
1597
1598 y = battery_adc_charge_current();
1599 if (y < 0) x = '-', y = -y;
1600 else x = ' ';
1601 lcd_putsf(0, line++, "CHRGISN:%c%d mA", x, y);
1602
1603 y = cccv_regulator_dissipation();
1604 lcd_putsf(0, line++, "P CCCV : %d mW", y);
1605
1606 y = battery_charge_current();
1607 if (y < 0) x = '-', y = -y;
1608 else x = ' ';
1609 lcd_putsf(0, line++, "I Charge:%c%d mA", x, y);
1610
1611 y = battery_adc_temp();
1612
1613 if (y != INT_MIN) {
1614 lcd_putsf(0, line++, "T Battery: %dC (%dF)", y,
1615 (9*y + 160) / 5);
1616 } else {
1617 /* Conversion disabled */
1618 lcd_puts(0, line++, "T Battery: ?");
1619 }
1620
1621 #elif defined(SANSA_E200) || defined(SANSA_C200) || defined(SANSA_CLIP) || defined(SANSA_FUZE)
1622 const int first = CHARGE_STATE_DISABLED;
1623 static const char * const chrgstate_strings[] =
1624 {
1625 [CHARGE_STATE_DISABLED-first] = "Disabled",
1626 [CHARGE_STATE_ERROR-first] = "Error",
1627 [DISCHARGING-first] = "Discharging",
1628 [CHARGING-first] = "Charging",
1629 };
1630 const char *str = NULL;
1631
1632 lcd_putsf(0, 3, "Charger: %s",
1633 charger_inserted() ? "present" : "absent");
1634
1635 y = charge_state - first;
1636 if ((unsigned)y < ARRAYLEN(chrgstate_strings))
1637 str = chrgstate_strings[y];
1638
1639 lcd_putsf(0, 4, "State: %s",
1640 str ? str : "<unknown>");
1641
1642 lcd_putsf(0, 5, "CHARGER: %02X",
1643 ascodec_read(AS3514_CHARGER));
1644 #elif defined(IPOD_NANO2G)
1645 y = pmu_read_battery_current();
1646 lcd_putsf(0, 2, "Battery current: %d mA", y);
1647 #else
1648 lcd_putsf(0, 3, "Charger: %s",
1649 charger_inserted() ? "present" : "absent");
1650 #endif /* target type */
1651 #endif /* CONFIG_CHARGING */
1652 break;
1653
1654 case 2: /* voltage deltas: */
1655 lcd_puts(0, 0, "Voltage deltas:");
1656
1657 for (i = 0; i <= 6; i++) {
1658 y = power_history[i] - power_history[i+1];
1659 lcd_putsf(0, i+1, "-%d min: %s%d.%03d V", i,
1660 (y < 0) ? "-" : "", ((y < 0) ? y * -1 : y) / 1000,
1661 ((y < 0) ? y * -1 : y ) % 1000);
1662 }
1663 break;
1664
1665 case 3: /* remaining time estimation: */
1666
1667 #ifdef ARCHOS_RECORDER
1668 lcd_putsf(0, 0, "charge_state: %d", charge_state);
1669
1670 lcd_putsf(0, 1, "Cycle time: %d m", powermgmt_last_cycle_startstop_min);
1671
1672 lcd_putsf(0, 2, "Lvl@cyc st: %d%%", powermgmt_last_cycle_level);
1673
1674 lcd_putsf(0, 3, "P=%2d I=%2d", pid_p, pid_i);
1675
1676 lcd_putsf(0, 4, "Trickle sec: %d/60", trickle_sec);
1677 #endif /* ARCHOS_RECORDER */
1678
1679 lcd_putsf(0, 5, "Last PwrHist: %d.%03dV",
1680 power_history[0] / 1000,
1681 power_history[0] % 1000);
1682
1683 lcd_putsf(0, 6, "battery level: %d%%", battery_level());
1684
1685 lcd_putsf(0, 7, "Est. remain: %d m", battery_time());
1686 break;
1687 }
1688
1689 lcd_update();
1690
1691 switch(get_action(CONTEXT_STD,HZ/2))
1692 {
1693 case ACTION_STD_PREV:
1694 if (view)
1695 view--;
1696 break;
1697
1698 case ACTION_STD_NEXT:
1699 if (view < 3)
1700 view++;
1701 break;
1702
1703 case ACTION_STD_CANCEL:
1704 lcd_setfont(FONT_UI);
1705 return false;
1706 }
1707 }
1708 lcd_setfont(FONT_UI);
1709 return false;
1710 }
1711
1712 #endif /* HAVE_LCD_BITMAP */
1713 #endif
1714
1715 #ifndef SIMULATOR
1716 #if (CONFIG_STORAGE & STORAGE_MMC) || (CONFIG_STORAGE & STORAGE_SD)
1717
1718 #if (CONFIG_STORAGE & STORAGE_MMC)
1719 #define CARDTYPE "MMC"
1720 #elif (CONFIG_STORAGE & STORAGE_SD)
1721 #define CARDTYPE "microSD"
1722 #endif
1723
1724 static int disk_callback(int btn, struct gui_synclist *lists)
1725 {
1726 tCardInfo *card;
1727 int *cardnum = (int*)lists->data;
1728 unsigned char card_name[6];
1729 unsigned char pbuf[32];
1730 char *title = lists->title;
1731 static const unsigned char i_vmin[] = { 0, 1, 5, 10, 25, 35, 60, 100 };
1732 static const unsigned char i_vmax[] = { 1, 5, 10, 25, 35, 45, 80, 200 };
1733 static const unsigned char * const kbit_units[] = { "kBit/s", "MBit/s", "GBit/s" };
1734 static const unsigned char * const nsec_units[] = { "ns", "µs", "ms" };
1735 #if (CONFIG_STORAGE & STORAGE_MMC)
1736 static const char * const mmc_spec_vers[] = { "1.0-1.2", "1.4", "2.0-2.2",
1737 "3.1-3.31", "4.0" };
1738 #endif
1739
1740 if ((btn == ACTION_STD_OK) || (btn == SYS_FS_CHANGED) || (btn == ACTION_REDRAW))
1741 {
1742 #ifdef HAVE_HOTSWAP
1743 if (btn == ACTION_STD_OK)
1744 {
1745 *cardnum ^= 0x1; /* change cards */
1746 }
1747 #endif
1748
1749 simplelist_set_line_count(0);
1750
1751 card = card_get_info(*cardnum);
1752
1753 if (card->initialized > 0)
1754 {
1755 unsigned i;
1756 for (i=0; i<sizeof(card_name); i++)
1757 {
1758 card_name[i] = card_extract_bits(card->cid, (103-8*i), 8);
1759 }
1760 strlcpy(card_name, card_name, sizeof(card_name));
1761 simplelist_addline(SIMPLELIST_ADD_LINE,
1762 "%s Rev %d.%d", card_name,
1763 (int) card_extract_bits(card->cid, 63, 4),
1764 (int) card_extract_bits(card->cid, 59, 4));
1765 simplelist_addline(SIMPLELIST_ADD_LINE,
1766 "Prod: %d/%d",
1767 #if (CONFIG_STORAGE & STORAGE_SD)
1768 (int) card_extract_bits(card->cid, 11, 4),
1769 (int) card_extract_bits(card->cid, 19, 8) + 2000
1770 #elif (CONFIG_STORAGE & STORAGE_MMC)
1771 (int) card_extract_bits(card->cid, 15, 4),
1772 (int) card_extract_bits(card->cid, 11, 4) + 1997
1773 #endif
1774 );
1775 simplelist_addline(SIMPLELIST_ADD_LINE,
1776 #if (CONFIG_STORAGE & STORAGE_SD)
1777 "Ser#: 0x%08lx",
1778 card_extract_bits(card->cid, 55, 32)
1779 #elif (CONFIG_STORAGE & STORAGE_MMC)
1780 "Ser#: 0x%04lx",
1781 card_extract_bits(card->cid, 47, 16)
1782 #endif
1783 );
1784
1785 simplelist_addline(SIMPLELIST_ADD_LINE, "M=%02x, "
1786 #if (CONFIG_STORAGE & STORAGE_SD)
1787 "O=%c%c",
1788 (int) card_extract_bits(card->cid, 127, 8),
1789 card_extract_bits(card->cid, 119, 8),
1790 card_extract_bits(card->cid, 111, 8)
1791 #elif (CONFIG_STORAGE & STORAGE_MMC)
1792 "O=%04x",
1793 (int) card_extract_bits(card->cid, 127, 8),
1794 (int) card_extract_bits(card->cid, 119, 16)
1795 #endif
1796 );
1797
1798 #if (CONFIG_STORAGE & STORAGE_MMC)
1799 int temp = card_extract_bits(card->csd, 125, 4);
1800 simplelist_addline(SIMPLELIST_ADD_LINE,
1801 "MMC v%s", temp < 5 ?
1802 mmc_spec_vers[temp] : "?.?");
1803 #endif
1804 simplelist_addline(SIMPLELIST_ADD_LINE,
1805 "Blocks: 0x%08lx", card->numblocks);
1806 output_dyn_value(pbuf, sizeof pbuf, card->speed / 1000,
1807 kbit_units, false);
1808 simplelist_addline(SIMPLELIST_ADD_LINE,
1809 "Speed: %s", pbuf);
1810 output_dyn_value(pbuf, sizeof pbuf, card->taac,
1811 nsec_units, false);
1812 simplelist_addline(SIMPLELIST_ADD_LINE,
1813 "Taac: %s", pbuf);
1814 simplelist_addline(SIMPLELIST_ADD_LINE,
1815 "Nsac: %d clk", card->nsac);
1816 simplelist_addline(SIMPLELIST_ADD_LINE,
1817 "R2W: *%d", card->r2w_factor);
1818 simplelist_addline(SIMPLELIST_ADD_LINE,
1819 "IRmax: %d..%d mA",
1820 i_vmin[card_extract_bits(card->csd, 61, 3)],
1821 i_vmax[card_extract_bits(card->csd, 58, 3)]);
1822 simplelist_addline(SIMPLELIST_ADD_LINE,
1823 "IWmax: %d..%d mA",
1824 i_vmin[card_extract_bits(card->csd, 55, 3)],
1825 i_vmax[card_extract_bits(card->csd, 52, 3)]);
1826 }
1827 else if (card->initialized == 0)
1828 {
1829 simplelist_addline(SIMPLELIST_ADD_LINE, "Not Found!");
1830 }
1831 #if (CONFIG_STORAGE & STORAGE_SD)
1832 else /* card->initialized < 0 */
1833 {
1834 simplelist_addline(SIMPLELIST_ADD_LINE, "Init Error! (%d)", card->initialized);
1835 }
1836 #endif
1837 snprintf(title, 16, "[" CARDTYPE " %d]", *cardnum);
1838 gui_synclist_set_title(lists, title, Icon_NOICON);
1839 gui_synclist_set_nb_items(lists, simplelist_get_line_count());
1840 gui_synclist_select_item(lists, 0);
1841 btn = ACTION_REDRAW;
1842 }
1843 return btn;
1844 }
1845 #elif (CONFIG_STORAGE & STORAGE_ATA)
1846 static int disk_callback(int btn, struct gui_synclist *lists)
1847 {
1848 (void)lists;
1849 int i;
1850 char buf[128];
1851 unsigned short* identify_info = ata_get_identify();
1852 bool timing_info_present = false;
1853 (void)btn;
1854
1855 simplelist_set_line_count(0);
1856
1857 for (i=0; i < 20; i++)
1858 ((unsigned short*)buf)[i]=htobe16(identify_info[i+27]);
1859 buf[40]=0;
1860 /* kill trailing space */
1861 for (i=39; i && buf[i]==' '; i--)
1862 buf[i] = 0;
1863 simplelist_addline(SIMPLELIST_ADD_LINE, "Model: %s", buf);
1864 for (i=0; i < 4; i++)
1865 ((unsigned short*)buf)[i]=htobe16(identify_info[i+23]);
1866 buf[8]=0;
1867 simplelist_addline(SIMPLELIST_ADD_LINE,
1868 "Firmware: %s", buf);
1869 snprintf(buf, sizeof buf, "%ld MB",
1870 ((unsigned long)identify_info[61] << 16 |
1871 (unsigned long)identify_info[60]) / 2048 );
1872 simplelist_addline(SIMPLELIST_ADD_LINE,
1873 "Size: %s", buf);
1874 unsigned long free;
1875 fat_size( IF_MV2(0,) NULL, &free );
1876 simplelist_addline(SIMPLELIST_ADD_LINE,
1877 "Free: %ld MB", free / 1024);
1878 simplelist_addline(SIMPLELIST_ADD_LINE,
1879 "Spinup time: %d ms", storage_spinup_time() * (1000/HZ));
1880 i = identify_info[83] & (1<<3);
1881 simplelist_addline(SIMPLELIST_ADD_LINE,
1882 "Power mgmt: %s", i ? "enabled" : "unsupported");
1883 i = identify_info[83] & (1<<9);
1884 simplelist_addline(SIMPLELIST_ADD_LINE,
1885 "Noise mgmt: %s", i ? "enabled" : "unsupported");
1886 i = identify_info[82] & (1<<6);
1887 simplelist_addline(SIMPLELIST_ADD_LINE,
1888 "Read-ahead: %s", i ? "enabled" : "unsupported");
1889 timing_info_present = identify_info[53] & (1<<1);
1890 if(timing_info_present) {
1891 char pio3[2], pio4[2];pio3[1] = 0;
1892 pio4[1] = 0;
1893 pio3[0] = (identify_info[64] & (1<<0)) ? '3' : 0;
1894 pio4[0] = (identify_info[64] & (1<<1)) ? '4' : 0;
1895 simplelist_addline(SIMPLELIST_ADD_LINE,
1896 "PIO modes: 0 1 2 %s %s", pio3, pio4);
1897 }
1898 else {
1899 simplelist_addline(SIMPLELIST_ADD_LINE,
1900 "No PIO mode info");
1901 }
1902 timing_info_present = identify_info[53] & (1<<1);
1903 if(timing_info_present) {
1904 simplelist_addline(SIMPLELIST_ADD_LINE,
1905 "Cycle times %dns/%dns",
1906 identify_info[67],
1907 identify_info[68] );
1908 } else {
1909 simplelist_addline(SIMPLELIST_ADD_LINE,
1910 "No timing info");
1911 }
1912 #ifdef HAVE_ATA_DMA
1913 if (identify_info[63] & (1<<0)) {
1914 char mdma0[2], mdma1[2], mdma2[2];
1915 mdma0[1] = mdma1[1] = mdma2[1] = 0;
1916 mdma0[0] = (identify_info[63] & (1<<0)) ? '0' : 0;
1917 mdma1[0] = (identify_info[63] & (1<<1)) ? '1' : 0;
1918 mdma2[0] = (identify_info[63] & (1<<2)) ? '2' : 0;
1919 simplelist_addline(SIMPLELIST_ADD_LINE,
1920 "MDMA modes: %s %s %s", mdma0, mdma1, mdma2);
1921 simplelist_addline(SIMPLELIST_ADD_LINE,
1922 "MDMA Cycle times %dns/%dns",
1923 identify_info[65],
1924 identify_info[66] );
1925 }
1926 else {
1927 simplelist_addline(SIMPLELIST_ADD_LINE,
1928 "No MDMA mode info");
1929 }
1930 if (identify_info[53] & (1<<2)) {
1931 char udma0[2], udma1[2], udma2[2], udma3[2], udma4[2], udma5[2], udma6[2];
1932 udma0[1] = udma1[1] = udma2[1] = udma3[1] = udma4[1] = udma5[1] = udma6[1] = 0;
1933 udma0[0] = (identify_info[88] & (1<<0)) ? '0' : 0;
1934 udma1[0] = (identify_info[88] & (1<<1)) ? '1' : 0;
1935 udma2[0] = (identify_info[88] & (1<<2)) ? '2' : 0;
1936 udma3[0] = (identify_info[88] & (1<<3)) ? '3' : 0;
1937 udma4[0] = (identify_info[88] & (1<<4)) ? '4' : 0;
1938 udma5[0] = (identify_info[88] & (1<<5)) ? '5' : 0;
1939 udma6[0] = (identify_info[88] & (1<<6)) ? '6' : 0;
1940 simplelist_addline(SIMPLELIST_ADD_LINE,
1941 "UDMA modes: %s %s %s %s %s %s %s", udma0, udma1, udma2,
1942 udma3, udma4, udma5, udma6);
1943 }
1944 else {
1945 simplelist_addline(SIMPLELIST_ADD_LINE,
1946 "No UDMA mode info");
1947 }
1948 #endif /* HAVE_ATA_DMA */
1949 timing_info_present = identify_info[53] & (1<<1);
1950 if(timing_info_present) {
1951 i = identify_info[49] & (1<<11);
1952 simplelist_addline(SIMPLELIST_ADD_LINE,
1953 "IORDY support: %s", i ? "yes" : "no");
1954 i = identify_info[49] & (1<<10);
1955 simplelist_addline(SIMPLELIST_ADD_LINE,
1956 "IORDY disable: %s", i ? "yes" : "no");
1957 } else {
1958 simplelist_addline(SIMPLELIST_ADD_LINE,
1959 "No timing info");
1960 }
1961 simplelist_addline(SIMPLELIST_ADD_LINE,
1962 "Cluster size: %d bytes", fat_get_cluster_size(IF_MV(0)));
1963 #ifdef HAVE_ATA_DMA
1964 i = ata_get_dma_mode();
1965 if (i == 0) {
1966 simplelist_addline(SIMPLELIST_ADD_LINE,
1967 "DMA not enabled");
1968 } else {
1969 simplelist_addline(SIMPLELIST_ADD_LINE,
1970 "DMA mode: %s %c",
1971 (i & 0x40) ? "UDMA" : "MDMA",
1972 '0' + (i & 7));
1973 }
1974 #endif /* HAVE_ATA_DMA */
1975 return btn;
1976 }
1977 #else /* No SD, MMC or ATA */
1978 static int disk_callback(int btn, struct gui_synclist *lists)
1979 {
1980 (void)btn;
1981 (void)lists;
1982 struct storage_info info;
1983 storage_get_info(0,&info);
1984 simplelist_addline(SIMPLELIST_ADD_LINE, "Vendor: %s", info.vendor);
1985 simplelist_addline(SIMPLELIST_ADD_LINE, "Model: %s", info.product);
1986 simplelist_addline(SIMPLELIST_ADD_LINE, "Firmware: %s", info.revision);
1987 simplelist_addline(SIMPLELIST_ADD_LINE,
1988 "Size: %ld MB", info.num_sectors*(info.sector_size/512)/2024);
1989 unsigned long free;
1990 fat_size( IF_MV2(0,) NULL, &free );
1991 simplelist_addline(SIMPLELIST_ADD_LINE,
1992 "Free: %ld MB", free / 1024);
1993 simplelist_addline(SIMPLELIST_ADD_LINE,
1994 "Cluster size: %d bytes", fat_get_cluster_size(IF_MV(0)));
1995 return btn;
1996 }
1997 #endif
1998
1999 #if (CONFIG_STORAGE & STORAGE_ATA)
2000 static bool dbg_identify_info(void)
2001 {
2002 int fd = creat("/identify_info.bin");
2003 if(fd >= 0)
2004 {
2005 #ifdef ROCKBOX_LITTLE_ENDIAN
2006 ecwrite(fd, ata_get_identify(), SECTOR_SIZE/2, "s", true);
2007 #else
2008 write(fd, ata_get_identify(), SECTOR_SIZE);
2009 #endif
2010 close(fd);
2011 }
2012 return false;
2013 }
2014 #endif
2015
2016 static bool dbg_disk_info(void)
2017 {
2018 struct simplelist_info info;
2019 simplelist_info_init(&info, "Disk Info", 1, NULL);
2020 #if (CONFIG_STORAGE & STORAGE_MMC) || (CONFIG_STORAGE & STORAGE_SD)
2021 char title[16];
2022 int card = 0;
2023 info.callback_data = (void*)&card;
2024 info.title = title;
2025 #endif
2026 info.action_callback = disk_callback;
2027 info.hide_selection = true;
2028 info.scroll_all = true;
2029 return simplelist_show_list(&info);
2030 }
2031 #endif /* !SIMULATOR */
2032
2033 #ifdef HAVE_DIRCACHE
2034 static int dircache_callback(int btn, struct gui_synclist *lists)
2035 {
2036 (void)btn; (void)lists;
2037 simplelist_set_line_count(0);
2038 simplelist_addline(SIMPLELIST_ADD_LINE, "Cache initialized: %s",
2039 dircache_is_enabled() ? "Yes" : "No");
2040 simplelist_addline(SIMPLELIST_ADD_LINE, "Cache size: %d B",
2041 dircache_get_cache_size());
2042 simplelist_addline(SIMPLELIST_ADD_LINE, "Last size: %d B",
2043 global_status.dircache_size);
2044 simplelist_addline(SIMPLELIST_ADD_LINE, "Limit: %d B",
2045 DIRCACHE_LIMIT);
2046 simplelist_addline(SIMPLELIST_ADD_LINE, "Reserve: %d/%d B",
2047 dircache_get_reserve_used(), DIRCACHE_RESERVE);
2048 simplelist_addline(SIMPLELIST_ADD_LINE, "Scanning took: %d s",
2049 dircache_get_build_ticks() / HZ);
2050 simplelist_addline(SIMPLELIST_ADD_LINE, "Entry count: %d",
2051 dircache_get_entry_count());
2052 return btn;
2053 }
2054
2055 static bool dbg_dircache_info(void)
2056 {
2057 struct simplelist_info info;
2058 simplelist_info_init(&info, "Dircache Info", 7, NULL);
2059 info.action_callback = dircache_callback;
2060 info.hide_selection = true;
2061 info.scroll_all = true;
2062 return simplelist_show_list(&info);
2063 }
2064
2065 #endif /* HAVE_DIRCACHE */
2066
2067 #ifdef HAVE_TAGCACHE
2068 static int database_callback(int btn, struct gui_synclist *lists)
2069 {
2070 (void)lists;
2071 struct tagcache_stat *stat = tagcache_get_stat();
2072 static bool synced = false;
2073
2074 simplelist_set_line_count(0);
2075
2076 simplelist_addline(SIMPLELIST_ADD_LINE, "Initialized: %s",
2077 stat->initialized ? "Yes" : "No");
2078 simplelist_addline(SIMPLELIST_ADD_LINE, "DB Ready: %s",
2079 stat->ready ? "Yes" : "No");
2080 simplelist_addline(SIMPLELIST_ADD_LINE, "RAM Cache: %s",
2081 stat->ramcache ? "Yes" : "No");
2082 simplelist_addline(SIMPLELIST_ADD_LINE, "RAM: %d/%d B",
2083 stat->ramcache_used, stat->ramcache_allocated);
2084 simplelist_addline(SIMPLELIST_ADD_LINE, "Progress: %d%% (%d entries)",
2085 stat->progress, stat->processed_entries);
2086 simplelist_addline(SIMPLELIST_ADD_LINE, "Curfile: %s",
2087 stat->curentry ? stat->curentry : "---");
2088 simplelist_addline(SIMPLELIST_ADD_LINE, "Commit step: %d",
2089 stat->commit_step);
2090 simplelist_addline(SIMPLELIST_ADD_LINE, "Commit delayed: %s",
2091 stat->commit_delayed ? "Yes" : "No");
2092
2093 simplelist_addline(SIMPLELIST_ADD_LINE, "Queue length: %d",
2094 stat->queue_length);
2095
2096 if (synced)
2097 {
2098 synced = false;
2099 tagcache_screensync_event();
2100 }
2101
2102 if (!btn && stat->curentry)
2103 {
2104 synced = true;
2105 return ACTION_REDRAW;
2106 }
2107
2108 if (btn == ACTION_STD_CANCEL)
2109 tagcache_screensync_enable(false);
2110
2111 return btn;
2112 }
2113 static bool dbg_tagcache_info(void)
2114 {
2115 struct simplelist_info info;
2116 simplelist_info_init(&info, "Database Info", 8, NULL);
2117 info.action_callback = database_callback;
2118 info.hide_selection = true;
2119 info.scroll_all = true;
2120
2121 /* Don't do nonblock here, must give enough processing time
2122 for tagcache thread. */
2123 /* info.timeout = TIMEOUT_NOBLOCK; */
2124 info.timeout = 1;
2125 tagcache_screensync_enable(true);
2126 return simplelist_show_list(&info);
2127 }
2128 #endif
2129
2130 #if CONFIG_CPU == SH7034
2131 static bool dbg_save_roms(void)
2132 {
2133 int fd;
2134 int oldmode = system_memory_guard(MEMGUARD_NONE);
2135
2136 fd = creat("/internal_rom_0000-FFFF.bin");
2137 if(fd >= 0)
2138 {
2139 write(fd, (void *)0, 0x10000);
2140 close(fd);
2141 }
2142
2143 fd = creat("/internal_rom_2000000-203FFFF.bin");
2144 if(fd >= 0)
2145 {
2146 write(fd, (void *)0x2000000, 0x40000);
2147 close(fd);
2148 }
2149
2150 system_memory_guard(oldmode);
2151 return false;
2152 }
2153 #elif defined CPU_COLDFIRE
2154 static bool dbg_save_roms(void)
2155 {
2156 int fd;
2157 int oldmode = system_memory_guard(MEMGUARD_NONE);
2158
2159 #if defined(IRIVER_H100_SERIES)
2160 fd = creat("/internal_rom_000000-1FFFFF.bin");
2161 #elif defined(IRIVER_H300_SERIES)
2162 fd = creat("/internal_rom_000000-3FFFFF.bin");
2163 #elif defined(IAUDIO_X5) || defined(IAUDIO_M5) || defined(IAUDIO_M3)
2164 fd = creat("/internal_rom_000000-3FFFFF.bin");
2165 #endif
2166 if(fd >= 0)
2167 {
2168 write(fd, (void *)0, FLASH_SIZE);
2169 close(fd);
2170 }
2171 system_memory_guard(oldmode);
2172
2173 #ifdef HAVE_EEPROM
2174 fd = creat("/internal_eeprom.bin");
2175 if (fd >= 0)
2176 {
2177 int old_irq_level;
2178 char buf[EEPROM_SIZE];
2179 int err;
2180
2181 old_irq_level = disable_irq_save();
2182
2183 err = eeprom_24cxx_read(0, buf, sizeof buf);
2184
2185 restore_irq(old_irq_level);
2186
2187 if (err)
2188 splashf(HZ*3, "Eeprom read failure (%d)", err);
2189 else
2190 {
2191 write(fd, buf, sizeof buf);
2192 }
2193
2194 close(fd);
2195 }
2196 #endif
2197
2198 return false;
2199 }
2200 #elif defined(CPU_PP) && !(CONFIG_STORAGE & STORAGE_SD)
2201 static bool dbg_save_roms(void)
2202 {
2203 int fd;
2204
2205 fd = creat("/internal_rom_000000-0FFFFF.bin");
2206 if(fd >= 0)
2207 {
2208 write(fd, (void *)0x20000000, FLASH_SIZE);
2209 close(fd);
2210 }
2211
2212 return false;
2213 }
2214 #elif CONFIG_CPU == IMX31L
2215 static bool dbg_save_roms(void)
2216 {
2217 int fd;
2218
2219 fd = creat("/flash_rom_A0000000-A01FFFFF.bin");
2220 if (fd >= 0)
2221 {
2222 write(fd, (void*)0xa0000000, FLASH_SIZE);
2223 close(fd);
2224 }
2225
2226 return false;
2227 }
2228 #elif defined(CPU_TCC780X)
2229 static bool dbg_save_roms(void)
2230 {
2231 int fd;
2232
2233 fd = creat("/eeprom_E0000000-E0001FFF.bin");
2234 if (fd >= 0)
2235 {
2236 write(fd, (void*)0xe0000000, 0x2000);
2237 close(fd);
2238 }
2239
2240 return false;
2241 }
2242 #endif /* CPU */
2243
2244 #ifndef SIMULATOR
2245 #if CONFIG_TUNER
2246 static int radio_callback(int btn, struct gui_synclist *lists)
2247 {
2248 (void)lists;
2249 if (btn == ACTION_STD_CANCEL)
2250 return btn;
2251 simplelist_set_line_count(1);
2252
2253 #if (CONFIG_TUNER & LV24020LP)
2254 simplelist_addline(SIMPLELIST_ADD_LINE,
2255 "CTRL_STAT: %02X", lv24020lp_get(LV24020LP_CTRL_STAT) );
2256 simplelist_addline(SIMPLELIST_ADD_LINE,
2257 "RADIO_STAT: %02X", lv24020lp_get(LV24020LP_REG_STAT) );
2258 simplelist_addline(SIMPLELIST_ADD_LINE,
2259 "MSS_FM: %d kHz", lv24020lp_get(LV24020LP_MSS_FM) );
2260 simplelist_addline(SIMPLELIST_ADD_LINE,
2261 "MSS_IF: %d Hz", lv24020lp_get(LV24020LP_MSS_IF) );
2262 simplelist_addline(SIMPLELIST_ADD_LINE,
2263 "MSS_SD: %d Hz", lv24020lp_get(LV24020LP_MSS_SD) );
2264 simplelist_addline(SIMPLELIST_ADD_LINE,
2265 "if_set: %d Hz", lv24020lp_get(LV24020LP_IF_SET) );
2266 simplelist_addline(SIMPLELIST_ADD_LINE,
2267 "sd_set: %d Hz", lv24020lp_get(LV24020LP_SD_SET) );
2268 #endif /* LV24020LP */
2269 #if (CONFIG_TUNER & S1A0903X01)
2270 simplelist_addline(SIMPLELIST_ADD_LINE,
2271 "Samsung regs: %08X", s1a0903x01_get(RADIO_ALL));
2272 /* This one doesn't return dynamic data atm */
2273 #endif /* S1A0903X01 */
2274 #if (CONFIG_TUNER & TEA5767)
2275 struct tea5767_dbg_info nfo;
2276 tea5767_dbg_info(&nfo);
2277 simplelist_addline(SIMPLELIST_ADD_LINE, "Philips regs:");
2278 simplelist_addline(SIMPLELIST_ADD_LINE,
2279 " Read: %02X %02X %02X %02X %02X",
2280 (unsigned)nfo.read_regs[0], (unsigned)nfo.read_regs[1],
2281 (unsigned)nfo.read_regs[2], (unsigned)nfo.read_regs[3],
2282 (unsigned)nfo.read_regs[4]);
2283 simplelist_addline(SIMPLELIST_ADD_LINE,
2284 " Write: %02X %02X %02X %02X %02X",
2285 (unsigned)nfo.write_regs[0], (unsigned)nfo.write_regs[1],
2286 (unsigned)nfo.write_regs[2], (unsigned)nfo.write_regs[3],
2287 (unsigned)nfo.write_regs[4]);
2288 #endif /* TEA5767 */
2289 #if (CONFIG_TUNER & SI4700)
2290 struct si4700_dbg_info nfo;
2291 si4700_dbg_info(&nfo);
2292 simplelist_addline(SIMPLELIST_ADD_LINE, "SI4700 regs:");
2293 /* Registers */
2294 simplelist_addline(SIMPLELIST_ADD_LINE,
2295 "%04X %04X %04X %04X",
2296 (unsigned)nfo.regs[0], (unsigned)nfo.regs[1],
2297 (unsigned)nfo.regs[2], (unsigned)nfo.regs[3]);
2298 simplelist_addline(SIMPLELIST_ADD_LINE,
2299 "%04X %04X %04X %04X",
2300 (unsigned)nfo.regs[4], (unsigned)nfo.regs[5],
2301 (unsigned)nfo.regs[6], (unsigned)nfo.regs[7]);
2302 simplelist_addline(SIMPLELIST_ADD_LINE,
2303 "%04X %04X %04X %04X",
2304 (unsigned)nfo.regs[8], (unsigned)nfo.regs[9],
2305 (unsigned)nfo.regs[10], (unsigned)nfo.regs[11]);
2306 simplelist_addline(SIMPLELIST_ADD_LINE,
2307 "%04X %04X %04X %04X",
2308 (unsigned)nfo.regs[12], (unsigned)nfo.regs[13],
2309 (unsigned)nfo.regs[14], (unsigned)nfo.regs[15]);
2310 #endif /* SI4700 */
2311 return ACTION_REDRAW;
2312 }
2313 static bool dbg_fm_radio(void)
2314 {
2315 struct simplelist_info info;
2316 info.scroll_all = true;
2317 simplelist_info_init(&info, "FM Radio", 1, NULL);
2318 simplelist_set_line_count(0);
2319 simplelist_addline(SIMPLELIST_ADD_LINE, "HW detected: %s",
2320 radio_hardware_present() ? "yes" : "no");
2321
2322 info.action_callback = radio_hardware_present()?radio_callback : NULL;
2323 info.hide_selection = true;
2324 return simplelist_show_list(&info);
2325 }
2326 #endif /* CONFIG_TUNER */
2327 #endif /* !SIMULATOR */
2328
2329 #ifdef HAVE_LCD_BITMAP
2330 extern bool do_screendump_instead_of_usb;
2331
2332 static bool dbg_screendump(void)
2333 {
2334 do_screendump_instead_of_usb = !do_screendump_instead_of_usb;
2335 splashf(HZ, "Screendump %s",
2336 do_screendump_instead_of_usb?"enabled":"disabled");
2337 return false;
2338 }
2339 #endif /* HAVE_LCD_BITMAP */
2340
2341 #if CONFIG_CPU == SH7034 || defined(CPU_COLDFIRE)
2342 static bool dbg_set_memory_guard(void)
2343 {
2344 static const struct opt_items names[MAXMEMGUARD] = {
2345 { "None", -1 },
2346 { "Flash ROM writes", -1 },
2347 { "Zero area (all)", -1 }
2348 };
2349 int mode = system_memory_guard(MEMGUARD_KEEP);
2350
2351 set_option( "Catch mem accesses", &mode, INT, names, MAXMEMGUARD, NULL);
2352 system_memory_guard(mode);
2353
2354 return false;
2355 }
2356 #endif /* CONFIG_CPU == SH7034 || defined(CPU_COLDFIRE) */
2357
2358 #if defined(HAVE_EEPROM) && !defined(HAVE_EEPROM_SETTINGS)
2359 static bool dbg_write_eeprom(void)
2360 {
2361 int fd;
2362 int rc;
2363 int old_irq_level;
2364 char buf[EEPROM_SIZE];
2365 int err;
2366
2367 fd = open("/internal_eeprom.bin", O_RDONLY);
2368
2369 if (fd >= 0)
2370 {
2371 rc = read(fd, buf, EEPROM_SIZE);
2372
2373 if(rc == EEPROM_SIZE)
2374 {
2375 old_irq_level = disable_irq_save();
2376
2377 err = eeprom_24cxx_write(0, buf, sizeof buf);
2378 if (err)
2379 splashf(HZ*3, "Eeprom write failure (%d)", err);
2380 else
2381 splash(HZ*3, "Eeprom written successfully");
2382
2383 restore_irq(old_irq_level);
2384 }
2385 else
2386 {
2387 splashf(HZ*3, "File read error (%d)",rc);
2388 }
2389 close(fd);
2390 }
2391 else
2392 {
2393 splash(HZ*3, "Failed to open 'internal_eeprom.bin'");
2394 }
2395
2396 return false;
2397 }
2398 #endif /* defined(HAVE_EEPROM) && !defined(HAVE_EEPROM_SETTINGS) */
2399 #ifdef CPU_BOOST_LOGGING
2400 static bool cpu_boost_log(void)
2401 {
2402 int i = 0,j=0;
2403 int count = cpu_boost_log_getcount();
2404 int lines = LCD_HEIGHT/SYSFONT_HEIGHT;
2405 char *str;
2406 bool done;
2407 lcd_setfont(FONT_SYSFIXED);
2408 str = cpu_boost_log_getlog_first();
2409 while (i < count)
2410 {
2411 lcd_clear_display();
2412 for(j=0; j<lines; j++,i++)
2413 {
2414 if (!str)
2415 str = cpu_boost_log_getlog_next();
2416 if (str)
2417 {
2418 if(strlen(str) > LCD_WIDTH/SYSFONT_WIDTH)
2419 lcd_puts_scroll(0, j, str);
2420 else
2421 lcd_puts(0, j,str);
2422 }
2423 str = NULL;
2424 }
2425 lcd_update();
2426 done = false;
2427 while (!done)
2428 {
2429 switch(get_action(CONTEXT_STD,TIMEOUT_BLOCK))
2430 {
2431 case ACTION_STD_OK:
2432 case ACTION_STD_PREV:
2433 case ACTION_STD_NEXT:
2434 done = true;
2435 break;
2436 case ACTION_STD_CANCEL:
2437 i = count;
2438 done = true;
2439 break;
2440 }
2441 }
2442 }
2443 get_action(CONTEXT_STD,TIMEOUT_BLOCK);
2444 lcd_setfont(FONT_UI);
2445 return false;
2446 }
2447 #endif
2448
2449 #if (defined(HAVE_WHEEL_ACCELERATION) && (CONFIG_KEYPAD==IPOD_4G_PAD) && !defined(SIMULATOR))
2450 extern bool wheel_is_touched;
2451 extern int old_wheel_value;
2452 extern int new_wheel_value;
2453 extern int wheel_delta;
2454 extern unsigned int accumulated_wheel_delta;
2455 extern unsigned int wheel_velocity;
2456
2457 static bool dbg_scrollwheel(void)
2458 {
2459 unsigned int speed;
2460
2461 lcd_setfont(FONT_SYSFIXED);
2462
2463 while (1)
2464 {
2465 if (action_userabort(HZ/10))
2466 break;
2467
2468 lcd_clear_display();
2469
2470 /* show internal variables of scrollwheel driver */
2471 lcd_putsf(0, 0, "wheel touched: %s", (wheel_is_touched) ? "true" : "false");
2472 lcd_putsf(0, 1, "new position: %2d", new_wheel_value);
2473 lcd_putsf(0, 2, "old position: %2d", old_wheel_value);
2474 lcd_putsf(0, 3, "wheel delta: %2d", wheel_delta);
2475 lcd_putsf(0, 4, "accumulated delta: %2d", accumulated_wheel_delta);
2476 lcd_putsf(0, 5, "velo [deg/s]: %4d", (int)wheel_velocity);
2477
2478 /* show effective accelerated scrollspeed */
2479 speed = button_apply_acceleration( (1<<31)|(1<<24)|wheel_velocity);
2480 lcd_putsf(0, 6, "accel. speed: %4d", speed);
2481
2482 lcd_update();
2483 }
2484 lcd_setfont(FONT_UI);
2485 return false;
2486 }
2487 #endif
2488
2489 #if defined (HAVE_USBSTACK)
2490
2491 #if defined(ROCKBOX_HAS_LOGF) && defined(USB_ENABLE_SERIAL)
2492 static bool toggle_usb_core_driver(int driver, char *msg)
2493 {
2494 bool enabled = !usb_core_driver_enabled(driver);
2495
2496 usb_core_enable_driver(driver,enabled);
2497 splashf(HZ, "%s %s", msg, enabled?"enabled":"disabled");
2498
2499 return false;
2500 }
2501
2502 static bool toggle_usb_serial(void)
2503 {
2504 return toggle_usb_core_driver(USB_DRIVER_SERIAL,"USB Serial");
2505 }
2506 #endif
2507
2508 #endif
2509
2510 #if CONFIG_USBOTG == USBOTG_ISP1583
2511 extern int dbg_usb_num_items(void);
2512 extern const char* dbg_usb_item(int selected_item, void *data,
2513 char *buffer, size_t buffer_len);
2514
2515 static int isp1583_action_callback(int action, struct gui_synclist *lists)
2516 {
2517 (void)lists;
2518 if (action == ACTION_NONE)
2519 action = ACTION_REDRAW;
2520 return action;
2521 }
2522
2523 static bool dbg_isp1583(void)
2524 {
2525 struct simplelist_info isp1583;
2526 isp1583.scroll_all = true;
2527 simplelist_info_init(&isp1583, "ISP1583", dbg_usb_num_items(), NULL);
2528 isp1583.timeout = HZ/100;
2529 isp1583.hide_selection = true;
2530 isp1583.get_name = dbg_usb_item;
2531 isp1583.action_callback = isp1583_action_callback;
2532 return simplelist_show_list(&isp1583);
2533 }
2534 #endif
2535
2536 #if defined(CREATIVE_ZVx) && !defined(SIMULATOR)
2537 extern int pic_dbg_num_items(void);
2538 extern const char* pic_dbg_item(int selected_item, void *data,
2539 char *buffer, size_t buffer_len);
2540
2541 static int pic_action_callback(int action, struct gui_synclist *lists)
2542 {
2543 (void)lists;
2544 if (action == ACTION_NONE)
2545 action = ACTION_REDRAW;
2546 return action;
2547 }
2548
2549 static bool dbg_pic(void)
2550 {
2551 struct simplelist_info pic;
2552 pic.scroll_all = true;
2553 simplelist_info_init(&pic, "PIC", pic_dbg_num_items(), NULL);
2554 pic.timeout = HZ/100;
2555 pic.hide_selection = true;
2556 pic.get_name = pic_dbg_item;
2557 pic.action_callback = pic_action_callback;
2558 return simplelist_show_list(&pic);
2559 }
2560 #endif
2561
2562
2563 /****** The menu *********/
2564 struct the_menu_item {
2565 unsigned char *desc; /* string or ID */
2566 bool (*function) (void); /* return true if USB was connected */
2567 };
2568 static const struct the_menu_item menuitems[] = {
2569 #if CONFIG_CPU == SH7034 || defined(CPU_COLDFIRE) || \
2570 (defined(CPU_PP) && !(CONFIG_STORAGE & STORAGE_SD)) || \
2571 CONFIG_CPU == IMX31L || defined(CPU_TCC780X)
2572 { "Dump ROM contents", dbg_save_roms },
2573 #endif
2574 #if CONFIG_CPU == SH7034 || defined(CPU_COLDFIRE) || defined(CPU_PP) \
2575 || CONFIG_CPU == S3C2440 || CONFIG_CPU == IMX31L || CONFIG_CPU == AS3525 \
2576 || CONFIG_CPU == DM320 || defined(CPU_S5L870X)
2577 { "View I/O ports", dbg_ports },
2578 #endif
2579 #if (CONFIG_RTC == RTC_PCF50605) && !defined(SIMULATOR)
2580 { "View PCF registers", dbg_pcf },
2581 #endif
2582 #if defined(HAVE_TSC2100) && !defined(SIMULATOR)
2583 { "TSC2100 debug", tsc2100_debug },
2584 #endif
2585 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
2586 { "CPU frequency", dbg_cpufreq },
2587 #endif
2588 #if defined(IRIVER_H100_SERIES) && !defined(SIMULATOR)
2589 { "S/PDIF analyzer", dbg_spdif },
2590 #endif
2591 #if CONFIG_CPU == SH7034 || defined(CPU_COLDFIRE)
2592 { "Catch mem accesses", dbg_set_memory_guard },
2593 #endif
2594 { "View OS stacks", dbg_os },
2595 #ifdef HAVE_LCD_BITMAP
2596 #ifndef SIMULATOR
2597 { "View battery", view_battery },
2598 #endif
2599 { "Screendump", dbg_screendump },
2600 #endif
2601 #ifndef SIMULATOR
2602 { "View HW info", dbg_hw_info },
2603 #endif
2604 #ifndef SIMULATOR
2605 { "View partitions", dbg_partitions },
2606 #endif
2607 #ifndef SIMULATOR
2608 { "View disk info", dbg_disk_info },
2609 #if (CONFIG_STORAGE & STORAGE_ATA)
2610 { "Dump ATA identify info", dbg_identify_info},
2611 #endif
2612 #endif
2613 #ifdef HAVE_DIRCACHE
2614 { "View dircache info", dbg_dircache_info },
2615 #endif
2616 #ifdef HAVE_TAGCACHE
2617 { "View database info", dbg_tagcache_info },
2618 #endif
2619 #ifdef HAVE_LCD_BITMAP
2620 #if CONFIG_CODEC == SWCODEC
2621 { "View buffering thread", dbg_buffering_thread },
2622 #elif !defined(SIMULATOR)
2623 { "View audio thread", dbg_audio_thread },
2624 #endif
2625 #ifdef PM_DEBUG
2626 { "pm histogram", peak_meter_histogram},
2627 #endif /* PM_DEBUG */
2628 #endif /* HAVE_LCD_BITMAP */
2629 #ifndef SIMULATOR
2630 #if CONFIG_TUNER
2631 { "FM Radio", dbg_fm_radio },
2632 #endif
2633 #endif
2634 #if defined(HAVE_EEPROM) && !defined(HAVE_EEPROM_SETTINGS)
2635 { "Write back EEPROM", dbg_write_eeprom },
2636 #endif
2637 #if CONFIG_USBOTG == USBOTG_ISP1583
2638 { "View ISP1583 info", dbg_isp1583 },
2639 #endif
2640 #if defined(CREATIVE_ZVx) && !defined(SIMULATOR)
2641 { "View PIC info", dbg_pic },
2642 #endif
2643 #ifdef ROCKBOX_HAS_LOGF
2644 {"Show Log File", logfdisplay },
2645 {"Dump Log File", logfdump },
2646 #endif
2647 #if defined(HAVE_USBSTACK)
2648 #if defined(ROCKBOX_HAS_LOGF) && defined(USB_ENABLE_SERIAL)
2649 {"USB Serial driver (logf)", toggle_usb_serial },
2650 #endif
2651 #endif /* HAVE_USBSTACK */
2652 #ifdef CPU_BOOST_LOGGING
2653 {"cpu_boost log",cpu_boost_log},
2654 #endif
2655 #if (defined(HAVE_WHEEL_ACCELERATION) && (CONFIG_KEYPAD==IPOD_4G_PAD) && !defined(SIMULATOR))
2656 {"Debug scrollwheel", dbg_scrollwheel },
2657 #endif
2658 };
2659 static int menu_action_callback(int btn, struct gui_synclist *lists)
2660 {
2661 int i;
2662 if (btn == ACTION_STD_OK)
2663 {
2664 FOR_NB_SCREENS(i)
2665 viewportmanager_theme_enable(i, false, NULL);
2666 menuitems[gui_synclist_get_sel_pos(lists)].function();
2667 btn = ACTION_REDRAW;
2668 FOR_NB_SCREENS(i)
2669 viewportmanager_theme_undo(i, false);
2670 }
2671 return btn;
2672 }
2673
2674 static const char* dbg_menu_getname(int item, void * data,
2675 char *buffer, size_t buffer_len)
2676 {
2677 (void)data; (void)buffer; (void)buffer_len;
2678 return menuitems[item].desc;
2679 }
2680
2681 bool debug_menu(void)
2682 {
2683 struct simplelist_info info;
2684
2685 simplelist_info_init(&info, "Debug Menu", ARRAYLEN(menuitems), NULL);
2686 info.action_callback = menu_action_callback;
2687 info.get_name = dbg_menu_getname;
2688 return simplelist_show_list(&info);
2689 }
My public Rockbox git repo