![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ne2100.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / arch / i386 / netboot|
Return to ne2100.c CVS log | Up to [Net/2] / Net2 / arch / i386 / netboot |
1.1 root 1: /* netboot
2: *
3: * ne2100.c,v
4: * Revision 1.1 1993/07/08 16:04:05 brezak
5: * Diskless boot prom code from Jim McKim ([email protected])
6: *
7: * Revision 1.1.1.1 1993/05/28 11:41:07 mckim
8: * Initial version.
9: *
10: *
11: * source in this file came from
12: * the Mach ethernet boot written by Leendert van Doorn.
13: *
14: * A very simple network driver for NE2100 boards that polls.
15: *
16: * Copyright (c) 1992 by Leendert van Doorn
17: */
18:
19: #include "assert.h"
20: #include "nbtypes.h"
21: #include "packet.h"
22: #include "ether.h"
23: #include "lance.h"
24: #include "proto.h"
25:
26: /* configurable parameters */
27: #define NE_BASEREG 0x300 /* base register */
28: #define NE_DMACHANNEL 5 /* DMA channel */
29:
30: /* Lance register offsets */
31: #define LA_CSR (NE_BASEREG+0x10)
32: #define LA_CSR1 (NE_BASEREG+0x10)
33: #define LA_CSR2 (NE_BASEREG+0x10)
34: #define LA_CSR3 (NE_BASEREG+0x10)
35: #define LA_RAP (NE_BASEREG+0x12)
36:
37: /*
38: * Some driver specific constants.
39: * Take care when tuning, this program only has 32 Kb
40: */
41: #define LANCEBUFSIZE 1518 /* plus 4 CRC bytes */
42: #define MAXLOOP 1000000L /* arbitrary retry limit */
43: #define LOG2NRCVRING 2 /* log2(NRCVRING) */
44: #define NRCVRING (1 << LOG2NRCVRING)
45:
46: u_char eth_myaddr[ETH_ADDRSIZE];
47:
48: static int next_rmd; /* next receive element */
49: static initblock_t *initblock; /* initialization block */
50: static tmde_t *tmd; /* transmit ring */
51: static rmde_t *rmd; /* receive ring */
52: static char rbuffer[NRCVRING][LANCEBUFSIZE]; /* receive buffers */
53:
54: static char *top = (char *)RAMSIZE;
55: static char last;
56:
57: static char *
58: aalloc(size, align)
59: int size, align;
60: {
61: register char *p;
62: register int mask;
63:
64: if (align == 0)
65: align = sizeof(int);
66: mask = align - 1;
67: assert((align & mask) == 0);
68: top = top - (size + align);
69: p = (char *)((int)top & ~mask);
70: assert(p > &last);
71: assert(p <= (char *) RAMSIZE);
72: return top = p;
73: }
74:
75: /*
76: * Program DMA channel 'chan' for cascade mode
77: */
78: static void
79: dma_cascade(chan)
80: int chan;
81: {
82: assert(chan >= 0);
83: assert(chan <= 7);
84: if (chan >= 0 && chan <= 3) {
85: outb(0x0B, 0xC0 | (chan & 03));
86: outb(0x0A, chan & 03);
87: } else {
88: outb(0xD6, 0xC0 | ((chan - 4) & 03));
89: outb(0xD4, (chan - 4) & 03);
90: }
91: }
92:
93: /*
94: * Reset ethernet board (i.e. after a timeout)
95: */
96: void
97: EtherReset(void) {
98: long l;
99: u_long addr;
100: int i;
101:
102: /* program DMA chip */
103: dma_cascade(NE_DMACHANNEL);
104:
105: /* stop the chip, and make sure it did */
106: outw(LA_RAP, RDP_CSR0);
107: outw(LA_CSR, CSR_STOP);
108: for (l = 0; (inw(LA_CSR) & CSR_STOP) == 0; l++) {
109: if (l >= MAXLOOP) {
110: printf("Lance failed to stop\n");
111: return;
112: }
113: }
114:
115: /* fill lance initialization block */
116: bzero(initblock, sizeof(initblock_t));
117:
118: /* set my ethernet address */
119: initblock->ib_padr[0] = eth_myaddr[0];
120: initblock->ib_padr[1] = eth_myaddr[1];
121: initblock->ib_padr[2] = eth_myaddr[2];
122: initblock->ib_padr[3] = eth_myaddr[3];
123: initblock->ib_padr[4] = eth_myaddr[4];
124: initblock->ib_padr[5] = eth_myaddr[5];
125:
126: /* receive ring pointer */
127: addr = LA(rmd);
128: initblock->ib_rdralow = (u_short)addr;
129: initblock->ib_rdrahigh = (u_char)(addr >> 16);
130: initblock->ib_rlen = LOG2NRCVRING << 5;
131:
132: /* transmit ring with one element */
133: addr = LA(tmd);
134: initblock->ib_tdralow = (u_short)addr;
135: initblock->ib_tdrahigh = (u_char)(addr >> 16);
136: initblock->ib_tlen = 0 << 5;
137:
138: /* setup the receive ring entries */
139: for (next_rmd = 0, i = 0; i < NRCVRING; i++) {
140: addr = LA(&rbuffer[i]);
141: rmd[i].rmd_ladr = (u_short)addr;
142: rmd[i].rmd_hadr = (u_char)(addr >> 16);
143: rmd[i].rmd_mcnt = 0;
144: rmd[i].rmd_bcnt = -LANCEBUFSIZE;
145: rmd[i].rmd_flags = RMD_OWN;
146: }
147:
148: /* zero transmit ring */
149: bzero(tmd, sizeof(tmde_t));
150:
151: /* give lance the init block */
152: addr = LA(initblock);
153: outw(LA_RAP, RDP_CSR1);
154: outw(LA_CSR1, (u_short)addr);
155: outw(LA_RAP, RDP_CSR2);
156: outw(LA_CSR2, (char)(addr >> 16));
157: outw(LA_RAP, RDP_CSR3);
158: outw(LA_CSR3, 0);
159:
160: /* and initialize it */
161: outw(LA_RAP, RDP_CSR0);
162: outw(LA_CSR, CSR_INIT|CSR_STRT);
163:
164: /* wait for the lance to complete initialization and fire it up */
165: for (l = 0; (inw(LA_CSR) & CSR_IDON) == 0; l++) {
166: if (l >= MAXLOOP) {
167: printf("Lance failed to initialize\n");
168: break;
169: }
170: }
171: for (l=0; (inw(LA_CSR)&(CSR_TXON|CSR_RXON))!=(CSR_TXON|CSR_RXON); l++) {
172: if (l >= MAXLOOP) {
173: printf("Lance not started\n");
174: break;
175: }
176: }
177: }
178:
179: /*
180: * Get ethernet address and compute checksum to be sure
181: * that there is a board at this address.
182: */
183: int
184: EtherInit()
185: {
186: u_short checksum, sum;
187: int i;
188:
189: for (i = 0; i < 6; i++)
190: eth_myaddr[i] = inb(NE_BASEREG + i);
191:
192: sum = 0;
193: for (i = 0x00; i <= 0x0B; i++)
194: sum += inb(NE_BASEREG + i);
195: for (i = 0x0E; i <= 0xF; i++)
196: sum += inb(NE_BASEREG + i);
197: checksum = inb(NE_BASEREG + 0x0C) | (inb(NE_BASEREG + 0x0D) << 8);
198: if (sum != checksum)
199: return 0;
200:
201: /* initblock, tmd, and rmd should be 8 byte aligned ! */
202: initblock = (initblock_t *) aalloc(sizeof(initblock_t), 8);
203: tmd = (tmde_t *) aalloc(sizeof(tmde_t), 8);
204: rmd = (rmde_t *) aalloc(NRCVRING * sizeof(rmde_t), 8);
205: EtherReset();
206: return 1;
207: }
208:
209: /*
210: * Disable DMA for channel 'chan'
211: */
212: static void
213: dma_done(chan)
214: int chan;
215: {
216: assert(chan >= 0);
217: assert(chan <= 7);
218: if (chan >= 0 && chan <= 3)
219: outb(0x0A, 0x04 | (chan & 03));
220: else
221: outb(0xD4, 0x04 | ((chan - 4 ) & 03));
222: }
223:
224: /*
225: * Stop ethernet board
226: */
227: void
228: EtherStop()
229: {
230: long l;
231:
232: /* stop chip and disable DMA access */
233: outw(LA_RAP, RDP_CSR0);
234: outw(LA_CSR, CSR_STOP);
235: for (l = 0; (inw(LA_CSR) & CSR_STOP) == 0; l++) {
236: if (l >= MAXLOOP) {
237: printf("Lance failed to stop\n");
238: break;
239: }
240: }
241: dma_done(NE_DMACHANNEL);
242: }
243:
244: /*
245: * Send an ethernet packet to destination 'dest'
246: */
247: void
248: EtherSend(pkt, proto, dest)
249: packet_t *pkt;
250: u_short proto;
251: u_char *dest;
252: {
253: ethhdr_t *ep;
254: long l;
255: u_long addr;
256: u_short csr;
257:
258: /* add ethernet header and fill in source & destination */
259: pkt->pkt_len += sizeof(ethhdr_t);
260: pkt->pkt_offset -= sizeof(ethhdr_t);
261: ep = (ethhdr_t *) pkt->pkt_offset;
262: ep->eth_proto = htons(proto);
263: bcopy(dest, ep->eth_dst, ETH_ADDRSIZE);
264: bcopy(eth_myaddr, ep->eth_src, ETH_ADDRSIZE);
265: if (pkt->pkt_len < 60)
266: pkt->pkt_len = 60;
267: assert(pkt->pkt_len <= 1514);
268:
269: /* set up transmit ring element */
270: assert((tmd->tmd_flags & TMD_OWN) == 0);
271: addr = LA(pkt->pkt_offset);
272: assert((addr & 1) == 0);
273: tmd->tmd_ladr = (u_short)addr;
274: tmd->tmd_hadr = (u_char)(addr >> 16);
275: tmd->tmd_bcnt = -pkt->pkt_len;
276: tmd->tmd_err = 0;
277: tmd->tmd_flags = TMD_OWN|TMD_STP|TMD_ENP;
278:
279: /* start transmission */
280: outw(LA_CSR, CSR_TDMD);
281:
282: /* wait for interrupt and acknowledge it */
283: for (l = 0; l < MAXLOOP; l++) {
284: if ((csr = inw(LA_CSR)) & CSR_TINT) {
285: outw(LA_CSR, CSR_TINT);
286: break;
287: }
288: }
289: }
290:
291: /*
292: * Poll the LANCE just see if there's an Ethernet packet
293: * available. If there is, its contents is returned in a
294: * pkt structure, otherwise a nil pointer is returned.
295: */
296: packet_t *
297: EtherReceive(void) {
298: packet_t *pkt;
299: rmde_t *rp;
300: u_long addr;
301: u_short csr;
302:
303: pkt = (packet_t *)0;
304: if ((csr = inw(LA_CSR)) & CSR_RINT) {
305: outw(LA_CSR, CSR_RINT);
306: assert(next_rmd >= 0);
307: assert(next_rmd <= NRCVRING);
308: rp = &rmd[next_rmd];
309: if ((rp->rmd_flags & ~RMD_OFLO) == (RMD_STP|RMD_ENP)) {
310: pkt = PktAlloc(0);
311: pkt->pkt_len = rp->rmd_mcnt - 4;
312: assert(pkt->pkt_len >= 0);
313: assert(pkt->pkt_len < PKT_DATASIZE);
314: bcopy(rbuffer[next_rmd], pkt->pkt_offset, pkt->pkt_len);
315: /* give packet back to the lance */
316: rp->rmd_bcnt = -LANCEBUFSIZE;
317: rp->rmd_mcnt = 0;
318: rp->rmd_flags = RMD_OWN;
319: }
320: next_rmd = (next_rmd + 1) & (NRCVRING - 1);
321: }
322: return pkt;
323: }
324:
325: /*
326: * Print an ethernet address in human readable form
327: */
328: void
329: EtherPrintAddr(addr)
330: u_char *addr;
331: {
332: printf("%x:%x:%x:%x:%x:%x",
333: addr[0] & 0xFF, addr[1] & 0xFF, addr[2] & 0xFF,
334: addr[3] & 0xFF, addr[4] & 0xFF, addr[5] & 0xFF);
335: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.