[unix-history] / usr / src / sys / pmax / dev / if_lereg.h

/*-
 * Copyright (c) 1992, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Ralph Campbell and Rick Macklem.
 *
 * %sccs.include.redist.c%
 *
 *	@(#)if_lereg.h	8.1 (Berkeley) %G%
 */

#define	LEMTU		1518
#define	LEBLEN		1520	/* LEMTU up to a multiple of 16 */
#define	LEMINSIZE	60	/* should be 64 if mode DTCR is set */
#define	LERBUF		32
#define	LERBUFLOG2	5
#define	LE_RLEN		(LERBUFLOG2 << 13)
#define	LETBUF		8
#define	LETBUFLOG2	3
#define	LE_TLEN		(LETBUFLOG2 << 13)

/*
 * LANCE registers.
 */
struct lereg1 {
	u_short	ler1_rdp;	/* data port */
	short	pad0;
	u_short	ler1_rap;	/* register select port */
	short	pad1;
};

/*
 * This structure is overlayed on the network dual-port RAM.
 * Currently 32 * 1520 receive plus 8 * 1520 transmit buffers plus
 * buffer descriptor rings.
 * There are two variants of the structure, one for the Pmax/3min/maxine
 * with 2 byte pads between entries and one for the 3max and turbochannel
 * option densely packed.
 */
struct	lermd {			/* +0x0020 */
	u_short	rmd0;
	u_short	rmd1;
	short	rmd2;
	u_short	rmd3;
};

struct	letmd {			/* +0x0058 */
	u_short	tmd0;
	u_short	tmd1;
	short	tmd2;
	u_short	tmd3;
};

struct	lermdpad {			/* +0x0020 */
	u_short	rmd0;
	short	pad0;
	u_short	rmd1;
	short	pad1;
	short	rmd2;
	short	pad2;
	u_short	rmd3;
	short	pad3;
};

struct	letmdpad {			/* +0x0058 */
	u_short	tmd0;
	short	pad0;
	u_short	tmd1;
	short	pad1;
	short	tmd2;
	short	pad2;
	u_short	tmd3;
	short	pad3;
};

struct lereg2 {
	/* init block */		/* CHIP address */
	u_short	ler2_mode;		/* +0x0000 */
	u_short	ler2_padr0;		/* +0x0002 */
	u_short	ler2_padr1;		/* +0x0004 */
	u_short	ler2_padr2;		/* +0x0006 */
	u_short	ler2_ladrf0;		/* +0x0008 */
	u_short	ler2_ladrf1;		/* +0x000A */
	u_short	ler2_ladrf2;		/* +0x000C */
	u_short	ler2_ladrf3;		/* +0x000E */
	u_short	ler2_rdra;		/* +0x0010 */
	u_short	ler2_rlen;		/* +0x0012 */
	u_short	ler2_tdra;		/* +0x0014 */
	u_short	ler2_tlen;		/* +0x0016 */
	short	pad0[4];		/* Pad to 16 shorts */
	/* receive message descriptors */
	struct lermd ler2_rmd[LERBUF];
	/* transmit message descriptors */
	struct letmd ler2_tmd[LETBUF];
	char	ler2_rbuf[LERBUF][LEBLEN]; /* +0x0060 */
	char	ler2_tbuf[LETBUF][LEBLEN]; /* +0x2FD0 */
};

struct lereg2pad {
	/* init block */		/* CHIP address */
	u_short	ler2_mode;		/* +0x0000 */
	short	pad0;
	u_short	ler2_padr0;		/* +0x0002 */
	short	pad1;
	u_short	ler2_padr1;		/* +0x0004 */
	short	pad2;
	u_short	ler2_padr2;		/* +0x0006 */
	short	pad3;
	u_short	ler2_ladrf0;		/* +0x0008 */
	short	pad4;
	u_short	ler2_ladrf1;		/* +0x000A */
	short	pad5;
	u_short	ler2_ladrf2;		/* +0x000C */
	short	pad6;
	u_short	ler2_ladrf3;		/* +0x000E */
	short	pad7;
	u_short	ler2_rdra;		/* +0x0010 */
	short	pad8;
	u_short	ler2_rlen;		/* +0x0012 */
	short	pad9;
	u_short	ler2_tdra;		/* +0x0014 */
	short	pad10;
	u_short	ler2_tlen;		/* +0x0016 */
	short	pad11[9];		/* Pad to 32 shorts */
	/* receive message descriptors */
	struct lermdpad ler2_rmd[LERBUF];
	/* transmit message descriptors */
	struct letmdpad ler2_tmd[LETBUF];
	short	ler2_rbuf[LERBUF][LEBLEN]; /* +0x0060 */
	short	ler2_tbuf[LETBUF][LEBLEN]; /* +0x2FD0 */
};

/*
 * Now for some truly ugly macros to access the structure fields
 * padded/non-padded at runtime. (For once, a Pascal like record variant
 * would be nice to have.)
 */
#define	LER2_RMDADDR(p, i) \
		(le->sc_ler2pad ? \
		 (volatile void *)&(((struct lereg2pad *)(p))->ler2_rmd[(i)]) : \
		 (volatile void *)&(((struct lereg2 *)(p))->ler2_rmd[(i)]))

#define	LER2_TMDADDR(p, i) \
		((le->sc_ler2pad ? \
		 (volatile void *)&(((struct lereg2pad *)(p))->ler2_tmd[(i)]) : \
		 (volatile void *)&(((struct lereg2 *)(p))->ler2_tmd[(i)])))

#define	LER2_RBUFADDR(p, i) \
		((le->sc_ler2pad ? \
		 (volatile void *)(((struct lereg2pad *)(p))->ler2_rbuf[(i)]) : \
		 (volatile void *)(((struct lereg2 *)(p))->ler2_rbuf[(i)])))

#define	LER2_TBUFADDR(p, i) \
		((le->sc_ler2pad ? \
		 (volatile void *)(((struct lereg2pad *)(p))->ler2_tbuf[(i)]) : \
		 (volatile void *)(((struct lereg2 *)(p))->ler2_tbuf[(i)])))

#define LER2_mode(p, v) \
	(le->sc_ler2pad ? (((volatile struct lereg2pad *)(p))->ler2_mode = (v)) : \
	 (((volatile struct lereg2 *)(p))->ler2_mode = (v)))
#define	LER2V_mode(p) \
	(le->sc_ler2pad ? ((volatile struct lereg2pad *)(p))->ler2_mode : \
	 ((volatile struct lereg2 *)(p))->ler2_mode)

#define LER2_padr0(p, v) \
	(le->sc_ler2pad ? (((volatile struct lereg2pad *)(p))->ler2_padr0 = (v)) : \
	 (((volatile struct lereg2 *)(p))->ler2_padr0 = (v)))
#define	LER2V_padr0(p) \
	(le->sc_ler2pad ? ((volatile struct lereg2pad *)(p))->ler2_padr0 : \
	 ((volatile struct lereg2 *)(p))->ler2_padr0)

#define LER2_padr1(p, v) \
	(le->sc_ler2pad ? (((volatile struct lereg2pad *)(p))->ler2_padr1 = (v)) : \
	 (((volatile struct lereg2 *)(p))->ler2_padr1 = (v)))
#define	LER2V_padr1(p) \
	(le->sc_ler2pad ? ((volatile struct lereg2pad *)(p))->ler2_padr1 : \
	 ((volatile struct lereg2 *)(p))->ler2_padr1)

#define LER2_padr2(p, v) \
	(le->sc_ler2pad ? (((volatile struct lereg2pad *)(p))->ler2_padr2 = (v)) : \
	 (((volatile struct lereg2 *)(p))->ler2_padr2 = (v)))
#define	LER2V_padr2(p) \
	(le->sc_ler2pad ? ((volatile struct lereg2pad *)(p))->ler2_padr2 : \
	 ((volatile struct lereg2 *)(p))->ler2_padr2)

#define LER2_ladrf0(p, v) \
	(le->sc_ler2pad ? (((volatile struct lereg2pad *)(p))->ler2_ladrf0 = (v)) : \
	 (((volatile struct lereg2 *)(p))->ler2_ladrf0 = (v)))
#define	LER2V_ladrf0(p) \
	(le->sc_ler2pad ? ((volatile struct lereg2pad *)(p))->ler2_ladrf0 : \
	 ((volatile struct lereg2 *)(p))->ler2_ladrf0)

#define LER2_ladrf1(p, v) \
	(le->sc_ler2pad ? (((volatile struct lereg2pad *)(p))->ler2_ladrf1 = (v)) : \
	 (((volatile struct lereg2 *)(p))->ler2_ladrf1 = (v)))
#define	LER2V_ladrf1(p) \
	(le->sc_ler2pad ? ((volatile struct lereg2pad *)(p))->ler2_ladrf1 : \
	 ((volatile struct lereg2 *)(p))->ler2_ladrf1)

#define LER2_ladrf2(p, v) \
	(le->sc_ler2pad ? (((volatile struct lereg2pad *)(p))->ler2_ladrf2 = (v)) : \
	 (((volatile struct lereg2 *)(p))->ler2_ladrf2 = (v)))
#define	LER2V_ladrf2(p) \
	(le->sc_ler2pad ? ((volatile struct lereg2pad *)(p))->ler2_ladrf2 : \
	 ((volatile struct lereg2 *)(p))->ler2_ladrf2)

#define LER2_ladrf3(p, v) \
	(le->sc_ler2pad ? (((volatile struct lereg2pad *)(p))->ler2_ladrf3 = (v)) : \
	 (((volatile struct lereg2 *)(p))->ler2_ladrf3 = (v)))
#define	LER2V_ladrf3(p) \
	(le->sc_ler2pad ? ((volatile struct lereg2pad *)(p))->ler2_ladrf3 : \
	 ((volatile struct lereg2 *)(p))->ler2_ladrf3)

#define LER2_rdra(p, v) \
	(le->sc_ler2pad ? (((volatile struct lereg2pad *)(p))->ler2_rdra = (v)) : \
	 (((volatile struct lereg2 *)(p))->ler2_rdra = (v)))
#define	LER2V_rdra(p) \
	(le->sc_ler2pad ? ((volatile struct lereg2pad *)(p))->ler2_rdra : \
	 ((volatile struct lereg2 *)(p))->ler2_rdra)

#define LER2_rlen(p, v) \
	(le->sc_ler2pad ? (((volatile struct lereg2pad *)(p))->ler2_rlen = (v)) : \
	 (((volatile struct lereg2 *)(p))->ler2_rlen = (v)))
#define	LER2V_rlen(p) \
	(le->sc_ler2pad ? ((volatile struct lereg2pad *)(p))->ler2_rlen : \
	 ((volatile struct lereg2 *)(p))->ler2_rlen)

#define LER2_tdra(p, v) \
	(le->sc_ler2pad ? (((volatile struct lereg2pad *)(p))->ler2_tdra = (v)) : \
	 (((volatile struct lereg2 *)(p))->ler2_tdra = (v)))
#define	LER2V_tdra(p) \
	(le->sc_ler2pad ? ((volatile struct lereg2pad *)(p))->ler2_tdra : \
	 ((volatile struct lereg2 *)(p))->ler2_tdra)

#define LER2_tlen(p, v) \
	(le->sc_ler2pad ? (((volatile struct lereg2pad *)(p))->ler2_tlen = (v)) : \
	 (((volatile struct lereg2 *)(p))->ler2_tlen = (v)))
#define	LER2V_tlen(p) \
	(le->sc_ler2pad ? ((volatile struct lereg2pad *)(p))->ler2_tlen : \
	 ((volatile struct lereg2 *)(p))->ler2_tlen)

#define LER2_rmd0(p, v) \
	(le->sc_ler2pad ? (((volatile struct lermdpad *)(p))->rmd0 = (v)) : \
	 ((((volatile struct lermd *)(p))->rmd0 = (v))))
#define LER2V_rmd0(p) \
	(le->sc_ler2pad ? ((volatile struct lermdpad *)(p))->rmd0 : \
	 ((volatile struct lermd *)(p))->rmd0)

#define LER2_rmd1(p, v) \
	(le->sc_ler2pad ? (((volatile struct lermdpad *)(p))->rmd1 = (v)) : \
	 (((volatile struct lermd *)(p))->rmd1 = (v)))
#define LER2V_rmd1(p) \
	(le->sc_ler2pad ? ((volatile struct lermdpad *)(p))->rmd1 : \
	 ((volatile struct lermd *)(p))->rmd1)

#define LER2_rmd2(p, v) \
	(le->sc_ler2pad ? (((volatile struct lermdpad *)(p))->rmd2 = (v)) : \
	 (((volatile struct lermd *)(p))->rmd2 = (v)))
#define LER2V_rmd2(p) \
	(le->sc_ler2pad ? ((volatile struct lermdpad *)(p))->rmd2 : \
	 ((volatile struct lermd *)(p))->rmd2)

#define LER2_rmd3(p, v) \
	(le->sc_ler2pad ? (((volatile struct lermdpad *)(p))->rmd3 = (v)) : \
	 (((volatile struct lermd *)(p))->rmd3 = (v)))
#define LER2V_rmd3(p) \
	(le->sc_ler2pad ? ((volatile struct lermdpad *)(p))->rmd3 : \
	 ((volatile struct lermd *)(p))->rmd3)

#define LER2_tmd0(p, v) \
	(le->sc_ler2pad ? (((volatile struct letmdpad *)(p))->tmd0 = (v)) : \
	 (((volatile struct letmd *)(p))->tmd0 = (v)))
#define LER2V_tmd0(p) \
	(le->sc_ler2pad ? ((volatile struct letmdpad *)(p))->tmd0 : \
	 ((volatile struct letmd *)(p))->tmd0)

#define LER2_tmd1(p, v) \
	(le->sc_ler2pad ? (((volatile struct letmdpad *)(p))->tmd1 = (v)) : \
	 (((volatile struct letmd *)(p))->tmd1 = (v)))
#define LER2V_tmd1(p) \
	(le->sc_ler2pad ? ((volatile struct letmdpad *)(p))->tmd1 : \
	 ((volatile struct letmd *)(p))->tmd1)

#define LER2_tmd2(p, v) \
	(le->sc_ler2pad ? (((volatile struct letmdpad *)(p))->tmd2 = (v)) : \
	 (((volatile struct letmd *)(p))->tmd2 = (v)))
#define LER2V_tmd2(p) \
	(le->sc_ler2pad ? ((volatile struct letmdpad *)(p))->tmd2 : \
	 ((volatile struct letmd *)(p))->tmd2)

#define LER2_tmd3(p, v) \
	(le->sc_ler2pad ? (((volatile struct letmdpad *)(p))->tmd3 = (v)) : \
	 (((volatile struct letmd *)(p))->tmd3 = (v)))
#define LER2V_tmd3(p) \
	(le->sc_ler2pad ? ((volatile struct letmdpad *)(p))->tmd3 : \
	 ((volatile struct letmd *)(p))->tmd3)

/*
 * Control and status bits -- lereg0
 */
#define	LE_IE		0x80		/* interrupt enable */
#define	LE_IR		0x40		/* interrupt requested */
#define	LE_LOCK		0x08		/* lock status register */
#define	LE_ACK		0x04		/* ack of lock */
#define	LE_JAB		0x02		/* loss of tx clock (???) */
#define LE_IPL(x)	((((x) >> 4) & 0x3) + 3)

/*
 * Control and status bits -- lereg1
 */
#define	LE_CSR0		0
#define	LE_CSR1		1
#define	LE_CSR2		2
#define	LE_CSR3		3

#define	LE_SERR		0x8000
#define	LE_BABL		0x4000
#define	LE_CERR		0x2000
#define	LE_MISS		0x1000
#define	LE_MERR		0x0800
#define	LE_RINT		0x0400
#define	LE_TINT		0x0200
#define	LE_IDON		0x0100
#define	LE_INTR		0x0080
#define	LE_INEA		0x0040
#define	LE_RXON		0x0020
#define	LE_TXON		0x0010
#define	LE_TDMD		0x0008
#define	LE_STOP		0x0004
#define	LE_STRT		0x0002
#define	LE_INIT		0x0001

#define	LE_BSWP		0x4
#define	LE_MODE		0x0

/*
 * Control and status bits -- lereg2
 */
#define	LE_OWN		0x8000
#define	LE_ERR		0x4000
#define	LE_STP		0x0200
#define	LE_ENP		0x0100

#define	LE_FRAM		0x2000
#define	LE_OFLO		0x1000
#define	LE_CRC		0x0800
#define	LE_RBUFF	0x0400

#define	LE_MORE		0x1000
#define	LE_ONE		0x0800
#define	LE_DEF		0x0400

#define	LE_TBUFF	0x8000
#define	LE_UFLO		0x4000
#define	LE_LCOL		0x1000
#define	LE_LCAR		0x0800
#define	LE_RTRY		0x0400
Commit	Line	Data
6c1a1c86	1	/*-
86090d31 KB	2	* Copyright (c) 1992, 1993
86090d31 KB	3	* The Regents of the University of California. All rights reserved.
12d43ee5 KM	4	*
12d43ee5 KM	5	* This code is derived from software contributed to Berkeley by
6c1a1c86	6	* Ralph Campbell and Rick Macklem.
12d43ee5 KM	7	*
	8	* %sccs.include.redist.c%
	9	*
86090d31	10	* @(#)if_lereg.h 8.1 (Berkeley) %G%
12d43ee5 KM	11	*/
	12
	13	#define LEMTU 1518
6c1a1c86	14	#define LEBLEN 1520 /* LEMTU up to a multiple of 16 */
12d43ee5 KM	15	#define LEMINSIZE 60 /* should be 64 if mode DTCR is set */
	16	#define LERBUF 32
	17	#define LERBUFLOG2 5
	18	#define LE_RLEN (LERBUFLOG2 << 13)
	19	#define LETBUF 8
	20	#define LETBUFLOG2 3
	21	#define LE_TLEN (LETBUFLOG2 << 13)
	22
	23	/*
	24	* LANCE registers.
	25	*/
	26	struct lereg1 {
	27	u_short ler1_rdp; /* data port */
	28	short pad0;
	29	u_short ler1_rap; /* register select port */
	30	short pad1;
	31	};
	32
	33	/*
13b3fbea	34	* This structure is overlayed on the network dual-port RAM.
6c1a1c86	35	* Currently 32 * 1520 receive plus 8 * 1520 transmit buffers plus
12d43ee5	36	* buffer descriptor rings.
6c1a1c86 RC	37	* There are two variants of the structure, one for the Pmax/3min/maxine
	38	* with 2 byte pads between entries and one for the 3max and turbochannel
	39	* option densely packed.
12d43ee5	40	*/
6c1a1c86 RC	41	struct lermd { /* +0x0020 */
	42	u_short rmd0;
	43	u_short rmd1;
	44	short rmd2;
	45	u_short rmd3;
	46	};
	47
	48	struct letmd { /* +0x0058 */
	49	u_short tmd0;
	50	u_short tmd1;
	51	short tmd2;
	52	u_short tmd3;
	53	};
	54
	55	struct lermdpad { /* +0x0020 */
	56	u_short rmd0;
	57	short pad0;
	58	u_short rmd1;
	59	short pad1;
	60	short rmd2;
	61	short pad2;
	62	u_short rmd3;
	63	short pad3;
	64	};
	65
	66	struct letmdpad { /* +0x0058 */
	67	u_short tmd0;
	68	short pad0;
	69	u_short tmd1;
	70	short pad1;
	71	short tmd2;
	72	short pad2;
	73	u_short tmd3;
	74	short pad3;
	75	};
	76
12d43ee5 KM	77	struct lereg2 {
	78	/* init block / / CHIP address */
	79	u_short ler2_mode; /* +0x0000 */
12d43ee5	80	u_short ler2_padr0; /* +0x0002 */
12d43ee5	81	u_short ler2_padr1; /* +0x0004 */
12d43ee5	82	u_short ler2_padr2; /* +0x0006 */
12d43ee5	83	u_short ler2_ladrf0; /* +0x0008 */
12d43ee5	84	u_short ler2_ladrf1; /* +0x000A */
12d43ee5	85	u_short ler2_ladrf2; /* +0x000C */
12d43ee5	86	u_short ler2_ladrf3; /* +0x000E */
12d43ee5	87	u_short ler2_rdra; /* +0x0010 */
12d43ee5	88	u_short ler2_rlen; /* +0x0012 */
12d43ee5	89	u_short ler2_tdra; /* +0x0014 */
12d43ee5	90	u_short ler2_tlen; /* +0x0016 */
6c1a1c86	91	short pad0[4]; /* Pad to 16 shorts */
12d43ee5	92	/* receive message descriptors */
6c1a1c86	93	struct lermd ler2_rmd[LERBUF];
12d43ee5	94	/* transmit message descriptors */
6c1a1c86 RC	95	struct letmd ler2_tmd[LETBUF];
	96	char ler2_rbuf[LERBUF][LEBLEN]; /* +0x0060 */
	97	char ler2_tbuf[LETBUF][LEBLEN]; /* +0x2FD0 */
12d43ee5 KM	98	};
12d43ee5 KM	99
6c1a1c86 RC	100	struct lereg2pad {
	101	/* init block / / CHIP address */
	102	u_short ler2_mode; /* +0x0000 */
	103	short pad0;
	104	u_short ler2_padr0; /* +0x0002 */
	105	short pad1;
	106	u_short ler2_padr1; /* +0x0004 */
	107	short pad2;
	108	u_short ler2_padr2; /* +0x0006 */
	109	short pad3;
	110	u_short ler2_ladrf0; /* +0x0008 */
	111	short pad4;
	112	u_short ler2_ladrf1; /* +0x000A */
	113	short pad5;
	114	u_short ler2_ladrf2; /* +0x000C */
	115	short pad6;
	116	u_short ler2_ladrf3; /* +0x000E */
	117	short pad7;
	118	u_short ler2_rdra; /* +0x0010 */
	119	short pad8;
	120	u_short ler2_rlen; /* +0x0012 */
	121	short pad9;
	122	u_short ler2_tdra; /* +0x0014 */
	123	short pad10;
	124	u_short ler2_tlen; /* +0x0016 */
	125	short pad11[9]; /* Pad to 32 shorts */
	126	/* receive message descriptors */
	127	struct lermdpad ler2_rmd[LERBUF];
	128	/* transmit message descriptors */
	129	struct letmdpad ler2_tmd[LETBUF];
	130	short ler2_rbuf[LERBUF][LEBLEN]; /* +0x0060 */
	131	short ler2_tbuf[LETBUF][LEBLEN]; /* +0x2FD0 */
	132	};
	133
	134	/*
	135	* Now for some truly ugly macros to access the structure fields
	136	* padded/non-padded at runtime. (For once, a Pascal like record variant
	137	* would be nice to have.)
	138	*/
	139	#define LER2_RMDADDR(p, i) \
	140	(le->sc_ler2pad ? \
	141	(volatile void )&(((struct lereg2pad )(p))->ler2_rmd[(i)]) : \
	142	(volatile void )&(((struct lereg2 )(p))->ler2_rmd[(i)]))
	143
	144	#define LER2_TMDADDR(p, i) \
	145	((le->sc_ler2pad ? \
	146	(volatile void )&(((struct lereg2pad )(p))->ler2_tmd[(i)]) : \
	147	(volatile void )&(((struct lereg2 )(p))->ler2_tmd[(i)])))
	148
	149	#define LER2_RBUFADDR(p, i) \
	150	((le->sc_ler2pad ? \
	151	(volatile void )(((struct lereg2pad )(p))->ler2_rbuf[(i)]) : \
	152	(volatile void )(((struct lereg2 )(p))->ler2_rbuf[(i)])))
	153
	154	#define LER2_TBUFADDR(p, i) \
	155	((le->sc_ler2pad ? \
	156	(volatile void )(((struct lereg2pad )(p))->ler2_tbuf[(i)]) : \
	157	(volatile void )(((struct lereg2 )(p))->ler2_tbuf[(i)])))
	158
	159	#define LER2_mode(p, v) \
	160	(le->sc_ler2pad ? (((volatile struct lereg2pad *)(p))->ler2_mode = (v)) : \
	161	(((volatile struct lereg2 *)(p))->ler2_mode = (v)))
	162	#define LER2V_mode(p) \
	163	(le->sc_ler2pad ? ((volatile struct lereg2pad *)(p))->ler2_mode : \
164	((volatile struct lereg2 *)(p))->ler2_mode)
165
166	#define LER2_padr0(p, v) \
167	(le->sc_ler2pad ? (((volatile struct lereg2pad *)(p))->ler2_padr0 = (v)) : \
168	(((volatile struct lereg2 *)(p))->ler2_padr0 = (v)))
169	#define LER2V_padr0(p) \
170	(le->sc_ler2pad ? ((volatile struct lereg2pad *)(p))->ler2_padr0 : \
171	((volatile struct lereg2 *)(p))->ler2_padr0)
172
173	#define LER2_padr1(p, v) \
174	(le->sc_ler2pad ? (((volatile struct lereg2pad *)(p))->ler2_padr1 = (v)) : \
175	(((volatile struct lereg2 *)(p))->ler2_padr1 = (v)))
176	#define LER2V_padr1(p) \
177	(le->sc_ler2pad ? ((volatile struct lereg2pad *)(p))->ler2_padr1 : \
178	((volatile struct lereg2 *)(p))->ler2_padr1)
179
180	#define LER2_padr2(p, v) \
181	(le->sc_ler2pad ? (((volatile struct lereg2pad *)(p))->ler2_padr2 = (v)) : \
182	(((volatile struct lereg2 *)(p))->ler2_padr2 = (v)))
183	#define LER2V_padr2(p) \
184	(le->sc_ler2pad ? ((volatile struct lereg2pad *)(p))->ler2_padr2 : \
185	((volatile struct lereg2 *)(p))->ler2_padr2)
186
187	#define LER2_ladrf0(p, v) \
188	(le->sc_ler2pad ? (((volatile struct lereg2pad *)(p))->ler2_ladrf0 = (v)) : \
189	(((volatile struct lereg2 *)(p))->ler2_ladrf0 = (v)))
190	#define LER2V_ladrf0(p) \
191	(le->sc_ler2pad ? ((volatile struct lereg2pad *)(p))->ler2_ladrf0 : \
192	((volatile struct lereg2 *)(p))->ler2_ladrf0)
193
194	#define LER2_ladrf1(p, v) \
195	(le->sc_ler2pad ? (((volatile struct lereg2pad *)(p))->ler2_ladrf1 = (v)) : \
196	(((volatile struct lereg2 *)(p))->ler2_ladrf1 = (v)))
197	#define LER2V_ladrf1(p) \
198	(le->sc_ler2pad ? ((volatile struct lereg2pad *)(p))->ler2_ladrf1 : \
199	((volatile struct lereg2 *)(p))->ler2_ladrf1)
200
201	#define LER2_ladrf2(p, v) \
202	(le->sc_ler2pad ? (((volatile struct lereg2pad *)(p))->ler2_ladrf2 = (v)) : \
203	(((volatile struct lereg2 *)(p))->ler2_ladrf2 = (v)))
204	#define LER2V_ladrf2(p) \
205	(le->sc_ler2pad ? ((volatile struct lereg2pad *)(p))->ler2_ladrf2 : \
206	((volatile struct lereg2 *)(p))->ler2_ladrf2)
207
208	#define LER2_ladrf3(p, v) \
209	(le->sc_ler2pad ? (((volatile struct lereg2pad *)(p))->ler2_ladrf3 = (v)) : \
210	(((volatile struct lereg2 *)(p))->ler2_ladrf3 = (v)))
211	#define LER2V_ladrf3(p) \
212	(le->sc_ler2pad ? ((volatile struct lereg2pad *)(p))->ler2_ladrf3 : \
213	((volatile struct lereg2 *)(p))->ler2_ladrf3)
214
215	#define LER2_rdra(p, v) \
216	(le->sc_ler2pad ? (((volatile struct lereg2pad *)(p))->ler2_rdra = (v)) : \
217	(((volatile struct lereg2 *)(p))->ler2_rdra = (v)))
218	#define LER2V_rdra(p) \
219	(le->sc_ler2pad ? ((volatile struct lereg2pad *)(p))->ler2_rdra : \
220	((volatile struct lereg2 *)(p))->ler2_rdra)
221
222	#define LER2_rlen(p, v) \
223	(le->sc_ler2pad ? (((volatile struct lereg2pad *)(p))->ler2_rlen = (v)) : \
224	(((volatile struct lereg2 *)(p))->ler2_rlen = (v)))
225	#define LER2V_rlen(p) \
226	(le->sc_ler2pad ? ((volatile struct lereg2pad *)(p))->ler2_rlen : \
227	((volatile struct lereg2 *)(p))->ler2_rlen)
228
229	#define LER2_tdra(p, v) \
230	(le->sc_ler2pad ? (((volatile struct lereg2pad *)(p))->ler2_tdra = (v)) : \
231	(((volatile struct lereg2 *)(p))->ler2_tdra = (v)))
232	#define LER2V_tdra(p) \
233	(le->sc_ler2pad ? ((volatile struct lereg2pad *)(p))->ler2_tdra : \
234	((volatile struct lereg2 *)(p))->ler2_tdra)
235
236	#define LER2_tlen(p, v) \
237	(le->sc_ler2pad ? (((volatile struct lereg2pad *)(p))->ler2_tlen = (v)) : \
238	(((volatile struct lereg2 *)(p))->ler2_tlen = (v)))
239	#define LER2V_tlen(p) \
240	(le->sc_ler2pad ? ((volatile struct lereg2pad *)(p))->ler2_tlen : \
241	((volatile struct lereg2 *)(p))->ler2_tlen)
242
243	#define LER2_rmd0(p, v) \
244	(le->sc_ler2pad ? (((volatile struct lermdpad *)(p))->rmd0 = (v)) : \
245	((((volatile struct lermd *)(p))->rmd0 = (v))))
246	#define LER2V_rmd0(p) \
247	(le->sc_ler2pad ? ((volatile struct lermdpad *)(p))->rmd0 : \
248	((volatile struct lermd *)(p))->rmd0)
249
250	#define LER2_rmd1(p, v) \
251	(le->sc_ler2pad ? (((volatile struct lermdpad *)(p))->rmd1 = (v)) : \
252	(((volatile struct lermd *)(p))->rmd1 = (v)))
253	#define LER2V_rmd1(p) \
254	(le->sc_ler2pad ? ((volatile struct lermdpad *)(p))->rmd1 : \
255	((volatile struct lermd *)(p))->rmd1)
256
257	#define LER2_rmd2(p, v) \
258	(le->sc_ler2pad ? (((volatile struct lermdpad *)(p))->rmd2 = (v)) : \
259	(((volatile struct lermd *)(p))->rmd2 = (v)))
260	#define LER2V_rmd2(p) \
261	(le->sc_ler2pad ? ((volatile struct lermdpad *)(p))->rmd2 : \
262	((volatile struct lermd *)(p))->rmd2)
263
264	#define LER2_rmd3(p, v) \
265	(le->sc_ler2pad ? (((volatile struct lermdpad *)(p))->rmd3 = (v)) : \
266	(((volatile struct lermd *)(p))->rmd3 = (v)))
267	#define LER2V_rmd3(p) \
268	(le->sc_ler2pad ? ((volatile struct lermdpad *)(p))->rmd3 : \
269	((volatile struct lermd *)(p))->rmd3)
270
271	#define LER2_tmd0(p, v) \
272	(le->sc_ler2pad ? (((volatile struct letmdpad *)(p))->tmd0 = (v)) : \
273	(((volatile struct letmd *)(p))->tmd0 = (v)))
274	#define LER2V_tmd0(p) \
275	(le->sc_ler2pad ? ((volatile struct letmdpad *)(p))->tmd0 : \
276	((volatile struct letmd *)(p))->tmd0)
277
278	#define LER2_tmd1(p, v) \
279	(le->sc_ler2pad ? (((volatile struct letmdpad *)(p))->tmd1 = (v)) : \
280	(((volatile struct letmd *)(p))->tmd1 = (v)))
281	#define LER2V_tmd1(p) \
282	(le->sc_ler2pad ? ((volatile struct letmdpad *)(p))->tmd1 : \
283	((volatile struct letmd *)(p))->tmd1)
284
285	#define LER2_tmd2(p, v) \
286	(le->sc_ler2pad ? (((volatile struct letmdpad *)(p))->tmd2 = (v)) : \
287	(((volatile struct letmd *)(p))->tmd2 = (v)))
288	#define LER2V_tmd2(p) \
289	(le->sc_ler2pad ? ((volatile struct letmdpad *)(p))->tmd2 : \
290	((volatile struct letmd *)(p))->tmd2)
291
292	#define LER2_tmd3(p, v) \
293	(le->sc_ler2pad ? (((volatile struct letmdpad *)(p))->tmd3 = (v)) : \
294	(((volatile struct letmd *)(p))->tmd3 = (v)))
295	#define LER2V_tmd3(p) \
296	(le->sc_ler2pad ? ((volatile struct letmdpad *)(p))->tmd3 : \
297	((volatile struct letmd *)(p))->tmd3)
298
12d43ee5 KM	299	/*
	300	* Control and status bits -- lereg0
	301	*/
	302	#define LE_IE 0x80 /* interrupt enable */
	303	#define LE_IR 0x40 /* interrupt requested */
	304	#define LE_LOCK 0x08 /* lock status register */
	305	#define LE_ACK 0x04 /* ack of lock */
	306	#define LE_JAB 0x02 /* loss of tx clock (???) */
	307	#define LE_IPL(x) ((((x) >> 4) & 0x3) + 3)
	308
	309	/*
	310	* Control and status bits -- lereg1
	311	*/
	312	#define LE_CSR0 0
	313	#define LE_CSR1 1
	314	#define LE_CSR2 2
	315	#define LE_CSR3 3
	316
	317	#define LE_SERR 0x8000
	318	#define LE_BABL 0x4000
	319	#define LE_CERR 0x2000
	320	#define LE_MISS 0x1000
	321	#define LE_MERR 0x0800
	322	#define LE_RINT 0x0400
	323	#define LE_TINT 0x0200
	324	#define LE_IDON 0x0100
	325	#define LE_INTR 0x0080
	326	#define LE_INEA 0x0040
	327	#define LE_RXON 0x0020
	328	#define LE_TXON 0x0010
	329	#define LE_TDMD 0x0008
	330	#define LE_STOP 0x0004
	331	#define LE_STRT 0x0002
	332	#define LE_INIT 0x0001
	333
	334	#define LE_BSWP 0x4
	335	#define LE_MODE 0x0
	336
	337	/*
	338	* Control and status bits -- lereg2
	339	*/
	340	#define LE_OWN 0x8000
	341	#define LE_ERR 0x4000
	342	#define LE_STP 0x0200
	343	#define LE_ENP 0x0100
	344
	345	#define LE_FRAM 0x2000
	346	#define LE_OFLO 0x1000
	347	#define LE_CRC 0x0800
	348	#define LE_RBUFF 0x0400
	349
	350	#define LE_MORE 0x1000
	351	#define LE_ONE 0x0800
	352	#define LE_DEF 0x0400
	353
	354	#define LE_TBUFF 0x8000
	355	#define LE_UFLO 0x4000
	356	#define LE_LCOL 0x1000
	357	#define LE_LCAR 0x0800
	358	#define LE_RTRY 0x0400