Bring the Digiboard driver (ALPHA version) into -current. Includes

latest patches for PC/Xe boards.
Submitted by:	"Serge A. Babkin" <babkin@hq.icb.chel.su>

4 files changed, 3120 insertions, 0 deletions

diff --git a/sys/dev/dgb/dgb.c b/sys/dev/dgb/dgb.c
new file mode 100644
index 0000000..18b0365
--- /dev/null
+++ b/sys/dev/dgb/dgb.c
@@ -0,0 +1,2063 @@
+/*-
+ *  dgb.c $Id: dgb.c,v 1.31 1995/07/13 09:25:09 root Exp root $
+ *
+ *  Copyright (C) 1995 by Serge Babkin <babkin@hq.icb.chel.su>
+ *
+ *  Digiboard driver.
+ *
+ *  Stage 1. "Better than nothing".
+ *
+ *  Based on sio driver by Bruce Evans and on Linux driver by Troy 
+ *  De Jongh <troyd@digibd.com> or <troyd@skypoint.com> 
+ *  which is under GNU General Public License version 2 so this driver 
+ *  is forced to be under GPL 2 too.
+ *
+ *	Serge Babkin does not guarantee that this file is totally correct
+ *  for any given task and users of this file must accept responsibility
+ *  for any damage that occurs from the application of this file.
+ *
+ *  Written by Serge Babkin,
+ *      Joint Stock Commercial Bank "Chelindbank"
+ *      (Chelyabinsk, Russia)
+ *      babkin@hq.icb.chel.su
+ */
+
+#include "dgb.h"
+
+#if NDGB > 0 
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/reboot.h>
+#include <sys/ioctl.h>
+#define	TTYDEFCHARS		/* XXX TK2.0 */
+#include <sys/tty.h>
+#undef	TTYDEFCHARS
+#include <sys/proc.h>
+#include <sys/user.h>
+#include <sys/conf.h>
+#include <sys/dkstat.h>
+#include <sys/file.h>
+#include <sys/uio.h>
+#include <sys/kernel.h>
+#include <sys/malloc.h>
+#include <sys/syslog.h>
+#include <sys/devconf.h>
+#include <sys/types.h>
+
+#include <machine/clock.h>
+
+#include <i386/isa/icu.h>	/* XXX just to get at `imen' */
+#include <i386/isa/isa.h>
+#include <i386/isa/isa_device.h>
+
+#include <vm/vm.h>
+
+#include "dgreg.h"
+#include "dgbios.h"
+#include "dgfep.h"
+
+void *pmap_mapdev();
+
+/*
+ * XXX temporary kludges for 2.0 (XXX TK2.0).
+ */
+#define	TS_RTS_IFLOW	0
+#define	TSA_CARR_ON(tp)		((void *)&(tp)->t_rawq)
+#define	TSA_OCOMPLETE(tp)	((void *)&(tp)->t_outq)
+#define	TSA_OLOWAT(tp)		((void *)&(tp)->t_outq)
+
+#define	TTY_BI		TTY_FE		/* XXX */
+#define	TTY_OE		TTY_PE		/* XXX */
+
+#define	CALLOUT_MASK		0x80
+#define	CONTROL_MASK		0x60
+#define	CONTROL_INIT_STATE	0x20
+#define	CONTROL_LOCK_STATE	0x40
+#define UNIT_MASK			0x30000
+#define PORT_MASK			0xF
+#define	DEV_TO_UNIT(dev)	(MINOR_TO_UNIT(minor(dev)))
+#define	MINOR_MAGIC_MASK	(CALLOUT_MASK | CONTROL_MASK)
+#define	MINOR_TO_UNIT(mynor)	(((mynor) & UNIT_MASK)>>16)
+#define MINOR_TO_PORT(mynor)	((mynor) & 0xF)
+
+/*
+ * Input buffer watermarks.
+ * The external device is asked to stop sending when the buffer exactly reaches
+ * high water, or when the high level requests it.
+ * The high level is notified immediately (rather than at a later clock tick)
+ * when this watermark is reached.
+ * The buffer size is chosen so the watermark should almost never be reached.
+ * The low watermark is invisibly 0 since the buffer is always emptied all at
+ * once.
+ */
+#define	RS_IHIGHWATER (3 * RS_IBUFSIZE / 4)
+
+/*
+ * com state bits.
+ * (CS_BUSY | CS_TTGO) and (CS_BUSY | CS_TTGO | CS_ODEVREADY) must be higher
+ * than the other bits so that they can be tested as a group without masking
+ * off the low bits.
+ *
+ * The following com and tty flags correspond closely:
+ *	CS_BUSY		= TS_BUSY (maintained by comstart() and comflush())
+ *	CS_TTGO		= ~TS_TTSTOP (maintained by comstart() and siostop())
+ *	CS_CTS_OFLOW	= CCTS_OFLOW (maintained by comparam())
+ *	CS_RTS_IFLOW	= CRTS_IFLOW (maintained by comparam())
+ * TS_FLUSH is not used.
+ * XXX I think TIOCSETA doesn't clear TS_TTSTOP when it clears IXON.
+ * XXX CS_*FLOW should be CF_*FLOW in com->flags (control flags not state).
+ */
+#define	CS_BUSY		0x80	/* output in progress */
+#define	CS_TTGO		0x40	/* output not stopped by XOFF */
+#define	CS_ODEVREADY	0x20	/* external device h/w ready (CTS) */
+#define	CS_CHECKMSR	1	/* check of MSR scheduled */
+#define	CS_CTS_OFLOW	2	/* use CTS output flow control */
+#define	CS_DTR_OFF	0x10	/* DTR held off */
+#define	CS_ODONE	4	/* output completed */
+#define	CS_RTS_IFLOW	8	/* use RTS input flow control */
+
+static	char const * const	error_desc[] = {
+#define	CE_OVERRUN			0
+	"silo overflow",
+#define	CE_INTERRUPT_BUF_OVERFLOW	1
+	"interrupt-level buffer overflow",
+#define	CE_TTY_BUF_OVERFLOW		2
+	"tty-level buffer overflow",
+};
+
+#define	CE_NTYPES			3
+#define	CE_RECORD(com, errnum)		(++(com)->delta_error_counts[errnum])
+
+/* types.  XXX - should be elsewhere */
+typedef u_int	Port_t;		/* hardware port */
+typedef u_char	bool_t;		/* boolean */
+
+/* digiboard port structure */
+struct dgb_p {
+	bool_t	status;
+
+	u_char unit;           /* board unit number */
+	u_char pnum;           /* port number */
+	u_char omodem;         /* FEP output modem status     */
+	u_char imodem;         /* FEP input modem status      */
+	u_char modemfake;      /* Modem values to be forced   */
+	u_char modem;          /* Force values                */
+	u_char hflow;
+	u_char dsr;
+	u_char dcd;
+	u_char stopc;
+	u_char startc;
+	u_char stopca;
+	u_char startca;
+	u_char fepstopc;
+	u_char fepstartc;
+	u_char fepstopca;
+	u_char fepstartca;
+	u_char txwin;
+	u_char rxwin;
+	ushort fepiflag;
+	ushort fepcflag;
+	ushort fepoflag;
+	ushort txbufhead;
+	ushort txbufsize;
+	ushort rxbufhead;
+	ushort rxbufsize;
+	int close_delay;
+	int count;
+	int blocked_open;
+	int event;
+	int asyncflags;
+	u_long statusflags;
+	u_char *txptr;
+	u_char *rxptr;
+	struct board_chan *brdchan;
+	struct tty *tty;
+
+	bool_t  active_out;	/* nonzero if the callout device is open */
+	int	dtr_wait;	/* time to hold DTR down on close (* 1/hz) */
+	u_int	wopeners;	/* # processes waiting for DCD in open() */
+
+	/*
+	 * The high level of the driver never reads status registers directly
+	 * because there would be too many side effects to handle conveniently.
+	 * Instead, it reads copies of the registers stored here by the
+	 * interrupt handler.
+	 */
+	u_char	last_modem_status;	/* last MSR read by intr handler */
+	u_char	prev_modem_status;	/* last MSR handled by high level */
+
+	struct tty	*tp;	/* cross reference */
+
+	/* Initial state. */
+	struct termios	it_in;	/* should be in struct tty */
+	struct termios	it_out;
+
+	/* Lock state. */
+	struct termios	lt_in;	/* should be in struct tty */
+	struct termios	lt_out;
+
+	/* flags of state, are used in sleep() too */
+	u_char closing;	/* port is being closed now */
+	u_char draining; /* port is being drained now */
+	u_char used;	/* port is being used now */
+	u_char mustdrain; /* data must be waited to drain in dgbparam() */
+};
+
+/* Digiboard per-board structure */
+struct dgb_softc {
+	/* struct board_info */
+	u_char status;	/* status: DISABLED/ENABLED */
+	u_char unit;	/* unit number */
+	u_char type;	/* type of card: PCXE, PCXI, PCXEVE */
+	u_char altpin;	/* do we need alternate pin setting ? */
+	ushort numports;	/* number of ports on card */
+	ushort port;	/* I/O port */
+	u_char *vmem; /* virtual memory address */
+	long pmem; /* physical memory address */
+	int mem_seg;  /* internal memory segment */
+	struct dgb_p *ports;	/* pointer to array of port descriptors */
+	struct tty *ttys;	/* pointer to array of TTY structures */
+	volatile struct global_data *mailbox;
+	};
+	
+
+struct dgb_softc dgb_softc[NDGB];
+
+/*
+ * The public functions in the com module ought to be declared in a com-driver
+ * system header.
+ */
+
+/* Interrupt handling entry points. */
+void	dgbintr		__P((int unit));
+void	dgbpoll		__P((void *unit_c));
+
+/* Device switch entry points. */
+int	dgbopen		__P((dev_t dev, int oflags, int devtype,
+			     struct proc *p));
+int	dgbclose	__P((dev_t dev, int fflag, int devtype,
+			     struct proc *p));
+int	dgbread		__P((dev_t dev, struct uio *uio, int ioflag));
+int	dgbwrite	__P((dev_t dev, struct uio *uio, int ioflag));
+int	dgbioctl	__P((dev_t dev, int cmd, caddr_t data,
+			     int fflag, struct proc *p));
+void	dgbstop		__P((struct tty *tp, int rw));
+#define	dgbreset	noreset
+int	dgbselect	__P((dev_t dev, int rw, struct proc *p));
+#define	dgbmmap		nommap
+#define	dgbstrategy	nostrategy
+
+static	int	dgbattach	__P((struct isa_device *dev));
+static	int	dgbprobe	__P((struct isa_device *dev));
+
+static void fepcmd(struct dgb_p *port, int cmd, int op1, int op2,
+	int ncmds, int bytecmd);
+
+static	void	dgbstart	__P((struct tty *tp));
+static	int	dgbparam	__P((struct tty *tp, struct termios *t));
+static void dgbhardclose	__P((struct dgb_p *port));
+static	void	dgb_drain_or_flush	__P((struct dgb_p *port));
+static	int	dgbdrain	__P((struct dgb_p *port));
+static	void	dgb_pause	__P((void *chan));
+
+
+struct isa_driver	dgbdriver = {
+	dgbprobe, dgbattach, "dgb",0
+};
+
+static	speed_t	dgbdefaultrate = TTYDEF_SPEED;
+static	u_int	dgb_events;	/* input chars + weighted output completions */
+static	int	dgbmajor;
+
+static	struct speedtab dgbspeedtab[] = {
+	0,	0, /* old (sysV-like) Bx codes */
+	50,	1,
+	75,	2,
+	110, 3,
+	134, 4,
+	150, 5,
+	200, 6,
+	300, 7,
+	600, 8,
+	1200, 9,
+	1800, 10,
+	2400, 11,
+	4800, 12,
+	9600, 13,
+	19200, 14,
+	38400, 15,
+	57600, (02000 | 1),	/* B50 & fast baud table */
+	115200, (02000 | 2), /* B100 & fast baud table */
+	-1,	-1
+};
+
+#ifdef DEBUG
+	int dgbdebug=1;
+#else
+	int dgbdebug=0;
+#endif
+
+static int polltimeout=0;
+
+static int setwin(struct dgb_softc *sc, unsigned addr);
+static int setinitwin(struct dgb_softc *sc, unsigned addr);
+static void hidewin(struct dgb_softc *sc);
+
+static inline int 
+setwin(sc,addr)
+	struct dgb_softc *sc;
+	unsigned int addr;
+{
+	if(sc->type==PCXEVE) {
+		outb(sc->port+1, FEPWIN|(addr>>13));
+		DPRINT3("dgb%d: switched to window 0x%x\n",sc->unit,addr>>13);
+		return (addr & 0x1FFF);
+	} else {
+		outb(sc->port,FEPMEM);
+		return addr;
+	}
+}
+
+static inline int 
+setinitwin(sc,addr)
+	struct dgb_softc *sc;
+	unsigned int addr;
+{
+	if(sc->type==PCXEVE) {
+		outb(sc->port+1, FEPWIN|(addr>>13));
+		DPRINT3("dgb%d: switched to window 0x%x\n",sc->unit,addr>>13);
+		return (addr & 0x1FFF);
+	} else {
+		outb(sc->port,inb(sc->port)|FEPMEM);
+		return addr;
+	}
+}
+
+static inline void
+hidewin(sc)
+	struct dgb_softc *sc;
+{
+	if(sc->type==PCXEVE)
+		outb(sc->port+1, 0);
+	else
+		outb(sc->port,0);
+}
+
+static inline void
+towin(sc,win)
+	struct dgb_softc *sc;
+	int win;
+{
+	if(sc->type==PCXEVE) {
+		outb(sc->port+1, win);
+	} else {
+		outb(sc->port,FEPMEM);
+	}
+}
+
+static int
+dgbprobe(dev)
+	struct isa_device	*dev;
+{
+	struct dgb_softc *sc= &dgb_softc[dev->id_unit];
+	int i, v, t;
+	u_long win_size;  /* size of vizible memory window */
+	u_char *mem;
+	int addr;
+	int unit=dev->id_unit;
+
+	sc->unit=dev->id_unit;
+	sc->port=dev->id_iobase;
+
+	if(dev->id_flags & DGBFLAG_ALTPIN)
+		sc->altpin=1;
+	else
+		sc->altpin=0;
+
+	/* left 24 bits only (ISA address) */
+	sc->pmem=((long)dev->id_maddr & 0xFFFFFF); 
+	
+	DPRINT4("dgb%d: port 0x%x mem 0x%x\n",unit,sc->port,sc->pmem);
+
+	outb(sc->port, FEPRST);
+	sc->status=DISABLED;
+
+	for(i=0; i< 1000; i++) {
+		DELAY(1);
+		if( (inb(sc->port) & FEPMASK) == FEPRST ) {
+			sc->status=ENABLED;
+			DPRINT3("dgb%d: got reset after %d us\n",unit,i);
+			break;
+		}
+	}
+
+	if(sc->status!=ENABLED) {
+		DPRINT2("dgb%d: failed to respond\n",dev->id_unit);
+		return 0;
+	}
+
+	/* check type of card and get internal memory characteristics */
+
+	v=inb(sc->port);
+
+	if( v & 0x1 ) {
+		switch( v&0x30 ) {
+		case 0:
+			sc->mem_seg=0xF000;
+			win_size=0x10000;
+			printf("dgb%d: PC/Xi 64K\n",dev->id_unit);
+			break;
+		case 0x10:
+			sc->mem_seg=0xE000;
+			win_size=0x20000;
+			printf("dgb%d: PC/Xi 128K\n",dev->id_unit);
+			break;
+		case 0x20:
+			sc->mem_seg=0xC000;
+			win_size=0x40000;
+			printf("dgb%d: PC/Xi 256K\n",dev->id_unit);
+			break;
+		default: /* case 0x30: */
+			sc->mem_seg=0x8000;
+			win_size=0x80000;
+			printf("dgb%d: PC/Xi 512K\n",dev->id_unit);
+			break;
+		}
+		sc->type=PCXI;
+	} else {
+		outb(sc->port, 1);
+		v=inb(sc->port);
+
+		if( v & 0x1 ) {
+			printf("dgb%d: PC/Xm isn't supported\n",dev->id_unit);
+			sc->status=DISABLED;
+			return 0;
+			}
+
+		sc->mem_seg=0xF000;
+
+		if(dev->id_flags==DGBFLAG_NOWIN || ( v&0xC0 )==0) {
+			win_size=0x10000;
+			printf("dgb%d: PC/Xe 64K\n",dev->id_unit);
+			sc->type=PCXE;
+		} else {
+			win_size=0x2000;
+			printf("dgb%d: PC/Xe 64/8K (windowed)\n",dev->id_unit);
+			sc->type=PCXEVE;
+			if((u_long)sc->pmem & ~0xFFE000) {
+				printf("dgb%d: warning: address 0x%x truncated to 0x%x\n",
+					dev->id_unit, sc->pmem,
+					(long)sc->pmem & 0xFFE000);
+
+				dev->id_maddr= (u_char *)( (long)sc->pmem & 0xFFE000 );
+			}
+		}
+	}
+
+	/* save size of vizible memory segment */
+	dev->id_msize=win_size;
+
+	/* map memory */
+	dev->id_maddr=sc->vmem=pmap_mapdev(sc->pmem,dev->id_msize);
+
+	outb(sc->port, FEPCLR); /* drop RESET */
+
+	return 4; /* we need I/O space of 4 ports */
+}
+
+static struct kern_devconf kdc_dgb[NDGB] = { {
+	0, 0, 0,		/* filled in by dev_attach */
+	"dgb", 0, { MDDT_ISA, 0, "tty" },
+	isa_generic_externalize, 0, 0, ISA_EXTERNALLEN,
+	&kdc_isa0,		/* parent */
+	0,			/* parentdata */
+	DC_UNCONFIGURED,
+	"DigiBoard multiport card"
+} };
+
+static void
+dgbregisterdev(id)
+	struct isa_device *id;
+{
+	int	unit;
+
+	unit = id->id_unit;
+	if (unit != 0)
+		kdc_dgb[unit] = kdc_dgb[0];
+	kdc_dgb[unit].kdc_unit = unit;
+	kdc_dgb[unit].kdc_isa = id;
+
+	/* now we assume that multiport is always 'open' for simplicity */
+	kdc_dgb[unit].kdc_state = DC_BUSY;
+	dev_attach(&kdc_dgb[unit]);
+}
+
+
+static int
+dgbattach(dev)
+	struct isa_device	*dev;
+{
+	int unit=dev->id_unit;
+	struct dgb_softc *sc= &dgb_softc[dev->id_unit];
+	int i, t;
+	u_char *mem;
+	u_char *ptr;
+	int addr;
+	struct dgb_p *port;
+	struct board_chan *bc;
+	struct global_data *gd;
+	int shrinkmem;
+	int nfails;
+	ushort *pstat;
+	int lowwater;
+
+	if(sc->status!=ENABLED) {
+		DPRINT2("dbg%d: try to attach a disabled card\n",unit);
+		return 0;
+		}
+
+	mem=sc->vmem;
+
+	DPRINT3("dgb%d: internal memory segment 0x%x\n",unit,sc->mem_seg);
+
+	outb(sc->port, FEPRST); DELAY(1);
+
+	for(i=0; (inb(sc->port) & FEPMASK) != FEPRST ; i++) {
+		if(i>10000) {
+			printf("dgb%d: 1st reset failed\n",dev->id_unit);
+			sc->status=DISABLED;
+			hidewin(sc);
+			return 0;
+		}
+		DELAY(1);
+	}
+
+	DPRINT3("dgb%d: got reset after %d us\n",unit,i);
+
+	/* for PCXEVE set up interrupt and base address */
+
+	if(sc->type==PCXEVE) {
+		t=(((u_long)sc->pmem>>8) & 0xFFE0) | 0x10 /* enable windowing */;
+
+		/* IRQ isn't used */
+#if 0
+		switch(dev->id_irq) {
+		case IRQ3:
+			t|=0x1;
+			break;
+		case IRQ5:
+			t|=2;
+			break;
+		case IRQ7:
+			t|=3;
+			break;
+		case IRQ10:
+			t|=4;
+			break;
+		case IRQ11:
+			t|=5;
+			break;
+		case IRQ12:
+			t|=6;
+			break;
+		case IRQ15:
+			t|=7;
+			break;
+		default:
+			printf("dgb%d: wrong IRQ mask 0x%x\n",dev->id_unit,dev->id_irq);
+			sc->status=DISABLED;
+			return 0;
+		}
+#endif
+
+		outb(sc->port+2,t & 0xFF);
+		outb(sc->port+3,t>>8);
+	} else if(sc->type==PCXE) {
+		t=(((u_long)sc->pmem>>8) & 0xFFE0) /* disable windowing */;
+		outb(sc->port+2,t & 0xFF);
+		outb(sc->port+3,t>>8);
+	}
+
+
+	if(sc->type==PCXI || sc->type==PCXE) {
+		outb(sc->port, FEPRST|FEPMEM); DELAY(1);
+
+		for(i=0; (inb(sc->port) & FEPMASK) != (FEPRST|FEPMEM) ; i++) {
+			if(i>10000) {
+				printf("dgb%d: 2nd reset failed\n",dev->id_unit);
+				sc->status=DISABLED;
+				hidewin(sc);
+				return 0;
+			}
+			DELAY(1);
+		}
+
+		DPRINT3("dgb%d: got memory after %d us\n",unit,i);
+	}
+
+	mem=sc->vmem;
+
+	/* very short memory test */
+
+	addr=setinitwin(sc,BOTWIN);
+	*(u_long *)(mem+addr) = 0xA55A3CC3;
+	if(*(u_long *)(mem+addr)!=0xA55A3CC3) {
+		printf("dgb%d: 1st memory test failed\n",dev->id_unit);
+		sc->status=DISABLED;
+		hidewin(sc);
+		return 0;
+	}
+		
+	addr=setinitwin(sc,TOPWIN);
+	*(u_long *)(mem+addr) = 0x5AA5C33C;
+	if(*(u_long *)(mem+addr)!=0x5AA5C33C) {
+		printf("dgb%d: 2nd memory test failed\n",dev->id_unit);
+		sc->status=DISABLED;
+		hidewin(sc);
+		return 0;
+	}
+		
+	addr=setinitwin(sc,BIOSCODE+((0xF000-sc->mem_seg)<<4));
+	*(u_long *)(mem+addr) = 0x5AA5C33C;
+	if(*(u_long *)(mem+addr)!=0x5AA5C33C) {
+		printf("dgb%d: 3rd (BIOS) memory test failed\n",dev->id_unit);
+	}
+		
+	addr=setinitwin(sc,MISCGLOBAL);
+	for(i=0; i<16; i++) {
+		mem[addr+i]=0;
+	}
+
+	if(sc->type==PCXI || sc->type==PCXE) {
+
+		addr=BIOSCODE+((0xF000-sc->mem_seg)<<4);
+
+		DPRINT3("dgb%d: BIOS local address=0x%x\n",unit,addr);
+
+		ptr= mem+addr;
+
+		for(i=0; i<pcxx_nbios; i++, ptr++)
+			*ptr = pcxx_bios[i];
+
+		ptr= mem+addr;
+
+		nfails=0;
+		for(i=0; i<pcxx_nbios; i++, ptr++)
+			if( *ptr != pcxx_bios[i] ) {
+				DPRINT5("dgb%d: wrong code in BIOS at addr 0x%x : \
+0x%x instead of 0x%x\n", unit, ptr-(mem+addr), *ptr, pcxx_bios[i] );
+
+				if(++nfails>=5) {
+					printf("dgb%d: 4th memory test (BIOS load) fails\n",unit);
+					break;
+					}
+				}
+
+		outb(sc->port,FEPMEM);
+
+		for(i=0; (inb(sc->port) & FEPMASK) != FEPMEM ; i++) {
+			if(i>10000) {
+				printf("dgb%d: BIOS start failed\n",dev->id_unit);
+				sc->status=DISABLED;
+				hidewin(sc);
+				return 0;
+			}
+			DELAY(1);
+		}
+
+		DPRINT3("dgb%d: reset dropped after %d us\n",unit,i);
+
+		for(i=0; i<200000; i++) {
+			if( *((ushort *)(mem+MISCGLOBAL)) == *((ushort *)"GD") )
+				goto load_fep;
+			DELAY(1);
+		}
+		printf("dgb%d: BIOS download failed\n",dev->id_unit);
+		DPRINT4("dgb%d: code=0x%x must be 0x%x\n",
+			dev->id_unit,
+			*((ushort *)(mem+MISCGLOBAL)),
+			*((ushort *)"GD"));
+
+		sc->status=DISABLED;
+		hidewin(sc);
+		return 0;
+	}
+
+	if(sc->type==PCXEVE) {
+		/* set window 7 */
+		outb(sc->port+1,0xFF);
+
+		ptr= mem+(BIOSCODE & 0x1FFF);
+
+		for(i=0; i<pcxx_nbios; i++)
+			*ptr++ = pcxx_bios[i];
+
+		ptr= mem+(BIOSCODE & 0x1FFF);
+
+		nfails=0;
+		for(i=0; i<pcxx_nbios; i++, ptr++)
+			if( *ptr != pcxx_bios[i] ) {
+				DPRINT5("dgb%d: wrong code in BIOS at addr 0x%x : \
+0x%x instead of 0x%x\n", unit, ptr-(mem+addr), *ptr, pcxx_bios[i] );
+
+				if(++nfails>=5) {
+					printf("dgb%d: 4th memory test (BIOS load) fails\n",unit);
+					break;
+					}
+				}
+
+		outb(sc->port,FEPCLR);
+
+		setwin(sc,0);
+
+		for(i=0; (inb(sc->port) & FEPMASK) != FEPCLR ; i++) {
+			if(i>10000) {
+				printf("dgb%d: BIOS start failed\n",dev->id_unit);
+				sc->status=DISABLED;
+				hidewin(sc);
+				return 0;
+			}
+			DELAY(1);
+		}
+
+		DPRINT3("dgb%d: reset dropped after %d us\n",unit,i);
+
+		addr=setwin(sc,MISCGLOBAL);
+
+		for(i=0; i<200000; i++) {
+			if(*(ushort *)(mem+addr)== *(ushort *)"GD")
+				goto load_fep;
+			DELAY(1);
+		}
+		printf("dgb%d: BIOS download failed\n",dev->id_unit);
+		DPRINT5("dgb%d: Error#(0x%x,0x%x) code=0x%x\n",
+			dev->id_unit,
+			*(ushort *)(mem+0xC12),
+			*(ushort *)(mem+0xC14),
+			*(ushort *)(mem+MISCGLOBAL));
+
+		sc->status=DISABLED;
+		hidewin(sc);
+		return 0;
+	}
+
+load_fep:
+	DPRINT2("dgb%d: BIOS loaded\n",dev->id_unit);
+
+	addr=setwin(sc,FEPCODE);
+
+	ptr= mem+addr;
+
+	for(i=0; i<pcxx_ncook; i++)
+		*ptr++ = pcxx_cook[i];
+
+	addr=setwin(sc,MBOX);
+	*(ushort *)(mem+addr+ 0)=2;
+	*(ushort *)(mem+addr+ 2)=sc->mem_seg+FEPCODESEG;
+	*(ushort *)(mem+addr+ 4)=0;
+	*(ushort *)(mem+addr+ 6)=FEPCODESEG;
+	*(ushort *)(mem+addr+ 8)=0;
+	*(ushort *)(mem+addr+10)=pcxx_ncook;
+	
+	outb(sc->port,FEPMEM|FEPINT); /* send interrupt to BIOS */
+	outb(sc->port,FEPMEM);
+
+	for(i=0; *(ushort *)(mem+addr)!=0; i++) {
+		if(i>200000) {
+			printf("dgb%d: FEP code download failed\n",unit);
+			DPRINT3("dgb%d: code=0x%x must be 0\n", unit,
+				*(ushort *)(mem+addr));
+			sc->status=DISABLED;
+			hidewin(sc);
+			return 0;
+		}
+	}
+
+	DPRINT2("dgb%d: FEP code loaded\n",unit);
+
+	*(ushort *)(mem+setwin(sc,FEPSTAT))=0;
+	addr=setwin(sc,MBOX);
+	*(ushort *)(mem+addr+0)=1;
+	*(ushort *)(mem+addr+2)=FEPCODESEG;
+	*(ushort *)(mem+addr+4)=0x4;
+
+	outb(sc->port,FEPINT); /* send interrupt to BIOS */
+	outb(sc->port,FEPCLR);
+
+	addr=setwin(sc,FEPSTAT);
+	for(i=0; *(ushort *)(mem+addr)!= *(ushort *)"OS"; i++) {
+		if(i>200000) {
+			printf("dgb%d: FEP/OS start failed\n",dev->id_unit);
+			sc->status=DISABLED;
+			hidewin(sc);
+			return 0;
+		}
+	}
+
+	DPRINT2("dgb%d: FEP/OS started\n",dev->id_unit);
+
+	sc->numports= *(ushort *)(mem+setwin(sc,NPORT));
+
+	printf("dgb%d: %d ports\n",unit,sc->numports);
+
+	if(sc->numports > MAX_DGB_PORTS) {
+		printf("dgb%d: too many ports\n",unit);
+		sc->status=DISABLED;
+		hidewin(sc);
+		return 0;
+	}
+
+	addr=setwin(sc,PORTBASE);
+	pstat=(ushort *)(mem+addr);
+
+	for(i=0; i<32 && pstat[i]; i++);
+
+	if(i!=sc->numports) {
+		printf("dgb%d: %d ports are shown as valid ones\n",unit,i);
+		if(i<sc->numports)
+			sc->numports=i;
+		printf("dgb%d: %d ports will be used\n",unit,sc->numports);
+	}
+
+	MALLOC(sc->ports, struct dgb_p *, sizeof(struct dgb_p)*sc->numports,
+		M_TTYS, M_NOWAIT);
+
+	if(sc->ports==0) {
+		printf("dgb%d: unable to malloc the per port structures\n",unit);
+		sc->status=DISABLED;
+		hidewin(sc);
+		return 0;
+		}
+
+	bzero(sc->ports, sizeof(struct dgb_p)*sc->numports);
+
+	MALLOC(sc->ttys, struct tty *, sizeof(struct tty)*sc->numports,
+		M_TTYS, M_NOWAIT);
+
+	if(sc->ttys==0) {
+		printf("dgb%d: unable to malloc the tty structures\n",unit);
+		FREE(sc->ttys, M_TTYS);
+		sc->status=DISABLED;
+		hidewin(sc);
+		return 0;
+		}
+
+	bzero(sc->ttys, sizeof(struct tty)*sc->numports);
+
+	/* We should now init per-port structures */
+	bc=(struct board_chan *)(mem + CHANSTRUCT);
+	sc->mailbox=(struct global_data *)(mem + FEP_GLOBAL);
+
+	if(sc->numports<3)
+		shrinkmem=1;
+	else
+		shrinkmem=0;
+
+
+	for(i=0; i<sc->numports; i++, bc++) {
+		port= &sc->ports[i];
+
+		port->status=ENABLED;
+
+		port->tty=&sc->ttys[i];
+		port->unit=unit;
+
+		port->brdchan=bc;
+
+		if(sc->altpin) {
+			port->dsr=CD;
+			port->dcd=DSR;
+		} else {
+			port->dcd=CD;
+			port->dsr=DSR;
+		}
+
+		port->pnum=i;
+
+		if(shrinkmem) {
+			DPRINT2("dgb%d: shrinking memory\n",unit);
+			fepcmd(port, SETBUFFER, 32, 0, 0, 0);
+			shrinkmem=0;
+			}
+
+		if(sc->type!=PCXEVE) {
+			port->txptr=mem+((bc->tseg-sc->mem_seg)<<4);
+			port->rxptr=mem+((bc->rseg-sc->mem_seg)<<4);
+			port->txwin=port->rxwin=0;
+		} else {
+			port->txptr=mem+( ((bc->tseg-sc->mem_seg)<<4) & 0x1FFF );
+			port->rxptr=mem+( ((bc->rseg-sc->mem_seg)<<4) & 0x1FFF );
+			port->txwin=FEPWIN | ((bc->tseg-sc->mem_seg)>>9);
+			port->rxwin=FEPWIN | ((bc->rseg-sc->mem_seg)>>9);
+		}
+
+		port->txbufhead=0;
+		port->rxbufhead=0;
+		port->txbufsize=bc->tmax+1;
+		port->rxbufsize=bc->rmax+1;
+
+		lowwater= (port->txbufsize>=2000) ? 1024 : (port->txbufsize/2);
+		fepcmd(port, STXLWATER, lowwater, 0, 10, 0);
+		fepcmd(port, SRXLWATER, port->rxbufsize/4, 0, 10, 0);
+		fepcmd(port, SRXHWATER, 3*port->rxbufsize/4, 0, 10, 0);
+
+		bc->edelay=100;
+		bc->idata=1;
+
+		port->startc=bc->startc;
+		port->startca=bc->startca;
+		port->stopc=bc->stopc;
+		port->stopca=bc->stopca;
+			
+		port->close_delay=50;
+
+		/*
+		 * We don't use all the flags from <sys/ttydefaults.h> since they
+		 * are only relevant for logins.  It's important to have echo off
+		 * initially so that the line doesn't start blathering before the
+		 * echo flag can be turned off.
+		 */
+		port->it_in.c_iflag = TTYDEF_IFLAG;
+		port->it_in.c_oflag = TTYDEF_OFLAG;
+		port->it_in.c_cflag = TTYDEF_CFLAG;
+		port->it_in.c_lflag = TTYDEF_LFLAG;
+		termioschars(&port->it_in);
+		port->it_in.c_ispeed = port->it_in.c_ospeed = dgbdefaultrate;
+		port->it_out = port->it_in;
+	}
+
+	hidewin(sc);
+
+	/* register the polling function */
+	timeout(dgbpoll, (void *)unit, hz/25);
+
+	return 1;
+}
+
+/* ARGSUSED */
+int
+dgbopen(dev, flag, mode, p)
+	dev_t		dev;
+	int		flag;
+	int		mode;
+	struct proc	*p;
+{
+	struct dgb_softc *sc;
+	struct tty *tp;
+	int unit;
+	int mynor;
+	int pnum;
+	struct dgb_p *port;
+	int s;
+	int error;
+	struct board_chan *bc;
+
+	error=0;
+
+	mynor=minor(dev);
+	unit=MINOR_TO_UNIT(mynor);
+	pnum=MINOR_TO_PORT(mynor);
+
+	if(unit >= NDGB) {
+		DPRINT2("dgb%d: try to open a nonexisting card\n",unit);
+		return ENXIO;
+	}
+
+	sc=&dgb_softc[unit];
+
+	if(sc->status!=ENABLED) {
+		DPRINT2("dgb%d: try to open a disabled card\n",unit);
+		return ENXIO;
+	}
+
+	if(pnum>=sc->numports) {
+		DPRINT3("dgb%d: try to open non-existing port %d\n",unit,pnum);
+		return ENXIO;
+	}
+
+	if(mynor & CONTROL_MASK)
+		return 0;
+
+	tp=&sc->ttys[pnum];
+	port=&sc->ports[pnum];
+	bc=port->brdchan;
+
+open_top:
+	
+	s=spltty();
+
+	while(port->closing) {
+		error=tsleep(&port->closing, TTOPRI|PCATCH, "dgocl", 0);
+
+		if(error) {
+			DPRINT4("dgb%d: port %d: tsleep(dgocl) error=%d\n",unit,pnum,error);
+			goto out;
+		}
+	}
+
+	if (tp->t_state & TS_ISOPEN) {
+		/*
+		 * The device is open, so everything has been initialized.
+		 * Handle conflicts.
+		 */
+		if (mynor & CALLOUT_MASK) {
+			if (!port->active_out) {
+				error = EBUSY;
+				DPRINT4("dgb%d: port %d: BUSY error=%d\n",unit,pnum,error);
+				goto out;
+			}
+		} else {
+			if (port->active_out) {
+				if (flag & O_NONBLOCK) {
+					error = EBUSY;
+					DPRINT4("dgb%d: port %d: BUSY error=%d\n",unit,pnum,error);
+					goto out;
+				}
+				error =	tsleep(&port->active_out,
+					       TTIPRI | PCATCH, "dgbi", 0);
+				if (error != 0) {
+					DPRINT4("dgb%d: port %d: tsleep(dgbi) error=%d\n",
+						unit,pnum,error);
+					goto out;
+				}
+				splx(s);
+				goto open_top;
+			}
+		}
+		if (tp->t_state & TS_XCLUDE && p->p_ucred->cr_uid != 0) {
+			error = EBUSY;
+			goto out;
+		}
+	} else {
+		/*
+		 * The device isn't open, so there are no conflicts.
+		 * Initialize it.  Initialization is done twice in many
+		 * cases: to preempt sleeping callin opens if we are
+		 * callout, and to complete a callin open after DCD rises.
+		 */
+		tp->t_oproc=dgbstart;
+		tp->t_param=dgbparam;
+		tp->t_dev=dev;
+		tp->t_termios= (mynor & CALLOUT_MASK) ?
+							port->it_out :
+							port->it_in;
+
+		setwin(sc,0);
+		port->imodem=bc->mstat;
+		bc->rout=bc->rin; /* clear input queue */
+		bc->idata=1;
+
+		hidewin(sc);
+
+		port->wopeners++;
+		error=dgbparam(tp, &tp->t_termios);
+		port->wopeners--;
+
+		if(error!=0) {
+			DPRINT4("dgb%d: port %d: dgbparam error=%d\n",unit,pnum,error);
+			goto out;
+		}
+
+		ttsetwater(tp);
+
+		/* handle fake DCD for callout devices */
+		/* and initial DCD */
+
+		if( (port->imodem & port->dcd) || mynor & CALLOUT_MASK )
+			linesw[tp->t_line].l_modem(tp,1);
+
+	}
+
+	/*
+	 * Wait for DCD if necessary.
+	 */
+	if (!(tp->t_state & TS_CARR_ON) && !(mynor & CALLOUT_MASK)
+	    && !(tp->t_cflag & CLOCAL) && !(flag & O_NONBLOCK)) {
+		++port->wopeners;
+		error = tsleep(TSA_CARR_ON(tp), TTIPRI | PCATCH, "dgdcd", 0);
+		--port->wopeners;
+		if (error != 0) {
+			DPRINT4("dgb%d: port %d: tsleep(dgdcd) error=%d\n",unit,pnum,error);
+			goto out;
+		}
+		splx(s);
+		goto open_top;
+	}
+	error =	linesw[tp->t_line].l_open(dev, tp);
+	DPRINT4("dgb%d: port %d: l_open error=%d\n",unit,pnum,error);
+
+	if (tp->t_state & TS_ISOPEN && mynor & CALLOUT_MASK)
+		port->active_out = TRUE;
+
+	port->used=1;
+	
+out:
+	splx(s);
+
+	if( !(tp->t_state & TS_ISOPEN) && port->wopeners==0 )
+		dgbhardclose(port);
+
+	DPRINT4("dgb%d: port %d: open() returns %d\n",unit,pnum,error);
+
+	return error;
+}
+
+/*ARGSUSED*/
+int
+dgbclose(dev, flag, mode, p)
+	dev_t		dev;
+	int		flag;
+	int		mode;
+	struct proc	*p;
+{
+	int		mynor;
+	struct tty	*tp;
+	int unit, pnum;
+	struct dgb_softc *sc;
+	struct dgb_p *port;
+	int s;
+
+	mynor=minor(dev);
+	unit=MINOR_TO_UNIT(mynor);
+	pnum=MINOR_TO_PORT(mynor);
+
+	sc=&dgb_softc[unit];
+	tp=&sc->ttys[pnum];
+	port=sc->ports+pnum;
+
+	if(mynor & CONTROL_MASK)
+		return 0;
+
+	DPRINT3("dgb%d: port %d: closing\n",unit,pnum);
+
+	s=spltty();
+
+	port->closing=1;
+	linesw[tp->t_line].l_close(tp,flag);
+	dgb_drain_or_flush(port);
+	dgbhardclose(port);
+	ttyclose(tp);
+	port->closing=0; wakeup(&port->closing);
+	port->used=0;
+
+	splx(s);
+
+	wakeup(TSA_CARR_ON(tp));
+	wakeup(&port->active_out);
+	port->active_out=0;
+
+	return 0;
+}
+
+static void
+dgbhardclose(port)
+	struct dgb_p *port;
+{
+	struct dgb_softc *sc=&dgb_softc[port->unit];
+	struct board_chan *bc=port->brdchan;
+	int s;
+
+	setwin(sc,0);
+
+	bc->idata=0; bc->iempty=0; bc->ilow=0;
+	if(port->tty->t_cflag & HUPCL) {
+		port->omodem &= ~(RTS|DTR);
+		fepcmd(port, SETMODEM, 0, DTR|RTS, 0, 1);
+	}
+
+	hidewin(sc);
+
+	timeout(dgb_pause, &port->brdchan, hz/2);
+	tsleep(&port->brdchan, TTIPRI | PCATCH, "dgclo", 0);
+}
+
+static void 
+dgb_pause(chan)
+	void *chan;
+{
+wakeup((caddr_t)chan);
+}
+
+
+int
+dgbread(dev, uio, flag)
+	dev_t		dev;
+	struct uio	*uio;
+	int		flag;
+{
+	int		mynor;
+	struct tty	*tp;
+	int error, unit, pnum;
+
+	mynor=minor(dev);
+	if (mynor & CONTROL_MASK)
+		return (ENODEV);
+	unit=MINOR_TO_UNIT(mynor);
+	pnum=MINOR_TO_PORT(mynor);
+
+	tp=&dgb_softc[unit].ttys[pnum];
+
+	error=linesw[tp->t_line].l_read(tp, uio, flag);
+	DPRINT4("dgb%d: port %d: read() returns %d\n",unit,pnum,error);
+
+	return error;
+}
+
+int
+dgbwrite(dev, uio, flag)
+	dev_t		dev;
+	struct uio	*uio;
+	int		flag;
+{
+	int		mynor;
+	struct tty	*tp;
+	int error, unit, pnum;
+
+	mynor=minor(dev);
+	if (mynor & CONTROL_MASK)
+		return (ENODEV);
+
+	unit=MINOR_TO_UNIT(mynor);
+	pnum=MINOR_TO_PORT(mynor);
+
+	tp=&dgb_softc[unit].ttys[pnum];
+
+	error=linesw[tp->t_line].l_write(tp, uio, flag);
+	DPRINT4("dgb%d: port %d: write() returns %d\n",unit,pnum,error);
+
+	return error;
+}
+
+void dgbpoll(unit_c)
+	void *unit_c;
+{
+	int unit=(int)unit_c;
+	int pnum;
+	struct dgb_p *port;
+	struct dgb_softc *sc=&dgb_softc[unit];
+	int head, tail;
+	u_char *eventbuf;
+	int event, mstat, lstat;
+	struct board_chan *bc;
+	struct tty *tp;
+	int rhead, rtail;
+	int whead, wtail;
+	int wrapmask;
+	int size;
+	int c=0;
+	u_char *ptr;
+	int ocount;
+
+	if(sc->status==DISABLED) {
+		printf("dgb%d: polling of disabled board stopped\n",unit);
+		return;
+	}
+	
+	setwin(sc,0);
+
+	head=sc->mailbox->ein;
+	tail=sc->mailbox->eout;
+
+	while(head!=tail) {
+		if(head >= FEP_IMAX-FEP_ISTART 
+		|| tail >= FEP_IMAX-FEP_ISTART 
+		|| (head|tail) & 03 ) {
+			printf("dgb%d: event queue's head or tail is wrong!\n", unit);
+			break;
+		}
+
+		eventbuf=sc->vmem+tail+FEP_ISTART;
+		pnum=eventbuf[0];
+		event=eventbuf[1];
+		mstat=eventbuf[2];
+		lstat=eventbuf[3];
+
+		port=&sc->ports[pnum];
+		bc=port->brdchan;
+		tp=&sc->ttys[pnum];
+
+		if(pnum>=sc->numports || port->status==DISABLED) {
+			printf("dgb%d: port %d: got event on nonexisting port\n",unit,pnum);
+		} else if(port->used || port->wopeners>0 ) {
+
+			if( !(event & ALL_IND) ) 
+				printf("dgb%d: port%d: ? event 0x%x mstat 0x%x lstat 0x%x\n",
+					unit, pnum, event, mstat, lstat);
+
+			if(event & DATA_IND) {
+				DPRINT3("dgb%d: port %d: DATA_IND\n",unit,pnum);
+
+				wrapmask=port->rxbufsize-1;
+
+				rhead=bc->rin & wrapmask; 
+				rtail=bc->rout & wrapmask;
+
+				if( !(tp->t_cflag & CREAD) || !port->used ) {
+					bc->rout=rhead;
+					goto end_of_data;
+				}
+
+				if(bc->orun) {
+					printf("dgb%d: port%d: overrun\n", unit, pnum);
+					bc->orun=0;
+				}
+
+				while(rhead!=rtail) {
+					DPRINT5("dgb%d: port %d: p rx head=%d tail=%d\n",
+						unit,pnum,rhead,rtail);
+
+					if(rhead>rtail)
+						size=rhead-rtail;
+					else
+						size=port->rxbufsize-rtail;
+
+					ptr=port->rxptr+rtail;
+
+					for(c=0; c<size; c++) {
+						int chr;
+
+						towin(sc,port->rxwin);
+						chr= *ptr++;
+
+#if 0
+						if(chr>=' ' && chr<127)
+							DPRINT4("dgb%d: port %d: got char '%c'\n",
+								unit,pnum,chr);
+						else
+							DPRINT4("dgb%d: port %d: got char 0x%x\n",
+								unit,pnum,chr);
+#endif
+
+						hidewin(sc);
+						linesw[tp->t_line].l_rint(chr, tp);
+					}
+
+					setwin(sc,0);
+					rtail= (rtail + size) & wrapmask;
+					bc->rout=rtail;
+					rhead=bc->rin & wrapmask; 
+				}
+					
+			end_of_data:
+			}
+
+			if(event & MODEMCHG_IND) {
+				DPRINT3("dgb%d: port %d: MODEMCHG_IND\n",unit,pnum);
+				port->imodem=mstat;
+				if(mstat & port->dcd) {
+					hidewin(sc);
+					linesw[tp->t_line].l_modem(tp,1);
+					setwin(sc,0);
+					wakeup(TSA_CARR_ON(tp));
+				} else {
+					hidewin(sc);
+					linesw[tp->t_line].l_modem(tp,0);
+					setwin(sc,0);
+					if( port->draining) {
+						port->draining=0;
+						wakeup(&port->draining);
+					}
+				}
+			}
+
+			if(event & BREAK_IND) {
+				DPRINT3("dgb%d: port %d: BREAK_IND\n",unit,pnum);
+				hidewin(sc);
+				linesw[tp->t_line].l_rint(TTY_BI, tp);
+				setwin(sc,0);
+			}
+
+			if(event & (LOWTX_IND | EMPTYTX_IND) ) {
+				DPRINT3("dgb%d: port %d: LOWTX_IND or EMPTYTX_IND\n",unit,pnum);
+
+				if( (event & EMPTYTX_IND ) && tp->t_outq.c_cc==0
+				&& port->draining) {
+					port->draining=0;
+					wakeup(&port->draining);
+					bc->ilow=0; bc->iempty=0;
+				}
+
+				wrapmask=port->txbufsize;
+
+				while( tp->t_outq.c_cc!=0 ) {
+					if(tp->t_outq.c_cc <= tp->t_lowat) {
+						if(tp->t_state & TS_ASLEEP) {
+							tp->t_state &= ~TS_ASLEEP;
+							wakeup(TSA_OLOWAT(tp));
+						}
+						selwakeup(&tp->t_wsel);
+					}
+
+					setwin(sc,0);
+
+					whead=bc->tin & wrapmask;
+					wtail=bc->tout & wrapmask;
+
+					DPRINT5("dgb%d: port%d: p tx head=%d tail=%d\n",
+						unit,pnum,whead,wtail);
+
+					if(whead<wtail)
+						size=wtail-whead-1;
+					else {
+						size=port->txbufsize-whead;
+						if(wtail==0)
+							size--;
+					}
+
+					if(size==0) {
+						bc->iempty=1; bc->ilow=1;
+						goto end_of_buffer;
+					}
+
+					towin(sc,port->txwin);
+
+					ocount=q_to_b(&tp->t_outq, port->txptr+whead, size);
+					whead+=ocount;
+
+					setwin(sc,0);
+					bc->tin=whead;
+				}
+				if(tp->t_state & TS_ASLEEP) {
+					tp->t_state &= ~TS_ASLEEP;
+					wakeup(TSA_OLOWAT(tp));
+				}
+				tp->t_state &= ~TS_BUSY;
+			end_of_buffer:
+			}
+		} else {
+			DPRINT4("dgb%d: port %d: got event 0x%x on closed port\n",
+				unit,pnum,event);
+			bc->rout=bc->rin;
+			bc->idata=bc->iempty=bc->ilow=0;
+		}
+			
+		bc->idata=1; 
+
+		tail= (tail+4) & (FEP_IMAX-FEP_ISTART-4);
+	}
+
+	sc->mailbox->eout=tail;
+	hidewin(sc);
+
+	timeout(dgbpoll, unit_c, hz/25);
+}
+
+void
+dgbintr(unit)
+	int	unit;
+{
+}
+
+int
+dgbioctl(dev, cmd, data, flag, p)
+	dev_t		dev;
+	int		cmd;
+	caddr_t		data;
+	int		flag;
+	struct proc	*p;
+{
+	struct dgb_softc *sc;
+	int unit, pnum;
+	struct dgb_p *port;
+	int mynor;
+	struct tty *tp;
+	struct board_chan *bc;
+	int error;
+	int s;
+	int tiocm_xxx;
+
+	mynor=minor(dev);
+	unit=MINOR_TO_UNIT(mynor);
+	pnum=MINOR_TO_PORT(mynor);
+
+	sc=&dgb_softc[unit];
+	port=&sc->ports[pnum];
+	tp=&sc->ttys[pnum];
+	bc=port->brdchan;
+
+	if (mynor & CONTROL_MASK) {
+		struct termios *ct;
+
+		switch (mynor & CONTROL_MASK) {
+		case CONTROL_INIT_STATE:
+			ct = mynor & CALLOUT_MASK ? &port->it_out : &port->it_in;
+			break;
+		case CONTROL_LOCK_STATE:
+			ct = mynor & CALLOUT_MASK ? &port->lt_out : &port->lt_in;
+			break;
+		default:
+			return (ENODEV);	/* /dev/nodev */
+		}
+		switch (cmd) {
+		case TIOCSETA:
+			error = suser(p->p_ucred, &p->p_acflag);
+			if (error != 0)
+				return (error);
+			*ct = *(struct termios *)data;
+			return (0);
+		case TIOCGETA:
+			*(struct termios *)data = *ct;
+			return (0);
+		case TIOCGETD:
+			*(int *)data = TTYDISC;
+			return (0);
+		case TIOCGWINSZ:
+			bzero(data, sizeof(struct winsize));
+			return (0);
+		default:
+			return (ENOTTY);
+		}
+	}
+
+	if (cmd == TIOCSETA || cmd == TIOCSETAW || cmd == TIOCSETAF) {
+		int	cc;
+		struct termios *dt = (struct termios *)data;
+		struct termios *lt = mynor & CALLOUT_MASK
+				     ? &port->lt_out : &port->lt_in;
+
+		dt->c_iflag = (tp->t_iflag & lt->c_iflag)
+			      | (dt->c_iflag & ~lt->c_iflag);
+		dt->c_oflag = (tp->t_oflag & lt->c_oflag)
+			      | (dt->c_oflag & ~lt->c_oflag);
+		dt->c_cflag = (tp->t_cflag & lt->c_cflag)
+			      | (dt->c_cflag & ~lt->c_cflag);
+		dt->c_lflag = (tp->t_lflag & lt->c_lflag)
+			      | (dt->c_lflag & ~lt->c_lflag);
+		for (cc = 0; cc < NCCS; ++cc)
+			if (lt->c_cc[cc] != 0)
+				dt->c_cc[cc] = tp->t_cc[cc];
+		if (lt->c_ispeed != 0)
+			dt->c_ispeed = tp->t_ispeed;
+		if (lt->c_ospeed != 0)
+			dt->c_ospeed = tp->t_ospeed;
+	}
+
+	if(cmd==TIOCSTOP) {
+		setwin(sc,0);
+		fepcmd(port, PAUSETX, 0, 0, 0, 0);
+		hidewin(sc);
+		return 0;
+	} else if(cmd==TIOCSTART) {
+		setwin(sc,0);
+		fepcmd(port, RESUMETX, 0, 0, 0, 0);
+		hidewin(sc);
+		return 0;
+	}
+
+	if(cmd==TIOCSETAW || cmd==TIOCSETAF)
+		port->mustdrain=1;
+
+	error = linesw[tp->t_line].l_ioctl(tp, cmd, data, flag, p);
+
+	if (error >= 0)
+		return error;
+	error = ttioctl(tp, cmd, data, flag);
+
+	port->mustdrain=0;
+
+	if (error >= 0)
+		return error;
+	s = spltty();
+	switch (cmd) {
+	case TIOCSBRK:
+		error=dgbdrain(port);
+
+		if(error!=0) {
+			splx(s);
+			return error;
+		}
+
+		setwin(sc,0);
+	
+		/* now it sends 250 millisecond break because I don't know */
+		/* how to send an infinite break */
+
+		fepcmd(port, SENDBREAK, 250, 0, 10, 0);
+		hidewin(sc);
+		break;
+	case TIOCCBRK:
+		/* now it's empty */
+		break;
+	case TIOCSDTR:
+		DPRINT3("dgb%d: port %d: set DTR\n",unit,pnum);
+		port->omodem |= DTR;
+		setwin(sc,0);
+		fepcmd(port, SETMODEM, port->omodem, RTS, 0, 1);
+
+		if( !(bc->mstat & DTR) ) {
+			DPRINT3("dgb%d: port %d: DTR is off\n",unit,pnum);
+		}
+
+		hidewin(sc);
+		break;
+	case TIOCCDTR:
+		DPRINT3("dgb%d: port %d: reset DTR\n",unit,pnum);
+		port->omodem &= ~DTR;
+		setwin(sc,0);
+		fepcmd(port, SETMODEM, port->omodem, RTS|DTR, 0, 1);
+
+		if( bc->mstat & DTR ) {
+			DPRINT3("dgb%d: port %d: DTR is on\n",unit,pnum);
+		}
+
+		hidewin(sc);
+		break;
+	case TIOCMSET:
+		if(*(int *)data & TIOCM_DTR)
+			port->omodem |=DTR;
+		else
+			port->omodem &=~DTR;
+
+		if(*(int *)data & TIOCM_RTS)
+			port->omodem |=RTS;
+		else
+			port->omodem &=~RTS;
+
+		setwin(sc,0);
+		fepcmd(port, SETMODEM, port->omodem, RTS|DTR, 0, 1);
+		hidewin(sc);
+		break;
+	case TIOCMBIS:
+		if(*(int *)data & TIOCM_DTR)
+			port->omodem |=DTR;
+
+		if(*(int *)data & TIOCM_RTS)
+			port->omodem |=RTS;
+
+		setwin(sc,0);
+		fepcmd(port, SETMODEM, port->omodem, RTS|DTR, 0, 1);
+		hidewin(sc);
+		break;
+	case TIOCMBIC:
+		if(*(int *)data & TIOCM_DTR)
+			port->omodem &=~DTR;
+
+		if(*(int *)data & TIOCM_RTS)
+			port->omodem &=~RTS;
+
+		setwin(sc,0);
+		fepcmd(port, SETMODEM, port->omodem, RTS|DTR, 0, 1);
+		hidewin(sc);
+		break;
+	case TIOCMGET:
+		setwin(sc,0);
+		port->imodem=bc->mstat;
+		hidewin(sc);
+
+		tiocm_xxx = TIOCM_LE;	/* XXX - always enabled while open */
+
+		DPRINT3("dgb%d: port %d: modem stat -- ",unit,pnum);
+
+		if (port->imodem & DTR) {
+			DPRINT1("DTR ");
+			tiocm_xxx |= TIOCM_DTR;
+		}
+		if (port->imodem & RTS) {
+			DPRINT1("RTS ");
+			tiocm_xxx |= TIOCM_RTS;
+		}
+		if (port->imodem & CTS) {
+			DPRINT1("CTS ");
+			tiocm_xxx |= TIOCM_CTS;
+		}
+		if (port->imodem & port->dcd) {
+			DPRINT1("DCD ");
+			tiocm_xxx |= TIOCM_CD;
+		}
+		if (port->imodem & port->dsr) {
+			DPRINT1("DSR ");
+			tiocm_xxx |= TIOCM_DSR;
+		}
+		if (port->imodem & RI) {
+			DPRINT1("RI ");
+			tiocm_xxx |= TIOCM_RI;
+		}
+		*(int *)data = tiocm_xxx;
+		DPRINT1("--\n");
+		break;
+	default:
+		splx(s);
+		return ENOTTY;
+	}
+	splx(s);
+	return 0;
+}
+
+static void 
+wakeflush(p)
+	void *p;
+{
+	struct dgb_p *port=p;
+
+	wakeup(&port->draining);
+}
+
+/* wait for the output to drain */
+
+static int
+dgbdrain(port)
+	struct dgb_p	*port;
+{
+	struct tty *tp=port->tty;
+	struct dgb_softc *sc=&dgb_softc[port->unit];
+	struct board_chan *bc=port->brdchan;
+	int error;
+	int head, tail;
+
+	setwin(sc,0);
+
+	bc->iempty=1;
+	tail=bc->tout;
+	head=bc->tin;
+
+	while(tail!=head) {
+		DPRINT5("dgb%d: port %d: drain: head=%d tail=%d\n",
+			port->unit, port->pnum, head, tail);
+
+		hidewin(sc);
+		port->draining=1;
+		timeout(wakeflush,port, hz);
+		error=tsleep(&port->draining, TTIPRI | PCATCH, "dgdrn", 0);
+		port->draining=0;
+		setwin(sc,0);
+
+		if (error != 0) {
+			DPRINT4("dgb%d: port %d: tsleep(dgdrn) error=%d\n",
+				port->unit,port->pnum,error);
+
+			bc->iempty=0;
+			hidewin(sc);
+			return error;
+		}
+
+		tail=bc->tout;
+		head=bc->tin;
+	}
+	DPRINT5("dgb%d: port %d: drain: head=%d tail=%d\n",
+		port->unit, port->pnum, head, tail);
+
+	return 0;
+}
+
+/* wait for the output to drain */
+/* or simply clear the buffer it it's stopped */
+
+static void
+dgb_drain_or_flush(port)
+	struct dgb_p	*port;
+{
+	struct tty *tp=port->tty;
+	struct dgb_softc *sc=&dgb_softc[port->unit];
+	struct board_chan *bc=port->brdchan;
+	int error;
+	int lasttail;
+	int head, tail;
+
+	setwin(sc,0);
+
+	lasttail=-1;
+	bc->iempty=1;
+	tail=bc->tout;
+	head=bc->tin;
+
+	while(tail!=head /* && tail!=lasttail */ ) {
+		DPRINT5("dgb%d: port %d: flush: head=%d tail=%d\n",
+			port->unit, port->pnum, head, tail);
+
+		/* if there is no carrier simply clean the buffer */
+		if( !(tp->t_state & TS_CARR_ON) ) {
+			bc->tout=bc->tin=0;
+			bc->iempty=0;
+			hidewin(sc);
+			return;
+		}
+
+		hidewin(sc);
+		port->draining=1;
+		timeout(wakeflush,port, hz);
+		error=tsleep(&port->draining, TTIPRI | PCATCH, "dgfls", 0);
+		port->draining=0;
+		setwin(sc,0);
+
+		if (error != 0) {
+			DPRINT4("dgb%d: port %d: tsleep(dgfls) error=%d\n",
+				port->unit,port->pnum,error);
+
+			/* silently clean the buffer */
+
+			bc->tout=bc->tin=0;
+			bc->iempty=0;
+			hidewin(sc);
+			return;
+		}
+
+		lasttail=tail;
+		tail=bc->tout;
+		head=bc->tin;
+	}
+	DPRINT5("dgb%d: port %d: flush: head=%d tail=%d\n",
+			port->unit, port->pnum, head, tail);
+}
+
+static int
+dgbparam(tp, t)
+	struct tty	*tp;
+	struct termios	*t;
+{
+	int dev=tp->t_dev;
+	int mynor=minor(dev);
+	int unit=MINOR_TO_UNIT(dev);
+	int pnum=MINOR_TO_PORT(dev);
+	struct dgb_softc *sc=&dgb_softc[unit];
+	struct dgb_p *port=&sc->ports[pnum];
+	struct board_chan *bc=port->brdchan;
+	int cflag;
+	int head;
+	int mval;
+	int iflag;
+	int hflow;
+	int s;
+
+	DPRINT3("dgb%d: port%d: setting parameters\n",unit,pnum);
+
+	if(port->mustdrain) {
+		DPRINT3("dgb%d: port%d: must call dgbdrain()\n",unit,pnum);
+		dgbdrain(port);
+	}
+
+	cflag=ttspeedtab(t->c_ospeed, dgbspeedtab);
+
+	if (t->c_ispeed == 0)
+		t->c_ispeed = t->c_ospeed;
+
+	if (cflag < 0 || cflag > 0 && t->c_ispeed != t->c_ospeed)
+		return (EINVAL);
+
+	s=spltty();
+
+	setwin(sc,0);
+
+	if(cflag==0) { /* hangup */
+		DPRINT3("dgb%d: port%d: hangup\n",unit,pnum);
+		head=bc->rin;
+		bc->rout=head;
+		head=bc->tin;
+		fepcmd(port, STOUT, head, 0, 0, 0);
+		mval= port->omodem & ~(DTR|RTS);
+	} else {
+		DPRINT4("dgb%d: port%d: CBAUD=%d\n",unit,pnum,cflag);
+
+		/* convert flags to sysV-style values */
+		if(t->c_cflag & PARODD)
+			cflag|=01000;
+		if(t->c_cflag & PARENB)
+			cflag|=00400;
+		if(t->c_cflag & CSTOPB)
+			cflag|=00100;
+
+		cflag|= (t->c_cflag & CSIZE) >> 4;
+		DPRINT4("dgb%d: port%d: CFLAG=0x%x\n",unit,pnum,cflag);
+
+		if(cflag!=port->fepcflag) {
+			DPRINT3("dgb%d: port%d: set cflag\n",unit,pnum);
+			port->fepcflag=cflag;
+			fepcmd(port, SETCTRLFLAGS, (unsigned)cflag, 0, 0, 0);
+		}
+		mval= port->omodem | (DTR|RTS) ;
+	}
+
+	iflag=t->c_iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK|ISTRIP);
+	if(t->c_cflag & IXON)
+		cflag|=002000;
+	if(t->c_cflag & IXANY)
+		cflag|=004000;
+	if(t->c_cflag & IXOFF)
+		cflag|=010000;
+
+	if(iflag!=port->fepiflag) {
+		DPRINT3("dgb%d: port%d: set iflag\n",unit,pnum);
+		port->fepiflag=iflag;
+		fepcmd(port, SETIFLAGS, (unsigned)iflag, 0, 0, 0);
+	}
+
+	bc->mint=port->dcd;
+
+	if(t->c_cflag & CRTSCTS)
+		hflow=(CTS|RTS);
+	else
+		hflow=0;
+
+	if(hflow!=port->hflow) {
+		DPRINT3("dgb%d: port%d: set hflow\n",unit,pnum);
+		port->hflow=hflow;
+		fepcmd(port, SETHFLOW, (unsigned)hflow, 0xff, 0, 1);
+	}
+	
+	if(port->omodem != mval) {
+		DPRINT4("dgb%d: port %d: setting modem parameters 0x%x\n",
+			unit,pnum,mval);
+		port->omodem=mval;
+		fepcmd(port, SETMODEM, (unsigned)mval, RTS|DTR, 0, 1);
+	}
+
+	if(port->fepstartc!=t->c_cc[VSTART] || port->fepstopc!=t->c_cc[VSTOP]) {
+		DPRINT3("dgb%d: port%d: set startc, stopc\n",unit,pnum);
+		port->fepstartc=t->c_cc[VSTART];
+		port->fepstopc=t->c_cc[VSTOP];
+		fepcmd(port, SONOFFC, port->fepstartc, port->fepstopc, 0, 1);
+	}
+
+	hidewin(sc);
+	splx(s);
+
+	return 0;
+
+}
+
+static void
+dgbstart(tp)
+	struct tty	*tp;
+{
+	int unit;
+	int pnum;
+	struct dgb_p *port;
+	struct dgb_softc *sc;
+	struct board_chan *bc;
+	int head, tail;
+	int size, ocount;
+	int s;
+	int wmask;
+
+	unit=MINOR_TO_UNIT(minor(tp->t_dev));
+	pnum=MINOR_TO_PORT(minor(tp->t_dev));
+	sc=&dgb_softc[unit];
+	port=&sc->ports[pnum];
+	bc=port->brdchan;
+
+	wmask=port->txbufsize-1;
+
+	s=spltty();
+
+	while( tp->t_outq.c_cc!=0 ) {
+		if(tp->t_outq.c_cc <= tp->t_lowat) {
+			if(tp->t_state & TS_ASLEEP) {
+				tp->t_state &= ~TS_ASLEEP;
+				wakeup(TSA_OLOWAT(tp));
+			}
+			selwakeup(&tp->t_wsel);
+		}
+
+		setwin(sc,0);
+
+		head=bc->tin & wmask;
+		tail=bc->tout & wmask;
+
+		DPRINT5("dgb%d: port%d: s tx head=%d tail=%d\n",unit,pnum,head,tail);
+
+		if(tail>head)
+			size=tail-head-1;
+		else {
+			size=port->txbufsize-head;
+			if(tail==0)
+				size--;
+		}
+
+		if(size==0) {
+			bc->iempty=1; bc->ilow=1;
+			hidewin(sc);
+			tp->t_state|=TS_BUSY;
+			splx(s);
+			return;
+		}
+
+		towin(sc,port->txwin);
+
+		ocount=q_to_b(&tp->t_outq, port->txptr+head, size);
+		head+=ocount;
+
+		setwin(sc,0);
+		bc->tin=head;
+	}
+
+	if(tp->t_state & TS_ASLEEP) {
+		tp->t_state &= ~TS_ASLEEP;
+		wakeup(TSA_OLOWAT(tp));
+	}
+	tp->t_state&=~TS_BUSY;
+
+	hidewin(sc);
+	splx(s);
+}
+
+void
+dgbstop(tp, rw)
+	struct tty	*tp;
+	int		rw;
+{
+}
+
+int
+dgbselect(dev, rw, p)
+	dev_t		dev;
+	int		rw;
+	struct proc	*p;
+{
+	if (minor(dev) & CONTROL_MASK)
+		return (ENODEV);
+	return (ttselect(dev & ~MINOR_MAGIC_MASK, rw, p));
+}
+
+static void 
+fepcmd(port, cmd, op1, op2, ncmds, bytecmd)
+	struct dgb_p *port;
+	int cmd, op1, op2, ncmds, bytecmd;
+{
+	struct dgb_softc *sc=&dgb_softc[port->unit];
+	u_char *mem=sc->vmem;
+	unsigned tail, head;
+	int count, n;
+
+	if(port->status==DISABLED) {
+		printf("dgb%d(%d): FEP command on disabled port\n", 
+			port->unit, port->pnum);
+		return;
+	}
+
+	setwin(sc,0);
+	head=sc->mailbox->cin;
+
+	if(head>=(FEP_CMAX-FEP_CSTART) || (head & 3)) {
+		printf("dgb%d(%d): wrong pointer head of command queue : 0x%x\n",
+			port->unit, port->pnum, head);
+		return;
+	}
+
+	if(bytecmd) {
+		mem[head+FEP_CSTART+0]=cmd;
+		mem[head+FEP_CSTART+1]=port->pnum;
+		mem[head+FEP_CSTART+2]=op1;
+		mem[head+FEP_CSTART+3]=op2;
+	} else {
+		mem[head+FEP_CSTART+0]=cmd;
+		mem[head+FEP_CSTART+1]=port->pnum;
+		*(ushort *)(mem+head+FEP_CSTART+2)=op1;
+	}
+
+	head=(head+4) & (FEP_CMAX-FEP_CSTART-4);
+	sc->mailbox->cin=head;
+
+	for(count=FEPTIMEOUT; count>0; count--) {
+		head=sc->mailbox->cin;
+		tail=sc->mailbox->cout;
+		n=(head-tail) & (FEP_CMAX-FEP_CSTART-4);
+
+		if(n <= ncmds * 4)
+			return;
+	}
+
+	printf("dgb%d(%d): timeout on FEP command\n",
+			port->unit, port->pnum);
+}
+
+#endif /* NDGB > 0 */
diff --git a/sys/dev/dgb/dgbios.h b/sys/dev/dgb/dgbios.h
new file mode 100644
index 0000000..b6e916e
--- /dev/null
+++ b/sys/dev/dgb/dgbios.h
@@ -0,0 +1,175 @@
+static unsigned char pcxx_bios[] = {
+	0x28,0x43,0x29,0x20,0x43,0x6F,0x70,0x79,0x72,0x69,0x67,0x68,
+	0x74,0x20,0x31,0x39,0x39,0x34,0x2C,0x20,0x44,0x69,0x67,0x69,
+	0x42,0x6F,0x61,0x72,0x64,0x20,0x49,0x6E,0x63,0x2E,0x00,0x00,
+	0x8A,0xF8,0x8A,0xF8,0x15,0xF9,0x8A,0xF8,0x8A,0xF8,0x8A,0xF8,
+	0x8A,0xF8,0x8A,0xF8,0xBC,0xF8,0x8A,0xF8,0x96,0xF8,0x96,0xF8,
+	0x96,0xF8,0x96,0xF8,0x96,0xF8,0x96,0xF8,0x8A,0xF8,0x8A,0xF8,
+	0x96,0xF8,0x96,0xF8,0x8A,0xF8,0xAD,0xF8,0xB0,0xF8,0x8A,0xF8,
+	0x8A,0xF8,0x8A,0xF8,0x8A,0xF8,0x8A,0xF8,0x8A,0xF8,0x8A,0xF8,
+	0x8A,0xF8,0x8A,0xF8,0x8A,0xF8,0x04,0x02,0x00,0x02,0x14,0x02,
+	0x10,0x02,0x24,0x02,0x20,0x02,0x34,0x02,0x30,0x02,0x44,0x02,
+	0x40,0x02,0x54,0x02,0x50,0x02,0x64,0x02,0x60,0x02,0x74,0x02,
+	0x70,0x02,0x04,0x01,0x00,0x01,0x1E,0x2E,0x8E,0x1E,0x22,0xF8,
+	0xFE,0x06,0x70,0x00,0x1F,0xCF,0x1E,0x50,0x52,0x2E,0x8E,0x1E,
+	0x22,0xF8,0xFE,0x06,0x71,0x00,0xB8,0x00,0x80,0xBA,0x22,0xFF,
+	0xEF,0x5A,0x58,0x1F,0xCF,0xB4,0x80,0xCF,0x1E,0x2E,0x8E,0x1E,
+	0x22,0xF8,0xFE,0x06,0x2B,0x00,0x1F,0xCF,0x1E,0x52,0x50,0x2E,
+	0x8E,0x1E,0x22,0xF8,0xCD,0x16,0xFE,0x06,0x2A,0x00,0x80,0x3E,
+	0x2A,0x00,0x12,0x72,0x39,0xC6,0x06,0x2A,0x00,0x00,0xFE,0x06,
+	0x29,0x00,0x80,0x3E,0x29,0x00,0x3C,0x72,0x29,0xC6,0x06,0x29,
+	0x00,0x00,0xFE,0x06,0x28,0x00,0x80,0x3E,0x28,0x00,0x3C,0x72,
+	0x19,0xC6,0x06,0x28,0x00,0x00,0xFE,0x06,0x27,0x00,0x80,0x3E,
+	0x27,0x00,0x18,0x72,0x09,0xC6,0x06,0x27,0x00,0x00,0xFF,0x06,
+	0x25,0x00,0xBA,0x22,0xFF,0xB8,0x00,0x80,0xEF,0x58,0x5A,0x1F,
+	0xCF,0x60,0x1E,0x06,0xFC,0x2E,0x8E,0x06,0x22,0xF8,0x2E,0x8E,
+	0x1E,0x22,0xF8,0x8D,0x36,0x40,0x00,0xAD,0x3C,0x3F,0x7F,0x22,
+	0x3C,0x1F,0x7F,0x22,0x32,0xE4,0xD1,0xE0,0x3D,0x16,0x00,0x90,
+	0x73,0x14,0xBB,0x56,0xF9,0x03,0xD8,0x2E,0xFF,0x17,0x8D,0x36,
+	0x40,0x00,0xB0,0x00,0x89,0x04,0x07,0x1F,0x61,0xCF,0xB4,0x80,
+	0xEB,0xF0,0xCD,0x15,0xEB,0xEC,0x6C,0xF9,0x79,0xF9,0xB9,0xF9,
+	0xD3,0xF9,0xD8,0xF9,0xE1,0xF9,0xE9,0xF9,0xF2,0xF9,0xFA,0xF9,
+	0xFD,0xF9,0x2A,0xFA,0xE4,0x00,0x24,0xF7,0xE6,0x00,0x0C,0x08,
+	0xE6,0x00,0xB4,0x00,0xC3,0x1E,0xAD,0x8B,0xD8,0xAD,0x8E,0xDB,
+	0x8B,0xF0,0x33,0xDB,0x8B,0x07,0x3D,0x4F,0x53,0x75,0x2A,0x8A,
+	0x47,0x02,0x32,0xE4,0x86,0xC4,0x8B,0xC8,0x32,0xC0,0x02,0x07,
+	0x43,0xE2,0xFB,0x0A,0xC0,0x75,0x16,0x8C,0xD9,0x1F,0x89,0x0E,
+	0x2E,0x00,0x89,0x36,0x2C,0x00,0x8D,0x1E,0x02,0x00,0xC7,0x07,
+	0x45,0x4D,0x32,0xE4,0xC3,0x1F,0xB4,0x80,0xC3,0xAD,0x8B,0xD8,
+	0xAD,0x8B,0xD0,0xAD,0x8E,0xC0,0xAD,0x8B,0xF8,0xAD,0x8B,0xC8,
+	0x8B,0xF2,0x1E,0x8E,0xDB,0xF3,0xA4,0x1F,0x32,0xE4,0xC3,0xEA,
+	0xF0,0xFF,0x00,0xF0,0xAD,0x8B,0xD0,0xEC,0x88,0x04,0x32,0xE4,
+	0xC3,0xAD,0x8B,0xD0,0xAC,0xEE,0x32,0xE4,0xC3,0xAD,0x8B,0xD0,
+	0xED,0x89,0x04,0x32,0xE4,0xC3,0xAD,0x8B,0xD0,0xAD,0xEF,0x32,
+	0xE4,0xC3,0xB4,0x80,0xC3,0xAC,0x3C,0x12,0x7F,0x25,0xFE,0xC8,
+	0x32,0xE4,0xD1,0xE0,0x8D,0x1E,0x66,0xF8,0x03,0xD8,0x2E,0x8B,
+	0x17,0xEC,0xAC,0x3C,0x0F,0x7F,0x10,0x3C,0x00,0x74,0x03,0xEE,
+	0x90,0x90,0xEC,0x8B,0xFE,0x1E,0x07,0xAA,0x32,0xE4,0xC3,0xB4,
+	0x80,0xC3,0xAC,0x3C,0x12,0x7F,0x1F,0xFE,0xC8,0x32,0xE4,0xD1,
+	0xE0,0x8D,0x1E,0x66,0xF8,0x03,0xD8,0x2E,0x8B,0x17,0xEC,0xAC,
+	0x3C,0x0F,0x7F,0x0A,0x3C,0x00,0x74,0x01,0xEE,0xAC,0xEE,0x32,
+	0xE4,0xC3,0xB4,0x80,0xC3,0xFC,0x8E,0xC0,0xB8,0xFF,0xFF,0x8B,
+	0xCB,0x33,0xFF,0xF3,0xAB,0x8B,0xCB,0x33,0xFF,0xF3,0xAF,0xE3,
+	0x01,0xC3,0x8B,0xCB,0xBF,0x00,0x00,0x26,0x89,0x3D,0x83,0xC7,
+	0x02,0xE2,0xF8,0xBE,0x00,0x00,0x8B,0xCB,0x26,0x8B,0x3C,0x3B,
+	0xFE,0x74,0x01,0xC3,0x83,0xC6,0x02,0x83,0xC7,0x02,0xE2,0xF0,
+	0x33,0xC0,0x8B,0xCB,0x33,0xFF,0xF3,0xAB,0x8B,0xCB,0x33,0xFF,
+	0xF3,0xAF,0xC3,0x32,0xC0,0x26,0x80,0x3E,0x23,0x00,0x00,0x74,
+	0x02,0x0C,0x01,0x26,0xF7,0x06,0x20,0x00,0x0F,0x00,0x74,0x02,
+	0x0C,0x02,0x26,0xF7,0x06,0x20,0x00,0xF0,0x00,0x74,0x02,0x0C,
+	0x04,0x26,0xF7,0x06,0x20,0x00,0x00,0xFF,0x74,0x02,0x0C,0x08,
+	0x26,0xA2,0x24,0x00,0xB8,0x00,0x40,0xBA,0x5E,0xFF,0xEF,0xBA,
+	0x66,0xFF,0xEF,0xBA,0x52,0xFF,0xB8,0x63,0x0E,0xEF,0xBA,0x56,
+	0xFF,0xB8,0x05,0xE0,0xEF,0xBA,0x28,0xFF,0xB8,0xFC,0x00,0xEF,
+	0xB8,0x00,0x02,0x26,0xA3,0x2E,0x00,0xB8,0x04,0x00,0x26,0xA3,
+	0x2C,0x00,0xB0,0xC3,0xE6,0x08,0x8A,0xD8,0xE4,0x08,0x3A,0xC3,
+	0x75,0x06,0x26,0xC6,0x06,0xB4,0x00,0x01,0xFC,0x8D,0x3E,0x00,
+	0x00,0xB8,0x47,0x44,0xAB,0xB8,0xFF,0xFF,0xAB,0xAB,0xAB,0xB8,
+	0x42,0x49,0xAB,0xB8,0x4F,0x53,0xAB,0xB8,0x58,0x69,0x26,0x80,
+	0x3E,0x10,0x00,0x04,0x74,0x0E,0xB8,0x58,0x65,0x26,0x80,0x3E,
+	0x10,0x00,0x03,0x74,0x03,0xB8,0x58,0x74,0xAB,0x8D,0x36,0xFE,
+	0xFF,0x8A,0x04,0x8D,0x36,0xFF,0xFF,0x8A,0x24,0xAB,0xFB,0x26,
+	0x81,0x0E,0x12,0x00,0x00,0x08,0x06,0x1F,0xA1,0x00,0x00,0x8B,
+	0x1E,0x02,0x00,0x3D,0x44,0x47,0x75,0x0B,0x26,0x81,0x0E,0x12,
+	0x00,0x00,0x10,0xFF,0x2E,0x2C,0x00,0x81,0xFB,0x45,0x4D,0x75,
+	0xE3,0x26,0x81,0x0E,0x12,0x00,0x00,0x20,0xFF,0x2E,0x2C,0x00,
+	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+	0xFF,0xFF,0xFF,0xFF,0xFA,0xBA,0xA8,0xFF,0xB8,0xBA,0x81,0xEF,
+	0xBA,0xA4,0xFF,0xB8,0x3A,0x00,0xEF,0x90,0xE4,0x00,0xA8,0x60,
+	0x75,0x0C,0x24,0x06,0x74,0x14,0x3C,0x02,0x74,0x1C,0x3C,0x04,
+	0x74,0x24,0xBB,0x38,0xC0,0xBE,0xF8,0x81,0xBF,0xBA,0xA0,0xEB,
+	0x22,0x90,0xBB,0x38,0xF0,0xBE,0xF8,0x41,0xBF,0xBA,0x81,0xEB,
+	0x16,0x90,0xBB,0x38,0xF0,0xBE,0xF8,0xE1,0xBF,0xBA,0x88,0xEB,
+	0x0A,0x90,0xBB,0x38,0xC0,0xBE,0xF8,0x41,0xBF,0xBA,0x81,0xBA,
+	0xA0,0xFF,0x8B,0xC3,0xEF,0xBA,0xA2,0xFF,0xB8,0xF8,0x0F,0xEF,
+	0xBA,0xA6,0xFF,0x8B,0xC6,0xEF,0xBA,0xA8,0xFF,0x8B,0xC7,0xEF,
+	0x8C,0xC8,0x8E,0xD8,0xE4,0x00,0x24,0x06,0x74,0x17,0xBB,0x00,
+	0x80,0xBD,0xC0,0xE0,0x3C,0x02,0x74,0x5A,0xBD,0xC0,0xC0,0x3C,
+	0x04,0x74,0x53,0xBD,0xC0,0x80,0xEB,0x4E,0x90,0xB9,0x08,0x00,
+	0xB8,0x00,0x80,0x8E,0xC0,0x26,0xA3,0x00,0x00,0x05,0x00,0x10,
+	0xE2,0xF5,0xBD,0xC0,0xF0,0xBB,0x00,0x7C,0xB8,0x00,0xE0,0x8E,
+	0xC0,0x26,0x8B,0x0E,0x00,0x00,0x3B,0xC8,0x75,0x28,0xBB,0x00,
+	0x80,0xBD,0xC0,0xE0,0xB8,0x00,0xC0,0x8E,0xC0,0x26,0x8B,0x0E,
+	0x00,0x00,0x3B,0xC8,0x75,0x14,0xBD,0xC0,0xC0,0xB8,0x00,0x80,
+	0x8E,0xC0,0x26,0x8B,0x0E,0x00,0x00,0x3B,0xC8,0x75,0x03,0xBD,
+	0xC0,0x80,0x8C,0xC8,0x8E,0xD0,0xBC,0xED,0xFC,0x8B,0xC5,0x25,
+	0x00,0xF0,0xE9,0x6C,0xFD,0xB4,0x00,0x74,0x06,0xB4,0xFF,0xEB,
+	0x02,0xE5,0xFC,0x8E,0xC5,0x2E,0x89,0x2E,0x22,0xF8,0xE4,0x00,
+	0x24,0x16,0x26,0xA2,0x11,0x00,0x26,0x83,0x0E,0x12,0x00,0x01,
+	0x80,0xFC,0x00,0x74,0x06,0x26,0x83,0x0E,0x14,0x00,0x01,0x26,
+	0xC7,0x06,0x18,0x00,0x40,0x00,0x26,0xC6,0x06,0x10,0x00,0x03,
+	0xA8,0x10,0x74,0x06,0x26,0xC6,0x06,0x10,0x00,0x04,0xB8,0x00,
+	0x00,0x8E,0xC0,0xB8,0xAA,0x55,0x26,0xA3,0x00,0x00,0x26,0xC7,
+	0x06,0x02,0x00,0x00,0x00,0x26,0xC7,0x06,0x04,0x00,0x00,0x00,
+	0x8B,0xCD,0x81,0xE1,0x00,0xF0,0x8E,0xC1,0x26,0x8B,0x1E,0x00,
+	0x00,0x3B,0xC3,0x75,0x13,0x8E,0xC5,0x26,0xC6,0x06,0x10,0x00,
+	0x05,0xB8,0x40,0x00,0x8E,0xD0,0xBC,0x00,0x04,0xE9,0x99,0x00,
+	0x8C,0xC8,0x8E,0xD0,0xBC,0x7C,0xFD,0xB8,0x00,0x00,0xBB,0x00,
+	0x20,0xE9,0xDD,0xFC,0xB4,0x00,0x74,0x06,0xB4,0xFF,0xEB,0x02,
+	0x74,0xFD,0x8E,0xC5,0x80,0xFC,0x00,0x74,0x08,0x26,0x83,0x0E,
+	0x14,0x00,0x02,0xEB,0x0D,0x26,0xC7,0x06,0x16,0x00,0x10,0x00,
+	0x26,0x83,0x0E,0x12,0x00,0x02,0xB8,0x40,0x00,0x8E,0xD0,0xBC,
+	0x00,0x04,0xE4,0x00,0xA8,0x60,0x75,0x07,0xBA,0xA2,0xFF,0xB8,
+	0xFC,0x0F,0xEF,0xB8,0x00,0x04,0x8E,0xC0,0xB8,0xAA,0x55,0x26,
+	0xA3,0x00,0x00,0x26,0xC7,0x06,0x02,0x00,0x00,0x00,0x26,0xC7,
+	0x06,0x04,0x00,0x00,0x00,0xB9,0x00,0x00,0x8E,0xC1,0x26,0x8B,
+	0x1E,0x00,0x00,0x3B,0xC3,0x75,0x02,0xEB,0x24,0x8E,0xC5,0x26,
+	0x83,0x0E,0x12,0x00,0x04,0xB8,0x00,0x04,0xBB,0x00,0x60,0x06,
+	0xE8,0x66,0xFC,0x07,0x75,0x09,0x26,0xC7,0x06,0x16,0x00,0x40,
+	0x00,0xEB,0x06,0x26,0x83,0x0E,0x14,0x00,0x04,0x8E,0xC5,0x8C,
+	0xC0,0x3D,0xC0,0xF0,0x75,0x03,0xE9,0x9F,0x00,0x3D,0xC0,0x80,
+	0x74,0x62,0x3D,0xC0,0xC0,0x74,0x23,0x26,0x83,0x0E,0x12,0x00,
+	0x08,0xB8,0x00,0xF0,0xBB,0x00,0x7C,0x06,0xE8,0x2E,0xFC,0x07,
+	0x75,0x08,0x26,0x83,0x06,0x18,0x00,0x40,0xEB,0x06,0x26,0x83,
+	0x0E,0x14,0x00,0x08,0xEB,0x72,0xB9,0x03,0x00,0xB8,0x00,0xD0,
+	0xBA,0x08,0x00,0xBB,0x00,0x80,0x3D,0x00,0xF0,0x75,0x03,0xBB,
+	0x00,0x7C,0x26,0x09,0x16,0x12,0x00,0x06,0x50,0x51,0xE8,0xFC,
+	0xFB,0x59,0x58,0x07,0x75,0x0F,0x26,0x83,0x06,0x18,0x00,0x40,
+	0xD1,0xE2,0x05,0x00,0x10,0xE2,0xD8,0xEB,0x05,0x26,0x09,0x16,
+	0x14,0x00,0xEB,0x38,0xB9,0x07,0x00,0xB8,0x00,0x90,0xBA,0x08,
+	0x00,0xBB,0x00,0x80,0x3D,0x00,0xF0,0x75,0x03,0xBB,0x00,0x7C,
+	0x26,0x09,0x16,0x12,0x00,0x06,0x50,0x51,0xE8,0xC2,0xFB,0x59,
+	0x58,0x07,0x75,0x0F,0x26,0x83,0x06,0x18,0x00,0x40,0xD1,0xE2,
+	0x05,0x00,0x10,0xE2,0xD8,0xEB,0x05,0x26,0x09,0x16,0x14,0x00,
+	0x26,0xA1,0x18,0x00,0x2D,0x10,0x00,0x26,0xA3,0x1A,0x00,0x06,
+	0xFC,0x33,0xFF,0x8E,0xC7,0xB9,0x00,0x02,0xB8,0x00,0xF0,0xF3,
+	0xAB,0x33,0xFF,0xBE,0x24,0xF8,0xB9,0x20,0x00,0xA5,0x47,0x47,
+	0xE2,0xFB,0xBE,0x64,0xF8,0xB9,0xE0,0x00,0x8B,0x1C,0x26,0x89,
+	0x1D,0x83,0xC7,0x04,0xE2,0xF8,0x07,0xBA,0x28,0xFF,0xB8,0xFD,
+	0x00,0xEF,0xBA,0x32,0xFF,0xB8,0x0D,0x00,0xEF,0xBA,0x34,0xFF,
+	0xB8,0x0F,0x00,0xEF,0xBA,0x36,0xFF,0xB8,0x0E,0x00,0xEF,0xBA,
+	0x38,0xFF,0xB8,0x19,0x00,0xEF,0xBA,0x3A,0xFF,0xB8,0x18,0x00,
+	0xEF,0xBA,0x3C,0xFF,0xB8,0x0B,0x00,0xEF,0xBA,0x3E,0xFF,0xB8,
+	0x1A,0x00,0xEF,0x8D,0x3E,0x90,0x00,0x8D,0x36,0x66,0xF8,0xB9,
+	0x10,0x00,0xF3,0xA5,0x8D,0x3E,0xB0,0x00,0x8D,0x36,0x86,0xF8,
+	0xB9,0x02,0x00,0xF3,0xA5,0xB9,0x10,0x00,0x8D,0x36,0x90,0x00,
+	0x83,0xC6,0x1E,0x26,0x8B,0x14,0xB3,0x10,0x32,0xC0,0xEC,0xB0,
+	0x0C,0xEE,0x8A,0xC3,0x8A,0xC3,0xEE,0x83,0xEE,0x02,0x26,0x8B,
+	0x14,0xFE,0xCB,0xE2,0xEB,0xB9,0x10,0x00,0x8D,0x36,0x90,0x00,
+	0x26,0x8B,0x14,0xB3,0x01,0xBF,0x00,0x80,0xB0,0x0C,0xEE,0xF6,
+	0xE8,0xEC,0x3A,0xC3,0x75,0x0E,0xD1,0xC7,0x26,0x09,0x3E,0x20,
+	0x00,0x26,0xFE,0x06,0x22,0x00,0xEB,0x07,0x33,0xC0,0x26,0x89,
+	0x04,0xD1,0xC7,0x83,0xC6,0x02,0x26,0x8B,0x14,0xFE,0xC3,0xE2,
+	0xD7,0x26,0xC6,0x06,0x23,0x00,0x01,0x8D,0x36,0xB0,0x00,0x26,
+	0x8B,0x14,0x32,0xC0,0xEE,0xB0,0x0C,0xEE,0xB0,0x5A,0xEE,0xB0,
+	0x0C,0xEE,0xF6,0xE8,0xEC,0x3C,0x5A,0x74,0x14,0x26,0xC7,0x06,
+	0xB0,0x00,0x00,0x00,0x26,0xC7,0x06,0xB2,0x00,0x00,0x00,0x26,
+	0xC6,0x06,0x23,0x00,0x00,0xE9,0xD3,0xFA,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0xEA,0x00,0xFC,0x00,0xF0,0x4D,0x2F,0x50,
+	0x43,0x2F,0x58,0x2A,0x39,0x34,0x34,0x30
+};
+
+static unsigned pcxx_nbios=sizeof(pcxx_bios);
diff --git a/sys/dev/dgb/dgfep.h b/sys/dev/dgb/dgfep.h
new file mode 100644
index 0000000..c60c66a
--- /dev/null
+++ b/sys/dev/dgb/dgfep.h
@@ -0,0 +1,516 @@
+static unsigned char pcxx_cook[] = {
+	0x4F,0x53,0x18,0x85,0xE9,0xBF,0x15,0x00,0x40,0x28,0x23,0x29,
+	0x46,0x45,0x50,0x4F,0x53,0x20,0x37,0x2E,0x30,0x37,0x20,0x31,
+	0x2F,0x31,0x30,0x2F,0x39,0x35,0x00,0x40,0x28,0x23,0x29,0x28,
+	0x43,0x29,0x43,0x6F,0x70,0x79,0x72,0x69,0x67,0x68,0x74,0x20,
+	0x31,0x39,0x38,0x39,0x2D,0x31,0x39,0x39,0x35,0x20,0x44,0x69,
+	0x67,0x69,0x42,0x6F,0x61,0x72,0x64,0x20,0x49,0x6E,0x63,0x2E,
+	0x00,0xCB,0x0C,0xCB,0x0C,0xE2,0x0C,0xCB,0x0C,0xCB,0x0C,0xCB,
+	0x0C,0xCB,0x0C,0xCB,0x0C,0x57,0x0C,0xCB,0x0C,0xCB,0x0C,0xCB,
+	0x0C,0x53,0x0B,0xCB,0x0C,0xCB,0x0C,0x42,0x0B,0xCB,0x0C,0xCB,
+	0x0C,0x12,0x0D,0xCB,0x0C,0xCB,0x0C,0xCB,0x0C,0xCB,0x0C,0xCB,
+	0x0C,0xCB,0x0C,0xCB,0x0C,0xCB,0x0C,0xCB,0x0C,0xCB,0x0C,0xCB,
+	0x0C,0xCB,0x0C,0xCB,0x0C,0x00,0x10,0x80,0x10,0x00,0x11,0x80,
+	0x11,0x00,0x12,0x80,0x12,0x00,0x13,0x80,0x13,0x00,0x14,0x80,
+	0x14,0x00,0x15,0x80,0x15,0x00,0x16,0x80,0x16,0x00,0x17,0x80,
+	0x17,0x78,0x0B,0xB9,0x0B,0x50,0x0C,0xB9,0x0B,0x8D,0x0B,0x8D,
+	0x0B,0x8D,0x0B,0x8D,0x0B,0xC0,0x0B,0xC0,0x0B,0xC0,0x0B,0xC0,
+	0x0B,0x8D,0x0B,0x8D,0x0B,0x8D,0x0B,0x8D,0x0B,0x50,0x0C,0xB9,
+	0x0B,0x50,0x0C,0xB9,0x0B,0x8D,0x0B,0x8D,0x0B,0x8D,0x0B,0x8D,
+	0x0B,0xC0,0x0B,0xC0,0x0B,0xC0,0x0B,0xC0,0x0B,0x8D,0x0B,0x8D,
+	0x0B,0x8D,0x0B,0x8D,0x0B,0x94,0x0B,0x94,0x0B,0x94,0x0B,0x94,
+	0x0B,0x94,0x0B,0x94,0x0B,0x94,0x0B,0x94,0x0B,0x94,0x0B,0x94,
+	0x0B,0x94,0x0B,0x94,0x0B,0x94,0x0B,0x94,0x0B,0x94,0x0B,0x94,
+	0x0B,0x94,0x0B,0x94,0x0B,0x94,0x0B,0x94,0x0B,0x94,0x0B,0x94,
+	0x0B,0x94,0x0B,0x94,0x0B,0x94,0x0B,0x94,0x0B,0x94,0x0B,0x94,
+	0x0B,0x94,0x0B,0x94,0x0B,0x94,0x0B,0x94,0x0B,0x16,0x00,0xFE,
+	0x11,0xFE,0x0B,0x2C,0x08,0xB5,0x06,0xFE,0x05,0x7E,0x04,0xFE,
+	0x02,0x7E,0x01,0xBE,0x00,0x7E,0x00,0x5E,0x00,0x2E,0x00,0x16,
+	0x00,0x0A,0x00,0x04,0x00,0x16,0x00,0x02,0x00,0x01,0x00,0x00,
+	0x00,0x0E,0x00,0x06,0x00,0x7E,0x04,0xFE,0x02,0x7E,0x01,0xBE,
+	0x00,0x7E,0x00,0x5E,0x00,0x2E,0x00,0x16,0x00,0x0A,0x00,0x04,
+	0x00,0x18,0x00,0x86,0x13,0x03,0x0D,0xDF,0x08,0x41,0x07,0x81,
+	0x06,0xE0,0x04,0x3F,0x03,0x9F,0x01,0xCE,0x00,0x89,0x00,0x66,
+	0x00,0x32,0x00,0x18,0x00,0x0B,0x00,0x0B,0x00,0x18,0x00,0x0B,
+	0x00,0x0B,0x00,0x0B,0x00,0x41,0x07,0x81,0x06,0xE0,0x04,0x3F,
+	0x03,0x9F,0x01,0xCE,0x00,0x89,0x00,0x66,0x00,0x32,0x00,0x18,
+	0x00,0x0B,0x00,0x0B,0x00,0x00,0x80,0x40,0xC0,0x1F,0x3F,0x7F,
+	0xFF,0x00,0x04,0x02,0x06,0x08,0x0C,0x0A,0x0E,0x00,0x04,0x02,
+	0x06,0x08,0x0C,0x0A,0x0E,0xA0,0x08,0xA0,0x08,0xA0,0x08,0xA0,
+	0x08,0xA0,0x08,0xA0,0x08,0xA0,0x08,0xA0,0x08,0x1E,0x06,0x3E,
+	0x06,0xEF,0x06,0xF8,0x05,0x0E,0x06,0x55,0x07,0xA0,0x08,0xA0,
+	0x08,0xA0,0x08,0xA0,0x08,0xA0,0x08,0xA0,0x08,0xA0,0x08,0xA0,
+	0x08,0xA0,0x08,0xA0,0x08,0xA0,0x08,0xA0,0x08,0xA0,0x08,0xA0,
+	0x08,0xA0,0x08,0xA0,0x08,0xA0,0x08,0xA0,0x08,0x9D,0x08,0x9D,
+	0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,
+	0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,
+	0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,
+	0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,
+	0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,
+	0x08,0x9D,0x08,0xA1,0x05,0xA1,0x05,0xA1,0x05,0xA1,0x05,0xA1,
+	0x05,0xA1,0x05,0xA1,0x05,0xA1,0x05,0xA1,0x05,0xA1,0x05,0xA1,
+	0x05,0xA1,0x05,0xA1,0x05,0xA1,0x05,0xA1,0x05,0xA1,0x05,0xA1,
+	0x05,0xA1,0x05,0xA1,0x05,0xA1,0x05,0xA1,0x05,0xA1,0x05,0xA1,
+	0x05,0xA1,0x05,0xA1,0x05,0xA1,0x05,0x9D,0x08,0x9D,0x08,0x9D,
+	0x08,0x9D,0x08,0x9D,0x08,0x5B,0x05,0xEA,0x05,0xEA,0x05,0xEA,
+	0x05,0xEA,0x05,0xEA,0x05,0xEA,0x05,0xEA,0x05,0xEA,0x05,0xEA,
+	0x05,0xEA,0x05,0xEA,0x05,0xEA,0x05,0xEA,0x05,0xEA,0x05,0xEA,
+	0x05,0xEA,0x05,0xEA,0x05,0xEA,0x05,0xEA,0x05,0xEA,0x05,0xEA,
+	0x05,0xEA,0x05,0xEA,0x05,0xEA,0x05,0xEA,0x05,0xEA,0x05,0x69,
+	0x05,0x77,0x05,0x85,0x05,0x93,0x05,0xA0,0x08,0xA0,0x08,0xA0,
+	0x08,0xA0,0x08,0xA0,0x08,0xA0,0x08,0xA0,0x08,0xA0,0x08,0xA0,
+	0x08,0xA0,0x08,0xA0,0x08,0xA0,0x08,0xA0,0x08,0xA0,0x08,0xA0,
+	0x08,0xA0,0x08,0xA0,0x08,0xA0,0x08,0xA0,0x08,0xA0,0x08,0xA0,
+	0x08,0xA0,0x08,0xA0,0x08,0xA0,0x08,0xA0,0x08,0xA0,0x08,0xA0,
+	0x08,0xA0,0x08,0xA0,0x08,0xA0,0x08,0xA0,0x08,0xA0,0x08,0xA0,
+	0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,
+	0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,
+	0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,
+	0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,
+	0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,
+	0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,
+	0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,
+	0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,
+	0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,
+	0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,
+	0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,
+	0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,
+	0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,
+	0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,
+	0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,
+	0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,0x08,0x9D,
+	0x08,0x00,0x00,0xFA,0x8A,0x5C,0x50,0xF6,0xC3,0x0E,0x75,0x3C,
+	0xF6,0xC3,0x40,0x75,0x16,0xF6,0xC3,0x10,0x74,0x26,0xF6,0xC3,
+	0x01,0x75,0x13,0xF6,0xC3,0x20,0x75,0x15,0xC7,0x04,0xB6,0x04,
+	0xE9,0xCF,0x00,0x8B,0x44,0x02,0x89,0x04,0xFF,0xE0,0xC7,0x04,
+	0x03,0x05,0xE9,0x0E,0x01,0xC7,0x04,0x66,0x08,0xE9,0x6A,0x04,
+	0xF6,0xC3,0x20,0x74,0x1A,0xC7,0x04,0xB3,0x08,0xE9,0xAB,0x04,
+	0x8B,0x54,0x20,0xEC,0x8A,0xC8,0xF6,0xC3,0x02,0x75,0x42,0xF6,
+	0xC3,0x08,0x75,0x0E,0xEB,0x69,0x90,0xC7,0x04,0x20,0x04,0xFB,
+	0x81,0xC6,0x80,0x00,0xFF,0x24,0xF6,0xC1,0x04,0x74,0x27,0x80,
+	0x64,0x50,0xF7,0xF6,0x44,0x51,0x02,0x74,0x13,0xF6,0x44,0x29,
+	0x10,0x74,0x0D,0x8A,0x44,0x5D,0x83,0xC2,0x02,0xEE,0x83,0xEA,
+	0x02,0xE9,0x49,0x04,0x8A,0x44,0x5C,0x83,0xC2,0x02,0xEE,0x83,
+	0xEA,0x02,0xE9,0x3C,0x04,0xF6,0x44,0x50,0x04,0x75,0x28,0x83,
+	0x7C,0x24,0xFF,0x74,0x1F,0xA1,0x00,0x0E,0x2B,0x44,0x26,0x3D,
+	0x64,0x00,0x77,0x14,0xB0,0x05,0xEE,0x8A,0x44,0x75,0x24,0xEF,
+	0x88,0x44,0x75,0xEE,0x80,0x64,0x50,0xFD,0x80,0x64,0x4B,0xFD,
+	0xE9,0x0E,0x04,0xB0,0x01,0xEE,0x90,0x90,0x90,0xEC,0xA8,0x01,
+	0x74,0x25,0xB0,0x05,0xEE,0x8A,0x44,0x75,0x0C,0x10,0x88,0x44,
+	0x75,0xEE,0xA1,0x00,0x0E,0x03,0x44,0x24,0x89,0x44,0x26,0x80,
+	0x64,0x50,0xFB,0x80,0x64,0x4B,0xFB,0x80,0x4C,0x50,0x02,0x80,
+	0x4C,0x4B,0x02,0xE9,0xDB,0x03,0xFA,0x8B,0x54,0x20,0xEC,0x8A,
+	0xC8,0x22,0x44,0x52,0x3A,0x44,0x53,0x75,0x19,0x8B,0x7C,0x0C,
+	0x3B,0x7C,0x0A,0x74,0x18,0x8E,0x44,0x08,0x26,0x8A,0x05,0x47,
+	0x23,0x7C,0x0E,0x89,0x7C,0x0C,0x83,0xC2,0x02,0xEE,0xFB,0x81,
+	0xC6,0x80,0x00,0xFF,0x24,0xB0,0x01,0xEE,0x90,0x90,0x90,0xEC,
+	0xA8,0x01,0x74,0x0C,0x80,0x64,0x50,0xEF,0x80,0x64,0x4B,0xEF,
+	0xC7,0x04,0xC3,0x03,0xFB,0x81,0xC6,0x80,0x00,0xFF,0x24,0xFA,
+	0x8B,0x54,0x20,0xEC,0x8A,0xC8,0x22,0x44,0x52,0x3A,0x44,0x53,
+	0x75,0x3A,0x8B,0x7C,0x0C,0x3B,0x7C,0x0A,0x74,0x1B,0x8E,0x44,
+	0x08,0x26,0x8A,0x05,0x47,0x23,0x7C,0x0E,0x89,0x7C,0x0C,0x8A,
+	0xD8,0x22,0x5C,0x62,0x32,0xFF,0x03,0xDB,0x2E,0xFF,0xA7,0xC1,
+	0x01,0xB0,0x01,0xEE,0x90,0x90,0x90,0xEC,0xA8,0x01,0x74,0x0C,
+	0x80,0x64,0x50,0xEF,0x80,0x64,0x4B,0xEF,0xC7,0x04,0xC3,0x03,
+	0xF6,0xC1,0x01,0x75,0x07,0xFB,0x81,0xC6,0x80,0x00,0xFF,0x24,
+	0xE9,0x61,0x03,0xF6,0x44,0x2A,0x01,0x75,0x03,0xE9,0x39,0x03,
+	0xB0,0x27,0xEB,0x42,0x90,0xF6,0x44,0x2A,0x01,0x75,0x03,0xE9,
+	0x2B,0x03,0xB0,0x28,0xEB,0x34,0x90,0xF6,0x44,0x2A,0x01,0x75,
+	0x03,0xE9,0x1D,0x03,0xB0,0x21,0xEB,0x26,0x90,0xF6,0x44,0x2A,
+	0x01,0x75,0x03,0xE9,0x0F,0x03,0xB0,0x29,0xEB,0x18,0x90,0xF6,
+	0x44,0x2A,0x01,0x75,0x03,0xE9,0x01,0x03,0xB0,0x5E,0xEB,0x0A,
+	0x90,0xF6,0x44,0x2A,0x01,0x75,0x03,0xE9,0xF3,0x02,0x88,0x44,
+	0x61,0xB0,0x5C,0x83,0xC2,0x02,0xEE,0x83,0xEA,0x02,0x80,0x4C,
+	0x50,0x40,0xC7,0x04,0xC6,0x05,0xC7,0x44,0x02,0xC6,0x05,0xE9,
+	0xCB,0x02,0xFA,0x8B,0x54,0x20,0xEC,0x8A,0xC8,0x22,0x44,0x52,
+	0x3A,0x44,0x53,0x75,0x12,0x80,0x64,0x50,0xBF,0xC7,0x04,0x03,
+	0x05,0x83,0x44,0x30,0x02,0x8A,0x44,0x61,0xE9,0xB9,0x02,0xE9,
+	0xA7,0x02,0xF6,0x44,0x2A,0x02,0x75,0x03,0xE9,0xAA,0x02,0x2C,
+	0x20,0xE9,0xA5,0x02,0x83,0xC2,0x02,0xEE,0x83,0xEA,0x02,0xF6,
+	0x44,0x2B,0x40,0x75,0x03,0xE9,0x89,0x02,0xB8,0x7F,0x00,0xE9,
+	0x9B,0x01,0x83,0xC2,0x02,0xEE,0x83,0xEA,0x02,0xF6,0x44,0x2B,
+	0x80,0x75,0xED,0xE9,0x73,0x02,0x83,0xC2,0x02,0xEE,0x83,0xEA,
+	0x02,0xF7,0x44,0x30,0xFF,0xFF,0x74,0x03,0xFF,0x4C,0x30,0xF6,
+	0x44,0x2B,0x20,0x75,0x03,0xE9,0x59,0x02,0xB8,0x02,0x00,0xE9,
+	0x6B,0x01,0xB3,0x18,0x22,0x5C,0x2B,0x75,0x16,0x83,0xC2,0x02,
+	0xEE,0x83,0xEA,0x02,0x8B,0x44,0x30,0x05,0x08,0x00,0x25,0xF8,
+	0xFF,0x89,0x44,0x30,0xE9,0x36,0x02,0x80,0xFB,0x18,0x75,0x57,
+	0xB0,0x20,0x83,0xC2,0x02,0xEE,0x83,0xEA,0x02,0x8B,0x44,0x30,
+	0x8B,0xD8,0x05,0x08,0x00,0x25,0xF8,0xFF,0x89,0x44,0x30,0x2B,
+	0xC3,0x48,0x74,0x38,0x89,0x44,0x32,0x80,0x4C,0x50,0x40,0xC7,
+	0x44,0x02,0x8F,0x06,0xC7,0x04,0x8F,0x06,0xE9,0x02,0x02,0xFA,
+	0x8B,0x54,0x20,0xEC,0x8A,0xC8,0x22,0x44,0x52,0x3A,0x44,0x53,
+	0x75,0x16,0xB0,0x20,0x83,0xC2,0x02,0xEE,0x83,0xEA,0x02,0xFF,
+	0x4C,0x32,0x75,0x08,0x80,0x64,0x50,0xBF,0xC7,0x04,0x03,0x05,
+	0xE9,0xDA,0x01,0x83,0xC2,0x02,0xEE,0x83,0xEA,0x02,0x80,0xFB,
+	0x08,0x75,0x18,0x8B,0x44,0x30,0x8B,0xD8,0x05,0x08,0x00,0x25,
+	0xF8,0xFF,0x89,0x44,0x30,0x2B,0xC3,0x3D,0x05,0x00,0x7C,0xDC,
+	0xE9,0xCE,0x00,0x8B,0x44,0x30,0x8B,0xD8,0x05,0x08,0x00,0x25,
+	0xF8,0xFF,0x89,0x44,0x30,0xB8,0x02,0x00,0xE9,0xBA,0x00,0xF6,
+	0x44,0x2A,0x20,0x75,0x43,0xF6,0x44,0x2A,0x04,0x74,0x42,0xF6,
+	0x44,0x2A,0x10,0x74,0x07,0xF7,0x44,0x30,0xFF,0xFF,0x74,0x30,
+	0xB0,0x0D,0x83,0xC2,0x02,0xEE,0x83,0xEA,0x02,0x80,0x4C,0x50,
+	0x40,0xC7,0x04,0x21,0x07,0xC7,0x44,0x02,0x21,0x07,0xE9,0x70,
+	0x01,0xFA,0x8B,0x54,0x20,0xEC,0x8A,0xC8,0x22,0x44,0x52,0x3A,
+	0x44,0x53,0x75,0x1C,0x80,0x64,0x50,0xBF,0xC7,0x04,0x03,0x05,
+	0xB0,0x0A,0xEB,0x2B,0x90,0xB0,0x0A,0x83,0xC2,0x02,0xEE,0x83,
+	0xEA,0x02,0xF6,0x44,0x2B,0x01,0x75,0x03,0xE9,0x42,0x01,0xB8,
+	0x05,0x00,0xEB,0x55,0x90,0xF6,0x44,0x2A,0x08,0x75,0xE2,0xF6,
+	0x44,0x2A,0x10,0x74,0x06,0x83,0x7C,0x30,0x00,0x74,0x13,0x83,
+	0xC2,0x02,0xEE,0x83,0xEA,0x02,0xB3,0x06,0x22,0x5C,0x2B,0x75,
+	0x08,0xC7,0x44,0x30,0x00,0x00,0xE9,0x14,0x01,0x80,0xFB,0x02,
+	0x75,0x14,0x8B,0x44,0x30,0xC1,0xE8,0x04,0x05,0x03,0x00,0x3D,
+	0x06,0x00,0x72,0x14,0xB8,0x06,0x00,0xEB,0x0F,0x90,0x80,0xFB,
+	0x04,0x75,0x06,0xB8,0x05,0x00,0xEB,0x04,0x90,0xB8,0x09,0x00,
+	0xC7,0x44,0x30,0x00,0x00,0xF6,0x44,0x2A,0x40,0x74,0x45,0x3D,
+	0x20,0x00,0x77,0x40,0xBB,0x01,0x00,0x3D,0x03,0x00,0x7E,0x03,
+	0xBB,0x02,0x00,0x89,0x5C,0x32,0x80,0x4C,0x50,0x40,0xC7,0x44,
+	0x02,0xD2,0x07,0xC7,0x04,0xD2,0x07,0xE9,0xBF,0x00,0xFA,0x8B,
+	0x54,0x20,0xEC,0x8A,0xC8,0x22,0x44,0x52,0x3A,0x44,0x53,0x75,
+	0x10,0x8A,0x44,0x60,0x83,0xC2,0x02,0xEE,0x83,0xEA,0x02,0x83,
+	0x6C,0x32,0x01,0x7E,0x50,0xE9,0x9D,0x00,0x05,0x06,0x00,0x03,
+	0xC0,0x89,0x44,0x32,0x80,0x4C,0x50,0x40,0xC7,0x44,0x02,0x0C,
+	0x08,0xC7,0x04,0x0C,0x08,0xE9,0x85,0x00,0xFA,0x8B,0x54,0x20,
+	0xEC,0x8A,0xC8,0xB0,0x01,0xEE,0x90,0x90,0x90,0xEC,0xA8,0x01,
+	0x74,0x0F,0xA1,0x00,0x0E,0x01,0x44,0x32,0xC7,0x44,0x02,0x30,
+	0x08,0xC7,0x04,0x30,0x08,0xEB,0x62,0x90,0x8B,0x54,0x20,0xEC,
+	0x8A,0xC8,0xA1,0x00,0x0E,0x2B,0x44,0x32,0x3D,0xE8,0x03,0x77,
+	0xEC,0x80,0x64,0x50,0xBF,0xC7,0x04,0x03,0x05,0xEB,0x46,0x90,
+	0xB0,0x01,0xEE,0x90,0x90,0x90,0xEC,0xA8,0x01,0x74,0x3A,0x80,
+	0x64,0x50,0xEF,0x80,0x64,0x4B,0xEF,0xC7,0x04,0xB3,0x08,0xEB,
+	0x2C,0x90,0xFA,0x8B,0x54,0x20,0xEC,0x8A,0xC8,0x22,0x44,0x52,
+	0x3A,0x44,0x53,0x75,0x1C,0x8B,0x7C,0x0C,0x3B,0x7C,0x0A,0x74,
+	0xCF,0x8E,0x44,0x08,0x26,0x8A,0x05,0x47,0x23,0x7C,0x0E,0x89,
+	0x7C,0x0C,0x83,0xC2,0x02,0xEE,0x83,0xEA,0x02,0xF6,0xC1,0x01,
+	0x75,0x26,0xFB,0x81,0xC6,0x80,0x00,0xFF,0x24,0xFF,0x44,0x30,
+	0x83,0xC2,0x02,0xEE,0x83,0xEA,0x02,0xF6,0xC1,0x01,0x75,0x10,
+	0xFB,0x81,0xC6,0x80,0x00,0xFF,0x24,0xFA,0x8B,0x54,0x20,0xEC,
+	0xA8,0x01,0x74,0xDA,0xC6,0x44,0x49,0x02,0x8B,0x7C,0x12,0x8E,
+	0x44,0x10,0xB0,0x01,0xEE,0x90,0x90,0x90,0xEC,0x8A,0xE0,0x90,
+	0xB0,0x30,0xEE,0x83,0xC2,0x02,0x90,0xEC,0x83,0xEA,0x02,0x23,
+	0x44,0x34,0xFF,0x64,0x06,0xB3,0x1C,0x22,0x5C,0x51,0x75,0x1A,
+	0xF6,0x44,0x29,0x04,0x74,0x21,0xF6,0x44,0x29,0x20,0x75,0x2B,
+	0x80,0x7C,0x5E,0x00,0x75,0x1D,0xC7,0x44,0x06,0x58,0x0A,0xE9,
+	0x56,0x01,0xF6,0xC3,0x10,0x75,0x2E,0xF6,0xC3,0x04,0x75,0x74,
+	0xEB,0x6B,0x90,0xC7,0x44,0x06,0x62,0x0A,0xE9,0x4B,0x01,0xC7,
+	0x44,0x06,0x53,0x0A,0xE9,0x34,0x01,0x80,0x7C,0x5E,0x00,0x75,
+	0x08,0xC7,0x44,0x06,0xCA,0x09,0xE9,0x9D,0x00,0xC7,0x44,0x06,
+	0xC5,0x09,0xE9,0x90,0x00,0x0A,0xC0,0x74,0x2A,0xFE,0x4C,0x63,
+	0x74,0x1A,0x80,0xE3,0xEF,0x75,0xC4,0xF6,0x44,0x29,0x04,0x74,
+	0x21,0xF6,0x44,0x29,0x20,0x75,0x21,0x80,0x7C,0x5E,0x00,0x75,
+	0x18,0xE9,0x00,0x01,0x80,0x64,0x51,0xEF,0x80,0xE3,0xEF,0x75,
+	0xA6,0xEB,0x85,0x80,0x64,0x51,0xEF,0xE9,0x06,0x01,0xE9,0xF5,
+	0x00,0xE9,0xE3,0x00,0x80,0x7C,0x5E,0x00,0x75,0x4F,0xEB,0x52,
+	0x90,0x80,0x64,0x51,0xF7,0xE9,0xE2,0x00,0x80,0x64,0x53,0x3F,
+	0x80,0x64,0x54,0xFE,0x80,0x4C,0x58,0x01,0x80,0x64,0x51,0xFB,
+	0xF6,0x44,0x29,0x40,0x75,0x2C,0x3A,0x44,0x5D,0x74,0x27,0x3A,
+	0x44,0x5C,0x74,0x22,0xF6,0x44,0x29,0x20,0x74,0x0A,0x3A,0x44,
+	0x5A,0x74,0x17,0x3A,0x44,0x5B,0x74,0x12,0xF6,0x44,0x5E,0xFF,
+	0x74,0x09,0x3A,0x44,0x5E,0x75,0x04,0x80,0x4C,0x51,0x08,0xE9,
+	0xA0,0x00,0xE9,0xAB,0x00,0x3A,0x44,0x5E,0x74,0x7D,0x3A,0x44,
+	0x5C,0x74,0x3D,0x3A,0x44,0x5D,0x74,0x55,0x3A,0x44,0x5A,0x74,
+	0x08,0x3A,0x44,0x5B,0x74,0x18,0xE9,0x81,0x00,0xF6,0x44,0x53,
+	0x40,0x74,0x07,0x80,0x64,0x53,0xBF,0xE9,0x82,0x00,0x3A,0x44,
+	0x5B,0x74,0x03,0xEB,0x7B,0x90,0x80,0x4C,0x53,0x40,0xF6,0x44,
+	0x29,0x08,0x74,0x70,0x80,0x4C,0x51,0x04,0xC7,0x44,0x06,0xE1,
+	0x08,0xEB,0x65,0x90,0xF6,0x44,0x53,0x80,0x74,0x0F,0x80,0x64,
+	0x53,0x7F,0x80,0x64,0x54,0xFE,0x80,0x4C,0x58,0x01,0xEB,0x50,
+	0x90,0x3A,0x44,0x5D,0x74,0x03,0xEB,0x48,0x90,0x80,0x4C,0x53,
+	0x80,0x80,0x4C,0x54,0x01,0x80,0x4C,0x58,0x01,0xF6,0x44,0x29,
+	0x08,0x74,0x35,0x80,0x4C,0x51,0x04,0xC7,0x44,0x06,0xE1,0x08,
+	0xEB,0x2A,0x90,0x80,0x4C,0x51,0x08,0xC7,0x44,0x06,0xE1,0x08,
+	0xEB,0x10,0x90,0x3A,0x44,0x5E,0x74,0xEF,0x3A,0x44,0x5C,0x74,
+	0xAF,0x3A,0x44,0x5D,0x74,0xC7,0x3D,0xFF,0x00,0x73,0x26,0xAA,
+	0x23,0x7C,0x16,0x3B,0x7C,0x14,0x74,0x4F,0xEC,0xA8,0x01,0x74,
+	0x03,0xE9,0x4E,0xFE,0x89,0x7C,0x12,0x2B,0x7C,0x14,0x23,0x7C,
+	0x16,0x3B,0x7C,0x1C,0x73,0x46,0xFB,0x81,0xC6,0x80,0x00,0xFF,
+	0x24,0x0A,0xE4,0x75,0x1E,0xB3,0x0C,0x22,0x5C,0x28,0x80,0xFB,
+	0x08,0x75,0xCC,0xAA,0x23,0x7C,0x16,0x3B,0x7C,0x14,0x74,0x1B,
+	0xAA,0x23,0x7C,0x16,0x3B,0x7C,0x14,0x74,0x12,0xEB,0xC1,0xF6,
+	0x44,0x28,0x04,0x75,0xBB,0xF6,0x44,0x28,0x08,0x75,0x50,0x32,
+	0xC0,0xEB,0xA8,0x4F,0x23,0x7C,0x16,0x89,0x7C,0x12,0xC6,0x44,
+	0x59,0x01,0xEB,0xA4,0xF6,0x44,0x51,0x02,0x74,0x07,0xFB,0x81,
+	0xC6,0x80,0x00,0xFF,0x24,0x80,0x4C,0x51,0x02,0xB0,0x05,0xEE,
+	0xB0,0x82,0x22,0x44,0x5F,0xF6,0xD0,0x22,0x44,0x75,0x88,0x44,
+	0x75,0xEE,0xF6,0x44,0x29,0x10,0x74,0x10,0x80,0x4C,0x54,0x04,
+	0x80,0x4C,0x58,0x04,0x80,0x74,0x50,0x08,0xC7,0x04,0xC3,0x03,
+	0xFB,0x81,0xC6,0x80,0x00,0xFF,0x24,0x26,0xC6,0x05,0xFF,0x47,
+	0x23,0x7C,0x16,0x3B,0x7C,0x14,0x74,0xA7,0x32,0xFF,0xF6,0x44,
+	0x29,0x80,0x74,0x0A,0x8A,0xDC,0xC0,0xEB,0x04,0x2E,0x8A,0xBF,
+	0xB1,0x01,0x26,0x88,0x3D,0x47,0x23,0x7C,0x16,0x3B,0x7C,0x14,
+	0x74,0x89,0xAA,0x23,0x7C,0x16,0x3B,0x7C,0x14,0x74,0x80,0xE9,
+	0x2E,0xFF,0x1E,0x2E,0x8E,0x1E,0xC1,0x03,0xFF,0x06,0x1C,0x0E,
+	0x60,0xBE,0x00,0x14,0xEB,0x0F,0x90,0x1E,0x2E,0x8E,0x1E,0xC1,
+	0x03,0xFF,0x06,0x1A,0x0E,0x60,0xBE,0x00,0x10,0xB9,0x08,0x00,
+	0x8B,0x54,0x20,0xB0,0x03,0xEE,0x90,0x90,0x32,0xFF,0xEC,0x8A,
+	0xD8,0x02,0xD8,0x2E,0xFF,0xA7,0xA9,0x00,0x81,0xC6,0x00,0x01,
+	0x8B,0x54,0x20,0x0B,0xD2,0xE0,0xE4,0xB8,0x00,0x80,0xBA,0x22,
+	0xFF,0xEF,0x61,0x1F,0xCF,0x81,0xCE,0x80,0x00,0x8B,0x54,0x20,
+	0xFF,0x06,0x20,0x0E,0xB0,0x01,0xEE,0x8A,0x44,0x71,0x24,0xE7,
+	0x88,0x44,0x71,0xEE,0xC6,0x44,0x49,0x02,0x80,0x4C,0x50,0x20,
+	0xC7,0x04,0xC3,0x03,0x81,0xE6,0x7F,0xFF,0x8B,0x54,0x20,0xEB,
+	0xAE,0x81,0xCE,0x80,0x00,0x8B,0x54,0x20,0xFF,0x06,0x22,0x0E,
+	0xEC,0x0A,0xC0,0x79,0x7A,0x80,0x4C,0x51,0x10,0xC7,0x44,0x06,
+	0xE1,0x08,0xC6,0x44,0x63,0x04,0xF6,0x44,0x51,0x04,0x74,0x08,
+	0x80,0x64,0x51,0xFB,0x80,0x64,0x53,0x3F,0xF6,0x44,0x28,0x01,
+	0x75,0x59,0xF6,0x44,0x28,0x02,0x75,0x4F,0x8B,0x7C,0x12,0x8C,
+	0xC3,0x8E,0x44,0x10,0xF6,0x44,0x28,0x08,0x74,0x1E,0xB0,0xFF,
+	0xAA,0x23,0x7C,0x16,0x3B,0x7C,0x14,0x74,0x26,0x32,0xC0,0xF6,
+	0x44,0x29,0x80,0x74,0x02,0xB0,0x10,0xAA,0x23,0x7C,0x16,0x3B,
+	0x7C,0x14,0x74,0x13,0x32,0xC0,0xAA,0x23,0x7C,0x16,0x3B,0x7C,
+	0x14,0x74,0x08,0x8E,0xC3,0x89,0x7C,0x12,0xEB,0x15,0x90,0x8E,
+	0xC3,0x4F,0x23,0x7C,0x16,0x89,0x7C,0x12,0xC6,0x44,0x59,0x01,
+	0xEB,0x05,0x90,0x80,0x4C,0x4F,0x01,0xB0,0x10,0xEE,0x81,0xE6,
+	0x7F,0xFF,0x8B,0x54,0x20,0xE9,0x17,0xFF,0xFF,0x06,0x1E,0x0E,
+	0xE9,0x10,0xFF,0x1E,0x2E,0x8E,0x1E,0xC1,0x03,0x50,0x52,0x55,
+	0x8B,0xEC,0x8B,0x46,0x08,0xA3,0x12,0x0E,0x32,0xE4,0xA0,0x22,
+	0x0C,0xA3,0x10,0x0E,0xFF,0x06,0x00,0x0E,0x83,0x06,0x0E,0x0E,
+	0x0A,0x83,0x3E,0x04,0x0E,0x00,0x74,0x31,0x8B,0x16,0x00,0x0E,
+	0x2B,0x16,0x02,0x0E,0x3B,0x16,0x04,0x0E,0x72,0x23,0x8B,0x16,
+	0x00,0x0E,0x89,0x16,0x02,0x0E,0x8B,0x16,0x18,0x0D,0x3B,0x16,
+	0x1A,0x0D,0x74,0x11,0x80,0x3E,0x10,0x0C,0x01,0x74,0x16,0xB0,
+	0x00,0x90,0xE6,0x00,0x0C,0x08,0x90,0xE6,0x00,0xB8,0x00,0x80,
+	0xBA,0x22,0xFF,0xEF,0x5D,0x5A,0x58,0x1F,0xCF,0xB0,0x80,0xE6,
+	0x00,0xA0,0x11,0x0C,0x0C,0x10,0xA2,0x11,0x0C,0xEB,0xE6,0x1E,
+	0x2E,0x8E,0x1E,0xC1,0x03,0xFF,0x06,0x28,0x0E,0x55,0x8B,0xEC,
+	0x8B,0x6E,0x02,0x89,0x2E,0x16,0x0E,0x5D,0x1F,0xCF,0x1E,0x2E,
+	0x8E,0x1E,0xC1,0x03,0xFF,0x06,0x24,0x0E,0x55,0x8B,0xEC,0x8B,
+	0x6E,0x02,0x89,0x2E,0x14,0x0E,0x5D,0x80,0x3E,0x10,0x0C,0x01,
+	0x75,0x12,0x50,0xA0,0x11,0x0C,0x0C,0x01,0xA2,0x11,0x0C,0xE4,
+	0x00,0x90,0x90,0x24,0x7F,0xE6,0x00,0x58,0x1F,0xCF,0x1E,0x06,
+	0x60,0xB8,0x00,0x80,0xBA,0x22,0xFF,0xEF,0x2E,0x8E,0x1E,0xC1,
+	0x03,0x2E,0x8E,0x06,0xC1,0x03,0x2E,0xFF,0x06,0x30,0x0D,0xFC,
+	0xFF,0x26,0x2E,0x0E,0x00,0x00,0xFB,0x40,0x43,0x41,0x42,0x46,
+	0x47,0x45,0xEB,0xF6,0xC3,0x00,0x00,0x8F,0x06,0x2E,0x0E,0x2E,
+	0xFF,0x06,0x3D,0x0D,0xB8,0x00,0x00,0xBA,0x58,0xFF,0xEF,0xB8,
+	0x00,0xE0,0xBA,0x5E,0xFF,0xEF,0x61,0x07,0x1F,0xCF,0xC2,0xFE,
+	0xFF,0x8B,0x7C,0x0A,0x2B,0x7C,0x0C,0x23,0x7C,0x0E,0x3B,0x7C,
+	0x18,0x77,0x2E,0xC6,0x44,0x4D,0x00,0x80,0x4C,0x4F,0x02,0xEB,
+	0x5A,0x90,0x8B,0x7C,0x0A,0x3B,0x7C,0x0C,0x75,0x1B,0x8B,0x3E,
+	0x10,0x0D,0x3B,0x3E,0x12,0x0D,0x75,0x53,0xF6,0x44,0x4B,0xFF,
+	0x75,0x4D,0xC6,0x44,0x4C,0x00,0x80,0x4C,0x4F,0x04,0xEB,0x43,
+	0x90,0xF6,0x44,0x50,0x10,0x75,0x3C,0xEB,0x09,0x90,0x8B,0x7C,
+	0x0A,0x2B,0x7C,0x0C,0x74,0x31,0x80,0x4C,0x50,0x10,0x80,0x4C,
+	0x4B,0x10,0xC7,0x04,0xC3,0x03,0xEB,0x23,0x90,0xFA,0x8B,0x36,
+	0x08,0x0E,0x8B,0x54,0x20,0xEC,0x8A,0xF8,0x8A,0x5C,0x54,0x32,
+	0xFB,0xF6,0x44,0x4D,0xFF,0x75,0x8E,0xF6,0x44,0x4C,0xFF,0x75,
+	0xA1,0xF6,0x44,0x50,0x10,0x74,0xC7,0xEC,0x32,0xC3,0x22,0xF8,
+	0x83,0x2E,0x10,0x0E,0x01,0x78,0x05,0xD0,0x6C,0x49,0x72,0x45,
+	0x8B,0x7C,0x12,0x2B,0x7C,0x14,0x74,0x22,0x80,0x7C,0x4E,0x00,
+	0x74,0x1C,0x23,0x7C,0x16,0x03,0xFF,0x3B,0x7C,0x16,0x73,0x43,
+	0x8B,0x0E,0x0E,0x0E,0x2B,0x4C,0x6E,0x3B,0x4C,0x22,0x73,0x37,
+	0x80,0x7C,0x49,0x00,0x74,0x31,0xF6,0x44,0x51,0x02,0x75,0x3C,
+	0xEC,0x32,0xC3,0x22,0xF8,0x80,0xE7,0x38,0xFB,0x89,0x1E,0x30,
+	0x0E,0xBE,0x00,0x10,0xFF,0x14,0xEB,0x61,0x90,0xB0,0x01,0xEE,
+	0x8A,0x44,0x71,0x0C,0x10,0x88,0x44,0x71,0xEE,0x80,0x64,0x50,
+	0xDF,0xC7,0x04,0xC3,0x03,0xEB,0xA5,0xC6,0x44,0x4E,0x00,0x8B,
+	0x0E,0x0E,0x0E,0x89,0x4C,0x6E,0x80,0x4C,0x4F,0x08,0xEB,0xBE,
+	0x8B,0x7C,0x12,0x2B,0x7C,0x14,0x23,0x7C,0x16,0x3B,0x7C,0x1A,
+	0x73,0xB6,0x80,0x64,0x51,0xFD,0xF6,0x44,0x29,0x10,0x74,0x10,
+	0x80,0x64,0x54,0xFB,0x80,0x4C,0x58,0x04,0x80,0x74,0x50,0x08,
+	0xC7,0x04,0xC3,0x03,0xB0,0x05,0xEE,0xB0,0x82,0x22,0x44,0x5F,
+	0x0A,0x44,0x75,0x88,0x44,0x75,0xEE,0xEB,0x8B,0xFA,0x8B,0x36,
+	0x08,0x0E,0x8B,0x1E,0x30,0x0E,0x8A,0xCB,0xE5,0x80,0x23,0x44,
+	0x2E,0x74,0x02,0xF6,0xD1,0x80,0xE1,0x40,0x0A,0xF9,0x8A,0xDF,
+	0x22,0x5C,0x55,0x30,0x5C,0x54,0x32,0xFB,0x88,0x7C,0x55,0x0A,
+	0x5C,0x58,0x88,0x5C,0x58,0x22,0x5C,0x56,0x75,0x24,0x80,0x7C,
+	0x4F,0x00,0x75,0x22,0xFB,0x03,0x74,0x1E,0x89,0x36,0x08,0x0E,
+	0xFF,0x06,0x26,0x0E,0x8B,0x3E,0x12,0x0D,0x3B,0x3E,0x10,0x0D,
+	0x75,0x46,0xBE,0x00,0x10,0xFF,0x14,0xE9,0xD3,0xFE,0x80,0x4C,
+	0x4F,0x20,0x8B,0x3E,0x18,0x0D,0x8A,0x44,0x48,0x8A,0x64,0x4F,
+	0x89,0x85,0x00,0x08,0x8A,0x44,0x54,0x8A,0x64,0x57,0x89,0x85,
+	0x02,0x08,0x83,0xC7,0x04,0x81,0xE7,0xFC,0x03,0x3B,0x3E,0x1A,
+	0x0D,0x74,0x13,0x88,0x44,0x57,0xC6,0x44,0x4F,0x00,0x8A,0x44,
+	0x56,0xF6,0xD0,0x20,0x44,0x58,0x89,0x3E,0x18,0x0D,0xEB,0xA4,
+	0xFF,0x06,0x2C,0x0E,0xBE,0x00,0x10,0xFF,0x14,0xFA,0x8B,0x3E,
+	0x12,0x0D,0x81,0xC7,0x00,0x04,0x8A,0x5D,0x01,0x83,0xE3,0x0F,
+	0x03,0xDB,0x2E,0x8B,0xB7,0x89,0x00,0x8B,0x54,0x20,0x0B,0xD2,
+	0x74,0x0D,0x8A,0x1D,0x83,0xE3,0x1F,0x03,0xDB,0xFA,0x2E,0xFF,
+	0xA7,0x9C,0x0F,0xFF,0x06,0x2A,0x0E,0x8B,0x3E,0x12,0x0D,0x8B,
+	0x36,0x18,0x0D,0x8B,0x9D,0x00,0x04,0x89,0x9C,0x00,0x08,0x8B,
+	0x9D,0x02,0x04,0x89,0x9C,0x02,0x08,0x83,0xC6,0x04,0x81,0xE6,
+	0xFC,0x03,0x3B,0x36,0x1A,0x0D,0x74,0x04,0x89,0x36,0x18,0x0D,
+	0xFB,0x8B,0x3E,0x12,0x0D,0x83,0xC7,0x04,0x81,0xE7,0xFC,0x03,
+	0x89,0x3E,0x12,0x0D,0xBE,0x00,0x10,0xFF,0x14,0xE9,0x1D,0xFE,
+	0xDC,0x0F,0xE4,0x0F,0xEC,0x0F,0x0D,0x10,0x1C,0x10,0x57,0x0F,
+	0x2F,0x10,0x57,0x0F,0x3B,0x10,0x54,0x10,0x83,0x10,0xCF,0x10,
+	0xDB,0x10,0xE4,0x10,0xEB,0x10,0x35,0x11,0x7D,0x11,0x83,0x11,
+	0xA1,0x11,0xB9,0x11,0xF2,0x11,0x38,0x12,0x03,0x13,0x0C,0x13,
+	0x57,0x0F,0x57,0x0F,0x57,0x0F,0x57,0x0F,0x57,0x0F,0x57,0x0F,
+	0x57,0x0F,0x57,0x0F,0x8B,0x45,0x02,0x89,0x44,0x1A,0xEB,0xA0,
+	0x8B,0x45,0x02,0x89,0x44,0x1C,0xEB,0x98,0x8B,0x45,0x02,0x8B,
+	0x5C,0x0A,0x2B,0x5C,0x0C,0x23,0x5C,0x0E,0x8B,0x4C,0x0A,0x2B,
+	0xC8,0x23,0x4C,0x0E,0x3B,0xD9,0x76,0x06,0x23,0x44,0x0E,0x89,
+	0x44,0x0C,0xE9,0x77,0xFF,0x80,0x4C,0x53,0x80,0x80,0x4C,0x54,
+	0x01,0x80,0x4C,0x58,0x01,0xE9,0x68,0xFF,0x80,0x64,0x53,0x3F,
+	0x80,0x64,0x54,0xFE,0x80,0x4C,0x58,0x01,0x80,0x64,0x51,0xFB,
+	0xE9,0x55,0xFF,0x8B,0x45,0x02,0x88,0x44,0x5A,0x88,0x64,0x5B,
+	0xE9,0x49,0xFF,0x8B,0x45,0x02,0x0B,0xC0,0x74,0x03,0x89,0x44,
+	0x24,0x80,0x4C,0x50,0x04,0x80,0x4C,0x4B,0x04,0xC7,0x04,0xC3,
+	0x03,0xE9,0x30,0xFF,0x8B,0x5D,0x02,0xF6,0xD7,0x22,0x7C,0x54,
+	0x0A,0xDF,0x8A,0x44,0x54,0x32,0xC3,0x24,0x82,0x30,0x44,0x54,
+	0xB0,0x05,0xEE,0x8A,0x44,0x75,0x32,0xD8,0x8A,0x7C,0x5F,0xF6,
+	0xD7,0x22,0xDF,0x80,0xE3,0x82,0x32,0xC3,0x88,0x44,0x75,0xEE,
+	0xE9,0x01,0xFF,0x8B,0x5D,0x02,0xF6,0xC7,0x04,0x75,0x08,0x80,
+	0x64,0x53,0x3F,0x80,0x64,0x51,0xFB,0x8A,0x44,0x29,0x32,0xC7,
+	0xA8,0x10,0x74,0x0E,0xF6,0x44,0x51,0x02,0x74,0x08,0x80,0x74,
+	0x50,0x08,0xC7,0x04,0xC3,0x03,0x88,0x5C,0x28,0x88,0x7C,0x29,
+	0xB4,0x60,0xF6,0xC3,0x10,0x74,0x03,0x80,0xCC,0x10,0x8A,0x44,
+	0x62,0xF6,0xC3,0x20,0x74,0x02,0x24,0x7F,0x89,0x44,0x34,0xC7,
+	0x44,0x06,0xE1,0x08,0xE9,0xB5,0xFE,0x8B,0x45,0x02,0x88,0x44,
+	0x5C,0x88,0x64,0x5D,0xE9,0xA9,0xFE,0x8B,0x45,0x02,0x89,0x44,
+	0x18,0xE9,0xA0,0xFE,0xFF,0x1E,0x24,0x0D,0xE9,0x99,0xFE,0xF6,
+	0x44,0x51,0x02,0x75,0x41,0x8B,0x44,0x12,0x2B,0x44,0x14,0x23,
+	0x44,0x16,0x3B,0x44,0x1A,0x72,0x33,0x80,0x4C,0x51,0x02,0xF6,
+	0x44,0x29,0x10,0x74,0x10,0x80,0x4C,0x54,0x04,0x80,0x4C,0x58,
+	0x04,0x80,0x74,0x50,0x08,0xC7,0x04,0xC3,0x03,0xF6,0x44,0x5F,
+	0x82,0x74,0x13,0xB0,0x05,0xEE,0x8A,0x44,0x75,0xB4,0x82,0x22,
+	0x64,0x5F,0xF6,0xD4,0x22,0xC4,0x88,0x44,0x75,0xEE,0xE9,0x4F,
+	0xFE,0xF6,0x44,0x51,0x02,0x74,0x3F,0x8B,0x44,0x12,0x2B,0x44,
+	0x14,0x23,0x44,0x16,0x3B,0x44,0x1C,0x73,0xE9,0x80,0x64,0x51,
+	0xFD,0xF6,0x44,0x29,0x10,0x74,0x10,0x80,0x64,0x54,0xFB,0x80,
+	0x4C,0x58,0x04,0x80,0x74,0x50,0x08,0xC7,0x04,0xC3,0x03,0xF6,
+	0x44,0x5F,0x02,0x74,0x11,0xB0,0x05,0xEE,0x8A,0x44,0x75,0xB4,
+	0x82,0x22,0x64,0x5F,0x0A,0xC4,0x88,0x44,0x75,0xEE,0xE9,0x07,
+	0xFE,0xE8,0x8A,0x02,0xE9,0x01,0xFE,0x8B,0x45,0x02,0xBB,0x10,
+	0x27,0xF7,0xE3,0xBB,0x0F,0x00,0xF7,0xF3,0xA3,0x06,0x0E,0xBA,
+	0x52,0xFF,0xEF,0xBA,0x50,0xFF,0xB8,0x00,0x00,0xEF,0xE9,0xE3,
+	0xFD,0x8B,0x45,0x02,0x3A,0x06,0x22,0x0C,0x72,0x0C,0x3B,0x06,
+	0x1A,0x0C,0x77,0x06,0xE8,0xAB,0x01,0xE9,0xCE,0xFD,0xE9,0x9E,
+	0xFD,0x8B,0x45,0x02,0x88,0x44,0x2A,0x88,0x64,0x2B,0x0B,0xC0,
+	0x75,0x07,0x80,0x64,0x50,0xFE,0xEB,0x10,0x90,0xF6,0x44,0x50,
+	0x01,0x75,0x09,0x80,0x4C,0x50,0x01,0xC7,0x44,0x30,0x00,0x00,
+	0xA8,0x80,0x75,0x07,0xC6,0x44,0x60,0x00,0xEB,0x05,0x90,0xC6,
+	0x44,0x60,0x7F,0xC7,0x04,0xC3,0x03,0xE9,0x92,0xFD,0x8B,0x5D,
+	0x02,0xF6,0xD7,0x22,0x7C,0x5F,0x0A,0xDF,0x8A,0xFB,0x88,0x5C,
+	0x5F,0x8A,0x44,0x52,0x8A,0x64,0x53,0x8B,0xCB,0x33,0xC8,0x81,
+	0xE1,0x38,0x38,0x33,0xC1,0x88,0x44,0x52,0x88,0x64,0x53,0xB0,
+	0x05,0xEE,0xF6,0xD3,0x22,0x5C,0x54,0xF6,0x44,0x51,0x02,0x75,
+	0x02,0x0A,0xDF,0x8A,0x44,0x75,0x32,0xD8,0x80,0xE3,0x82,0x32,
+	0xC3,0x88,0x44,0x75,0xEE,0xE9,0x4C,0xFD,0x8B,0x5D,0x02,0x88,
+	0x5C,0x2C,0x88,0x7C,0x2D,0x8B,0xCB,0x83,0xE3,0x0F,0x03,0xDB,
+	0x80,0x3E,0x10,0x0C,0x01,0x75,0x1F,0xA1,0x0E,0x0C,0x86,0xE0,
+	0x3D,0x32,0x31,0x73,0x15,0xF6,0xC5,0x04,0x75,0x08,0x2E,0x8B,
+	0x9F,0x69,0x01,0xEB,0x1B,0x90,0x2E,0x8B,0x9F,0x89,0x01,0xEB,
+	0x13,0x90,0xF6,0xC5,0x04,0x75,0x08,0x2E,0x8B,0x9F,0x29,0x01,
+	0xEB,0x06,0x90,0x2E,0x8B,0x9F,0x49,0x01,0xB0,0x0C,0xEE,0x8A,
+	0xC3,0x88,0x44,0x7C,0xEE,0xB0,0x0D,0x90,0x90,0xEE,0x8A,0xC7,
+	0x88,0x44,0x7D,0xEE,0xB0,0x04,0xEE,0xB0,0x44,0xF6,0xC1,0x40,
+	0x74,0x0C,0xF6,0xC1,0x80,0x74,0x05,0x04,0x04,0xEB,0x03,0x90,
+	0x0C,0x08,0xF6,0xC5,0x01,0x74,0x09,0x0C,0x01,0xF6,0xC5,0x02,
+	0x75,0x02,0x0C,0x02,0x88,0x44,0x74,0xEE,0xB0,0x03,0x90,0x90,
+	0xEE,0x8A,0xD9,0x80,0xE3,0x30,0xC0,0xEB,0x04,0x32,0xFF,0x2E,
+	0x8A,0xA7,0xA9,0x01,0x8A,0x44,0x73,0x24,0x3F,0x0A,0xC4,0x88,
+	0x44,0x73,0xEE,0x90,0x90,0xB0,0x05,0xEE,0xD0,0xEC,0x8A,0x44,
+	0x75,0x24,0x9F,0x0A,0xC4,0x88,0x44,0x75,0xEE,0x2E,0x8A,0x87,
+	0xAD,0x01,0x88,0x44,0x62,0xF6,0x44,0x28,0x20,0x74,0x02,0x24,
+	0x7F,0x88,0x44,0x34,0xE9,0x81,0xFC,0x8A,0x45,0x02,0x88,0x44,
+	0x5E,0xE9,0x78,0xFC,0x8B,0x45,0x02,0xBA,0x5A,0xFF,0xEF,0x9C,
+	0xFF,0x36,0x26,0x0D,0xFF,0x36,0x24,0x0D,0x1E,0x06,0x60,0x8B,
+	0x36,0x0A,0x0E,0xC7,0x04,0x3F,0x0D,0xE9,0x5A,0xFC,0xB8,0x00,
+	0x00,0x8E,0xC0,0x8B,0xF0,0x8B,0xF8,0x2E,0x8B,0x9C,0x49,0x00,
+	0x83,0xC6,0x02,0x26,0x89,0x1D,0x26,0x8C,0x4D,0x02,0x83,0xC7,
+	0x04,0x81,0xFF,0x80,0x00,0x72,0xE8,0x26,0xC7,0x05,0xCB,0x0C,
+	0x26,0x8C,0x4D,0x02,0x83,0xC7,0x04,0x81,0xFF,0x00,0x04,0x72,
+	0xEE,0xC3,0xC1,0xE0,0x06,0x8B,0xD8,0x8C,0xDA,0x81,0xC2,0x00,
+	0x04,0x8B,0xFA,0x8A,0x0E,0x22,0x0C,0xB5,0x00,0xBE,0x00,0x10,
+	0x33,0xC0,0x89,0x44,0x0A,0x89,0x44,0x0C,0x89,0x44,0x12,0x89,
+	0x44,0x14,0x81,0xC6,0x80,0x00,0xE2,0xEE,0x89,0x36,0x0A,0x0E,
+	0xB8,0x01,0x00,0x8B,0xD0,0xB3,0x00,0x8A,0x0E,0x22,0x0C,0xB5,
+	0x00,0xBE,0x00,0x10,0x2B,0xDA,0x72,0x29,0x89,0x44,0x16,0x81,
+	0xC6,0x80,0x00,0xE2,0xF3,0x8A,0x0E,0x22,0x0C,0xB5,0x00,0xBE,
+	0x00,0x10,0x2B,0xDA,0x72,0x13,0x89,0x44,0x0E,0x81,0xC6,0x80,
+	0x00,0xE2,0xF3,0x8B,0xD0,0x03,0xC0,0x81,0xFA,0x00,0x02,0x72,
+	0xCA,0x8A,0x0E,0x22,0x0C,0xB5,0x00,0xBE,0x00,0x10,0x89,0x7C,
+	0x10,0x8B,0x44,0x16,0x03,0xF8,0x8B,0xD7,0xC1,0xE0,0x04,0x48,
+	0x89,0x44,0x16,0x81,0xC6,0x80,0x00,0xE2,0xE9,0x8A,0x0E,0x22,
+	0x0C,0xB5,0x00,0xBE,0x00,0x10,0x89,0x7C,0x08,0x8B,0x44,0x0E,
+	0x03,0xF8,0x8B,0xD7,0xC1,0xE0,0x04,0x48,0x89,0x44,0x0E,0x81,
+	0xC6,0x80,0x00,0xE2,0xE9,0xC3,0xC7,0x04,0x20,0x04,0xC7,0x44,
+	0x06,0xE1,0x08,0x8B,0xC6,0x2D,0x00,0x10,0xB1,0x80,0xF6,0xF1,
+	0x88,0x44,0x48,0xC7,0x44,0x0A,0x00,0x00,0xC7,0x44,0x0C,0x00,
+	0x00,0xC7,0x44,0x12,0x00,0x00,0xC7,0x44,0x14,0x00,0x00,0xC7,
+	0x44,0x18,0x00,0x00,0xC7,0x44,0x1A,0x00,0x00,0xC7,0x44,0x1C,
+	0xFF,0xFF,0x8A,0x5C,0x48,0x83,0xE3,0x0F,0x03,0xDB,0x8B,0x97,
+	0x90,0x0C,0x89,0x54,0x20,0xB8,0x01,0x00,0x8A,0x4C,0x48,0xD3,
+	0xE0,0x89,0x44,0x2E,0xC7,0x44,0x24,0x19,0x00,0xC7,0x44,0x26,
+	0x00,0x00,0xC6,0x44,0x4A,0x00,0xC7,0x44,0x30,0x00,0x00,0xC7,
+	0x44,0x32,0x00,0x00,0xC6,0x44,0x4C,0x00,0xC6,0x44,0x4D,0x00,
+	0xC6,0x44,0x4E,0x00,0xC6,0x44,0x4F,0x00,0xC6,0x44,0x50,0x00,
+	0xC6,0x44,0x4B,0x00,0xC6,0x44,0x51,0x00,0xC6,0x44,0x28,0x00,
+	0xC6,0x44,0x29,0x00,0xC6,0x44,0x2A,0x00,0xC6,0x44,0x2B,0x00,
+	0xC6,0x44,0x54,0x00,0xC6,0x44,0x57,0x00,0xC6,0x44,0x55,0x00,
+	0xC6,0x44,0x56,0x00,0xC6,0x44,0x58,0x00,0xC6,0x44,0x52,0x04,
+	0xC6,0x44,0x53,0x04,0xC6,0x44,0x5F,0x00,0xC6,0x44,0x2C,0x3D,
+	0xC6,0x44,0x2D,0x00,0xC7,0x44,0x34,0xFF,0x60,0xC6,0x44,0x62,
+	0xFF,0xC6,0x44,0x5D,0x13,0xC6,0x44,0x5C,0x11,0xC6,0x44,0x5E,
+	0x00,0xC6,0x44,0x60,0x23,0xC6,0x44,0x61,0x23,0x0B,0xD2,0x75,
+	0x03,0xE9,0xD9,0x00,0xB0,0x09,0xEE,0x8A,0x4C,0x48,0xB0,0x80,
+	0xD2,0xE8,0xEE,0xC6,0x44,0x70,0x00,0xB0,0x01,0xEE,0xB0,0x11,
+	0x88,0x44,0x71,0xEE,0xB0,0x02,0x90,0x90,0xEE,0x8A,0x44,0x48,
+	0xC0,0xE0,0x03,0x24,0xF0,0x88,0x44,0x72,0xEE,0xB0,0x03,0x90,
+	0x90,0xEE,0xB0,0xC0,0x88,0x44,0x73,0xEE,0xB0,0x04,0x90,0x90,
+	0xEE,0xB0,0x44,0x88,0x44,0x74,0xEE,0xB0,0x05,0x90,0xEE,0xB0,
+	0x60,0x88,0x44,0x75,0xEE,0xC6,0x44,0x76,0x00,0xC6,0x44,0x77,
+	0x00,0xC6,0x44,0x78,0x00,0xB0,0x09,0xEE,0xB0,0x09,0x88,0x44,
+	0x79,0xEE,0xC6,0x44,0x7A,0x00,0xB0,0x0B,0xEE,0xB0,0x52,0x88,
+	0x44,0x7B,0xEE,0x80,0x3E,0x10,0x0C,0x01,0x75,0x21,0xA1,0x0E,
+	0x0C,0x86,0xE0,0x3D,0x32,0x31,0x73,0x17,0xB0,0x0C,0xEE,0xB0,
+	0x18,0x88,0x44,0x7C,0xEE,0xB0,0x0D,0x90,0x90,0xEE,0xB0,0x00,
+	0x88,0x44,0x7D,0xEE,0xEB,0x15,0x90,0xB0,0x0C,0xEE,0xB0,0x16,
+	0x88,0x44,0x7C,0xEE,0xB0,0x0D,0x90,0x90,0xEE,0xB0,0x00,0x88,
+	0x44,0x7D,0xEE,0xB0,0x0E,0x90,0x90,0xEE,0xB0,0x03,0x88,0x44,
+	0x7E,0xEE,0xB0,0x0F,0x90,0x90,0xEE,0xB0,0x80,0x88,0x44,0x7F,
+	0xEE,0xB0,0x03,0x90,0x90,0xEE,0x8A,0x44,0x73,0x0C,0x01,0x88,
+	0x44,0x73,0xEE,0x90,0x90,0xB0,0x05,0xEE,0x8A,0x44,0x75,0x0C,
+	0x08,0x88,0x44,0x75,0xEE,0xC3,0xFA,0x8C,0xD8,0x25,0x00,0xF0,
+	0x8E,0xD0,0xBC,0xFE,0x1F,0x8C,0xD8,0x25,0x00,0xF0,0x8E,0xD8,
+	0x80,0x3E,0x40,0x0D,0x01,0x75,0x51,0xA1,0x0E,0x0C,0x86,0xE0,
+	0x3D,0x30,0x32,0x73,0x47,0x8B,0x1E,0x20,0x0C,0x8A,0x16,0x23,
+	0x0C,0xC6,0x06,0x23,0x0C,0x00,0x83,0xFB,0x00,0x74,0x07,0xFE,
+	0xCA,0xC6,0x06,0x23,0x0C,0x01,0x88,0x16,0x22,0x0C,0xBE,0x10,
+	0x0C,0xBF,0x90,0x0C,0xB9,0x08,0x00,0x1E,0x07,0xFC,0xF3,0xA5,
+	0xBF,0xA0,0x0C,0xB8,0x00,0x00,0xB9,0x08,0x00,0xF3,0xAB,0xC7,
+	0x06,0x1A,0x0C,0x70,0x00,0xA0,0x40,0x0D,0xA2,0x10,0x0C,0xC6,
+	0x06,0x11,0x0C,0x00,0x2E,0x8C,0x1E,0xC1,0x03,0xC7,0x06,0x18,
+	0x0E,0x02,0x00,0xE8,0xEC,0xFC,0xC7,0x06,0x24,0x0D,0x5A,0x0D,
+	0x8C,0x0E,0x26,0x0D,0xC7,0x06,0x18,0x0E,0x06,0x00,0xA1,0x1A,
+	0x0C,0xE8,0x0A,0xFD,0xC7,0x06,0x18,0x0E,0x0A,0x00,0xBE,0x00,
+	0x10,0xC7,0x44,0x1E,0x80,0x00,0xE8,0xA5,0xFD,0x81,0xC6,0x80,
+	0x00,0x81,0xFE,0x00,0x18,0x72,0xEE,0xA0,0x22,0x0C,0xB4,0x80,
+	0xF6,0xE4,0xBE,0x00,0x10,0x03,0xF0,0x89,0x36,0x0A,0x0E,0x29,
+	0x44,0x9E,0xC7,0x06,0x00,0x0E,0x00,0x00,0xC7,0x06,0x02,0x0E,
+	0x00,0x00,0xC7,0x06,0x04,0x0E,0x00,0x00,0xC7,0x06,0x06,0x0E,
+	0x9A,0x02,0xBA,0x52,0xFF,0xA1,0x06,0x0E,0xEF,0xBA,0x50,0xFF,
+	0xB8,0x00,0x00,0xEF,0xBA,0x56,0xFF,0xB8,0x05,0xE0,0xEF,0xBA,
+	0x5E,0xFF,0xB8,0x00,0x40,0xEF,0xBA,0x66,0xFF,0xB8,0x00,0x40,
+	0xEF,0xC7,0x06,0x10,0x0D,0x00,0x00,0xC7,0x06,0x12,0x0D,0x00,
+	0x00,0xC7,0x06,0x14,0x0D,0x00,0x04,0xC7,0x06,0x16,0x0D,0xFC,
+	0x03,0xC7,0x06,0x18,0x0D,0x00,0x00,0xC7,0x06,0x1A,0x0D,0x00,
+	0x00,0xC7,0x06,0x1C,0x0D,0x00,0x08,0xC7,0x06,0x1E,0x0D,0xFC,
+	0x03,0xB0,0x00,0x90,0xE6,0x00,0xC7,0x06,0x18,0x0E,0x32,0x00,
+	0xBA,0x38,0xFF,0xB8,0x11,0x00,0xEF,0xBA,0x3A,0xFF,0xB8,0x08,
+	0x00,0xEF,0xBA,0x3C,0xFF,0xB8,0x08,0x00,0xEF,0xBA,0x3E,0xFF,
+	0xB8,0x08,0x00,0x80,0x3E,0x22,0x0C,0x08,0x76,0x03,0xB8,0x12,
+	0x00,0xEF,0xBA,0x32,0xFF,0xB8,0x05,0x00,0xEF,0xBA,0x28,0xFF,
+	0xB8,0x6C,0x00,0xEF,0xBA,0x22,0xFF,0xB8,0x00,0x80,0xEF,0xC7,
+	0x06,0x18,0x0E,0x33,0x00,0xC7,0x06,0x20,0x0D,0x4F,0x00,0xC7,
+	0x06,0x21,0x0D,0x53,0x00,0x8B,0x36,0x0A,0x0E,0xC7,0x04,0x3C,
+	0x0D,0xC7,0x06,0x08,0x0E,0x00,0x10,0xE9,0x63,0xF6,0x40,0x28,
+	0x23,0x29,0x20,0x24,0x49,0x64,0x3A,0x20,0x78,0x61,0x63,0x6F,
+	0x6F,0x6B,0x2E,0x61,0x73,0x6D,0x2C,0x76,0x20,0x37,0x2E,0x32,
+	0x35,0x20,0x31,0x39,0x39,0x35,0x2F,0x30,0x31,0x2F,0x31,0x32,
+	0x20,0x32,0x30,0x3A,0x35,0x39,0x3A,0x32,0x31,0x20,0x6D,0x69,
+	0x6C,0x74,0x20,0x45,0x78,0x70,0x20,0x24,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+};
+
+static unsigned pcxx_ncook=sizeof(pcxx_cook);
diff --git a/sys/dev/dgb/dgreg.h b/sys/dev/dgb/dgreg.h
new file mode 100644
index 0000000..3c32213
--- /dev/null
+++ b/sys/dev/dgb/dgreg.h
@@ -0,0 +1,366 @@
+/*-
+ *  dgreg.h $Id: dgreg.h,v 1.4 1995/07/13 08:07:46 root Exp root $
+ *
+ *  Copyright (C) 1995 by Serge Babkin <babkin@hq.icb.chel.su>
+ *
+ *  Digiboard driver.
+ *
+ *  Stage 1. "Better than nothing".
+ *
+ *  Based on sio driver by Bruce Evans and on Linux driver by Troy 
+ *  De Jongh <troyd@digibd.com> or <troyd@skypoint.com> 
+ *  which is under GNU General Public License version 2 so this driver 
+ *  is forced to be under GPL 2 too.
+ *
+ *	Serge Babkin does not guarantee that this file is totally correct
+ *  for any given task and users of this file must accept responsibility
+ *  for any damage that occurs from the application of this file.
+ *
+ *  Written by Serge Babkin,
+ *      Joint Stock Commercial Bank "Chelindbank"
+ *      (Chelyabinsk, Russia)
+ *      babkin@hq.icb.chel.su
+ */
+
+#define DEBUG  
+
+#define MAX_DGB_PORTS	32
+
+/* digi.h */
+/*          Definitions for DigiBoard ditty(1) command.                 */
+
+#if !defined(TIOCMODG)
+#define	TIOCMODG	('d'<<8) | 250		/* get modem ctrl state	*/
+#define	TIOCMODS	('d'<<8) | 251		/* set modem ctrl state	*/
+#endif
+
+#if !defined(TIOCMSET)
+#define	TIOCMSET	('d'<<8) | 252		/* set modem ctrl state	*/
+#define	TIOCMGET	('d'<<8) | 253		/* set modem ctrl state	*/
+#endif
+
+#if !defined(TIOCMBIC)
+#define	TIOCMBIC	('d'<<8) | 254		/* set modem ctrl state */
+#define	TIOCMBIS	('d'<<8) | 255		/* set modem ctrl state */
+#endif
+
+#if !defined(TIOCSDTR)
+#define	TIOCSDTR	('e'<<8) | 0		/* set DTR		*/
+#define	TIOCCDTR	('e'<<8) | 1		/* clear DTR		*/
+#endif
+
+/************************************************************************
+ * Ioctl command arguments for DIGI parameters.
+ ************************************************************************/
+#define DIGI_GETA	('e'<<8) | 94		/* Read params		*/
+
+#define DIGI_SETA	('e'<<8) | 95		/* Set params		*/
+#define DIGI_SETAW	('e'<<8) | 96		/* Drain & set params	*/
+#define DIGI_SETAF	('e'<<8) | 97		/* Drain, flush & set params */
+
+#define	DIGI_GETFLOW	('e'<<8) | 99		/* Get startc/stopc flow */
+						/* control characters 	 */
+#define	DIGI_SETFLOW	('e'<<8) | 100		/* Set startc/stopc flow */
+						/* control characters	 */
+#define	DIGI_GETAFLOW	('e'<<8) | 101		/* Get Aux. startc/stopc */
+						/* flow control chars 	 */
+#define	DIGI_SETAFLOW	('e'<<8) | 102		/* Set Aux. startc/stopc */
+						/* flow control chars	 */
+
+struct	digiflow_struct {
+	unsigned char	startc;				/* flow cntl start char	*/
+	unsigned char	stopc;				/* flow cntl stop char	*/
+};
+
+typedef struct digiflow_struct digiflow_t;
+
+
+/************************************************************************
+ * Values for digi_flags 
+ ************************************************************************/
+#define DIGI_IXON	0x0001		/* Handle IXON in the FEP	*/
+#define DIGI_FAST	0x0002		/* Fast baud rates		*/
+#define RTSPACE		0x0004		/* RTS input flow control	*/
+#define CTSPACE		0x0008		/* CTS output flow control	*/
+#define DSRPACE		0x0010		/* DSR output flow control	*/
+#define DCDPACE		0x0020		/* DCD output flow control	*/
+#define DTRPACE		0x0040		/* DTR input flow control	*/
+#define DIGI_FORCEDCD	0x0100		/* Force carrier		*/
+#define	DIGI_ALTPIN	0x0200		/* Alternate RJ-45 pin config	*/
+#define	DIGI_AIXON	0x0400		/* Aux flow control in fep	*/
+
+
+/************************************************************************
+ * Structure used with ioctl commands for DIGI parameters.
+ ************************************************************************/
+struct digi_struct {
+	unsigned short	digi_flags;		/* Flags (see above)	*/
+};
+
+typedef struct digi_struct digi_t;
+
+/* fep.h */
+
+#define FEP_CSTART       0x400L
+#define FEP_CMAX         0x800L
+#define FEP_ISTART       0x800L
+#define FEP_IMAX         0xC00L
+#define FEP_CIN          0xD10L
+#define FEP_GLOBAL       0xD10L
+#define FEP_EIN          0xD18L
+#define FEPSTAT      0xD20L
+#define CHANSTRUCT   0x1000L
+#define RXTXBUF      0x4000L
+
+
+struct global_data {
+	volatile ushort cin;
+	volatile ushort cout;
+	volatile ushort cstart;
+	volatile ushort cmax;
+	volatile ushort ein;
+	volatile ushort eout;
+	volatile ushort istart;
+	volatile ushort imax;
+};
+
+
+struct board_chan {
+	int filler1; 
+	int filler2;
+	volatile ushort tseg;
+	volatile ushort tin;
+	volatile ushort tout;
+	volatile ushort tmax;
+	
+	volatile ushort rseg;
+	volatile ushort rin;
+	volatile ushort rout;
+	volatile ushort rmax;
+	
+	volatile ushort tlow;
+	volatile ushort rlow;
+	volatile ushort rhigh;
+	volatile ushort incr;
+	
+	volatile ushort etime;
+	volatile ushort edelay;
+	volatile u_char *dev;
+	
+	volatile ushort iflag;
+	volatile ushort oflag;
+	volatile ushort cflag;
+	volatile ushort gmask;
+	
+	volatile ushort col;
+	volatile ushort delay;
+	volatile ushort imask;
+	volatile ushort tflush;
+
+	int filler3;
+	int filler4;
+	int filler5;
+	int filler6;
+	
+	volatile u_char num;
+	volatile u_char ract;
+	volatile u_char bstat;
+	volatile u_char tbusy;
+	volatile u_char iempty;
+	volatile u_char ilow;
+	volatile u_char idata;
+	volatile u_char eflag;
+	
+	volatile u_char tflag;
+	volatile u_char rflag;
+	volatile u_char xmask;
+	volatile u_char xval;
+	volatile u_char mstat;
+	volatile u_char mchange;
+	volatile u_char mint;
+	volatile u_char lstat;
+
+	volatile u_char mtran;
+	volatile u_char orun;
+	volatile u_char startca;
+	volatile u_char stopca;
+	volatile u_char startc;
+	volatile u_char stopc;
+	volatile u_char vnext;
+	volatile u_char hflow;
+
+	volatile u_char fillc;
+	volatile u_char ochar;
+	volatile u_char omask;
+
+	u_char filler7;
+	u_char filler8[28];
+}; 
+
+
+#define SRXLWATER      0xE0
+#define SRXHWATER      0xE1
+#define STOUT          0xE2
+#define PAUSETX        0xE3
+#define RESUMETX       0xE4
+#define SAUXONOFFC     0xE6
+#define SENDBREAK      0xE8
+#define SETMODEM       0xE9
+#define SETIFLAGS      0xEA
+#define SONOFFC        0xEB
+#define STXLWATER      0xEC
+#define PAUSERX        0xEE
+#define RESUMERX       0xEF
+#define SETBUFFER      0xF2
+#define SETCOOKED      0xF3
+#define SETHFLOW       0xF4
+#define SETCTRLFLAGS   0xF5
+#define SETVNEXT       0xF6
+
+
+
+#define BREAK_IND        0x01
+#define LOWTX_IND        0x02
+#define EMPTYTX_IND      0x04
+#define DATA_IND         0x08
+#define MODEMCHG_IND     0x20
+
+#define ALL_IND	(BREAK_IND|LOWTX_IND|EMPTYTX_IND|DATA_IND|MODEMCHG_IND)
+
+
+#define RTS   0x02
+#define CD    0x08
+#define DSR   0x10
+#define CTS   0x20
+#define RI    0x40
+#define DTR   0x80
+
+/* pcxx.h */
+
+#define FEPCODESEG  0x0200L
+#define FEPCODE     0x2000L
+#define BIOSCODE    0xf800L
+
+#define MISCGLOBAL  0x0C00L
+#define NPORT       0x0C22L
+#define MBOX        0x0C40L
+#define PORTBASE    0x0C90L
+#define BOTWIN      0x100L
+#define TOPWIN      0xFF00L
+
+#define FEPCLR      0x00
+#define FEPMEM      0x02
+#define FEPRST      0x04
+#define FEPINT      0x08
+#define	FEPMASK     0x0e
+#define	FEPWIN      0x80
+
+#define PCXI    0
+#define PCXE    1
+#define	PCXEVE	2
+
+static char *board_desc[] = {
+	"PC/Xi (64K)",
+	"PC/Xe (64K)",
+	"PC/Xe (8K) ",
+};
+
+#define STARTC      021
+#define STOPC       023
+#define IAIXON      0x2000
+
+
+struct board_info	{
+	u_char status;
+	u_char type;
+	u_char altpin;
+	ushort numports;
+	ushort port;
+	u_long  membase;
+};
+
+
+#define TXSTOPPED   0x1
+#define LOWWAIT		0x2
+#define EMPTYWAIT	0x4
+
+#define DISABLED   0
+#define ENABLED    1
+#define OFF        0
+#define ON         1
+
+#define FEPTIMEOUT 200000  
+#define SERIAL_TYPE_NORMAL	1
+#define SERIAL_TYPE_CALLOUT	2
+#define PCXE_EVENT_HANGUP   1
+
+struct channel {
+	u_char unit;           /* board unit number */
+	u_char omodem;         /* FEP output modem status     */
+	u_char imodem;         /* FEP input modem status      */
+	u_char modemfake;      /* Modem values to be forced   */
+	u_char modem;          /* Force values                */
+	u_char hflow;
+	u_char dsr;
+	u_char dcd;
+	u_char stopc;
+	u_char startc;
+	u_char stopca;
+	u_char startca;
+	u_char fepstopc;
+	u_char fepstartc;
+	u_char fepstopca;
+	u_char fepstartca;
+	u_char txwin;
+	u_char rxwin;
+	ushort fepiflag;
+	ushort fepcflag;
+	ushort fepoflag;
+	ushort txbufhead;
+	ushort txbufsize;
+	ushort rxbufhead;
+	ushort rxbufsize;
+	int close_delay;
+	int count;
+	int blocked_open;
+	int event;
+	int asyncflags;
+	uint dev;
+	long session;
+	long pgrp;
+	u_long statusflags;
+	u_long c_iflag;
+	u_long c_cflag;
+	u_long c_lflag;
+	u_long c_oflag;
+	u_char *txptr;
+	u_char *rxptr;
+	struct board_info *board;
+	struct board_chan *brdchan;
+	struct digi_struct digiext;
+	struct tty *tty;
+	struct termios normal_termios;
+	struct termios callout_termios;
+	volatile struct global_data *mailbox;
+};
+
+/* flags for configuring */
+
+#define	DGBFLAG_ALTPIN	0x0001	/* chande DCD and DCD */
+#define DGBFLAG_NOWIN	0x0002	/* use windowed PC/Xe as non-windowed */
+
+/* debugging printout */
+
+#ifdef DEBUG
+#	define DPRINT1(a1)	(dgbdebug ? printf(a1) : 0)
+#	define DPRINT2(a1,a2)	(dgbdebug ? printf(a1,a2) : 0)
+#	define DPRINT3(a1,a2,a3)	(dgbdebug ? printf(a1,a2,a3) : 0)
+#	define DPRINT4(a1,a2,a3,a4)	(dgbdebug ? printf(a1,a2,a3,a4) : 0)
+#	define DPRINT5(a1,a2,a3,a4,a5)	(dgbdebug ? printf(a1,a2,a3,a4,a5) : 0)
+#else
+#	define DPRINT1(a1)
+#	define DPRINT2(a1,a2)
+#	define DPRINT3(a1,a2,a3)
+#	define DPRINT4(a1,a2,a3,a4)
+#	define DPRINT5(a1,a2,a3,a4,a5)
+#endif