* Copyright (c) 1999 Shin Takemura.

/* $NetBSD: disptest.c,v 1.6 2009/03/18 10:22:29 cegger Exp $ */

/*-
* Copyright (c) 1999 Shin Takemura.
* All rights reserved.
*
* This software is part of the PocketBSD.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the PocketBSD project
* and its contributors.
* 4. Neither the name of the project nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
*/
#include <pbsdboot.h>

extern BOOL SetKMode(BOOL);
#define ARRAYSIZEOF(a) (sizeof(a)/sizeof(*(a)))

static struct area {
long start, end;
} targets[] = {
{ 0x0a000000, 0x0b000000 },
{ 0x10000000, 0x14000000 },
};
int ntargets = ARRAYSIZEOF(targets);

void
flush_XX(void)
{
static volatile unsigned char tmp[1024*64];
int i, s;

for (i = 0; i < ARRAYSIZEOF(tmp); i++) {
s += tmp[i];
}
}

static void
gpio_test(void)
{
#define GIUBASE 0xab000000
#define GIUOFFSET 0x0100
volatile unsigned short *giusell;
volatile unsigned short *giuselh;
volatile unsigned short *giupiodl;
volatile unsigned short *giupiodh;
unsigned short sell = 0;
unsigned short selh = 0;
unsigned short piodl = 0;
unsigned short piodh = 0;
int res, i;
unsigned short regs[16];
unsigned short prev_regs[16];

unsigned char* p = (char*)VirtualAlloc(0, 1024, MEM_RESERVE,
PAGE_NOACCESS);
res = VirtualCopy((LPVOID)p, (LPVOID)(GIUBASE >> 8), 1024,
PAGE_READWRITE|PAGE_NOCACHE|PAGE_PHYSICAL);
if (!res) {
win_printf(TEXT("VirtualCopy() failed."));
}

for (i = 0; i < 16; i++) {
prev_regs[i] = ~0;
}

giusell = (unsigned short*)(p + GIUOFFSET + 0);
giuselh = (unsigned short*)(p + GIUOFFSET + 2);
giupiodl = (unsigned short*)(p + GIUOFFSET + 4);
giupiodh = (unsigned short*)(p + GIUOFFSET + 6);

while (1) {
sell = *giusell;
selh = *giuselh;
*giusell = sell;
*giuselh = selh;

piodl = *giupiodl;
piodh = *giupiodh;
*giupiodl = piodl;
*giupiodh = piodh;
for (i = 0; i < 16; i++) {
regs[i] = *(unsigned short*)(p + GIUOFFSET + i * 2);
}
for (i = 0; i < 16; i++) {
if (i != 3 && i != 5 && regs[i] != prev_regs[i]) {
win_printf(TEXT("IOSEL=%04x%04x "),
regs[1], regs[0]);
win_printf(TEXT("PIOD=%04x%04x "),
regs[3], regs[2]);
win_printf(TEXT("STAT=%04x%04x "),
regs[5], regs[4]);
win_printf(TEXT("(%04x%04x) "),
regs[5]&regs[7], regs[4]&regs[6]);
win_printf(TEXT("EN=%04x%04x "),
regs[7], regs[6]);
win_printf(TEXT("TYP=%04x%04x "),
regs[9], regs[8]);
win_printf(TEXT("ALSEL=%04x%04x "),
regs[11], regs[10]);
win_printf(TEXT("HTSEL=%04x%04x "),
regs[13], regs[12]);
win_printf(TEXT("PODAT=%04x%04x "),
regs[15], regs[14]);
win_printf(TEXT("\n"));
for (i = 0; i < 16; i++) {
prev_regs[i] = regs[i];
}
break;
}
}
}
}

static struct regdesc {
TCHAR *name;
int physaddr;
int size;
int mask;
//void *addr;
unsigned long val;
unsigned long preval;
} test_regs[] = {
#if 0
/*
* Vrc4172 GPIO and PWM
*/
{ TEXT("EXGPDATA0"), 0x15001080, 2, 0xfffd },
{ TEXT("EXGPDATA1"), 0x150010c0, 2, 0xffff },
{ TEXT("LCDDUTYEN"), 0x15003880, 2, 0xffff },
{ TEXT("LCDFREQ"), 0x15003882, 2, 0xffff },
{ TEXT("LCDDUTY"), 0x15003884, 2, 0xffff },
#endif

#if 0
/*
* Vr41xx GPIO
*/
{ TEXT("GIUPIODL"), 0x0b000104, 2, 0xffff },
{ TEXT("GIUPIODH"), 0x0b000106, 2, 0xffff },
{ TEXT("GIUPODATL"), 0x0b00011c, 2, 0xffff },
{ TEXT("GIUPODATH"), 0x0b00011e, 2, 0xffff },
{ TEXT("GIUUSEUPDN"), 0x0b0002e0, 2, 0xffff },
{ TEXT("GIUTERMUPDN"), 0x0b0002e2, 2, 0xffff },
#endif

/*
* MQ200
*/
{ TEXT("PM00R"), 0x0a600000, 4, 0xffffffff },
{ TEXT("PM01R"), 0x0a600004, 4, 0xffffffff },
{ TEXT("PM02R"), 0x0a600008, 4, 0xffffffff },
{ TEXT("PM06R"), 0x0a600018, 4, 0xffffffff },
{ TEXT("PM07R"), 0x0a60001c, 4, 0xffffffff },

{ TEXT("CC00R"), 0x0a602000, 4, 0x0000003f },
{ TEXT("CC01R"), 0x0a602004, 4, 0x00000000 },

{ TEXT("MM00R"), 0x0a604000, 4, 0x00000007 },
{ TEXT("MM01R"), 0x0a604004, 4, 0xffffffff },
{ TEXT("MM02R"), 0x0a604008, 4, 0xffffffff },
{ TEXT("MM03R"), 0x0a60400c, 4, 0x00000001 },
{ TEXT("MM04R"), 0x0a604010, 4, 0x00000001 },

{ TEXT("IN00R"), 0x0a608000, 4, 0x0000001f },
{ TEXT("IN01R"), 0x0a608004, 4, 0x0000ffff },
{ TEXT("IN02R"), 0x0a608008, 4, 0x00000000 },
{ TEXT("IN03R"), 0x0a60800c, 4, 0x00000000 },

{ TEXT("GC00R"), 0x0a60a000, 4, 0xfffff9ff },
{ TEXT("GC01R"), 0x0a60a004, 4, 0x10ffffff },
{ TEXT("GC20R"), 0x0a60a080, 4, 0xffffffff },
{ TEXT("GC21R"), 0x0a60a084, 4, 0x0000007f },

{ TEXT("FP00R"), 0x0a60e000, 4, 0xffffffff },
{ TEXT("FP01R"), 0x0a60e004, 4, 0xffffffff },
{ TEXT("FP02R"), 0x0a60e008, 4, 0x007fffff },
{ TEXT("FP03R"), 0x0a60e00c, 4, 0x0707003f },
{ TEXT("FP04R"), 0x0a60e010, 4, 0xffff3fff },
{ TEXT("FP05R"), 0x0a60e014, 4, 0xffffffff },
{ TEXT("FP0FR"), 0x0a60e03c, 4, 0xffffffff },

{ TEXT("DC00R"), 0x0a614000, 4, 0xffffffff },
{ TEXT("DC01R"), 0x0a614004, 4, 0x0000003f },
{ TEXT("DC02R"), 0x0a614008, 4, 0xffffffff },
{ TEXT("DC03R"), 0x0a61400c, 4, 0xffffffff },

{ TEXT("PC00R"), 0x0a616000, 4, 0xffffffff },
{ TEXT("PC04R"), 0x0a616004, 4, 0xffffffff },
{ TEXT("PC08R"), 0x0a616008, 4, 0xffffffff },
{ TEXT("PC0CR"), 0x0a61600c, 4, 0xffffffff },
{ TEXT("PC10R"), 0x0a616010, 4, 0xffffffff },
{ TEXT("PC14R"), 0x0a616014, 4, 0xffffffff },
{ TEXT("PC2CR"), 0x0a61602c, 4, 0xffffffff },
{ TEXT("PC3CR"), 0x0a61603c, 4, 0xffffffff },
{ TEXT("PC40R"), 0x0a616040, 4, 0xffffffff },
{ TEXT("PC44R"), 0x0a616044, 4, 0x00000003 },
};

extern int SetKMode(int);
static void
regfetch(struct regdesc* desc)
{
SetKMode(1);
switch (desc->size) {
case 1:
desc->val = *(unsigned char*)(desc->physaddr | 0xa0000000);
break;
case 2:
desc->val = *(unsigned short*)(desc->physaddr | 0xa0000000);
break;
case 4:
desc->val = *(unsigned long*)(desc->physaddr | 0xa0000000);
break;
default:
win_printf(TEXT("Invalid size"));
break;
}
SetKMode(0);
desc->val &= desc->mask;
}

static void
register_test(void)
{
int i;
int nregs = sizeof(test_regs)/sizeof(*test_regs);

for (i = 0; i < nregs; i++) {
regfetch(&test_regs[i]);
test_regs[i].preval = test_regs[i].val;
}

while (1) {
for (i = 0; i < nregs; i++) {
regfetch(&test_regs[i]);
if (test_regs[i].val != test_regs[i].preval) {
win_printf(TEXT("%20s(%08x) %08x -> %08x\n"),
test_regs[i].name,
test_regs[i].physaddr,
test_regs[i].preval,
test_regs[i].val);
test_regs[i].preval = test_regs[i].val;
}
}
Sleep(10); /* 10 msec */
}
}

static void
dump_memory(void)
{
HANDLE fh = INVALID_HANDLE_VALUE;
#define UNICODE_MEMORY_CARD \
TEXT('\\'), 0xff92, 0xff93, 0xff98, TEXT(' '), 0xff76, 0xff70, \
0xff84, 0xff9e
TCHAR filename[] = { UNICODE_MEMORY_CARD, TEXT('2'), TEXT('\\'),
TEXT('d'), TEXT('u'), TEXT('m'), TEXT('p'), 0 };
unsigned long *addr;
int found;

win_printf(TEXT("dump to %s\n"), filename);
fh = CreateFile(
filename, /* file name */
GENERIC_WRITE, /* access (read-write) mode */
FILE_SHARE_WRITE,/* share mode */
NULL, /* pointer to security attributes */
CREATE_ALWAYS, /* how to create */
FILE_ATTRIBUTE_NORMAL, /* file attributes*/
NULL /* handle to file with attributes to */
);
if (fh == INVALID_HANDLE_VALUE) {
return;
}

for (addr = (unsigned long*)0xbe000000;
addr < (unsigned long*)0xbfffffff;
addr += 2048) {
char buf[2048];
DWORD n;

SetKMode(1);
memcpy(buf, addr, 2048);
SetKMode(0);
if (WriteFile(fh, buf, 2048, &n, NULL) == 0 ||
n != 2048) {
win_printf(TEXT("dump failed\n"));
break;
}
}

CloseHandle(fh);
}

static void
serial_test(void)
{
#if 1
# define SIUADDR 0xac000000
# define REGOFFSET 0x0
#else
# define SIUADDR 0xab000000
# define REGOFFSET 0x1a0
#endif
#define REGSIZE 32
int i, changed, res;
unsigned char regs[REGSIZE], prev_regs[REGSIZE];
unsigned char* p = (char*)VirtualAlloc(0, 1024, MEM_RESERVE,
PAGE_NOACCESS);

for (i = 0; i < ARRAYSIZEOF(prev_regs); i++) {
prev_regs[i] = ~0;
}

res = VirtualCopy((LPVOID)p, (LPVOID)(SIUADDR >> 8), 1024,
PAGE_READWRITE|PAGE_NOCACHE|PAGE_PHYSICAL);
if (!res) {
win_printf(TEXT("VirtualCopy() failed."));
}

while (1) {
flush_XX();

for (i = 0; i < ARRAYSIZEOF(regs); i++) {
regs[i] = p[REGOFFSET + i];
}

changed = 0;
for (i = 0; i < ARRAYSIZEOF(regs); i++) {
if (regs[i] != prev_regs[i]) {
changed++;
}
prev_regs[i] = regs[i];
}
if (changed) {
win_printf(TEXT("SIU regs: "));
for (i = 0; i < ARRAYSIZEOF(regs); i++) {
win_printf(TEXT("%02x "), regs[i]);
}
win_printf(TEXT("\n"));
}
}

VirtualFree(p, 0, MEM_RELEASE);
}

static long
checksum(char* addr, int size)
{
long sum = 0;
int i;

for (i = 0; i < size; i++) {
sum += *addr++ * i;
}
return (sum);
}

static int
examine(char* addr, int size)
{
long random_data[256];
long dijest;
int i;

for (i = 0; i < ARRAYSIZEOF(random_data); i++) {
random_data[i] = Random();
}
if (sizeof(random_data) < size) {
size = sizeof(random_data);
}
memcpy(addr, (char*)random_data, size);
dijest= checksum((char*)random_data, size);

return (dijest == checksum(addr, size));
}

void
display_search(void)
{
int step = 0x10000;
int i;
long addr;

for (i = 0; i < ntargets; i++) {
int prevres = -1;
for (addr = targets[i].start;
addr < targets[i].end;
addr += step) {
int res;
#if 0
char* p = (char*)VirtualAlloc(0, step, MEM_RESERVE,
PAGE_NOACCESS);
res = VirtualCopy((LPVOID)p, (LPVOID)(addr >> 8), step,
PAGE_READWRITE|PAGE_NOCACHE|PAGE_PHYSICAL);
if (!res) {
win_printf(TEXT("VirtualCopy() failed."));
}
res = examine(p, step);
VirtualFree(p, 0, MEM_RELEASE);
#else
SetKMode(1);
res = examine((char*)((int)addr | 0xa0000000), step);
SetKMode(0);
#endif
if (res != prevres && prevres != -1) {
if (res) {
win_printf(TEXT("0x%x "), addr);
} else {
win_printf(TEXT("- 0x%x\n"), addr);
}
} else
if (res && prevres == -1) {
win_printf(TEXT("0x%x "), addr);
}
prevres = res;
}
if (prevres) {
win_printf(TEXT("\n"));
}
}
}

void
display_draw(void)
{
long addr = 0x13000000;
int size = 0x80000;
char* p;
int i, j, res;
int x, y;
int stride = 1280;

p = (char*)VirtualAlloc(0, size, MEM_RESERVE,
PAGE_NOACCESS);
res = VirtualCopy((LPVOID)p, (LPVOID)(addr >> 8), size,
PAGE_READWRITE|PAGE_NOCACHE|PAGE_PHYSICAL);
if (!res) {
win_printf(TEXT("VirtualCopy() failed."));
}

for (i = 0; i < 10000; i++) {
p[i] = i;
}
for (x = 0; x < 640; x += 10) {
for (y = 0; y < 240; y += 1) {
p[stride * y + x] = (char)0xff;
}
}
for (y = 0; y < 240; y += 10) {
for (x = 0; x < 640; x += 1) {
p[stride * y + x] = (char)0xff;
}
}
for (i = 0; i < 16; i++) {
for (j = 0; j < 16; j++) {
for (x = i * 32; x < i * 32 + 32; x++) {
for (y = j * 15; y < j * 15 + 15; y++) {
p[stride * y + x] = j * 16 + i;
}
}
}
}

VirtualFree(p, 0, MEM_RELEASE);
}

#define PCIC_IDENT 0x00
#define PCIC_REG_INDEX 0
#define PCIC_REG_DATA 1
#define PCIC_IDENT_EXPECTED 0x83

void
pcic_search(void)
{
long addr;
int window_size = 0x10000;
int i;

for (addr = 0x14000000; addr < 0x18000000; addr += window_size) {
int res;
unsigned char* p;
p = (char*)VirtualAlloc(0, window_size, MEM_RESERVE,
PAGE_NOACCESS);
res = VirtualCopy((LPVOID)p, (LPVOID)(addr >> 8), window_size,
PAGE_READWRITE|PAGE_NOCACHE|PAGE_PHYSICAL);
if (!res) {
win_printf(TEXT("VirtualCopy() failed."));
}

for (i = 0; i < window_size; i += 2) {
p[i + PCIC_REG_INDEX] = PCIC_IDENT;
if (p[i + PCIC_REG_DATA] == PCIC_IDENT_EXPECTED) {
win_printf(TEXT("pcic is found at 0x%x\n"),
addr + i);
}
}

VirtualFree(p, 0, MEM_RELEASE);
}
}

#define VRPCIU_CONFA (*(u_int32_t*)0xaf000c18)
#define VRPCIU_CONFD (*(u_int32_t*)0xaf000c14)

void
pci_dump(void)
{
int mode, i;
BOOL SetKMode(BOOL);
int bus, dev;
u_int32_t addr, val;
u_int32_t addrs[] = {
0x00000800,
0x00001000,
0x00002000,
0x00004000,
0x00008000,
0x00010000,
0x00020000,
0x00040000,
0x00080000,
0x00100000,
0x00200000,
0x00400000,
0x00800000,
0x01000000,
0x02000000,
0x04000000,
0x08000000,
0x10000000,
0x20000000,
0x40000000,
0x80000000,
};

#if 0 /* You can find Vrc4173 BCU at 0xb6010000 on Sigmarion II */
win_printf(TEXT("Vrc4173 CMUCLKMSK: %04X\n"),
*(u_int16_t*)0xb6010040);
win_printf(TEXT("Vrc4173 CMUSRST: %04X\n"),
*(u_int16_t*)0xb6010042);

/* enable CARDU clock */
*(u_int16_t*)0xb6010042 = 0x0006; /* enable CARD1RST and CARD2RST */
*(u_int16_t*)0xb6010040 = *(u_int16_t*)0xb6010040 | 0x00c0;
*(u_int16_t*)0xb6010042 = 0x0000; /* disable CARD1RST and CARD2RST */

win_printf(TEXT("Vrc4173 CMUCLKMSK: %04X\n"),
*(u_int16_t*)0xb6010040);
win_printf(TEXT("Vrc4173 CMUSRST: %04X\n"),
*(u_int16_t*)0xb6010042);
#endif

for (i = 0; i < sizeof(addrs)/sizeof(*addrs); i++) {
VRPCIU_CONFA = addrs[i];
val = VRPCIU_CONFD;
win_printf(TEXT("%2d: %08X %04X %04X\n"),
i, addrs[i], val & 0xffff, (val >> 16) & 0xffff);
}

mode = SetKMode(1);
SetKMode(mode);
}

void
hardware_test(void)
{
int do_gpio_test = 0;
int do_register_test = 0;
int do_serial_test = 0;
int do_display_draw = 0;
int do_display_search = 0;
int do_pcic_search = 0;
int do_dump_memory = 0;
int do_pci_dump = 0;

if (do_gpio_test) {
gpio_test();
}
if (do_register_test) {
register_test();
}
if (do_serial_test) {
serial_test();
}
if (do_display_draw) {
display_draw();
}
if (do_display_search) {
display_search();
}
if (do_pcic_search) {
pcic_search();
}
if (do_dump_memory) {
dump_memory();
}
if (do_pci_dump) {
pci_dump();
}
}