/*	$OpenBSD: asi.c,v 1.2 2003/07/12 07:09:25 jason Exp $	*/

/*
 * Copyright (c) 2003 Jason L. Wright (jason@thought.net)
 * All rights reserved.
 *
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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 <sys/types.h>

#include <machine/psl.h>
#include <machine/ctlreg.h>

#include <stdlib.h>
#include <limits.h>
#include <stdio.h>
#include <string.h>
#include <err.h>
#include <errno.h>
#include "fpregs.h"

struct fpquad {
        u_int32_t x1;
        u_int32_t x2;
        u_int32_t x3;
        u_int32_t x4;
};

int compare_regs(union fpregs *, union fpregs *);
void dump_reg(union fpregs *);
void dump_regs(union fpregs *, union fpregs *, union fpregs *);
int compare_quads(struct fpquad *, struct fpquad *);
void c_stqa_asi(int, union fpregs *, struct fpquad *);
void c_ldqa_asi(int, union fpregs *, struct fpquad *);
void asm_ldqa_asi(int, struct fpquad *);
void asm_stqa_asi(int, struct fpquad *);
void asm_ldqa_imm(int asi, struct fpquad *);
void asm_stqa_imm(int asi, struct fpquad *);
void asm_stqa_primary(struct fpquad *);
void asm_ldqa_primary(struct fpquad *);
void asm_stqa_secondary(struct fpquad *);
void asm_ldqa_secondary(struct fpquad *);
void asm_stqa_primary_nofault(struct fpquad *);
void asm_ldqa_primary_nofault(struct fpquad *);
void asm_stqa_secondary_nofault(struct fpquad *);
void asm_ldqa_secondary_nofault(struct fpquad *);
void asm_stqa_primary_little(struct fpquad *);
void asm_ldqa_primary_little(struct fpquad *);
void asm_stqa_secondary_little(struct fpquad *);
void asm_ldqa_secondary_little(struct fpquad *);
void asm_stqa_primary_nofault_little(struct fpquad *);
void asm_ldqa_primary_nofault_little(struct fpquad *);
void asm_stqa_secondary_nofault_little(struct fpquad *);
void asm_ldqa_secondary_nofault_little(struct fpquad *);
void check_asi(int, union fpregs *, union fpregs *, union fpregs *);
void check_asi_asi(int, union fpregs *, union fpregs *, union fpregs *);
void check_asi_imm(int, union fpregs *, union fpregs *, union fpregs *);
int main(int, char *[]);

int
compare_regs(union fpregs *fr1, union fpregs *fr2)
{
	return (memcmp(fr1, fr2, sizeof(*fr2)));
}

void
dump_reg(union fpregs *fr)
{
	int i;

	for (i = 0; i < 64; i++) {
		if ((i & 3) == 0)
			printf("f%-2d:", i);
		printf(" %08x", fr->f_reg32[i]);
		if ((i & 3) == 3)
			printf("\n");
	}
}

void
dump_regs(union fpregs *fr1, union fpregs *fr2, union fpregs *fr3)
{
	printf("BEFORE ASM\n");
	dump_reg(fr1);
	printf("AFTER ASM\n");
	dump_reg(fr2);
	printf("MANUAL\n");
	dump_reg(fr3);
}

int
compare_quads(struct fpquad *q1, struct fpquad *q2)
{
	return (memcmp(q1, q2, sizeof(*q2)));
}

void
c_stqa_asi(int asi, union fpregs *frp, struct fpquad *q)
{
	if (asi == ASI_PRIMARY ||
	    asi == ASI_PRIMARY_NOFAULT ||
	    asi == ASI_SECONDARY ||
	    asi == ASI_SECONDARY_NOFAULT) {
		q->x1 = frp->f_reg32[0];
		q->x2 = frp->f_reg32[0 + 1];
		q->x3 = frp->f_reg32[0 + 2];
		q->x4 = frp->f_reg32[0 + 3];
		return;
	}
	if (asi == ASI_PRIMARY_LITTLE ||
	    asi == ASI_PRIMARY_NOFAULT_LITTLE ||
	    asi == ASI_SECONDARY_LITTLE ||
	    asi == ASI_SECONDARY_NOFAULT_LITTLE) {
		q->x4 = htole32(frp->f_reg32[0]);
		q->x3 = htole32(frp->f_reg32[0 + 1]);
		q->x2 = htole32(frp->f_reg32[0 + 2]);
		q->x1 = htole32(frp->f_reg32[0 + 3]);
		return;
	}
	errx(1, "c_stqa_asi: bad asi %d", asi);
}

void
c_ldqa_asi(int asi, union fpregs *frp, struct fpquad *q)
{
	if (asi == ASI_PRIMARY ||
	    asi == ASI_PRIMARY_NOFAULT ||
	    asi == ASI_SECONDARY ||
	    asi == ASI_SECONDARY_NOFAULT) {
		frp->f_reg32[0] = q->x1;
		frp->f_reg32[0 + 1] = q->x2;
		frp->f_reg32[0 + 2] = q->x3;
		frp->f_reg32[0 + 3] = q->x4;
		return;
	}
	if (asi == ASI_PRIMARY_LITTLE ||
	    asi == ASI_PRIMARY_NOFAULT_LITTLE ||
	    asi == ASI_SECONDARY_LITTLE ||
	    asi == ASI_SECONDARY_NOFAULT_LITTLE) {
		frp->f_reg32[0] = htole32(q->x4);
		frp->f_reg32[0 + 1] = htole32(q->x3);
		frp->f_reg32[0 + 2] = htole32(q->x2);
		frp->f_reg32[0 + 3] = htole32(q->x1);
		return;
	}
	errx(1, "c_ldqa_asi: bad asi %d", asi);
}

void
asm_stqa_imm(int asi, struct fpquad *q)
{
	switch (asi) {
	case ASI_PRIMARY:
		asm_stqa_primary(q);
		break;
	case ASI_SECONDARY:
		asm_stqa_secondary(q);
		break;
	case ASI_PRIMARY_NOFAULT:
		asm_stqa_primary_nofault(q);
		break;
	case ASI_SECONDARY_NOFAULT:
		asm_stqa_secondary_nofault(q);
		break;
	case ASI_PRIMARY_LITTLE:
		asm_stqa_primary_little(q);
		break;
	case ASI_SECONDARY_LITTLE:
		asm_stqa_secondary_little(q);
		break;
	case ASI_PRIMARY_NOFAULT_LITTLE:
		asm_stqa_primary_nofault_little(q);
		break;
	case ASI_SECONDARY_NOFAULT_LITTLE:
		asm_stqa_secondary_nofault_little(q);
		break;
	default:
		errx(1, "asm_stqa_imm: bad asi %d", asi);
	}
}

void
asm_ldqa_imm(int asi, struct fpquad *q)
{
	switch (asi) {
	case ASI_PRIMARY:
		asm_ldqa_primary(q);
		break;
	case ASI_SECONDARY:
		asm_ldqa_secondary(q);
		break;
	case ASI_PRIMARY_NOFAULT:
		asm_ldqa_primary_nofault(q);
		break;
	case ASI_SECONDARY_NOFAULT:
		asm_ldqa_secondary_nofault(q);
		break;
	case ASI_PRIMARY_LITTLE:
		asm_ldqa_primary_little(q);
		break;
	case ASI_SECONDARY_LITTLE:
		asm_ldqa_secondary_little(q);
		break;
	case ASI_PRIMARY_NOFAULT_LITTLE:
		asm_ldqa_primary_nofault_little(q);
		break;
	case ASI_SECONDARY_NOFAULT_LITTLE:
		asm_ldqa_secondary_nofault_little(q);
		break;
	default:
		errx(1, "asm_ldqa_imm: bad asi %d", asi);
	}
}

void
check_asi(int asi, union fpregs *fr1, union fpregs *fr2, union fpregs *fr3)
{
	check_asi_asi(asi, fr1, fr2, fr3);
	check_asi_imm(asi, fr1, fr2, fr3);
}

void
check_asi_asi(int asi, union fpregs *fr1, union fpregs *fr2, union fpregs *fr3)
{
	struct fpquad q1;

	initfpregs(fr1);
	initfpregs(fr2);
	initfpregs(fr3);

	q1.x1 = 0x01234567;
	q1.x2 = 0x89abcdef;
	q1.x3 = 0x55aa55aa;
	q1.x4 = 0xa5a5a5a5;

	loadfpregs(fr1);
	asm_ldqa_asi(asi, &q1);
	savefpregs(fr2);

	c_ldqa_asi(asi, fr3, &q1);

	if (compare_regs(fr2, fr3)) {
		printf("ASI 0x%x failed\n", asi);
		dump_regs(fr1, fr2, fr3);
		exit(1);
	}
}

void
check_asi_imm(int asi, union fpregs *fr1, union fpregs *fr2, union fpregs *fr3)
{
	struct fpquad q1;

	initfpregs(fr1);
	initfpregs(fr2);
	initfpregs(fr3);

	q1.x1 = 0x01234567;
	q1.x2 = 0x89abcdef;
	q1.x3 = 0x55aa55aa;
	q1.x4 = 0xa5a5a5a5;

	loadfpregs(fr1);
	asm_ldqa_imm(asi, &q1);
	savefpregs(fr2);

	c_ldqa_asi(asi, fr3, &q1);

	if (compare_regs(fr2, fr3)) {
		printf("ASI 0x%x failed\n", asi);
		dump_regs(fr1, fr2, fr3);
		exit(1);
	}
}

int
main(int argc, char *argv[])
{
	union fpregs fr1, fr2, fr3;

	check_asi(ASI_PRIMARY, &fr1, &fr2, &fr3);
	check_asi(ASI_PRIMARY_NOFAULT, &fr1, &fr2, &fr3);
	check_asi(ASI_PRIMARY_LITTLE, &fr1, &fr2, &fr3);
	check_asi(ASI_PRIMARY_NOFAULT_LITTLE, &fr1, &fr2, &fr3);
	check_asi(ASI_SECONDARY, &fr1, &fr2, &fr3);
	check_asi(ASI_SECONDARY_NOFAULT, &fr1, &fr2, &fr3);
	check_asi(ASI_SECONDARY_LITTLE, &fr1, &fr2, &fr3);
	check_asi(ASI_SECONDARY_NOFAULT_LITTLE, &fr1, &fr2, &fr3);
	return (0);
}