![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_acereg.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / sys / tahoeif|
Return to if_acereg.h CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / sys / tahoeif |
1.1 root 1: /* */
2: /* ACC ethernet controller definitions, VERSAbus version */
3: /* product name V/EIU, unix name ACE */
4: /* */
5:
6: /* */
7: /* register definitions */
8: /* */
9: struct acedevice{
10: struct rx_addr_ram { /* receive address match ram. */
11: short station_addr[6]; /* Ethernet Station Addr */
12: short broadcast_en[2]; /* Broadcast Reception OK */
13: short mcast_hash_code[8]; /* Multicast Hash Code */
14: } rar;
15: short csr; /* hardwired control and status register */
16: short tseg; /* active transmit segment # */
17: short rseg; /* active receive segment # */
18: short segb; /* segment boundary register */
19: short lrf; /* lost receive frame counter */
20: short ivct; /* interrupt vector register. */
21: short nada0; /* -- reserved for future use -- */
22: short fcoll; /* force collision register. */
23: };
24:
25: /*
26: The following two structure define the format of "transmit and receive
27: segments" in the V/EIU's Dual-Ported Memory. Each segment is 2KBytes
28: long and buffers either an outgoing (transmit segment) or incoming
29: (receive segment) Ethernet Frame.
30: */
31:
32: struct tx_segment {
33: short tx_csr; /* control and status register */
34: char tx_data[2014]; /* frame buffer area */
35: short tx_backoff[16]; /* control and status register */
36: };
37:
38: struct rx_segment {
39: short rx_csr; /* control and status register */
40: char rx_data[2046]; /* frame buffer area */
41: };
42:
43: /*
44: The following two structures define the descriptors used to represent a logical
45: queue of Ethernet frames. The structure supports a FIFO queue mechanism.
46: For each queue there is a general control structure that tracks the location
47: of the first and last elements of the queue. Each element contains infromation
48: relating to the location of the Ethernet frame & the # of bytes it contains,
49: and the location of the next element in the queue.
50: */
51:
52: struct ace_element {
53: struct ace_element *pNext; /* ptr to the next element of the queue */
54: char *pFrame; /* ptr to Ethernet frame assoc w/ elem. */
55: };
56:
57:
58: struct ace_queue {
59: struct ace_element* phead; /* ptr to first element of queue */
60: struct ace_element* ptail; /* ptr to last element of queue */
61: };
62:
63:
64: /*
65: The following structure defines the statistics control block which maintains
66: the Ethernet data transfer statistics for a single V/EIU unit.
67: */
68:
69: struct ace_stats {
70: int rx_datagrams; /* # valid datagrams received */
71: int rx_crc_errors; /* # rcv'd w/ CRC errors */
72: int rx_overruns; /* # rcv'd too large( > 1514) */
73: int rx_underruns; /* # rcv'd too small( < 64) */
74: int rx_align_errors; /* # rcv'd w/ odd # bytes */
75: int rx_reserved; /* <reserved for future use> */
76: int rx_busy; /* # of busy recv segment */
77: int rx_mbuf; /* # of recvd mbufs */
78: int rx_oddoff; /* # of odd offset in recv mbuf */
79: int rx_rintcnt; /* # of incoming packets */
80: int rx_rwoint; /* # of recv WITHOUT interrpt */
81:
82: int tx_datagrams; /* # datagrams tx'd successful */
83: int tx_retries; /* # tx retries due to collision */
84: int tx_discarded; /* # tx dropped from >15 retries */
85: int tx_busy; /* # of busy xmit segment */
86: int tx_cbusy; /* # acecint() finds busy segment*/
87: int tx_mbuf; /* # of transmitted mbufs */
88: int tx_oddoff; /* # of odd offset in xmit mbuf */
89: int tx_outcnt; /* # of outputting requests */
90: int tx_startcnt; /* # of calls to acestart() */
91: int tx_cintcnt; /* # of completed transmissions */
92: int tx_xwoint; /* # of xmit WITHOUT interrpt */
93: };
94:
95: /*
96: The following structure defines the format of Ethernet Station Address and
97: the format of the Hash Code used by the V/EIU do filter receipt of multicast
98: datagram incoming from the Ethernet.
99: */
100:
101: struct station_addr {
102: char esa[6]; /* 6 byte field in address */
103: };
104:
105: struct hash_code {
106: char mhc[8]; /* 8 byte field in hash code */
107: };
108:
109: /*
110: The following structure defines the descriptor used to represent a logical
111: V/EIU unit. Often referred to as "Unit Control Block (UCB)", this structure
112: maintains information as to the location, state, and status of the controller.
113: */
114:
115: #ifdef INLINE
116: struct ace_unit {
117: struct ace_regs *pReg; /* ptr to unit's I/O registers */
118: char* pDpm; /* ptr to unit's Dual-Port Memory */
119: short segboundry; /* first Tx Seg in unit's DPM */
120: short eictr; /* Rx segment tracking counter */
121: short eoctr; /* Tx segment tracking counter */
122: short tx_next; /* next available Tx segment ctr */
123: EVENTCOUNT rx_arrived; /* received frames eventcounter */
124: EVENTCOUNT rx_processed; /* rx'd & processed frames EC */
125: EVENTCOUNT tx_complete; /* tx'd frames eventcounter */
126: SEMAPHORE rx_semaphore; /* receive frame semaphore */
127: SEMAPHORE tx_semaphore; /* transmit frame semaphore */
128: short cur_rnd; /* current random # value */
129: short diag_code; /* diagnostic error & test codes */
130: short state; /* status of unit */
131: struct ace_queue rx_queue; /* received frame queue */
132: struct ace_queue av_queue; /* available queue (free list) */
133: struct ace_element av_elements[9]; /* unit queue elements */
134: struct ace_stats statistics; /* unit's statistics */
135: short rx_reset; /* receive code's reset ctl word */
136: short tx_reset; /* transmit code's reset ctl word */
137: short rx_waiting; /* receiver sleeping status flag */
138: short tx_waiting; /* transmitter sleeping status flg*/
139: };
140: #endif INLINE
141:
142: /*
143: V/EIU CONTROL/STATUS REGISTER BIT DEFINITIONS
144: =============================================
145:
146: The following defines the bits in the V/EIU's "Control/Status Register".
147: Each bit definition is followed by a brief description which includes
148: a reference to its read/write capabilities as well as it's active state
149: if appropriate. "r/w" := read/write, "r" := read only, and "w" := write
150: only. "aL" := active LOW and "aH" := active high". The first three letters
151: of the bits' names, "CSR", indicate definition for the "CSR register" only.
152: */
153:
154: #define CSR_UNUSED 0xFD00 /* unused bits "??_??" */
155: #define CSR_ENXMITODD 0x0200 /* Enable Odd # byte transmission "rw_aH" */
156: #define CSR_ACTIVE 0x0080 /* V/EIU is active & running "r _aH" */
157: #define CSR_RESET 0x0040 /* V/EIU reset control line " w_aH" */
158: #define CSR_PROMISCUOUS 0x0020 /* Enable "promiscous mode" operation"rw_aH" */
159: #define CSR_NOXMITCRC 0x0010 /* Disable CRC generation & checking "rw_aH" */
160: #define CSR_LOOP3 0x0008 /* Enable MODE 3 LOOPBACK mode "rw_aH" */
161: #define CSR_LOOP2 0x0004 /* Enable MODE 2 LOOPBACK mode "rw_aH" */
162: #define CSR_ENINT 0x0002 /* Enable Interrupts to VERSAbus "rw_aH" */
163: #define CSR_GO 0x0001 /* Enable V/EIU operations " w_aH" */
164:
165: /*
166: V/EIU VALID BIT MASKS
167: =====================
168:
169: The following defines the valid bits of "short" fields contained in
170: the V/EIU's "Receive Address Match Ram". The first three letters
171: of the masks' names indicate definition for the following:
172: RAR ==> Receive Address Ram IVC ==> Interrupt Vector Register
173: LRF ==> Lost Receive Frame Counter FCL ==> Force Collision Register
174: */
175:
176: #define RAR_VALID 0x00FF /* Valid bits in Receive Address Ram fields */
177: #define LRF_VALID 0x000F /* Valid bits in Lost Receive Frame register */
178: #define IVC_VALID 0x00F8 /* Valid bits in Interrupt Vector register */
179: #define FCL_VALID 0xFFFF /* Valid bits in Force Collision register */
180:
181: /*
182: V/EIU TRANSMIT SEGMENT CONTROL/STATUS BIT DEFINITIONS
183: =====================================================
184:
185: The following defines the bit-fields in the "Control/Status Field" of a
186: Transmit Segment in the V/EIU's Dual-Ported Memory. There are two
187: types of bit-fields it this field, those that produce a response by the
188: V/EIU ("command") and those that indicate the response ("status")
189: The first three letters of the bits' names, "TCS", indicate definition
190: for the "Tx segment CSr" only.
191: */
192:
193: /* commands */
194: #define TCS_TBFULL (short)0x8000 /* Tx Bfr Full so send it */
195: #define TCS_TBC (short)0x07FF /* Tx Byte Count */
196: /* status */
197: #define TCS_TBMT (short)0x8000 /* Tx Buffer Empty (avail for Tx) */
198: #define TCS_RTFAIL (short)0x4000 /* Tx Retries Failed (frame dropped)*/
199: #define TCS_RTC (short)0x000F /* Tx # Retries which collided */
200:
201: /*
202: V/EIU RECEIVE SEGMENT CONTROL/STATUS BIT DEFINITIONS
203: ====================================================
204:
205: The following defines the bit-fields in the "Control/Status Field" of a
206: Receive Segment in the V/EIU's Dual-Ported Memory. There are two
207: types of bit-fields it this field, those that produce a response by the
208: V/EIU ("command") and those that indicate the response ("status")
209: The first three letters of the bits' names, "RCS", indicate definition
210: for the "Rx segment CSr" only.
211: */
212:
213: #define RCS_RBMT 0x8000 /* command: Rx Bfr Empty (avail for Rx) */
214: #define RCS_RBFULL 0x8000 /* status : Rx Bfr Full (frame Rx'd) */
215: #define RCS_ROVRN 0x4000 /* : Rx Bfr Overrun Error (too long) */
216: #define RCS_RCRC 0x2000 /* : Rx Bfr CRC Error (bad data) */
217: #define RCS_RODD 0x1000 /* : Rx Bfr Alignment Error (odd cnt) */
218: #define RCS_RBC 0x07FF /* : Rx Bfr Byte Count */
219:
220: /*
221: V/EIU SPECIAL FUNCTION CODE DEFINITIONS
222: =======================================
223:
224: The following define the valid functions codes available for use with
225: the "spfun ()" entry point into this driver.
226: */
227:
228: #define ACE_INIT 0x0001 /* V/EIU Initialize command */
229: #define ACE_RESP 0x0002 /* V/EIU Initialize response */
230: #define ACE_STATS 0x0003 /* V/EIU Statistics query */
231: #define ACE_ECMAP 0x0004 /* V/EIU Event counter map request */
232: #define ACE_IOPORTS 0x0005 /* V/EIU I/O Ports Dump */
233: #define ACE_UCBSTATS 0x0006 /* V/EIU UCB contents Dump */
234:
235: /*
236: V/EIU RETURNED ERROR CODES
237: ==========================
238:
239: The following define the range of error codes which may be returned by
240: this driver to calling user processes. The first letter of the error code's
241: names, "E", indicates definition for "returned error codes" only.
242: */
243:
244: #define E_BADDEV (-100) /* illegal minor device */
245: #define E_OFFLINE (-101) /* requested unit is not on-line */
246: #define E_LOSTSYNC (-102) /* driver syncronization lost w/ hardware */
247: #define E_SIGNALED (-103) /* I/O request terminated due to signal() */
248: #define E_2BIG (-104) /* transmit request for oversize frame */
249: #define E_2SMALL (-105) /* receive request for undersize frame */
250: #define E_BADCALL (-106) /* illegal "spfun()" call */
251: #define E_RESET (-107) /* unit reset while waiting for i/o to end*/
252:
253: /*
254: V/EIU MISCELLANEOUS DEFINTIIONS
255: ===============================
256:
257: The following are miscellaneous constant definitions and come from
258: a number of places for a number of different reasons.
259: */
260:
261: #define ACE_OFFLINE 0 /* off-line unit status */
262: #define ACE_ONLINE 0 /* on-line unit status */
263: #define CRC_SIZE 4 /* number of bytes in a rx seg's CRC */
264: #define RCW_SIZE 2 /* number of bytes in a rx seg's csr */
265: #define M_READ "read" /* read diagnostic string */
266: #define M_WRITE "write" /* write diagnostic string */
267: #define SEG_MAX 15 /* largest valid V/EIU segment number */
268: #define MXRXPKTSZ 1516 /* max. size of allowed rx/tx frames +RCW */
269: #define ET_MINLEN 64 /* min. size of allowed rx/tx frames */
270: #define ET_MAXLEN 1514 /* max. size of rx/tx frames w/o CRC & RCW*/
271: #define EC_ARRIVED 42 /* EC mapping number for "rx_arrived EC */
272: #define EC_PROCESSED 43 /* EC mapping number for "rx_processed EC */
273: #define RX_ARVD_EC 42 /* Select code for rx_arrived EC mapping */
274: #define RX_PRCD_EC 43 /* Select code for rx_processed EC mapping*/
275:
276:
277: /*
278: * Ethernet software status per interface.
279: *
280: * Each interface is referenced by a network interface structure,
281: * is_if, which the routing code uses to locate the interface.
282: * This structure contains the output queue for the interface, its address, ...
283: */
284: struct ace_softc {
285: struct arpcom is_ac; /* Ethernet common part */
286: #define is_if is_ac.ac_if /* network-visible interface */
287: #define is_addr is_ac.ac_enaddr /* hardware Ethernet address */
288: char *is_dpm;
289: short is_flags;
290: #define ACEF_OACTIVE 0x1 /* output is active */
291: #define ACEF_RCVPENDING 0x2 /* start rcv in acecint */
292: short is_promiscuous; /* true is enabled */
293: short is_segboundry; /* first TX Seg in dpm */
294: short is_eictr; /* Rx segment tracking ctr */
295: short is_eoctr; /* Tx segment tracking ctr */
296: short is_txnext; /* Next available Tx segment */
297: short is_currnd; /* current random backoff */
298: struct ace_stats is_stats; /* holds board statistics */
299: short is_xcnt; /* count xmitted segments to be acked
300: by the controller */
301: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.