fab_custom.c

树大根深三棱尽所标杆ssfsfsa fdsafs

 * Serial Peripheral Interface Master
 */
static void
spimcont_put(Fab *f, Reg *r)
{
	reg_put(f, r);
	putln(f,"if (db_SPIMCONT.anon.XCH && db_SPIMCONT.anon.IRQEN) {\n"
		"	db_SPIMCONT.anon.SPIMIRQ = 1;\n"
		"	db_SPIMCONT.anon.XCH = 0;\n"
		"	switch (db_PFDATA.x & 0x0f) {\n"
		"	case 0x6:\n"
		"		db_SPIMDATA.x = (0xff - CustShptr->penx) * 2;\n"
		"		break;\n"
		"	case 0x9:\n"
		"		db_SPIMDATA.x = (0xff - CustShptr->peny) * 2;\n"
		"		break;\n"
		"	}\n"
		"}\n");
}

/*
 * UART Controller
 */
static void
ustcnt_put(Fab *f, Reg *r)
{
	reg_put(f, r);
	putln(f,"CustShptr->serial_flags = (db_USTCNT.anon.PARITY_ENABLE << 3) |\n"
		"	(db_USTCNT.anon.ODD_EVEN << 2) | (db_USTCNT.anon.STOP_BITS << 1) |\n"
		"	(db_USTCNT.anon.BITS_8);\n");
}

static void
ubaud_put(Fab *f, Reg *r)
{
	reg_put(f, r);
	putln(f,"CustShptr->serial_baud = 1036800 / (1 << db_UBAUD.anon.DIVIDE) /\n"
		"	(65 - db_UBAUD.anon.PRESCALER);\n");
}

static void
urx_get(Fab *f, Reg *r)
{
	putln(f,"if (DEBUGGER_READING) {\n"
		"	db_URXdb.anon.DATA_READY = 0;\n"
		"	return db_URXdb.x;\n"
		"} else {\n"
		"	db_URX.anon.DATA_READY = 0;\n"
		"	db_IPR.anon.UART = 0;\n"
		"	updateisr();\n"
		"	return db_URX.x;\n"
		"}\n");
}

static void
urx_get_xxx(Fab *f, Reg *r)
{
#if CHECKME
	putln(f,"if (DEBUGGER_READING) {\n"
		"	db_URXdb.anon.DATA_READY = 0;\n"
		"	return db_URXdb.x >> 8;\n"
		"} else {\n"
		"	db_URX.anon.DATA_READY = 0;\n"
		"	db_IPR.anon.UART = 0;\n"
		"	updateisr();\n"
		"	return db_URX.x >> 8;\n"
		"}\n");

	f->lvl -= 2;
	putln(f,"	case %s + 1:\n", r->name);
	f->lvl += 2;

	putln(f,"if (DEBUGGER_READING) {\n"
		"	db_URXdb.anon.DATA_READY = 0;\n"
		"	return db_URXdb.x;\n"
		"} else {\n"
		"	db_URX.anon.DATA_READY = 0;\n"
		"	db_IPR.anon.UART = 0;\n"
		"	updateisr();\n"
		"	return db_URX.x;\n"
		"}\n");
#else
	putln(f,"if (DEBUGGER_READING) {\n"
		"	return db_URXdb.x >> 8;\n"
		"} else {\n"
		"	return db_URX.x >> 8;\n"
		"}\n");
#endif
}

static void
urx_put(Fab *f, Reg *r)
{
	putln(f,"/* ignore db_URX.x = value; */\n");
}

static void
utx_put(Fab *f, Reg *r)
{
	reg_put(f, r);
	putln(f,"if (db_UMISC.anon.LOOP) {\n"
		"	if (DEBUGGER_WRITING) {\n"
		"		db_URXdb.anon.DATA = db_UTX.anon.DATA;\n"
		"		db_URXdb.anon.DATA_READY = 1;\n"
		"	} else {\n"
		"		db_URX.anon.DATA = db_UTX.anon.DATA;\n"
		"		db_URX.anon.DATA_READY = 1;\n"
		"		if (db_USTCNT.anon.RX_READY_ENABLE) {\n"
		"			db_IPR.anon.UART = 1;\n"
		"			updateisr();\n"
		"		}\n"
		"	}\n"
		"} else {\n"
		"	unsigned char	outbuf = value & 0xff;\n"
		"	int		fd = (DEBUGGER_WRITING) ? CustShptr->gdb_writefd : CustShptr->serial_writefd;\n"
		"	write(fd, &outbuf, 1);\n"
		"}\n");
}

static void
utx_put_xxx(Fab *f, Reg *r)
{
	putln(f,"abort();\n");

	putln(f,"break;\n");
	f->lvl -= 2;
	putln(f,"	case %s + 1:\n", r->name);
	f->lvl += 2;

	putln(f,"db_%s.anon.DATA = value;\n", r->name);
	putln(f,"if (db_UMISC.anon.LOOP) {\n"
		"	if (DEBUGGER_WRITING) {\n"
		"		db_URXdb.anon.DATA = db_UTX.anon.DATA;\n"
		"		db_URXdb.anon.DATA_READY = 1;\n"
		"	} else {\n"
		"		db_URX.anon.DATA = db_UTX.anon.DATA;\n"
		"		db_URX.anon.DATA_READY = 1;\n"
		"		if (db_USTCNT.anon.RX_READY_ENABLE) {\n"
		"			db_IPR.anon.UART = 1;\n"
		"			updateisr();\n"
		"		}\n"
		"	}\n"
		"} else {\n"
		"	unsigned char	outbuf = value & 0xff;\n"
		"	int		fd = (DEBUGGER_WRITING) ? CustShptr->gdb_writefd : CustShptr->serial_writefd;\n"
		"	write(fd, &outbuf, 1);\n"
		"}\n");
}

static void
utx_get(Fab *f, Reg *r)
{
	putln(f,"db_UTX.anon.FIFO_EMPTY = 1;\n"
		"db_UTX.anon.FIFO_HALF = 1;\n"
		"db_UTX.anon.TX_AVAIL = 1;\n"
		"db_UTX.anon.CTS_STATUS = 1;\n");
	reg_get(f, r);
}

/*
 * LCD Controller
 */
static void
lssa_put(Fab *f, Reg *r)
{
	reg_put(f, r);
	putln(f,"CustShptr->lssa = value;\n");
}

static void
lvpw_put(Fab *f, Reg *r)
{
	reg_put(f, r);
	putln(f,"CustShptr->VPW = value;\n");
}

static void
lpicf_put(Fab *f, Reg *r)
{
	reg_put(f, r);
	putln(f,"CustShptr->PICF = value;\n");
}

static void
lckcon_put(Fab *f, Reg *r)
{
	reg_put(f, r);
	putln(f,"CustShptr->LcdPower = db_%s.anon.LCDCON ? lcdOn : lcdOff;\n", r->name);
}

static void
lposr_put(Fab *f, Reg *r)
{
	reg_put(f, r);
	putln(f,"CustShptr->POSR = value;\n");
}

static void
lgpmr_put(Fab *f, Reg *r)
{
	reg_put(f, r);
	putln(f,"CustShptr->grpalette[0] = db_%s.anon.G0;\n", r->name);
	putln(f,"CustShptr->grpalette[1] = db_%s.anon.G1;\n", r->name);
	putln(f,"CustShptr->grpalette[2] = db_%s.anon.G2;\n", r->name);
	putln(f,"CustShptr->grpalette[3] = db_%s.anon.G3;\n", r->name);
}

/*
 * Real Time Clock
 */
static void
rhmsr_get(Fab *f, Reg *r)
{
	putln(f,"{\n"
		"	struct tm	*st;\n"
		"	time_t		t;\n"
		"	t = time(0);\n"
		"	st = localtime(&t);\n"
		"	db_RTCHMS.anon.HOURS = st->tm_hour;\n"
		"	db_RTCHMS.anon.MINUTES = st->tm_min;\n"
		"	db_RTCHMS.anon.SECONDS = st->tm_sec;\n"
		"}\n");
	reg_get(f, r);
}

static void
rctl_put_xxx(Fab *f, Reg *r)
{
	putln(f,"db_%s.x = (UBYTE) value;\n", r->name);
}

static void
risr_put(Fab *f, Reg *r)
{
	putln(f,"db_%s.x &= ~value;\n", r->name);
}

static void
risr_put_xxx(Fab *f, Reg *r)
{
	putln(f,"db_%s.x &= ~(UBYTE) value;\n", r->name);
}

static void
rienr_put_xxx(Fab *f, Reg *r)
{
	putln(f,"db_%s.x = (UBYTE) value;\n", r->name);
}

/*---------------------------------------------------------------------------*
 * Function generators
 *---------------------------------------------------------------------------*/
static void
gen_defs(Fab *f, Reg chip[])
{
	Reg	*r;

	for (r = chip; r->name != NULL; r++) {
		putln(f,"#define %s	0x%x\n", r->name, r->addr);
	}
	putln(f,"\n");
}

static void
gen_vars(Fab *f, Reg chip[])
{
	Reg	*r;

#define MAX_LEN		32
#define MAX_COUNT	32
	r = chip;
	while (r->name != NULL) {
		char	buff[1024];

		putln(f,"static union {\n");
		switch (r->size) {
		case 1: putln(f,"	UBYTE x;\n"); break;
		case 2: putln(f,"	UWORD x;\n"); break;
		case 4: putln(f,"	ULONG x;\n"); break;
		}

		/* print out bit fields for hardware register */
		{
			char	field[MAX_COUNT][MAX_LEN];
			char	*s;	/* source */
			char	*d;	/* dest */
			int	count;
			int	len;
			int	i;

			putln(f,"	struct {\n");
			/* break up fields into seperate strings */
			count = 0;
			s = r->fields;
			d = field[count];
			while (1) {
				if (*s == '\0') {
					*d++ = '\0';
					break;
				} else if (*s == ':') {
					*d++ = '\t';
					*d++ = *s;
				} else if (*s == ';') {
					*d++ = *s;
					*d++ = '\0';
					count++;
					d = field[count];
				} else {
					*d++ = *s;
				}
				s++;
			}

			/* output fields depending on byte order of target */
			switch (f->bo) {
			case FAB_BIGENDIAN:
				for (i = count - 1; i >= 0; i--) {
					putln(f,"		unsigned %s\n",
						field[i]);
				}
				break;
			case FAB_LITTLEENDIAN:
				for (i = 0; i < count; i++) {
					putln(f,"		unsigned %s\n",
						field[i]);
				}
				break;
			}
			putln(f,"	} anon;\n");
		}

		/* print out name of variables */
		{
			char	name[1024];
			char	*ptr = buff;
			char	*last_fields = r->fields;
			Reg	*next_r = r + 1;

			sprintf(ptr," db_%s", r->name);
			ptr += strlen(ptr);

			while (next_r->name != NULL) {
				if ((strcmp(next_r->fields, r->fields) == 0)
				    && (next_r->size == r->size)) {
					sprintf(ptr,", db_%s", next_r->name);
					ptr += strlen(ptr);
					next_r++;
				} else {
					break;
				}
			}
			r = next_r;
		}

		putln(f,"}%s;\n", buff);
		putln(f,"\n");
	}
}

static void
gen_init(Fab *f, Reg chip[])
{
	Reg	*r;

	putln(f,"static void\n"
		"db_reset(void)\n"
		"{\n");

	f->lvl++;
	for (r = chip; r->name != NULL; r++) {
		switch (r->size) {
		case 1:
			putln(f,"db_%s.x = 0x%02x;\n", r->name, r->init);
			break;
		case 2:
			putln(f,"db_%s.x = 0x%04x;\n", r->name, r->init);
			break;
		case 4:
			putln(f,"db_%s.x = 0x%08x;\n", r->name, r->init);
			break;
		}
	}
	f->lvl--;

	putln(f,"}\n"
		"\n");
}

void
gen_bget(Fab *f, Reg chip[])
{
	Reg	*r;

	putln(f,"static UBYTE\n"
		"custom_bget(CPTR addr)\n"
		"{\n"
		"	switch (addr & 0xffff) {\n");

	for (r = chip; r->name != NULL; r++) {
		if (r->b.get != 0) {
			putln(f,"	case %s:\n", r->name);
			f->lvl += 2;
			r->b.get(f, r);
			f->lvl -= 2;
		}
	}

	putln(f,"	default:\n"
		"		fatal();\n"
		"		return 0;\n"
		"	}\n"
		"}\n"
		"\n");
}

void
gen_bput(Fab *f, Reg chip[])
{
	Reg	*r;

	putln(f,"static void\n"
		"custom_bput(CPTR addr, UBYTE value)\n"
		"{\n"
		"	switch (addr & 0xffff) {\n");

	for (r = chip; r->name != NULL; r++) {
		if (r->b.put != 0) {
			putln(f,"	case %s:\n", r->name);
			f->lvl += 2;
			r->b.put(f, r);
			f->lvl -= 2;
			putln(f,"		break;\n");
		}
	}

	putln(f,"	default:\n"
		"		fatal();\n"
		"		break;\n"
		"	}\n"
		"}\n"
		"\n");
}


void
gen_wget(Fab *f, Reg chip[])
{
	Reg	*r;

	putln(f,"static UWORD\n"
		"custom_wget(CPTR addr)\n"
		"{\n"
		"	switch (addr & 0xffff) {\n");

	for (r = chip; r->name != NULL; r++) {
		if (r->w.get != 0) {
			putln(f,"	case %s:\n", r->name);
			f->lvl += 2;
			r->w.get(f, r);
			f->lvl -= 2;
		}
	}

	putln(f,"	default:\n"
		"		fatal();\n"
		"		return 0;\n"
		"	}\n"
		"}\n"
		"\n");
}