mpc6xxinc.c

Coldfire MCF5282 DBug bootloader

/*
 * This program generates the offsets used by the assembly file
 * to access the MPC60X registers buffer.
 *
 * NOTE:  There is an important assumption in that the PowerPC
 * C compiler and the C compiler used to generate this file
 * match EXACTLY in the way the REGISTERS data structure is
 * produced.  Ie, no reordering, no alignment issues...
 *
 * NOTE: By using the form below, maximum capability between Diab and
 * GNU PPC assembler is achieved!!!!
 *
 *     .equ   symbol,value
 *
 * When compiling this utility from this directory, use:
 *
 * gcc -D CPU_MPC603 -I ../../../../../include/cpu mpc6xxinc.c
 *
 * Eric DeVolder
 */

#include <cpu.h>
#include "mpc6xx.h"

static REGISTERS regs;

#define ENTRY(PPC,REG,SPR) {#PPC, #REG, SPR, (void *)&regs.REG}

typedef struct
{
	char *	proc;
	char *	reg;
	int		spr;
	void *	offset;
} ppc_reg;

#define REGTAB_SIZE	(sizeof(regtab) / sizeof(ppc_reg))
#define REG_OFFSET(X)	(void *)((char *)X - (char *)&regs)

static const ppc_reg regtab[] =
{
	 
ENTRY(0,r0,0),
ENTRY(0,r1,0),
ENTRY(0,r2,0),
ENTRY(0,r3,0),
ENTRY(0,r4,0),
ENTRY(0,r5,0),
ENTRY(0,r6,0),
ENTRY(0,r7,0),
ENTRY(0,r8,0),
ENTRY(0,r9,0),
ENTRY(0,r10,0),
ENTRY(0,r11,0),
ENTRY(0,r12,0),
ENTRY(0,r13,0),
ENTRY(0,r14,0),
ENTRY(0,r15,0),
ENTRY(0,r16,0),
ENTRY(0,r17,0),
ENTRY(0,r18,0),
ENTRY(0,r19,0),
ENTRY(0,r20,0),
ENTRY(0,r21,0),
ENTRY(0,r22,0),
ENTRY(0,r23,0),
ENTRY(0,r24,0),
ENTRY(0,r25,0),
ENTRY(0,r26,0),
ENTRY(0,r27,0),
ENTRY(0,r28,0),
ENTRY(0,r29,0),
ENTRY(0,r30,0),
ENTRY(0,r31,0),

ENTRY(0,f0,0),
ENTRY(0,f1,0),
ENTRY(0,f2,0),
ENTRY(0,f3,0),
ENTRY(0,f4,0),
ENTRY(0,f5,0),
ENTRY(0,f6,0),
ENTRY(0,f7,0),
ENTRY(0,f8,0),
ENTRY(0,f9,0),
ENTRY(0,f10,0),
ENTRY(0,f11,0),
ENTRY(0,f12,0),
ENTRY(0,f13,0),
ENTRY(0,f14,0),
ENTRY(0,f15,0),
ENTRY(0,f16,0),
ENTRY(0,f17,0),
ENTRY(0,f18,0),
ENTRY(0,f19,0),
ENTRY(0,f20,0),
ENTRY(0,f21,0),
ENTRY(0,f22,0),
ENTRY(0,f23,0),
ENTRY(0,f24,0),
ENTRY(0,f25,0),
ENTRY(0,f26,0),
ENTRY(0,f27,0),
ENTRY(0,f28,0),
ENTRY(0,f29,0),
ENTRY(0,f30,0),
ENTRY(0,f31,0),

ENTRY(0,cr,0),
ENTRY(0,fpscr,0),
ENTRY(0,xer,1),
ENTRY(0,lr,8),
ENTRY(0,ctr,9),

ENTRY(0,tbl,268),
ENTRY(0,tbu,269),

ENTRY(0,msr,0),

ENTRY(0,pvr,287),

ENTRY(0,ibat0u,528),
ENTRY(0,ibat0l,529),
ENTRY(0,ibat1u,530),
ENTRY(0,ibat1l,531),
ENTRY(0,ibat2u,532),
ENTRY(0,ibat2l,533),
ENTRY(0,ibat3u,534),
ENTRY(0,ibat3l,535),

ENTRY(0,dbat0u,536),
ENTRY(0,dbat0l,537),
ENTRY(0,dbat1u,538),
ENTRY(0,dbat1l,539),
ENTRY(0,dbat2u,540),
ENTRY(0,dbat2l,541),
ENTRY(0,dbat3u,542),
ENTRY(0,dbat3l,543),

ENTRY(0,sr0,0),
ENTRY(0,sr1,0),
ENTRY(0,sr2,0),
ENTRY(0,sr3,0),
ENTRY(0,sr4,0),
ENTRY(0,sr5,0),
ENTRY(0,sr6,0),
ENTRY(0,sr7,0),
ENTRY(0,sr8,0),
ENTRY(0,sr9,0),
ENTRY(0,sr10,0),
ENTRY(0,sr11,0),
ENTRY(0,sr12,0),
ENTRY(0,sr13,0),
ENTRY(0,sr14,0),
ENTRY(0,sr15,0),

ENTRY(0,sdr1,25),

ENTRY(0,dar,19),
ENTRY(0,dsisr,18),
ENTRY(0,srr0,26),
ENTRY(0,srr1,27),
ENTRY(0,sprg0,272),
ENTRY(0,sprg1,273),
ENTRY(0,sprg2,274),
ENTRY(0,sprg3,275),

ENTRY(0,dec,22),

/*
 * MPC603
 */
ENTRY(603,psr.mpc603.hid0,1008),
ENTRY(603,psr.mpc603.dmiss,976),
ENTRY(603,psr.mpc603.dcmp,977),
ENTRY(603,psr.mpc603.hash1,978),
ENTRY(603,psr.mpc603.hash2,979),
ENTRY(603,psr.mpc603.imiss,980),
ENTRY(603,psr.mpc603.icmp,981),
ENTRY(603,psr.mpc603.rpa,982),
ENTRY(603,psr.mpc603.iabr,1010),
ENTRY(603,psr.mpc603.ear,282),

/*
 * MPC603e
 */
ENTRY(603e,psr.mpc603e.hid0,1008),
ENTRY(603e,psr.mpc603e.hid1,1009),
ENTRY(603e,psr.mpc603e.dmiss,976),
ENTRY(603e,psr.mpc603e.dcmp,977),
ENTRY(603e,psr.mpc603e.hash1,978),
ENTRY(603e,psr.mpc603e.hash2,979),
ENTRY(603e,psr.mpc603e.imiss,980),
ENTRY(603e,psr.mpc603e.icmp,981),
ENTRY(603e,psr.mpc603e.rpa,982),
ENTRY(603e,psr.mpc603e.iabr,1010),
ENTRY(603e,psr.mpc603e.ear,282),

/*
 * MPC604
 */
ENTRY(604,psr.mpc604.hid0,1008),
ENTRY(604,psr.mpc604.pmc1,953),
ENTRY(604,psr.mpc604.pmc2,954),
ENTRY(604,psr.mpc604.mmcr0,952),
ENTRY(604,psr.mpc604.sda,959),
ENTRY(604,psr.mpc604.sia,955),
ENTRY(604,psr.mpc604.iabr,1010),
ENTRY(604,psr.mpc604.dabr,1013),
ENTRY(604,psr.mpc604.ear,282),
ENTRY(604,psr.mpc604.pir,1023),

/*
 * MPC604e
 */
ENTRY(604e,psr.mpc604e.hid0,1008),
ENTRY(604e,psr.mpc604e.hid1,1009),
ENTRY(604e,psr.mpc604e.pmc1,953),
ENTRY(604e,psr.mpc604e.pmc2,954),
ENTRY(604e,psr.mpc604e.pmc3,957),
ENTRY(604e,psr.mpc604e.pmc4,958),
ENTRY(604e,psr.mpc604e.mmcr0,952),
ENTRY(604e,psr.mpc604e.mmcr1,956),
ENTRY(604e,psr.mpc604e.sda,959),
ENTRY(604e,psr.mpc604e.sia,955),
ENTRY(604e,psr.mpc604e.iabr,1010),
ENTRY(604e,psr.mpc604e.dabr,1013),
ENTRY(604e,psr.mpc604e.ear,282),
ENTRY(604e,psr.mpc604e.pir,1023),

/*
 * MPC750
 */
ENTRY(750,psr.mpc750.upmc1,937),
ENTRY(750,psr.mpc750.upmc2,938),
ENTRY(750,psr.mpc750.upmc3,941),
ENTRY(750,psr.mpc750.upmc4,942),
ENTRY(750,psr.mpc750.usia,939),
ENTRY(750,psr.mpc750.ummcr0,936),
ENTRY(750,psr.mpc750.ummcr1,940),
ENTRY(750,psr.mpc750.hid0,1008),
ENTRY(750,psr.mpc750.hid1,1009),
ENTRY(750,psr.mpc750.pmc1,953),
ENTRY(750,psr.mpc750.pmc2,954),
ENTRY(750,psr.mpc750.pmc3,957),
ENTRY(750,psr.mpc750.pmc4,958),
ENTRY(750,psr.mpc750.mmcr0,952),
ENTRY(750,psr.mpc750.mmcr1,956),
ENTRY(750,psr.mpc750.sia,955),
ENTRY(750,psr.mpc750.thrm1,1020),
ENTRY(750,psr.mpc750.thrm2,1021),
ENTRY(750,psr.mpc750.thrm3,1022),
ENTRY(750,psr.mpc750.ictc,1019),
ENTRY(750,psr.mpc750.l2cr,1017),
ENTRY(750,psr.mpc750.iabr,1010),
ENTRY(750,psr.mpc750.dabr,1013),
ENTRY(750,psr.mpc750.ear,282),
} ;


static void
get_reg (char *outstr, char *instr)
{
	/*
	 * Strip structure dereferences to get register name
	 * Outstr can not be equal to instr
	 */
	int slen = strlen(instr);
	int i, j;

	i = slen;

	while ((instr[i] != '.') && (i > 0))
		--i;

	if (instr[i] == '.') ++i;

	for (j = 0; i <= slen; ++j, ++i)
		outstr[j] = instr[i];
}

static void
dump_sprs (void)
{
	int index;
	char ppcreg[60];

	for (index = 0; index < REGTAB_SIZE; ++index)
	{
		get_reg(ppcreg, regtab[index].reg);
		if (regtab[index].spr != 0)
		{
			if (strcmp("0",regtab[index].proc) == 0)
				printf("	.equ	spr_%s,%d\n",
				ppcreg,
				regtab[index].spr);
			else
				printf("	.equ	spr_%s_%s,%d\n",
				regtab[index].proc,
				ppcreg,
				regtab[index].spr);
		}
	}
}
 
static void
dump_offsets (void)
{
	int index;
	char ppcreg[60];

	for (index = 0; index < REGTAB_SIZE; ++index)
	{
		get_reg(ppcreg, regtab[index].reg);
		if (strcmp("0",regtab[index].proc) == 0)
			printf("	.equ	o_%s,%#06x\n",
			ppcreg,
			REG_OFFSET(regtab[index].offset));
		else
			printf("	.equ	o_%s_%s,%#06x\n",
			regtab[index].proc,
			ppcreg,
			REG_OFFSET(regtab[index].offset));
	}
}
 
void main (void)
{
	printf("	#\n");
	printf("	# File:		mpc60x.inc\n");
	printf("	#\n");
	printf("	# Purpose:	Definitions for PowerPC registers\n");
	printf("	#\n");
	printf("	# Author:	Eric DeVolder\n");
	printf("	#\n");
	printf("	# Notes:	This file automatically generated.\n");
	printf("	#			See mpc60xinc.c utility.\n");
	printf("	#\n");
	printf("\n");
	printf("\n");
	printf("	#\n");
	printf("	# Offsets of registers in the REGISTERS data structure.\n");
	printf("	# NOTE:  Offsets must match compiler calculated offsets!\n");
	printf("	#\n");
	printf("\n");
	dump_offsets();
	printf("\n");
	printf("\n");
	printf("	#\n");
	printf("	# PowerPC Special Purpose Register numbers\n");
	printf("	#\n");
	printf("\n");
	dump_sprs();
	printf("\n");
	printf("\n");
}