Annotation of sys/arch/vax/boot/boot/if_ze.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: if_ze.c,v 1.5 2006/08/24 22:10:36 miod Exp $ */
2: /* $NetBSD: if_ze.c,v 1.12 2002/05/27 16:54:18 ragge Exp $ */
3: /*
4: * Copyright (c) 1998 James R. Maynard III. All rights reserved.
5: *
6: * Redistribution and use in source and binary forms, with or without
7: * modification, are permitted provided that the following conditions
8: * are met:
9: * 1. Redistributions of source code must retain the above copyright
10: * notice, this list of conditions and the following disclaimer.
11: * 2. Redistributions in binary form must reproduce the above copyright
12: * notice, this list of conditions and the following disclaimer in the
13: * documentation and/or other materials provided with the distribution.
14: * 3. All advertising materials mentioning features or use of this software
15: * must display the following acknowledgement:
16: * This product includes software developed by James R. Maynard III.
17: * 4. The name of the author may not be used to endorse or promote products
18: * derived from this software without specific prior written permission
19: *
20: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
21: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
22: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
23: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
24: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
29: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30: *
31: * Standalone routine for the SGEC Ethernet controller.
32: */
33:
34: #include <sys/param.h>
35: #include <sys/types.h>
36: #include <sys/socket.h>
37: #include <sys/queue.h>
38:
39: #include <net/if.h>
40:
41: #include <netinet/in.h>
42: #include <netinet/in_systm.h>
43: #include <netinet/if_ether.h>
44:
45: #include <lib/libsa/netif.h>
46: #include <lib/libsa/stand.h>
47: #include <lib/libsa/net.h>
48:
49: #include <arch/vax/if/sgecreg.h>
50:
51: #include "arch/vax/include/sid.h"
52: #include "arch/vax/include/rpb.h"
53:
54: #include "vaxstand.h"
55:
56: static int ze_get(struct iodesc *, void *, size_t, time_t);
57: static int ze_put(struct iodesc *, void *, size_t);
58:
59: #define ETHER_MIN_LEN 64
60: #define ETHER_MAX_LEN 1518
61:
62: struct netif_driver ze_driver = {
63: 0, 0, 0, 0, ze_get, ze_put,
64: };
65:
66: #define NRCV 8 /* allocate 8 receive descriptors */
67: #define NXMT 4 /* and 4 transmit - must be >1 */
68: #define SETUP_FRAME_LEN 128 /* length of the setup frame */
69:
70: /* allocate a buffer on an octaword boundary */
71: #define OW_ALLOC(x) ((void *)((int)((int)alloc((x) + 15) + 15) & ~15))
72:
73: static volatile struct zedevice *addr;
74:
75: struct ze_tdes *ze_tdes_list; /* transmit desc list */
76: struct ze_rdes *ze_rdes_list; /* and receive desc list */
77: u_char ze_myaddr[ETHER_ADDR_LEN]; /* my Ethernet address */
78:
79: int
80: zeopen(struct open_file *f, int adapt, int ctlr, int unit, int part)
81: {
82: u_long nicsr0_work, *nisa_rom;
83: struct ze_tdes *ze_setup_tdes_list;
84: int i;
85:
86: /* point to the device in memory */
87: if (askname == 0) /* Override if autoboot */
88: addr = (struct zedevice *)bootrpb.csrphy;
89: else
90: addr = (struct zedevice *)0x20008000;
91:
92: /* reset the device and wait for completion */
93: addr->ze_nicsr6 = ZE_NICSR6_MBO | ZE_NICSR6_RE;
94: while ((addr->ze_nicsr5 & ZE_NICSR5_ID) == 0)
95: ;
96: if (addr->ze_nicsr5 & ZE_NICSR5_SF) {
97: printf("SGEC self-test failed...\n");
98: return 1;
99: }
100:
101: /* Get our Ethernet address */
102: if (vax_boardtype == VAX_BTYP_49) {
103: nisa_rom = (u_long *)0x27800000;
104: for (i=0; i<ETHER_ADDR_LEN; i++)
105: ze_myaddr[i] = nisa_rom[i] & 0377;
106: } else if (vax_boardtype == VAX_BTYP_VXT) {
107: nisa_rom = (u_long *)0x200c4000;
108: for (i=0; i<ETHER_ADDR_LEN; i++)
109: ze_myaddr[i] = nisa_rom[i] & 0xff;
110: } else {
111: nisa_rom = (u_long *)0x20084000;
112: for (i=0; i<ETHER_ADDR_LEN; i++)
113: if (vax_boardtype == VAX_BTYP_660)
114: ze_myaddr[i] = (nisa_rom[i] & 0xff000000) >> 24;
115: else
116: ze_myaddr[i] = (nisa_rom[i] & 0x0000ff00) >> 8;
117: }
118: printf("SGEC: Ethernet address %s", ether_sprintf(ze_myaddr));
119:
120: /* initialize SGEC operating mode */
121: /* disable interrupts here */
122: nicsr0_work = ZE_NICSR0_IPL14 | ZE_NICSR0_SA | ZE_NICSR0_MBO |
123: (ZE_NICSR0_IV_MASK & 0x0108);
124: do {
125: addr->ze_nicsr0 = nicsr0_work;
126: } while (addr->ze_nicsr0 != nicsr0_work);
127: if (addr->ze_nicsr5 & ZE_NICSR5_ME)
128: addr->ze_nicsr5 |= ZE_NICSR5_ME;
129: /* reenable interrupts here */
130:
131: /* Allocate space for descriptor lists and buffers,
132: then initialize them. Set up both lists as a ring. */
133: ze_rdes_list = OW_ALLOC((NRCV+1) * sizeof(struct ze_rdes));
134: ze_tdes_list = OW_ALLOC((NXMT+1) * sizeof(struct ze_tdes));
135: for (i=0; i < NRCV; i++) {
136: bzero(ze_rdes_list+i,sizeof(struct ze_rdes));
137: ze_rdes_list[i].ze_framelen = ZE_FRAMELEN_OW;
138: ze_rdes_list[i].ze_bufsize = ETHER_MAX_LEN;
139: ze_rdes_list[i].ze_bufaddr = alloc(ETHER_MAX_LEN);
140: }
141: bzero(ze_rdes_list+NRCV,sizeof(struct ze_rdes));
142: ze_rdes_list[NRCV].ze_framelen = ZE_FRAMELEN_OW;
143: ze_rdes_list[NRCV].ze_rdes1 = ZE_RDES1_CA;
144: ze_rdes_list[NRCV].ze_bufaddr = (u_char *)ze_rdes_list;
145: for (i=0; i < NXMT; i++) {
146: bzero(ze_tdes_list+i,sizeof(struct ze_tdes));
147: ze_tdes_list[i].ze_tdes1 = ZE_TDES1_FS | ZE_TDES1_LS;
148: ze_tdes_list[i].ze_bufsize = ETHER_MAX_LEN;
149: ze_tdes_list[i].ze_bufaddr = alloc(ETHER_MAX_LEN);
150: }
151: bzero(ze_tdes_list+NXMT,sizeof(struct ze_tdes));
152: ze_tdes_list[NXMT].ze_tdes1 = ZE_TDES1_CA;
153: ze_tdes_list[NXMT].ze_tdr = ZE_TDR_OW;
154: ze_tdes_list[NXMT].ze_bufaddr = (u_char *)ze_tdes_list;
155:
156: printf("."); /* XXX VXT */
157:
158: /* Build setup frame. We set the SGEC to do a
159: perfect filter on our own address. */
160: ze_setup_tdes_list = OW_ALLOC(2*sizeof(struct ze_tdes));
161: bzero(ze_setup_tdes_list+0,2*sizeof(struct ze_tdes));
162: ze_setup_tdes_list[0].ze_tdr = ZE_TDR_OW;
163: ze_setup_tdes_list[0].ze_tdes1 = ZE_TDES1_DT_SETUP;
164: ze_setup_tdes_list[0].ze_bufsize = SETUP_FRAME_LEN;
165: ze_setup_tdes_list[0].ze_bufaddr = alloc(SETUP_FRAME_LEN);
166: bzero(ze_setup_tdes_list[0].ze_bufaddr,SETUP_FRAME_LEN);
167: for (i=0; i < 16; i++)
168: bcopy(ze_myaddr,ze_setup_tdes_list[0].ze_bufaddr+(8*i),
169: ETHER_ADDR_LEN);
170: ze_setup_tdes_list[1].ze_tdes1 = ZE_TDES1_CA;
171: ze_setup_tdes_list[1].ze_bufaddr = (u_char *)ze_setup_tdes_list;
172:
173: printf("."); /* XXX VXT */
174:
175: /* Start the transmitter and initialize almost everything else. */
176: addr->ze_nicsr4 = ze_setup_tdes_list;
177: addr->ze_nicsr6 = ZE_NICSR6_MBO | ZE_NICSR6_SE | ZE_NICSR6_ST |
178: ZE_NICSR6_DC | ZE_NICSR6_BL_4;
179: while ((addr->ze_nicsr5 & ZE_NICSR5_TS) != ZE_NICSR5_TS_SUSP)
180: ; /* wait for the frame to be processed */
181:
182: printf("."); /* XXX VXT */
183:
184: /* Setup frame is done processing, initialize the receiver and
185: point the transmitter to the real tdes list. */
186: addr->ze_nicsr4 = ze_tdes_list;
187: addr->ze_nicsr3 = ze_rdes_list;
188: addr->ze_nicsr6 |= ZE_NICSR6_SR;
189:
190: /* And away-y-y we go! */
191:
192: printf("\n");
193: net_devinit(f, &ze_driver, ze_myaddr);
194: return 0;
195: }
196:
197: int
198: ze_get(desc, pkt, maxlen, timeout)
199: struct iodesc *desc;
200: void *pkt;
201: size_t maxlen;
202: time_t timeout;
203: {
204: int timeout_ctr=100000*timeout, len, rdes;
205:
206: while (timeout_ctr-- > 0) {
207:
208: /* If there's not a packet waiting for us, just decrement the
209: timeout counter. */
210: if (!(addr->ze_nicsr5 & ZE_NICSR5_RI))
211: continue;
212:
213: /* Look through the receive descriptor list for the packet. */
214: for (rdes=0; rdes<NRCV; rdes++) {
215: if (ze_rdes_list[rdes].ze_framelen & ZE_FRAMELEN_OW)
216: continue;
217:
218: /* If the packet has an error, ignore it. */
219: if (ze_rdes_list[rdes].ze_rdes0 & ZE_RDES0_ES)
220: len = 0;
221:
222: /* Copy the packet, up to the length supplied by the caller, to
223: the caller's buffer. */
224: else {
225: if ((len = (ze_rdes_list[rdes].ze_framelen &
226: (~ ZE_FRAMELEN_OW))) > maxlen)
227: len = maxlen;
228: bcopy((void *)ze_rdes_list[rdes].ze_bufaddr,
229: pkt,len);
230: }
231:
232: /* Give ownership of this descriptor back to the SGEC. */
233: ze_rdes_list[rdes].ze_framelen = ZE_FRAMELEN_OW;
234:
235: /* If we actually got a good packet, reset the error flags and
236: tell the SGEC to look for more before returning. */
237: if (len > 0) {
238: addr->ze_nicsr5=ZE_NICSR5_RU | ZE_NICSR5_RI |
239: ZE_NICSR5_IS;
240: addr->ze_nicsr2=ZE_NICSR2_RXPD;
241: return len;
242: }
243: }
244: }
245:
246: /* If we're going to return an error indication, at least reset the
247: error flags and tell the SGEC to keep receiving first. */
248: addr->ze_nicsr5=ZE_NICSR5_RU | ZE_NICSR5_RI | ZE_NICSR5_IS;
249: addr->ze_nicsr2=ZE_NICSR2_RXPD;
250: return 0;
251: }
252:
253: int
254: ze_put(desc, pkt, len)
255: struct iodesc *desc;
256: void *pkt;
257: size_t len;
258: {
259: int timeout=100000;
260:
261: /* The SGEC maintains its position in the transmit descriptor list
262: for the next frame to transmit. Unfortunately, there's no way to tell
263: from software just where that is. We're forced to reset the position
264: whenever we send a frame, which requires waiting for the previous
265: frame to be sent. Argh. */
266: while ((addr->ze_nicsr5 & ZE_NICSR5_TS) == ZE_NICSR5_TS_RUN)
267: ;
268:
269: /* Copy the packet to the buffer we allocated. */
270: bcopy(pkt, (void *)ze_tdes_list[0].ze_bufaddr, len);
271:
272: /* Set the packet length in the descriptor, increasing it to the
273: minimum size if needed. */
274: ze_tdes_list[0].ze_bufsize = len;
275: if (len < ETHER_MIN_LEN)
276: ze_tdes_list[0].ze_bufsize = ETHER_MIN_LEN;
277:
278: /* Give ownership of the descriptor to the SGEC and tell it to start
279: transmitting. */
280: ze_tdes_list[0].ze_tdr = ZE_TDR_OW;
281: addr->ze_nicsr4 = ze_tdes_list;
282: addr->ze_nicsr1 = ZE_NICSR1_TXPD;
283:
284: /* Wait for the frame to be sent, but not too long. */
285: timeout = 100000;
286: while (((addr->ze_nicsr5 & ZE_NICSR5_TI) == 0) && (--timeout>0))
287: ;
288:
289: /* Reset the transmitter interrupt pending flag. */
290: addr->ze_nicsr5 |= ZE_NICSR5_TI;
291:
292: /* Return good if we didn't timeout, or error if we did. */
293: if (timeout>0) return len;
294: return -1;
295: }
296:
297: int
298: zeclose(struct open_file *f)
299: {
300: addr->ze_nicsr6 = ZE_NICSR6_RE;
301:
302: return 0;
303: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to if_ze.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / vax / boot / boot