![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_ns8390.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / i386 / i386at|
Return to if_ns8390.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at |
1.1 root 1: /*
2: * Mach Operating System
3: * Copyright (c) 1991,1990,1989 Carnegie Mellon University
4: * All Rights Reserved.
5: *
6: * Permission to use, copy, modify and distribute this software and its
7: * documentation is hereby granted, provided that both the copyright
8: * notice and this permission notice appear in all copies of the
9: * software, derivative works or modified versions, and any portions
10: * thereof, and that both notices appear in supporting documentation.
11: *
12: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
13: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
14: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
15: *
16: * Carnegie Mellon requests users of this software to return to
17: *
18: * Software Distribution Coordinator or [email protected]
19: * School of Computer Science
20: * Carnegie Mellon University
21: * Pittsburgh PA 15213-3890
22: *
23: * any improvements or extensions that they make and grant Carnegie Mellon
24: * the rights to redistribute these changes.
25: */
26: /* NOTE:
27: * There are three outstanding bug/features in this implementation.
28: * They may even be hardware misfeatures. The conditions are registered
29: * by counters maintained by the software.
30: * 1: over_write is a condition that means that the board wants to store
31: * packets, but there is no room. So new packets are lost. What seems to
32: * be happening is that we get an over_write condition, but there are no
33: * or just a few packets in the board's ram. Also it seems that we get
34: * several over_writes in a row.
35: * 2: Since there is only one transmit buffer, we need a lock to indicate
36: * whether it is in use. We clear this lock when we get a transmit interrupt.
37: * Sometimes we go to transmit and although there is no transmit in progress,
38: * the lock is set. (In this case, we just ignore the lock.) It would look
39: * like we can miss transmit interrupts?
40: * 3: We tried to clean up the unnecessary switches to bank 0.
41: * Unfortunately, when you do an ifconfig "down", the system tend to lock up
42: * a few seconds later (this was when DSF_RUNNING) was not being set before.
43: * But even with DSF_RUNNING, on an EISA bus machine we ALWAYS lock up after
44: * a few seconds.
45: */
46:
47: /*
48: * Western Digital 8003E Mach Ethernet driver (for intel 80386)
49: * Copyright (c) 1990 by Open Software Foundation (OSF).
50: */
51:
52: /*
53: Copyright 1990 by Open Software Foundation,
54: Cambridge, MA.
55:
56: All Rights Reserved
57:
58: Permission to use, copy, modify, and distribute this software and
59: its documentation for any purpose and without fee is hereby granted,
60: provided that the above copyright notice appears in all copies and
61: that both the copyright notice and this permission notice appear in
62: supporting documentation, and that the name of OSF or Open Software
63: Foundation not be used in advertising or publicity pertaining to
64: distribution of the software without specific, written prior
65: permission.
66:
67: OSF DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
68: <INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
69: IN NO EVENT SHALL OSF BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
70: CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
71: LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
72: NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
73: WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
74: */
75:
76: #define IF_CNTRS MACH
77:
78: #include <ns8390.h>
79: #if NNS8390 > 0
80:
81: #include <mach_ttd.h>
82: #include <kern/time_out.h>
83: #include <device/device_types.h>
84: #include <device/errno.h>
85: #include <device/io_req.h>
86: #include <device/if_hdr.h>
87: #include <device/if_ether.h>
88: #include <device/net_status.h>
89: #include <device/net_io.h>
90: #include "vm_param.h"
91: #include <i386/ipl.h>
92: #include <chips/busses.h>
93: #include <i386at/ds8390.h>
94: #include <i386at/if_wd8003.h>
95: #include <i386at/if_3c503.h>
96:
97: #if MACH_TTD
98: #include <ttd/ttd_stub.h>
99: #endif /* MACH_TTD */
100:
101:
102: #define SPLNET spl6
103:
104: int wd_debug = 0;
105:
106: int ns8390probe();
107: void ns8390attach();
108: int ns8390intr();
109: int ns8390init();
110: int ns8390output();
111: int ns8390ioctl();
112: int ns8390reset();
113: int ns8390rcv();
114: int ns8390watch();
115: int ns8390get_CURR();
116: int ns8390over_write();
117:
118: struct bus_device *ns8390info[NNS8390]; /* ???? */
119:
120: static vm_offset_t ns8390_std[NNS8390] = { 0 };
121: static struct bus_device *ns8390_info[NNS8390];
122: struct bus_driver ns8390driver =
123: {ns8390probe, 0, ns8390attach, 0, ns8390_std, "ns8390", ns8390_info, 0, 0, 0};
124:
125: int watchdog_id;
126:
127: char *wd8003_card = "wd";
128: char *elii_card = "el";
129: /* 2e0, 2a0, 280, 250, 350, 330, 310, 300*/
130: int elii_irq[8] = {5, 2, 2, 5, 5, 0x711, 0x711, 5};
131: int elii_bnc[8] = {1, 0, 1, 1, 0, 0x711, 0x711, 0};
132: /*int elii_bnc[8] = {0, 1, 1, 1, 1, 1, 0, 1}; */
133:
134: typedef struct {
135: #ifdef MACH_KERNEL
136: struct ifnet ds_if; /* generic interface header */
137: u_char ds_addr[6]; /* Ethernet hardware address */
138: #else MACH_KERNEL
139: struct arpcom ns8390_ac;
140: #define ds_if ns8390_ac.ac_if
141: #define ds_addr ns8390_ac.ac_enaddr
142: #endif MACH_KERNEL
143: int flags;
144: int timer;
145: int interrupt;
146: char *nic;
147: u_char address[ETHER_ADDR_SIZE];
148: short mode;
149: int tbusy;
150: char *sram; /* beginning of the shared memory RAM buffer */
151: int read_nxtpkt_ptr;/* pointer to next packet available */
152: int pstart; /* page start hold */
153: int pstop; /* page stop hold */
154: int tpsr; /* transmit page start hold */
155: int fifo_depth; /* NIC fifo threshold */
156: char *card;
157: int board_id;
158: }
159: ns8390_softc_t;
160:
161: ns8390_softc_t ns8390_softc[NNS8390];
162:
163: struct ns8390_cntrs {
164: u_int ovw,
165: jabber,
166: crc,
167: frame,
168: miss,
169: fifo,
170: rcv;
171: u_int xmt,
172: xmti,
173: busy,
174: heart;
175: } ns8390_cntrs[NNS8390];
176:
177: #if MACH_TTD
178: boolean_t ttd_poll_loop;
179:
180: int ns8390poll_receive();
181: int ns8390transmit_ttd();
182: #endif /* MACH_TTD */
183:
184: #ifdef IF_CNTRS
185: int ns_narp = 1, ns_arp = 0;
186: int ns_ein[32], ns_eout[32];
187: int ns_lin[128/8], ns_lout[128/8];
188: static
189: log_2(no)
190: unsigned long no;
191: {
192: return ({ unsigned long _temp__;
193: asm("bsr %1, %0; jne 0f; xorl %0, %0; 0:" :
194: "=r" (_temp__) : "a" (no));
195: _temp__;});
196: }
197: #endif IF_CNTRS
198:
199: /* Interrupts mask bits */
200: int imr_hold = DSIM_PRXE|DSIM_PTXE|DSIM_RXEE|DSIM_TXEE|DSIM_OVWE|DSIM_CNTE;
201:
202: /*
203: * ns8390probe:
204: *
205: * This function "probes" or checks for the wd8003 board on the bus to see
206: * if it is there. As far as I can tell, the best break between this
207: * routine and the attach code is to simply determine whether the board
208: * is configured in properly. Currently my approach to this is to test the
209: * base I/O special offset for the Western Digital unique byte sequence
210: * identifier. If the bytes match we assume board is there.
211: * The config code expects to see a successful return from the probe
212: * routine before attach will be called.
213: *
214: * input : address device is mapped to, and unit # being checked
215: * output : a '1' is returned if the board exists, and a 0 otherwise
216: *
217: */
218:
219: ns8390probe(port, dev)
220: struct bus_device *dev;
221: {
222: caddr_t hdwbase = (caddr_t)dev->address;
223: int unit = dev->unit;
224: ns8390_softc_t *sp = &ns8390_softc[unit];
225: int tmp;
226: int vendor_id;
227:
228: if ((unit < 0) || (unit > NNS8390)) {
229: printf("ns8390 ethernet unit %d out of range\n", unit);
230: return(0);
231: }
232: if (((u_char) inb(hdwbase+IFWD_LAR_0) == (u_char) WD_NODE_ADDR_0) &&
233: ((u_char) inb(hdwbase+IFWD_LAR_1) == (u_char) WD_NODE_ADDR_1) &&
234: ((u_char) inb(hdwbase+IFWD_LAR_2) == (u_char) WD_NODE_ADDR_2)) {
235: ns8390info[unit] = dev;
236: sp->card = wd8003_card;
237: dev->name = wd8003_card;
238: sp->nic = hdwbase + OFF_8390;
239: /* enable mem access to board */
240: sp->board_id = wd80xxget_board_id(dev);
241:
242: *(sp->address) = inb(hdwbase+IFWD_LAR_0);
243: *(sp->address + 1) = inb(hdwbase+IFWD_LAR_1);
244: *(sp->address + 2) = inb(hdwbase+IFWD_LAR_2);
245: *(sp->address + 3) = inb(hdwbase+IFWD_LAR_3);
246: *(sp->address + 4) = inb(hdwbase+IFWD_LAR_4);
247: *(sp->address + 5) = inb(hdwbase+IFWD_LAR_5);
248: return (1);
249: } /* checks the address of the board to verify that it is a WD */
250:
251: /* try to avoid any NE2000 pretending to be an el II */
252: if (inb(hdwbase + 0x408) == 0xff)
253: return 0;
254:
255: /* check vendor id */
256: tmp = inb(hdwbase + CTLR);
257:
258: outb(hdwbase + CTLR, CTLR_RST|CTLR_THIN); /* Reset it... */
259: outb(hdwbase + CTLR, CTLR_THIN);
260: /*
261: * Map the station addr PROM into the lower I/O ports. We now
262: * check for both the old and new 3Com prefix
263: */
264: outb(hdwbase + CTLR, CTLR_STA_ADDR|CTLR_THIN);
265: vendor_id = inb(hdwbase)*0x10000 + inb(hdwbase + 1)*0x100 +
266: inb(hdwbase + 2);
267: /* Restore the register we frobbed. */
268: outb(hdwbase + CTLR, tmp);
269: if ((vendor_id != OLD_3COM_ID) && (vendor_id != NEW_3COM_ID))
270: return 0;
271:
272: if ((tmp = inb(hdwbase+BCFR))) {
273: switch(tmp) {
274: case (1<<7): sp->board_id = 7; break; /*irq5 xvcr*/
275: #ifdef not_currently_possible
276: case (1<<6): sp->board_id = 6; break;
277: case (1<<5): sp->board_id = 5; break;
278: #endif not_currently_possible
279: case (1<<4): sp->board_id = 4; break;
280: case (1<<3): sp->board_id = 3; break;
281: case (1<<2): sp->board_id = 2; break; /*irq2 bnc*/
282: case (1<<1): sp->board_id = 1; break; /*irq2 xvcr*/
283: case (1<<0): sp->board_id = 0; break; /*irq5 bnc*/
284: default: return 0;
285: }
286: switch (inb(hdwbase+PCFR)) {
287: case (1<<7): dev->phys_address = 0xDC000; break;
288: case (1<<6): dev->phys_address = 0xD8000; break;
289: #ifdef not_currently_possible
290: case (1<<5): dev->phys_address = 0xCC000; break;
291: case (1<<4): dev->phys_address = 0xC8000; break;
292: #endif not_currently_possible
293: default:
294: printf("EtherLink II with NO memory configured\n");
295: return 0;
296: }
297: ns8390info[unit] = dev;
298: dev->sysdep1 = elii_irq[sp->board_id];
299: if (dev->sysdep1 == 2)
300: dev->sysdep1 = 9;
301: sp->card = elii_card;
302: dev->name = elii_card;
303: sp->nic = hdwbase;
304: return 1;
305: }
306:
307: return(0);
308: }
309:
310: /*
311: * ns8390attach:
312: *
313: * This function attaches a ns8390 board to the "system". The rest of
314: * runtime structures are initialized here (this routine is called after
315: * a successful probe of the board). Once the ethernet address is read
316: * and stored, the board's ifnet structure is attached and readied.
317: *
318: * input : bus_device structure setup in autoconfig
319: * output : board structs and ifnet is setup
320: *
321: */
322:
323: void ns8390attach(dev)
324: struct bus_device *dev;
325: {
326: ns8390_softc_t *sp;
327: struct ifnet *ifp;
328: u_char unit;
329: int temp;
330:
331: take_dev_irq(dev);
332: unit = (u_char)dev->unit;
333: sp = &ns8390_softc[unit];
334: printf(", port = %x, spl = %d, pic = %d. ",
335: dev->address, dev->sysdep, dev->sysdep1);
336:
337: if (sp->card == elii_card) {
338: if (elii_bnc[sp->board_id])
339: printf("cheapernet ");
340: else
341: printf("ethernet ");
342: } else
343: printf("ethernet ");
344:
345: (volatile char *)sp->sram =
346: (volatile char *) phystokv(dev->phys_address);
347: dev->address = (vm_offset_t) phystokv(dev->address);
348: sp->timer = -1;
349: sp->flags = 0;
350: sp->mode = 0;
351:
352: if (!ns8390hwrst(unit)) {
353: printf("%s%d: attach(): reset failed.\n",
354: sp->card, unit);
355: return;
356: }
357: /* N.B. sp->address is not determined till
358: * hwrst time. */
359: *(sp->ds_addr) = *(sp->address);
360: *(sp->ds_addr + 1) = *(sp->address + 1);
361: *(sp->ds_addr + 2) = *(sp->address + 2);
362: *(sp->ds_addr + 3) = *(sp->address + 3);
363: *(sp->ds_addr + 4) = *(sp->address + 4);
364: *(sp->ds_addr + 5) = *(sp->address + 5);
365:
366: printf("id [%x:%x:%x:%x:%x:%x]",
367: sp->address[0],sp->address[1],sp->address[2],
368: sp->address[3],sp->address[4],sp->address[5]);
369: ifp = &(sp->ds_if);
370: ifp->if_unit = unit;
371: ifp->if_mtu = ETHERMTU;
372: ifp->if_flags = IFF_BROADCAST;
373: #ifdef MACH_KERNEL
374: ifp->if_header_size = sizeof(struct ether_header);
375: ifp->if_header_format = HDR_ETHERNET;
376: ifp->if_address_size = 6;
377: ifp->if_address = (char *)&sp->address[0];
378: if_init_queues(ifp);
379: #else MACH_KERNEL
380: ifp->if_name = sp->card;
381: ifp->if_init = ns8390init;
382: ifp->if_output = ns8390output;
383: ifp->if_ioctl = ns8390ioctl;
384: ifp->if_reset = ns8390reset;
385: ifp->if_next = NULL;
386: if_attach(ifp);
387: #ifdef notdef
388: watchdog_id = timeout(ns8390watch, &(ifp->if_unit), 20*HZ);
389: #endif
390: #endif MACH_KERNEL
391:
392: #ifdef MACH_KERNEL
393: #if MACH_TTD
394: if (!ttd_get_packet) {
395: ttd_device_unit = unit;
396: ttd_get_packet = ns8390poll_receive;
397: ttd_send_packet = ns8390transmit_ttd;
398: ttd_host_ether_id.array[0] = *(sp->address);
399: ttd_host_ether_id.array[1] = *(sp->address + 1);
400: ttd_host_ether_id.array[2] = *(sp->address + 2);
401: ttd_host_ether_id.array[3] = *(sp->address + 3);
402: ttd_host_ether_id.array[4] = *(sp->address + 4);
403: ttd_host_ether_id.array[5] = *(sp->address + 5);
404: }
405: #endif /* MACH_TTD */
406: #endif /* MACH_KERNEL */
407: }
408:
409: /*
410: * ns8390watch():
411: *
412: */
413:
414: int
415: ns8390watch(b_ptr)
416: caddr_t b_ptr;
417: {
418: int x,
419: y,
420: opri,
421: unit;
422: int temp_cr;
423: caddr_t nic;
424:
425: unit = *b_ptr;
426: #ifdef MACH_KERNEL
427: timeout(ns8390watch,b_ptr,20*HZ);
428: #else MACH_KERNEL
429: watchdog_id = timeout(ns8390watch,b_ptr,20*HZ);
430: #endif MACH_KERNEL
431: nic = ns8390_softc[unit].nic;
432: temp_cr = inb(nic+ds_cmd);
433: outb(nic + ds_cmd, (temp_cr & 0x3f) | DSCM_PG0);
434: printf("<<< ISR=%x CURR=%x rdnxt=%x BNDY=%x>>> ",
435: inb(nic + ds0_isr),
436: ns8390get_CURR(unit), ns8390_softc[unit].read_nxtpkt_ptr,
437: inb(nic+ds0_bndy));
438: outb(nic+ds_cmd,temp_cr);
439: }
440:
441: #ifdef MACH_KERNEL
442: int ns8390start(); /* forward */
443:
444: /*ARGSUSED*/
445: wd8003open(dev, flag)
446: dev_t dev;
447: int flag;
448: {
449: register int unit = minor(dev);
450:
451: if (ns8390_softc[unit].card != wd8003_card)
452: return (ENXIO);
453: if (unit < 0 || unit >= NNS8390 ||
454: ns8390_softc[unit].nic == 0)
455: return (ENXIO);
456:
457: ns8390_softc[unit].ds_if.if_flags |= IFF_UP;
458: ns8390init(unit);
459: return(0);
460: }
461:
462: eliiopen(dev, flag)
463: dev_t dev;
464: int flag;
465: {
466: register int unit = minor(dev);
467:
468: if (ns8390_softc[unit].card != elii_card)
469: return (ENXIO);
470: if (unit < 0 || unit >= NNS8390 ||
471: ns8390_softc[unit].nic == 0)
472: return (ENXIO);
473:
474: ns8390_softc[unit].ds_if.if_flags |= IFF_UP;
475: ns8390init(unit);
476: return(0);
477: }
478:
479: ns8390output(dev, ior)
480: dev_t dev;
481: io_req_t ior;
482: {
483: register int unit = minor(dev);
484:
485: if (unit < 0 || unit >= NNS8390 ||
486: ns8390_softc[unit].nic == 0)
487: return (ENXIO);
488: return (net_write(&ns8390_softc[unit].ds_if, ns8390start, ior));
489: }
490:
491: ns8390setinput(dev, receive_port, priority, filter, filter_count)
492: dev_t dev;
493: mach_port_t receive_port;
494: int priority;
495: filter_t filter[];
496: unsigned int filter_count;
497: {
498: register int unit = minor(dev);
499:
500: if (unit < 0 || unit >= NNS8390 ||
501: ns8390_softc[unit].nic == 0)
502: return (ENXIO);
503:
504: return (net_set_filter(&ns8390_softc[unit].ds_if,
505: receive_port, priority,
506: filter, filter_count));
507: }
508:
509: #else MACH_KERNEL
510: /*
511: * ns8390output:
512: *
513: * This routine is called by the "if" layer to output a packet to
514: * the network. This code resolves the local ethernet address, and
515: * puts it into the mbuf if there is room. If not, then a new mbuf
516: * is allocated with the header information and precedes the data
517: * to be transmitted. The routine ns8390xmt() which actually
518: * transmits the data expects the ethernet header to precede the
519: * data in the mbuf.
520: *
521: * input: ifnet structure pointer, an mbuf with data, and address
522: * to be resolved
523: * output: mbuf is updated to hold enet address, or a new mbuf
524: * with the address is added
525: *
526: */
527:
528: ns8390output(ifp, m0, dst)
529: struct ifnet *ifp;
530: struct mbuf *m0;
531: struct sockaddr *dst;
532: {
533: register ns8390_softc_t *is = &ns8390_softc[ifp->if_unit];
534: u_char edst[6];
535: struct in_addr idst;
536: register struct mbuf *m = m0;
537: register struct ether_header *eh;
538: register int off;
539: int usetrailers;
540: int type, error;
541: spl_t opri;
542:
543: if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
544: printf("%s%d output(): Turning off board %d\n",
545: is->card, ifp->if_unit);
546: ns8390intoff(ifp->if_unit);
547: error = ENETDOWN;
548: goto bad;
549: }
550: switch (dst->sa_family) {
551: #ifdef INET
552: case AF_INET:
553: idst = ((struct sockaddr_in *)dst)->sin_addr;
554: if (!arpresolve(&is->ns8390_ac, m, &idst, edst, &usetrailers)){
555: return (0); /* if not yet resolved */
556: }
557: off = ntohs((u_short)mtod(m, struct ip *)->ip_len) - m->m_len;
558: if (usetrailers && off > 0 && (off & 0x1ff) == 0 &&
559: m->m_off >= MMINOFF + 2 * sizeof (u_short)) {
560: type = ETHERTYPE_TRAIL + (off>>9);
561: m->m_off -= 2 * sizeof (u_short);
562: m->m_len += 2 * sizeof (u_short);
563: *mtod(m, u_short *) = htons((u_short)ETHERTYPE_IP);
564: *(mtod(m, u_short *) + 1) = htons((u_short)m->m_len);
565: goto gottrailertype;
566: }
567: type = ETHERTYPE_IP;
568: off = 0;
569: goto gottype;
570: #endif
571: #ifdef NS
572: case AF_NS:
573: type = ETHERTYPE_NS;
574: bcopy((caddr_t)&(((struct sockaddr_ns *)dst)->sns_addr.x_host),
575: (caddr_t)edst,
576: sizeof (edst));
577: off = 0;
578: goto gottype;
579: #endif
580: case AF_UNSPEC:
581: eh = (struct ether_header *)dst->sa_data;
582: bcopy((caddr_t)eh->ether_dhost, (caddr_t)edst, sizeof (edst));
583: type = eh->ether_type;
584: goto gottype;
585: default:
586: printf("%s%d output(): can't handle af%d\n",
587: is->card, ifp->if_unit,
588: dst->sa_family);
589: error = EAFNOSUPPORT;
590: goto bad;
591: }
592: gottrailertype:
593: /*
594: * Packet to be sent as trailer: move first packet
595: * (control information) to end of chain.
596: */
597: while (m->m_next)
598: m = m->m_next;
599: m->m_next = m0;
600: m = m0->m_next;
601: m0->m_next = 0;
602: m0 = m;
603: gottype:
604: /*
605: * Add local net header. If no space in first mbuf,
606: * allocate another.
607: */
608: if (m->m_off > MMAXOFF ||
609: MMINOFF + sizeof (struct ether_header) > m->m_off) {
610: m = m_get(M_DONTWAIT, MT_HEADER);
611: if (m == 0) {
612: error = ENOBUFS;
613: goto bad;
614: }
615: m->m_next = m0;
616: m->m_off = MMINOFF;
617: m->m_len = sizeof (struct ether_header);
618: } else {
619: m->m_off -= sizeof (struct ether_header);
620: m->m_len += sizeof (struct ether_header);
621: }
622: eh = mtod(m, struct ether_header *);
623: eh->ether_type = htons((u_short)type);
624: bcopy((caddr_t)edst, (caddr_t)eh->ether_dhost, sizeof (edst));
625: bcopy((caddr_t)is->address,
626: (caddr_t)eh->ether_shost,
627: sizeof(edst));
628: /*
629: * Queue message on interface, and start output if interface
630: * not yet active.
631: */
632: opri = SPLNET();
633: if (IF_QFULL(&ifp->if_snd)) {
634: IF_DROP(&ifp->if_snd);
635: splx(opri);
636: m_freem(m);
637: return (ENOBUFS);
638: }
639: IF_ENQUEUE(&ifp->if_snd, m);
640: /*
641: * Some action needs to be added here for checking whether the
642: * board is already transmitting. If it is, we don't want to
643: * start it up (ie call ns8390start()). We will attempt to send
644: * packets that are queued up after an interrupt occurs. Some
645: * flag checking action has to happen here and/or in the start
646: * routine. This note is here to remind me that some thought
647: * is needed and there is a potential problem here.
648: *
649: */
650: ns8390start(ifp->if_unit);
651: splx(opri);
652: return (0);
653: bad:
654: m_freem(m0);
655: return (error);
656: }
657: #endif MACH_KERNEL
658:
659: /*
660: * ns8390reset:
661: *
662: * This routine is in part an entry point for the "if" code. Since most
663: * of the actual initialization has already (we hope already) been done
664: * by calling ns8390attach().
665: *
666: * input : unit number or board number to reset
667: * output : board is reset
668: *
669: */
670:
671: int
672: ns8390reset(unit)
673: int unit;
674: {
675:
676: ns8390_softc[unit].ds_if.if_flags &= ~IFF_RUNNING;
677: return(ns8390init(unit));
678: }
679:
680: /*
681: * ns8390init:
682: *
683: * Another routine that interfaces the "if" layer to this driver.
684: * Simply resets the structures that are used by "upper layers".
685: * As well as calling ns8390hwrst that does reset the ns8390 board.
686: *
687: * input : board number
688: * output : structures (if structs) and board are reset
689: *
690: */
691:
692: int
693: ns8390init(unit)
694: int unit;
695: {
696: struct ifnet *ifp;
697: int stat;
698: spl_t oldpri;
699:
700: ifp = &(ns8390_softc[unit].ds_if);
701: #ifdef MACH_KERNEL
702: #else MACH_KERNEL
703: if (ifp->if_addrlist == (struct ifaddr *)0) {
704: return;
705: }
706: #endif MACH_KERNEL
707: oldpri = SPLNET();
708: if ((stat = ns8390hwrst(unit)) == TRUE) {
709: ns8390_softc[unit].ds_if.if_flags |= IFF_RUNNING;
710: ns8390_softc[unit].flags |= DSF_RUNNING;
711: ns8390_softc[unit].tbusy = 0;
712: ns8390start(unit);
713: } else
714: printf("%s%d init(): trouble resetting board %d\n",
715: ns8390_softc[unit].card, unit);
716: ns8390_softc[unit].timer = 5;
717: splx(oldpri);
718: return(stat);
719: }
720:
721: /*
722: * ns8390start:
723: *
724: * This is yet another interface routine that simply tries to output a
725: * in an mbuf after a reset.
726: *
727: * input : board number
728: * output : stuff sent to board if any there
729: *
730: */
731:
732: ns8390start(unit)
733: int unit;
734: {
735: register ns8390_softc_t *is = &ns8390_softc[unit];
736: struct ifnet *ifp;
737: #ifdef MACH_KERNEL
738: io_req_t m;
739: #else MACH_KERNEL
740: struct mbuf *m;
741: #endif MACH_KERNEL
742:
743: if (is->tbusy) {
744: caddr_t nic = ns8390_softc[unit].nic;
745: if (!(inb(nic+ds_cmd) & DSCM_TRANS)) {
746: is->tbusy = 0;
747: ns8390_cntrs[unit].busy++;
748: } else
749: return;
750: }
751:
752: ifp = &(ns8390_softc[unit].ds_if);
753:
754: IF_DEQUEUE(&ifp->if_snd, m);
755: #ifdef MACH_KERNEL
756: if (m != 0)
757: #else MACH_KERNEL
758: if (m != (struct mbuf *)0)
759: #endif MACH_KERNEL
760: {
761: is->tbusy++;
762: ns8390_cntrs[unit].xmt++;
763: ns8390xmt(unit, m);
764: }
765: }
766:
767: #ifdef MACH_KERNEL
768: /*ARGSUSED*/
769: ns8390getstat(dev, flavor, status, count)
770: dev_t dev;
771: int flavor;
772: dev_status_t status; /* pointer to OUT array */
773: unsigned int *count; /* out */
774: {
775: register int unit = minor(dev);
776:
777: if (unit < 0 || unit >= NNS8390 ||
778: ns8390_softc[unit].nic == 0)
779: return (ENXIO);
780:
781: return (net_getstat(&ns8390_softc[unit].ds_if,
782: flavor,
783: status,
784: count));
785: }
786: ns8390setstat(dev, flavor, status, count)
787: dev_t dev;
788: int flavor;
789: dev_status_t status;
790: unsigned int count;
791: {
792: register int unit = minor(dev);
793: register ns8390_softc_t *sp;
794:
795: if (unit < 0 || unit >= NNS8390 ||
796: ns8390_softc[unit].nic == 0)
797: return (ENXIO);
798:
799: sp = &ns8390_softc[unit];
800:
801: switch (flavor) {
802: case NET_STATUS:
803: {
804: /*
805: * All we can change are flags, and not many of those.
806: */
807: register struct net_status *ns = (struct net_status *)status;
808: int mode = 0;
809:
810: if (count < NET_STATUS_COUNT)
811: return (D_INVALID_SIZE);
812:
813: if (ns->flags & IFF_ALLMULTI)
814: mode |= MOD_ENAL;
815: if (ns->flags & IFF_PROMISC)
816: mode |= MOD_PROM;
817:
818: /*
819: * Force a complete reset if the receive mode changes
820: * so that these take effect immediately.
821: */
822: if (sp->mode != mode) {
823: sp->mode = mode;
824: if (sp->flags & DSF_RUNNING) {
825: sp->flags &= ~(DSF_LOCK | DSF_RUNNING);
826: ns8390init(unit);
827: }
828: }
829: break;
830: }
831:
832: default:
833: return (D_INVALID_OPERATION);
834: }
835: return (D_SUCCESS);
836: }
837: #else MACH_KERNEL
838: /*
839: * ns8390ioctl:
840: *
841: * This routine processes an ioctl request from the "if" layer
842: * above.
843: *
844: * input : pointer the appropriate "if" struct, command, and data
845: * output : based on command appropriate action is taken on the
846: * ns8390 board(s) or related structures
847: * return : error is returned containing exit conditions
848: *
849: */
850:
851: int
852: ns8390ioctl(ifp, cmd, data)
853: struct ifnet *ifp;
854: int cmd;
855: caddr_t data;
856: {
857: register struct ifaddr *ifa = (struct ifaddr *)data;
858: register ns8390_softc_t *is;
859: int error;
860: spl_t opri;
861: short mode = 0;
862:
863: is = &ns8390_softc[ifp->if_unit];
864: opri = SPLNET();
865: error = 0;
866: switch (cmd) {
867: case SIOCSIFADDR:
868: ifp->if_flags |= IFF_UP;
869: ns8390init(ifp->if_unit);
870: switch (ifa->ifa_addr.sa_family) {
871: #ifdef INET
872: case AF_INET:
873: ((struct arpcom *)ifp)->ac_ipaddr =
874: IA_SIN(ifa)->sin_addr;
875: arpwhohas((struct arpcom *)ifp, &IA_SIN(ifa)->sin_addr);
876: break;
877: #endif
878: #ifdef NS
879: case AF_NS:
880: {
881: register struct ns_addr *ina =
882: &(IA_SNS(ifa)->sns_addr);
883: if (ns_nullhost(*ina))
884: ina->x_host =
885: *(union ns_host *)(ds->ds_addr);
886: else
887: ????
888: ns8390seteh(ina->x_host.c_host,
889: ns8390_softc[ifp->if_unit].base);
890: break;
891: }
892: #endif
893: }
894: break;
895: case SIOCSIFFLAGS:
896: if (ifp->if_flags & IFF_ALLMULTI)
897: mode |= MOD_ENAL;
898: if (ifp->if_flags & IFF_PROMISC)
899: mode |= MOD_PROM;
900: /*
901: * force a complete reset if the receive multicast/
902: * promiscuous mode changes so that these take
903: * effect immediately.
904: *
905: */
906: if (is->mode != mode) {
907: is->mode = mode;
908: if (is->flags & DSF_RUNNING) {
909: is->flags &=
910: ~(DSF_LOCK|DSF_RUNNING);
911: ns8390init(ifp->if_unit);
912: }
913: }
914: if ((ifp->if_flags & IFF_UP) == 0 &&
915: is->flags & DSF_RUNNING) {
916: printf("%s%d ioctl(): turning off board %d\n",
917: is->card, ifp->if_unit);
918: is->flags &= ~(DSF_LOCK | DSF_RUNNING);
919: is->timer = -1;
920: ns8390intoff(ifp->if_unit);
921: ns8390over_write(ifp->if_unit);
922: } else
923: if (ifp->if_flags & IFF_UP &&
924: (is->flags & DSF_RUNNING) == 0)
925: ns8390init(ifp->if_unit);
926: break;
927: #ifdef IF_CNTRS
928: case SIOCCIFCNTRS:
929: if (!suser()) {
930: error = EPERM;
931: break;
932: }
933: bzero((caddr_t)ns_ein, sizeof (ns_ein));
934: bzero((caddr_t)ns_eout, sizeof (ns_eout));
935: bzero((caddr_t)ns_lin, sizeof (ns_lin));
936: bzero((caddr_t)ns_lout, sizeof (ns_lout));
937: bzero((caddr_t)&ns_arp, sizeof (int));
938: bzero((caddr_t)&ns8390_cntrs, sizeof (ns8390_cntrs));
939: break;
940: #endif IF_CNTRS
941: default:
942: error = EINVAL;
943: }
944: splx(opri);
945: return (error);
946: }
947: #endif MACH_KERNEL
948:
949: /*
950: * ns8390hwrst:
951: *
952: * This routine resets the ns8390 board that corresponds to the
953: * board number passed in.
954: *
955: * input : board number to do a hardware reset
956: * output : board is reset
957: *
958: */
959:
960: int
961: ns8390hwrst(unit)
962: int unit;
963: {
964: caddr_t nic = ns8390_softc[unit].nic;
965: int count;
966: u_char stat;
967: spl_t spl = SPLNET();
968:
969: if (ns8390_softc[unit].card == wd8003_card &&
970: config_wd8003(unit) == FALSE) {
971: printf("%s%d hwrst(): config_wd8003 failed.\n",
972: ns8390_softc[unit].card, unit);
973: splx(spl);
974: return(FALSE);
975: }
976: if (ns8390_softc[unit].card == elii_card &&
977: config_3c503(unit) == FALSE) {
978: printf("%s%d hwrst(): config_3c503 failed.\n",
979: ns8390_softc[unit].card, unit);
980: splx(spl);
981: return(FALSE);
982: }
983: if (config_nic(unit) == FALSE) {
984: printf("%s%d hwrst(): config_nic failed.\n",
985: ns8390_softc[unit].card, unit);
986: splx(spl);
987: return(FALSE);
988: }
989: splx(spl);
990: return(TRUE);
991: }
992:
993: /*
994: * ns8390intr:
995: *
996: * This function is the interrupt handler for the ns8390 ethernet
997: * board. This routine will be called whenever either a packet
998: * is received, or a packet has successfully been transfered and
999: * the unit is ready to transmit another packet.
1000: *
1001: * input : board number that interrupted
1002: * output : either a packet is received, or a packet is transfered
1003: *
1004: */
1005: int
1006: ns8390intr(unit)
1007: {
1008: int opri, i;
1009: int isr_status;
1010: int temp_cr;
1011: caddr_t nic = ns8390_softc[unit].nic;
1012:
1013: temp_cr = inb(nic+ds_cmd);
1014: outb(nic+ds_cmd, (temp_cr & 0x3f) | DSCM_PG0);
1015: outb(nic+ds0_imr, 0); /* stop board interrupts */
1016: outb(nic+ds_cmd, temp_cr);
1017: while (isr_status = inb(nic+ds0_isr)) {
1018: outb(nic+ds0_isr, isr_status); /* clear interrupt status */
1019:
1020: if ((isr_status & (DSIS_ROVRN|DSIS_RXE)) == DSIS_RXE) {
1021: int rsr = inb(nic+ds0_rsr);
1022: if (rsr & DSRS_DFR) ns8390_cntrs[unit].jabber++;
1023: if (rsr & ~(DSRS_DFR|DSRS_PHY|DSRS_FAE|DSRS_CRC|DSIS_RX))
1024: printf("%s%d intr(): isr = %x, RSR = %x\n",
1025: ns8390_softc[unit].card, unit,
1026: isr_status, rsr);
1027: } else if (isr_status & DSIS_ROVRN) {
1028: ns8390_cntrs[unit].ovw++;
1029: ns8390over_write(unit);
1030: }
1031: if (isr_status & DSIS_RX) { /* DFR & PRX is possible */
1032: ns8390rcv(unit);
1033:
1034: #if MACH_TTD
1035: if (kttd_active)
1036: ttd_poll_loop = FALSE;
1037: #endif /* MACH_TTD */
1038: }
1039:
1040: if (isr_status & DSIS_TXE) {
1041: int tsr = inb(nic+ds0_tsr);
1042: tsr &= ~0x2; /* unadvertised special */
1043: #if MACH_TTD
1044: if (!kttd_active)
1045: #endif /* MACH_TTD */
1046: {
1047: if (tsr == (DSTS_CDH|DSTS_ABT))
1048: ns8390_cntrs[unit].heart++;
1049: else
1050: printf("%s%d intr(): isr = %x, TSR = %x\n",
1051: ns8390_softc[unit].card, unit,
1052: isr_status, tsr);
1053: ns8390_softc[unit].tbusy = 0;
1054: ns8390start(unit);
1055: }
1056: } else if (isr_status & DSIS_TX) {
1057: #if MACH_TTD
1058: if (!kttd_active)
1059: #endif /* MACH_TTD */
1060: {
1061: ns8390_cntrs[unit].xmti++;
1062: ns8390_softc[unit].tbusy = 0;
1063: ns8390start(unit);
1064: }
1065: }
1066:
1067: if (isr_status & DSIS_CTRS) {
1068: int c0 = inb(nic+ds0_cntr0);
1069: int c1 = inb(nic+ds0_cntr1);
1070: int c2 = inb(nic+ds0_cntr2);
1071: ns8390_cntrs[unit].frame += c0;
1072: ns8390_cntrs[unit].crc += c1;
1073: ns8390_cntrs[unit].miss += c2;
1074: #ifdef COUNTERS
1075: printf("%s%d intr(): isr = %x, FRAME %x, CRC %x, MISS %x\n",
1076: ns8390_softc[unit].card, unit,
1077: isr_status, c0, c1, c2);
1078: printf("%s%d intr(): TOTAL , FRAME %x, CRC %x, MISS %x\n",
1079: ns8390_softc[unit].card, unit,
1080: ns8390_cntrs[unit].frame,
1081: ns8390_cntrs[unit].crc,
1082: ns8390_cntrs[unit].miss);
1083: #endif COUNTERS
1084: outb(nic+ds0_isr, isr_status); /* clear interrupt status again */
1085: }
1086: }
1087: temp_cr=inb(nic+ds_cmd);
1088: outb(nic+ds_cmd, (temp_cr & 0x3f) | DSCM_PG0);
1089: outb(nic+ds0_imr, imr_hold);
1090: outb(nic+ds_cmd, temp_cr);
1091: return(0);
1092: }
1093:
1094: /*
1095: * Called if on board buffer has been completely filled by ns8390intr. It stops
1096: * the board, reads in all the buffers that are currently in the buffer, and
1097: * then restart board.
1098: */
1099: ns8390over_write(unit)
1100: int unit;
1101: {
1102: caddr_t nic = ns8390_softc[unit].nic;
1103: int no;
1104: int count = 0;
1105:
1106: outb(nic+ds_cmd, DSCM_NODMA|DSCM_STOP|DSCM_PG0); /* clear the receive buffer */
1107: outb(nic+ds0_rbcr0, 0);
1108: outb(nic+ds0_rbcr1, 0);
1109: while ((!(inb (nic + ds0_isr) & DSIS_RESET)) && (count < 10000))
1110: count++;
1111: if (count == 10000) {
1112: printf("%s%d: over_write(): would not reset.\n",
1113: ns8390_softc[unit].card, unit);
1114: }
1115: no = ns8390rcv(unit);
1116: #ifdef OVWBUG
1117: printf("%s%d over_write(): ns8390 OVW ... %d.\n",
1118: ns8390_softc[unit].card, unit, no);
1119: #endif OVWBUG
1120: outb(nic+ds0_tcr, DSTC_LB0); /* External loopback mode */
1121: outb(nic+ds_cmd, DSCM_NODMA|DSCM_START|DSCM_PG0);
1122: outb(nic+ds0_tcr, 0);
1123: return;
1124: }
1125:
1126: /*
1127: * ns8390rcv:
1128: *
1129: * This routine is called by the interrupt handler to initiate a
1130: * packet transfer from the board to the "if" layer above this
1131: * driver. This routine checks if a buffer has been successfully
1132: * received by the ns8390. If so, it does the actual transfer of the
1133: * board data (including the ethernet header) into a packet (consisting
1134: * of an mbuf chain) and enqueues it to a higher level.
1135: * Then check again whether there are any packets in the receive ring,
1136: * if so, read the next packet, until there are no more.
1137: *
1138: * input : number of the board to check
1139: * output : if a packet is available, it is "sent up"
1140: */
1141: ns8390rcv(unit)
1142: int unit;
1143: {
1144: register ns8390_softc_t *is = &ns8390_softc[unit];
1145: register struct ifnet *ifp = &is->ds_if;
1146: caddr_t nic = is->nic;
1147: int packets = 0;
1148: struct ether_header eh;
1149: u_short mlen, len, bytes_in_mbuf, bytes;
1150: u_short remaining;
1151: int temp_cr;
1152: u_char *mb_p;
1153: int board_id = is->board_id;
1154: vm_offset_t hdwbase = ns8390info[unit]->address;
1155: spl_t s;
1156:
1157: /* calculation of pkt size */
1158: int nic_overcount; /* NIC says 1 or 2 more than we need */
1159: int pkt_size; /* calculated size of received data */
1160: int wrap_size; /* size of data before wrapping it */
1161: int header_nxtpkt_ptr; /* NIC's next pkt ptr in rcv header */
1162: int low_byte_count; /* low byte count of read from rcv header */
1163: int high_byte_count; /* calculated high byte count */
1164:
1165:
1166: volatile char *sram_nxtpkt_ptr; /* mem location of next packet */
1167: volatile char *sram_getdata_ptr; /* next location to be read */
1168: #ifdef MACH_KERNEL
1169: ipc_kmsg_t new_kmsg;
1170: struct ether_header *ehp;
1171: struct packet_header *pkt;
1172: #else MACH_KERNEL
1173: struct mbuf *m, *tm; /* initial allocation of mem; temp */
1174: #endif MACH_KERNEL
1175:
1176:
1177: #if MACH_TTD
1178: if (((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) &&
1179: !kttd_active) {
1180: #else
1181: if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
1182: #endif /* MACH_TTD */
1183: temp_cr = inb(nic+ds_cmd); /* get current CR value */
1184: outb(nic+ds_cmd,((temp_cr & 0x3F)|DSCM_PG0|DSCM_STOP));
1185: outb(nic+ds0_imr, 0); /* Interrupt Mask Register */
1186: outb(nic+ds_cmd, temp_cr);
1187: return -1;
1188: }
1189:
1190: while(is->read_nxtpkt_ptr != ns8390get_CURR(unit)) {
1191:
1192: /* while there is a packet to read from the buffer */
1193:
1194: if ((is->read_nxtpkt_ptr < is->pstart) ||
1195: (is->read_nxtpkt_ptr >= is->pstop)) {
1196: ns8390hwrst(unit);
1197: return -1;
1198: } /* if next packet pointer is out of receive ring bounds */
1199:
1200: #if MACH_TTD
1201: if (!kttd_active)
1202: #endif /* MACH_TTD */
1203: {
1204: packets++;
1205: ns8390_cntrs[unit].rcv++;
1206: }
1207:
1208: sram_nxtpkt_ptr = (char *) (is->sram + (is->read_nxtpkt_ptr << 8));
1209:
1210: /* get packet size and location of next packet */
1211: header_nxtpkt_ptr = *(sram_nxtpkt_ptr + 1);
1212: header_nxtpkt_ptr &= 0xFF;
1213: low_byte_count = *(sram_nxtpkt_ptr + 2);
1214: low_byte_count &= 0xFF;
1215:
1216: if ((low_byte_count + NIC_HEADER_SIZE) > NIC_PAGE_SIZE)
1217: nic_overcount = 2;
1218: else
1219: nic_overcount = 1;
1220: if (header_nxtpkt_ptr > is->read_nxtpkt_ptr) {
1221: wrap_size = 0;
1222: high_byte_count = header_nxtpkt_ptr - is->read_nxtpkt_ptr -
1223: nic_overcount;
1224: } else {
1225: wrap_size = (int) (is->pstop - is->read_nxtpkt_ptr - nic_overcount);
1226: high_byte_count = is->pstop - is->read_nxtpkt_ptr +
1227: header_nxtpkt_ptr - is->pstart - nic_overcount;
1228: }
1229: pkt_size = (high_byte_count << 8) | (low_byte_count & 0xFF);
1230: /* does not seem to include NIC_HEADER_SIZE */
1231: if (!pkt_size) {
1232: printf("%s%d rcv(): zero length.\n",
1233: ns8390_softc[unit].card, unit);
1234: goto next_pkt;
1235: }
1236: len = pkt_size;
1237:
1238: sram_getdata_ptr = sram_nxtpkt_ptr + NIC_HEADER_SIZE;
1239: if (board_id & IFWD_SLOT_16BIT) {
1240: #if MACH_TTD
1241: if (!kttd_active)
1242: #endif /* MACH_TTD */
1243: { s = splhi(); }
1244:
1245: en_16bit_access(hdwbase, board_id);
1246: bcopy16 (sram_getdata_ptr,
1247: &eh,
1248: sizeof(struct ether_header));
1249: dis_16bit_access (hdwbase, board_id);
1250: #if MACH_TTD
1251: if (!kttd_active)
1252: #endif /* MACH_TTD */
1253: { splx(s); }
1254:
1255: } else {
1256: bcopy16 (sram_getdata_ptr,
1257: &eh,
1258: sizeof(struct ether_header));
1259: }
1260: sram_getdata_ptr += sizeof(struct ether_header);
1261: len -= (sizeof(struct ether_header) + 4); /* crc size */
1262: #ifdef MACH_KERNEL
1263: #if MACH_TTD
1264: if (kttd_active) {
1265: new_kmsg = (ipc_kmsg_t)ttd_request_msg;
1266: }else
1267: #endif /* MACH_TTD */
1268: {
1269: new_kmsg = net_kmsg_get();
1270: if (new_kmsg == IKM_NULL) {
1271: /*
1272: * Drop the packet.
1273: */
1274: is->ds_if.if_rcvdrops++;
1275: /*
1276: * not only do we want to return, we need to drop
1277: * the packet on the floor to clear the interrupt.
1278: */
1279: ns8390lost_frame(unit);
1280: return;/* packets;*/
1281: }
1282: }
1283:
1284: #if DEBUG_TTD
1285: dump_ether_header("ns8390wire",&eh);
1286: #endif /* DEBUG_TTD */
1287:
1288: ehp = (struct ether_header *) (&net_kmsg(new_kmsg)->header[0]);
1289: pkt = (struct packet_header *) (&net_kmsg(new_kmsg)->packet[0]);
1290:
1291: #if DEBUG_TTD
1292: printf("!ehp = 0x%x, pkt = 0x%x!",ehp, pkt);
1293: #endif /* DEBUG_TTD */
1294:
1295: *ehp = eh;
1296: if (len >
1297: (wrap_size = (is->sram + (is->pstop << 8) - sram_getdata_ptr))) {
1298: /* if needs to wrap */
1299: if (board_id & IFWD_SLOT_16BIT) {
1300: #if MACH_TTD
1301: if (!kttd_active)
1302: #endif /* MACH_TTD */
1303: { s = splhi(); }
1304:
1305: en_16bit_access(hdwbase, board_id);
1306: bcopy16 (sram_getdata_ptr, (char *) (pkt + 1),
1307: wrap_size);
1308: dis_16bit_access (hdwbase, board_id);
1309: #if MACH_TTD
1310: if (!kttd_active)
1311: #endif /* MACH_TTD */
1312: { splx(s); }
1313: } else {
1314: bcopy (sram_getdata_ptr, (char *) (pkt + 1),
1315: wrap_size);
1316: }
1317: sram_getdata_ptr = (volatile char *)
1318: (is->sram + (is->pstart << 8));
1319: } else { /* normal getting data from buffer */
1320: wrap_size = 0;
1321: }
1322: if (board_id & IFWD_SLOT_16BIT) {
1323: #if MACH_TTD
1324: if (!kttd_active)
1325: #endif /* MACH_TTD */
1326: { s = splhi(); }
1327: en_16bit_access(hdwbase, board_id);
1328: bcopy16 (sram_getdata_ptr,
1329: (char *) (pkt + 1) + wrap_size,
1330: len - wrap_size);
1331: dis_16bit_access (hdwbase, board_id);
1332: #if MACH_TTD
1333: if (!kttd_active)
1334: #endif /* MACH_TTD */
1335: { splx(s); }
1336: } else {
1337: bcopy (sram_getdata_ptr,
1338: (char *) (pkt + 1) + wrap_size,
1339: len - wrap_size);
1340: }
1341:
1342: pkt->type = ehp->ether_type;
1343: pkt->length = len + sizeof(struct packet_header);
1344:
1345: #if MACH_TTD
1346: /*
1347: * Don't want to call net_packet if we are polling
1348: * for a packet.
1349: */
1350: if (!kttd_active)
1351: #endif /* MACH_TTD */
1352: {
1353: /*
1354: * Hand the packet to the network module.
1355: */
1356: net_packet(ifp, new_kmsg, pkt->length,
1357: ethernet_priority(new_kmsg));
1358: }
1359:
1360: #else MACH_KERNEL
1361: #define NEW
1362: #ifdef NEW
1363: m = (struct mbuf *) 0;
1364: eh.ether_type = ntohs(eh.ether_type);
1365: MGET(m, M_DONTWAIT, MT_DATA);
1366: if (m == (struct mbuf *) 0) {
1367: printf("%s%d rcv(): Lost frame\n",
1368: ns8390_softc[unit].card, unit);
1369: ns8390lost_frame(unit); /* update NIC pointers and registers */
1370: return packets;
1371: }
1372: m->m_next = (struct mbuf *) 0;
1373: tm = m;
1374: m->m_len = MLEN;
1375: if (len > 2 * MLEN - sizeof (struct ifnet **)) {
1376: MCLGET(m);
1377: }
1378: *(mtod(tm, struct ifnet **)) = ifp;
1379: mlen = sizeof (struct ifnet **);
1380: bytes_in_mbuf = m->m_len - sizeof(struct ifnet **);
1381: mb_p = mtod(tm, u_char *) + sizeof (struct ifnet **);
1382: bytes = min(bytes_in_mbuf, len);
1383: remaining = (int) (is->sram + (is->pstop << 8) -
1384: sram_getdata_ptr);
1385: bytes = min(bytes, remaining);
1386: do {
1387: if (board_id & IFWD_SLOT_16BIT) {
1388: s = splhi();
1389: en_16bit_access(hdwbase, board_id);
1390: bcopy16 (sram_getdata_ptr, mb_p, bytes);
1391: dis_16bit_access (hdwbase, board_id);
1392: splx(s);
1393: } else {
1394: bcopy16 (sram_getdata_ptr, mb_p, bytes);
1395: }
1396:
1397: mlen += bytes;
1398:
1399: if (!(bytes_in_mbuf -= bytes)) {
1400: MGET(tm->m_next, M_DONTWAIT, MT_DATA);
1401: tm = tm->m_next;
1402: if (tm == (struct mbuf *)0) {
1403: printf("%s%d rcv(): No mbufs, lost frame\n",
1404: ns8390_softc[unit].card, unit);
1405: m_freem(m); /* free the mbuf chain */
1406: ns8390lost_frame(unit); /* update NIC pointers and registers */
1407: return;
1408: }
1409: mlen = 0;
1410: tm->m_len = MLEN;
1411: bytes_in_mbuf = MLEN;
1412: mb_p = mtod(tm, u_char *);
1413: } else
1414: mb_p += bytes;
1415:
1416: if (!(len -= bytes)) {
1417: tm->m_len = mlen;
1418: break;
1419: } else if (bytes == remaining) {
1420: sram_getdata_ptr = (volatile char *) (is->sram +
1421: (is->pstart << 8));
1422: bytes = len;
1423: remaining = ETHERMTU;
1424: } else {
1425: sram_getdata_ptr += bytes;
1426: remaining -= bytes;
1427: }
1428:
1429: bytes = min(bytes_in_mbuf, len);
1430: bytes = min(bytes, remaining);
1431: } while(1);
1432: #else NEW
1433: m = (struct mbuf *) 0;
1434: eh.ether_type = ntohs(eh.ether_type);
1435:
1436: while ( len ) {
1437: if (m == (struct mbuf *) 0) {
1438: m = m_get(M_DONTWAIT, MT_DATA);
1439: if (m == (struct mbuf *) 0) {
1440: printf("%s%d rcv(): Lost frame\n",
1441: ns8390_softc[unit].card, unit);
1442: ns8390lost_frame(unit); /* update NIC pointers and registers */
1443: return packets;
1444: }
1445: tm = m;
1446: tm->m_off = MMINOFF;
1447:
1448:
1449: /*
1450: * first mbuf in the packet must contain a pointer to the
1451: * ifnet structure. other mbufs that follow and make up
1452: * the packet do not need this pointer in the mbuf.
1453: *
1454: */
1455:
1456: *(mtod(tm, struct ifnet **)) = ifp;
1457: tm->m_len = sizeof(struct ifnet **);
1458:
1459: /* end of first buffer of packet */
1460: } else {
1461: tm->m_next = m_get(M_DONTWAIT, MT_DATA);
1462: tm = tm->m_next;
1463: if (tm == (struct mbuf *) 0) {
1464: printf("%s%d rcv(): No mbufs, lost frame\n",
1465: ns8390_softc[unit].card, unit);
1466: m_freem(m); /* free the mbuf chain */
1467: ns8390lost_frame(unit); /* update NIC pointers and registers */
1468: return packets;
1469: }
1470: tm->m_off = MMINOFF;
1471: tm->m_len = 0;
1472: }
1473:
1474: tlen = MIN( MLEN - tm->m_len, len);
1475: /* size of mbuf so you know how much you can copy from board */
1476: tm->m_next = (struct mbuf *) 0;
1477: if (sram_getdata_ptr + tlen >=
1478: (volatile char *) (is->sram + (is->pstop << 8))) {
1479: /* if needs to wrap */
1480: wrap_size = (int) (is->sram + (is->pstop << 8) -
1481: sram_getdata_ptr);
1482: if (board_id & IFWD_SLOT_16BIT) {
1483: s = splhi();
1484: en_16bit_access(hdwbase, board_id);
1485: bcopy16 (sram_getdata_ptr,
1486: mtod(tm, char*) + tm->m_len,
1487: wrap_size);
1488: dis_16bit_access (hdwbase, board_id);
1489: splx(s);
1490: } else {
1491: bcopy16 (sram_getdata_ptr,
1492: mtod(tm, char*) + tm->m_len,
1493: wrap_size);
1494: }
1495: tm->m_len += wrap_size;
1496: len -= wrap_size;
1497:
1498: sram_getdata_ptr = (volatile char *) (is->sram +
1499: (is->pstart << 8));
1500: } else { /* normal getting data from buffer */
1501: if (board_id & IFWD_SLOT_16BIT) {
1502: s = splhi();
1503: en_16bit_access(hdwbase, board_id);
1504: bcopy16 (sram_getdata_ptr,
1505: mtod(tm, char*) + tm->m_len,
1506: tlen);
1507: dis_16bit_access (hdwbase, board_id);
1508: splx(s);
1509: } else {
1510: bcopy16 (sram_getdata_ptr,
1511: mtod(tm, char*) + tm->m_len,
1512: tlen);
1513: }
1514: sram_getdata_ptr += tlen;
1515: tm->m_len += tlen;
1516: len -= tlen;
1517:
1518: }
1519: }
1520:
1521: #endif NEW
1522: if (!ns8390send_packet_up(m, &eh, is))
1523: m_freem(m);
1524: #ifdef IF_CNTRS
1525: ns_ein[log_2(pkt_size)]++;
1526: if (pkt_size < 128) ns_lin[(pkt_size)>>3]++;
1527:
1528: if (eh.ether_type == ETHERTYPE_ARP) {
1529: ns_arp++;
1530: if (ns_narp) {
1531: ns_ein[log_2(pkt_size)]--;
1532: if (pkt_size < 128) ns_lin[(pkt_size)>>3]--;
1533: }
1534: }
1535: #endif IF_CNTRS
1536: #endif MACH_KERNEL
1537:
1538: next_pkt:
1539: is->read_nxtpkt_ptr = *(sram_nxtpkt_ptr + 1);
1540: is->read_nxtpkt_ptr &= 0xFF;
1541:
1542: #if MACH_TTD
1543: if (!kttd_active)
1544: #endif /* MACH_TTD */
1545: {
1546: temp_cr = inb(nic+ds_cmd);
1547: outb(nic+ds_cmd, (temp_cr & 0x3f) | DSCM_PG0);
1548: }
1549:
1550: if (is->read_nxtpkt_ptr == ns8390get_CURR(unit))
1551: if (is->read_nxtpkt_ptr == is->pstart)
1552: outb(nic+ds0_bndy, is->pstop - 1);
1553: else
1554: outb(nic+ds0_bndy, is->read_nxtpkt_ptr - 1);
1555: else
1556: outb(nic+ds0_bndy, is->read_nxtpkt_ptr);
1557:
1558: #if MACH_TTD
1559: if (!kttd_active)
1560: #endif /* MACH_TTD */
1561: { outb(nic+ds_cmd, temp_cr); }
1562:
1563: #if MACH_TTD
1564: /*
1565: * Hand the packet back to the TTD server, if active.
1566: */
1567: if (kttd_active && pkt_size)
1568: return 1;
1569: #endif /* MACH_TTD */
1570:
1571:
1572: }
1573: return packets;
1574:
1575: }
1576:
1577: #ifdef MACH_KERNEL
1578: #if MACH_TTD
1579: /*
1580: * Polling routines for the TTD debugger.
1581: */
1582: int ns8390poll_receive(unit)
1583: int unit;
1584: {
1585: int s;
1586: int orig_cr;
1587: int orig_imr;
1588: int isr_status;
1589: int pkts;
1590:
1591: ttd_poll_loop = TRUE;
1592:
1593:
1594: /*
1595: * Should already in at splhigh. Is this necessary? XXX
1596: */
1597: s = splhigh();
1598:
1599: #if 0
1600: if (kttd_debug)
1601: printf("ns8390poll_receive: beginning polling loop\n");
1602: #endif /* DEBUG_TTD */
1603:
1604: /*
1605: * Loop until packet arrives.
1606: */
1607: while(ttd_poll_loop) {
1608:
1609: /*
1610: * Call intr routine
1611: */
1612:
1613: ns8390intr(unit);
1614: }
1615:
1616: #if 0
1617: if (kttd_debug)
1618: printf("ns8390poll_receive: got packet exiting loop\n");
1619: #endif /* DEBUG_TTD */
1620:
1621: splx(s);
1622: }
1623:
1624: int ns8390transmit_ttd(unit, packet, len)
1625: int unit;
1626: char * packet;
1627: int len;
1628: {
1629: ns8390_softc_t *is = &ns8390_softc[unit];
1630: caddr_t nic = is->nic;
1631: u_short count = 0; /* amount of data already copied */
1632: volatile char *sram_write_pkt;
1633: int board_id = is->board_id;
1634: caddr_t hdwbase = ns8390info[unit]->address;
1635: int s;
1636: int orig_cr;
1637: int orig_imr;
1638: int isr_status;
1639: boolean_t loop = TRUE;
1640:
1641: #if 0
1642: dump_ipudpbootp("Beg of xmit",packet);
1643: #endif
1644:
1645: s = splhigh();
1646:
1647: /* begining of physical address of transmition buffer */
1648:
1649: sram_write_pkt = is->sram + is->tpsr * 0x100;
1650:
1651: count = len;
1652: if (board_id & IFWD_SLOT_16BIT) {
1653: en_16bit_access(hdwbase, board_id);
1654: bcopy16 (packet, sram_write_pkt, count);
1655: dis_16bit_access (hdwbase, board_id);
1656: } else {
1657: bcopy (packet, sram_write_pkt, count);
1658: }
1659:
1660: while (count < ETHERMIN+sizeof(struct ether_header)) {
1661: *(sram_write_pkt + count) = 0;
1662: count++;
1663: }
1664: outb(nic+ds_cmd, DSCM_NODMA|DSCM_START|DSCM_PG0); /* select page 0 */
1665: outb(nic+ds0_tpsr, is->tpsr); /* xmt page start at 0 of RAM */
1666: outb(nic+ds0_tbcr1, count >> 8); /* upper byte of count */
1667: outb(nic+ds0_tbcr0, count & 0xFF); /* lower byte of count */
1668: outb(nic+ds_cmd, DSCM_TRANS|DSCM_NODMA|DSCM_START); /* start transmission */
1669:
1670: ns8390intr(unit);
1671:
1672: splx(s);
1673: }
1674: #endif /* MACH_TTD */
1675: #endif /* MACH_KERNEL */
1676:
1677: #ifdef MACH_KERNEL
1678: #else MACH_KERNEL
1679: /*
1680: * Send a packet composed of an mbuf chain to the higher levels
1681: *
1682: */
1683: ns8390send_packet_up(m, eh, is)
1684: struct mbuf *m;
1685: struct ether_header *eh;
1686: ns8390_softc_t *is;
1687: {
1688: register struct ifqueue *inq;
1689: spl_t opri;
1690:
1691: switch (eh->ether_type) {
1692: #ifdef INET
1693: case ETHERTYPE_IP:
1694: schednetisr(NETISR_IP);
1695: inq = &ipintrq;
1696: break;
1697: case ETHERTYPE_ARP:
1698: arpinput(&is->ns8390_ac, m);
1699: return(TRUE);
1700: #endif
1701: #ifdef NS
1702: case ETHERTYPE_NS:
1703: schednetisr(NETISR_NS);
1704: inq = &nsintrq;
1705: break;
1706: #endif
1707: default:
1708: return(FALSE);
1709: }
1710: opri = SPLNET();
1711: if (IF_QFULL(inq)) {
1712: IF_DROP(inq);
1713: splx(opri);
1714: return(FALSE);
1715: }
1716: IF_ENQUEUE(inq, m);
1717: splx(opri);
1718: return(TRUE);
1719: }
1720: #endif MACH_KERNEL
1721:
1722: /*
1723: * ns8390lost_frame:
1724: * this routine called by ns8390read after memory for mbufs could not be
1725: * allocated. It sets the boundary pointers and registers to the next
1726: * packet location.
1727: */
1728:
1729: ns8390lost_frame(unit)
1730: int unit;
1731: {
1732: ns8390_softc_t *is = &ns8390_softc[unit];
1733: caddr_t nic = is->nic;
1734: volatile char *sram_nxtpkt_ptr;
1735: int temp_cr;
1736:
1737:
1738:
1739: sram_nxtpkt_ptr = (volatile char *) (is->sram +
1740: (is->read_nxtpkt_ptr << 8));
1741:
1742: is->read_nxtpkt_ptr = *(sram_nxtpkt_ptr + 1);
1743: is->read_nxtpkt_ptr &= 0xFF;
1744:
1745: temp_cr = inb(nic+ds_cmd);
1746: outb(nic+ds_cmd, (temp_cr & 0x3f) | DSCM_PG0);
1747:
1748: /* update boundary register */
1749: if (is->read_nxtpkt_ptr == ns8390get_CURR(unit))
1750: if (is->read_nxtpkt_ptr == is->pstart)
1751: outb(nic+ds0_bndy, is->pstop - 1);
1752: else
1753: outb(nic+ds0_bndy, is->read_nxtpkt_ptr - 1);
1754: else
1755: outb(nic+ds0_bndy, is->read_nxtpkt_ptr);
1756:
1757: outb(nic+ds_cmd, temp_cr);
1758:
1759: return;
1760: }
1761:
1762: /*
1763: * ns8390get_CURR():
1764: *
1765: * Returns the value of the register CURR, which points to the next
1766: * available space for NIC to receive from network unto receive ring.
1767: *
1768: */
1769:
1770: int
1771: ns8390get_CURR(unit)
1772: int unit;
1773: {
1774: caddr_t nic = ns8390_softc[unit].nic;
1775: int temp_cr;
1776: int ret_val;
1777: spl_t s;
1778:
1779: s = SPLNET();
1780:
1781: temp_cr = inb(nic+ds_cmd); /* get current CR value */
1782: outb(nic+ds_cmd, ((temp_cr & 0x3F) | DSCM_PG1)); /* select page 1 registers */
1783: ret_val = inb(nic+ds1_curr); /* read CURR value */
1784: outb(nic+ds_cmd, temp_cr);
1785: splx(s);
1786: return (ret_val & 0xFF);
1787: }
1788:
1789: /*
1790: * ns8390xmt:
1791: *
1792: * This routine fills in the appropriate registers and memory
1793: * locations on the ns8390 board and starts the board off on
1794: * the transmit.
1795: *
1796: * input : board number of interest, and a pointer to the mbuf
1797: * output : board memory and registers are set for xfer and attention
1798: *
1799: */
1800:
1801: ns8390xmt(unit, m)
1802: int unit;
1803: #ifdef MACH_KERNEL
1804: io_req_t m;
1805: #else MACH_KERNEL
1806: struct mbuf *m;
1807: #endif MACH_KERNEL
1808: {
1809: ns8390_softc_t *is = &ns8390_softc[unit];
1810: caddr_t nic = is->nic;
1811: struct ether_header *eh;
1812: int i;
1813: int opri;
1814: u_short count = 0; /* amount of data already copied */
1815: volatile char *sram_write_pkt;
1816: int board_id = is->board_id;
1817: vm_offset_t hdwbase = ns8390info[unit]->address;
1818: spl_t s;
1819:
1820: #ifdef MACH_KERNEL
1821: #else MACH_KERNEL
1822: register struct mbuf *tm_p;
1823: #endif MACH_KERNEL
1824: /* begining of physical address of transmition buffer */
1825:
1826: sram_write_pkt = is->sram + is->tpsr * 0x100;
1827:
1828: #ifdef MACH_KERNEL
1829: count = m->io_count;
1830: if (board_id & IFWD_SLOT_16BIT) {
1831: s = splhi();
1832: en_16bit_access(hdwbase, board_id);
1833: bcopy16 (m->io_data, sram_write_pkt, count);
1834: dis_16bit_access (hdwbase, board_id);
1835: splx(s);
1836: } else {
1837: bcopy (m->io_data, sram_write_pkt, count);
1838: }
1839: #else MACH_KERNEL
1840: for(tm_p = m; tm_p != (struct mbuf *)0; tm_p = tm_p->m_next) {
1841: if (count + tm_p->m_len > ETHERMTU + sizeof (struct ether_header))
1842: break;
1843: if (tm_p->m_len == 0)
1844: continue;
1845: if (board_id & IFWD_SLOT_16BIT) {
1846: s = splhi();
1847: en_16bit_access(hdwbase, board_id);
1848: bcopy16 (mtod(tm_p, caddr_t),
1849: sram_write_pkt + count,
1850: tm_p->m_len);
1851: dis_16bit_access (hdwbase, board_id);
1852: splx(s);
1853: } else {
1854: bcopy16 (mtod(tm_p, caddr_t),
1855: sram_write_pkt + count,
1856: tm_p->m_len);
1857: }
1858: count += tm_p->m_len;
1859: }
1860: #ifdef IF_CNTRS
1861: ns_eout[log_2(count+4/*crc*/)]++;
1862: if (count < 128) ns_lout[(count+4/*crc*/)>>3]++;
1863: #endif IF_CNTRS
1864: #endif MACH_KERNEL
1865: while (count < ETHERMIN+sizeof(struct ether_header)) {
1866: *(sram_write_pkt + count) = 0;
1867: count++;
1868: }
1869:
1870: /* select page 0 */
1871: outb(nic+ds_cmd, DSCM_NODMA|DSCM_START|DSCM_PG0);
1872: outb(nic+ds0_tpsr, is->tpsr); /* xmt page start at 0 of RAM */
1873: outb(nic+ds0_tbcr1, count >> 8); /* upper byte of count */
1874: outb(nic+ds0_tbcr0, count & 0xFF); /* lower byte of count */
1875: /* start transmission */
1876: outb(nic+ds_cmd, DSCM_TRANS|DSCM_NODMA|DSCM_START);
1877:
1878: #ifdef MACH_KERNEL
1879: iodone(m);
1880: m=0;
1881: #else MACH_KERNEL
1882: /* If this is a broadcast packet, loop it back to rcv. */
1883: eh = mtod( m, struct ether_header *);
1884: for (i=0; ((i < 6) && (eh->ether_dhost[i] == 0xff)); i++) ;
1885: if (i == 6) {
1886: if (!ns8390send_packet_up(m, eh, is))
1887: m_freem(m);
1888: } else
1889: m_freem(m);
1890: #endif MACH_KERNEL
1891: return;
1892: }
1893:
1894: config_nic(unit)
1895: int unit;
1896: {
1897: ns8390_softc_t *is = &ns8390_softc[unit];
1898: caddr_t nic = is->nic;
1899: int i;
1900: int temp;
1901: int count = 0;
1902: spl_t s;
1903:
1904: /* soft reset and page 0 */
1905: outb (nic+ds_cmd, DSCM_PG0|DSCM_NODMA|DSCM_STOP);
1906:
1907: while ((!(inb (nic + ds0_isr) & DSIS_RESET)) && (count < 10000))
1908: count++;
1909: if (count == 10000) {
1910: printf("%s%d: config_nic(): would not reset.\n",
1911: ns8390_softc[unit].card, unit);
1912: }
1913:
1914: /* fifo depth | not loopback */
1915: temp = ((is->fifo_depth & 0x0c) << 3) | DSDC_BMS;
1916:
1917: /* word xfer select (16 bit cards ) */
1918: if (is->board_id & IFWD_SLOT_16BIT)
1919: temp |= DSDC_WTS;
1920:
1921: outb (nic+ds0_dcr, temp);
1922: outb (nic+ds0_tcr, 0);
1923: outb (nic+ds0_rcr, DSRC_MON); /* receive configuration register */
1924: /* recieve ring starts 2k into RAM */
1925: outb (nic+ds0_pstart, is->pstart);
1926: /* stop at last RAM buffer rcv location */
1927: outb (nic+ds0_pstop, is->pstop);
1928:
1929: /* boundary pointer for page 0 */
1930: outb (nic+ds0_bndy, is->pstart);
1931: s = SPLNET();
1932:
1933: /* maintain rst | sel page 1 */
1934: outb (nic+ds_cmd, DSCM_PG1|DSCM_NODMA|DSCM_STOP);
1935:
1936: /* internal next packet pointer */
1937: is->read_nxtpkt_ptr = is->pstart + 1;
1938:
1939: outb (nic+ds1_curr, is->read_nxtpkt_ptr); /* Current page register */
1940: for(i=0; i<ETHER_ADDR_SIZE; i++)
1941: outb (nic+ds1_par0+i, is->address[i]);
1942: for(i=0; i<8; i++)
1943: outb (nic+ds1_mar0+i, 0);
1944:
1945: outb (nic+ds_cmd, DSCM_PG0|DSCM_STOP|DSCM_NODMA);
1946: splx(s);
1947: outb (nic+ds0_isr, 0xff); /* clear all interrupt status bits */
1948: outb (nic+ds0_imr, imr_hold); /* Enable interrupts */
1949: outb (nic+ds0_rbcr0, 0); /* clear remote byte count */
1950: outb (nic+ds0_rbcr1, 0);
1951:
1952: /* start NIC | select page 0 */
1953: outb (nic+ds_cmd, DSCM_PG0|DSCM_START|DSCM_NODMA);
1954:
1955: outb (nic+ds0_rcr, DSRC_AB); /* receive configuration register */
1956:
1957: return TRUE;
1958: }
1959:
1960: /*
1961: * config_ns8390:
1962: *
1963: * This routine does a standard config of a wd8003 family board, with
1964: * the proper modifications to different boards within this family.
1965: *
1966: */
1967: config_wd8003(unit)
1968: int unit;
1969: {
1970: ns8390_softc_t *is = &ns8390_softc[unit];
1971: vm_offset_t hdwbase = ns8390info[unit]->address;
1972: int i;
1973: int RAMsize;
1974: volatile char *RAMbase;
1975: int addr_temp;
1976:
1977: is->tpsr = 0; /* transmit page start hold */
1978: is->pstart = 0x06; /* receive page start hold */
1979: is->read_nxtpkt_ptr = is->pstart + 1; /* internal next packet pointer */
1980: is->fifo_depth = 0x08; /* NIC fifo threshold */
1981: switch (is->board_id & IFWD_RAM_SIZE_MASK) {
1982: case IFWD_RAM_SIZE_8K:
1983: RAMsize = 0x2000; break;
1984: case IFWD_RAM_SIZE_16K:
1985: RAMsize = 0x4000; break;
1986: case IFWD_RAM_SIZE_32K:
1987: RAMsize = 0x8000; break;
1988: case IFWD_RAM_SIZE_64K:
1989: RAMsize = 0x10000; break;
1990: default:
1991: RAMsize = 0x2000; break;
1992: }
1993: is->pstop = (((int)RAMsize >> 8) & 0x0ff); /* rcv page stop hold */
1994: RAMbase = (volatile char *)ns8390info[unit]->phys_address;
1995: addr_temp = ((int)(RAMbase) >> 13) & 0x3f; /* convert to be written to MSR */
1996: outb(hdwbase+IFWD_MSR, addr_temp | IFWD_MENB); /* initialize MSR */
1997: /* enable 16 bit access from lan controller */
1998: if (is->board_id & IFWD_SLOT_16BIT) {
1999: if (is->board_id & IFWD_INTERFACE_CHIP) {
2000: outb(hdwbase+IFWD_REG_5,
2001: (inb(hdwbase + IFWD_REG_5) & IFWD_REG5_MEM_MASK) |
2002: IFWD_LAN16ENB);
2003: } else {
2004: outb(hdwbase+IFWD_REG_5, (IFWD_LAN16ENB | IFWD_LA19));
2005: }
2006: }
2007: /*
2008: outb(hdwbase+LAAR, LAN16ENB | LA19| MEM16ENB | SOFTINT);
2009: */
2010:
2011: return TRUE;
2012: }
2013:
2014: /*
2015: * config_ns8390:
2016: *
2017: * This routine does a standard config of a 3 com etherlink II board.
2018: *
2019: */
2020: int
2021: config_3c503(unit)
2022: int unit;
2023: {
2024: ns8390_softc_t *is = &ns8390_softc[unit];
2025: struct bus_device *dev = ns8390info[unit];
2026: vm_offset_t hdwbase = dev->address;
2027: int RAMsize = dev->am;
2028: int i;
2029:
2030: is->tpsr = 0x20; /* transmit page start hold */
2031: is->sram = (char *)phystokv(dev->phys_address) - is->tpsr * 0x100;
2032: /* When NIC says page 20, this means go to
2033: the beginning of the sram range */
2034: is->pstart = 0x26; /* receive page start hold */
2035: is->read_nxtpkt_ptr = is->pstart + 1; /* internal next packet pointer */
2036: is->fifo_depth = 0x08; /* NIC fifo threshold */
2037: is->pstop = is->tpsr + ((RAMsize >> 8) & 0x0ff); /* rcv page stop hold */
2038:
2039: outb(hdwbase+CTLR, CTLR_RST|CTLR_THIN);
2040: outb(hdwbase+CTLR, CTLR_THIN);
2041: outb(hdwbase+CTLR, CTLR_STA_ADDR|CTLR_THIN);
2042: for (i = 0; i < 6; i++)
2043: is->address[i] = inb(hdwbase+i);
2044: outb(hdwbase+CTLR, elii_bnc[is->board_id]?CTLR_THIN:CTLR_THICK);
2045: outb(hdwbase+PSTR, is->pstart);
2046: outb(hdwbase+PSPR, is->pstop);
2047: outb(hdwbase+IDCFR, IDCFR_IRQ2 << (elii_irq[is->board_id] - 2));
2048: outb(hdwbase+GACFR, GACFR_TCM|GACFR_8K);
2049: /* BCFR & PCRFR ro */
2050: /* STREG ro & dma */
2051: outb(hdwbase+DQTR, 0);
2052: outb(hdwbase+DAMSB, 0);
2053: outb(hdwbase+DALSB, 0);
2054: outb(hdwbase+VPTR2, 0);
2055: outb(hdwbase+VPTR1, 0);
2056: outb(hdwbase+VPTR0, 0);
2057: outb(hdwbase+RFMSB, 0);
2058: outb(hdwbase+RFLSB, 0);
2059: return TRUE;
2060: }
2061:
2062: /*
2063: * ns8390intoff:
2064: *
2065: * This function turns interrupts off for the ns8390 board indicated.
2066: *
2067: */
2068: void
2069: ns8390intoff(unit)
2070: int unit;
2071: {
2072: caddr_t nic = ns8390_softc[unit].nic;
2073: int temp_cr = inb(nic+ds_cmd); /* get current CR value */
2074:
2075: outb(nic+ds_cmd,((temp_cr & 0x3F)|DSCM_PG0|DSCM_STOP));
2076: outb(nic+ds0_imr, 0); /* Interrupt Mask Register */
2077: outb(nic+ds_cmd, temp_cr|DSCM_STOP);
2078:
2079: }
2080:
2081:
2082: /*
2083: * wd80xxget_board_id:
2084: *
2085: * determine which board is being used.
2086: * Currently supports:
2087: * wd8003E (tested)
2088: * wd8003EBT
2089: * wd8003EP (tested)
2090: * wd8013EP (tested)
2091: *
2092: */
2093: wd80xxget_board_id(dev)
2094: struct bus_device *dev;
2095: {
2096: vm_offset_t hdwbase = dev->address;
2097: long unit = dev->unit;
2098: long board_id = 0;
2099: int reg_temp;
2100: int rev_num; /* revision number */
2101: int ram_flag;
2102: int intr_temp;
2103: int i;
2104: boolean_t register_aliasing;
2105:
2106: rev_num = (inb(hdwbase + IFWD_BOARD_ID) & IFWD_BOARD_REV_MASK) >> 1;
2107: printf("%s%d: ", ns8390_softc[unit].card, unit);
2108:
2109: if (rev_num == 0) {
2110: printf("rev 0x00\n");
2111: /* It must be 8000 board */
2112: return 0;
2113: }
2114:
2115: /* Check if register aliasing is true, that is reading from register
2116: offsets 0-7 will return the contents of register offsets 8-f */
2117:
2118: register_aliasing = TRUE;
2119: for (i = 1; i < 5; i++) {
2120: if (inb(hdwbase + IFWD_REG_0 + i) !=
2121: inb(hdwbase + IFWD_LAR_0 + i))
2122: register_aliasing = FALSE;
2123: }
2124: if (inb(hdwbase + IFWD_REG_7) != inb(hdwbase + IFWD_CHKSUM))
2125: register_aliasing = FALSE;
2126:
2127:
2128: if (register_aliasing == FALSE) {
2129: /* Check if board has interface chip */
2130:
2131: reg_temp = inb(hdwbase + IFWD_REG_7); /* save old */
2132: outb(hdwbase + IFWD_REG_7, 0x35); /* write value */
2133: inb(hdwbase + IFWD_REG_0); /* dummy read */
2134: if ((inb(hdwbase + IFWD_REG_7) & 0xff) == 0x35) {
2135: outb(hdwbase + IFWD_REG_7, 0x3a);/* Try another value*/
2136: inb(hdwbase + IFWD_REG_0); /* dummy read */
2137: if ((inb(hdwbase + IFWD_REG_7) & 0xff) == 0x3a) {
2138: board_id |= IFWD_INTERFACE_CHIP;
2139: outb(hdwbase + IFWD_REG_7, reg_temp);
2140: /* restore old value */
2141: }
2142: }
2143:
2144: /* Check if board is 16 bit by testing if bit zero in
2145: register 1 is unchangeable by software. If so then
2146: card has 16 bit capability */
2147: reg_temp = inb(hdwbase + IFWD_REG_1);
2148: outb(hdwbase + IFWD_REG_1, reg_temp ^ IFWD_16BIT);
2149: inb(hdwbase + IFWD_REG_0); /* dummy read */
2150: if ((inb(hdwbase + IFWD_REG_1) & IFWD_16BIT) ==
2151: (reg_temp & IFWD_16BIT)) { /* Is bit unchanged */
2152: board_id |= IFWD_BOARD_16BIT; /* Yes == 16 bit */
2153: reg_temp &= 0xfe; /* For 16 bit board
2154: always reset bit 0 */
2155: }
2156: outb(hdwbase + IFWD_REG_1, reg_temp); /* write value back */
2157:
2158: /* Test if 16 bit card is in 16 bit slot by reading bit zero in
2159: register 1. */
2160: if (board_id & IFWD_BOARD_16BIT) {
2161: if (inb(hdwbase + IFWD_REG_1) & IFWD_16BIT) {
2162: board_id |= IFWD_SLOT_16BIT;
2163: }
2164: }
2165: }
2166:
2167: /* Get media type */
2168:
2169: if (inb(hdwbase + IFWD_BOARD_ID) & IFWD_MEDIA_TYPE) {
2170: board_id |= IFWD_ETHERNET_MEDIA;
2171: } else if (rev_num == 1) {
2172: board_id |= IFWD_STARLAN_MEDIA;
2173: } else {
2174: board_id |= IFWD_TWISTED_PAIR_MEDIA;
2175: }
2176:
2177: if (rev_num == 2) {
2178: if (inb(hdwbase + IFWD_BOARD_ID) & IFWD_SOFT_CONFIG) {
2179: if ((board_id & IFWD_STATIC_ID_MASK) == WD8003EB ||
2180: (board_id & IFWD_STATIC_ID_MASK) == WD8003W) {
2181: board_id |= IFWD_ALTERNATE_IRQ_BIT;
2182: }
2183: }
2184: /* Check for memory size */
2185:
2186: ram_flag = inb(hdwbase + IFWD_BOARD_ID) & IFWD_MEMSIZE;
2187:
2188: switch (board_id & IFWD_STATIC_ID_MASK) {
2189: case WD8003E: /* same as WD8003EBT */
2190: case WD8003S: /* same as WD8003SH */
2191: case WD8003WT:
2192: case WD8003W:
2193: case WD8003EB: /* same as WD8003EP */
2194: if (ram_flag)
2195: board_id |= IFWD_RAM_SIZE_32K;
2196: else
2197: board_id |= IFWD_RAM_SIZE_8K;
2198: break;
2199: case WD8003ETA:
2200: case WD8003STA:
2201: case WD8003EA:
2202: case WD8003SHA:
2203: case WD8003WA:
2204: board_id |= IFWD_RAM_SIZE_16K;
2205: break;
2206: case WD8013EBT:
2207: if (board_id & IFWD_SLOT_16BIT) {
2208: if (ram_flag)
2209: board_id |= IFWD_RAM_SIZE_64K;
2210: else
2211: board_id |= IFWD_RAM_SIZE_16K;
2212: } else {
2213: if (ram_flag)
2214: board_id |= IFWD_RAM_SIZE_32K;
2215: else
2216: board_id |= IFWD_RAM_SIZE_8K;
2217: }
2218: break;
2219: default:
2220: board_id |= IFWD_RAM_SIZE_UNKNOWN;
2221: break;
2222: }
2223: } else if (rev_num >= 3) {
2224: board_id &= (long) ~IFWD_MEDIA_MASK; /* remove media info */
2225: board_id |= IFWD_INTERFACE_584_CHIP;
2226: board_id |= wd80xxget_eeprom_info(hdwbase, board_id);
2227: } else {
2228: /* Check for memory size */
2229: if (board_id & IFWD_BOARD_16BIT) {
2230: if (board_id & IFWD_SLOT_16BIT)
2231: board_id |= IFWD_RAM_SIZE_16K;
2232: else
2233: board_id |= IFWD_RAM_SIZE_8K;
2234: } else if (board_id & IFWD_MICROCHANNEL)
2235: board_id |= IFWD_RAM_SIZE_16K;
2236: else if (board_id & IFWD_INTERFACE_CHIP) {
2237: if (inb(hdwbase + IFWD_REG_1) & IFWD_MEMSIZE)
2238: board_id |= IFWD_RAM_SIZE_32K;
2239: else
2240: board_id |= IFWD_RAM_SIZE_8K;
2241: } else
2242: board_id |= IFWD_RAM_SIZE_UNKNOWN;
2243:
2244: /* No support for 690 chip yet. It should be checked here */
2245: }
2246:
2247: switch (board_id & IFWD_STATIC_ID_MASK) {
2248: case WD8003E: printf("WD8003E or WD8003EBT"); break;
2249: case WD8003S: printf("WD8003S or WD8003SH"); break;
2250: case WD8003WT: printf("WD8003WT"); break;
2251: case WD8003W: printf("WD8003W"); break;
2252: case WD8003EB:
2253: if (board_id & IFWD_INTERFACE_584_CHIP)
2254: printf("WD8003EP");
2255: else
2256: printf("WD8003EB");
2257: break;
2258: case WD8003EW: printf("WD8003EW"); break;
2259: case WD8003ETA: printf("WD8003ETA"); break;
2260: case WD8003STA: printf("WD8003STA"); break;
2261: case WD8003EA: printf("WD8003EA"); break;
2262: case WD8003SHA: printf("WD8003SHA"); break;
2263: case WD8003WA: printf("WD8003WA"); break;
2264: case WD8013EBT: printf("WD8013EBT"); break;
2265: case WD8013EB:
2266: if (board_id & IFWD_INTERFACE_584_CHIP)
2267: printf("WD8013EP");
2268: else
2269: printf("WD8013EB");
2270: break;
2271: case WD8013W: printf("WD8013W"); break;
2272: case WD8013EW: printf("WD8013EW"); break;
2273: default: printf("unknown"); break;
2274: }
2275: printf(" rev 0x%02x", rev_num);
2276: switch(board_id & IFWD_RAM_SIZE_RES_7) {
2277: case IFWD_RAM_SIZE_UNKNOWN:
2278: break;
2279: case IFWD_RAM_SIZE_8K:
2280: printf(" 8 kB ram");
2281: break;
2282: case IFWD_RAM_SIZE_16K:
2283: printf(" 16 kB ram");
2284: break;
2285: case IFWD_RAM_SIZE_32K:
2286: printf(" 32 kB ram");
2287: break;
2288: case IFWD_RAM_SIZE_64K:
2289: printf(" 64 kB ram");
2290: break;
2291: default:
2292: printf("wd: Internal error ram size value invalid %d\n",
2293: (board_id & IFWD_RAM_SIZE_RES_7)>>16);
2294: }
2295:
2296: if (board_id & IFWD_BOARD_16BIT) {
2297: if (board_id & IFWD_SLOT_16BIT) {
2298: printf(", in 16 bit slot");
2299: } else {
2300: printf(", 16 bit board in 8 bit slot");
2301: }
2302: }
2303: if (board_id & IFWD_INTERFACE_CHIP) {
2304: if (board_id & IFWD_INTERFACE_584_CHIP) {
2305: printf(", 584 chip");
2306: } else {
2307: printf(", 583 chip");
2308: }
2309: }
2310: if ((board_id & IFWD_INTERFACE_CHIP) == IFWD_INTERFACE_CHIP) {
2311: /* program the WD83C583 EEPROM registers */
2312: int irr_temp, icr_temp;
2313:
2314: icr_temp = inb(hdwbase + IFWD_ICR);
2315: irr_temp = inb(hdwbase + IFWD_IRR);
2316:
2317: irr_temp &= ~(IFWD_IR0 | IFWD_IR1);
2318: irr_temp |= IFWD_IEN;
2319:
2320: icr_temp &= IFWD_WTS;
2321:
2322: if (!(board_id & IFWD_INTERFACE_584_CHIP)) {
2323: icr_temp |= IFWD_DMAE | IFWD_IOPE;
2324: if (ram_flag)
2325: icr_temp |= IFWD_MSZ;
2326: }
2327:
2328: if (board_id & IFWD_INTERFACE_584_CHIP) {
2329: switch(ns8390info[unit]->sysdep1) {
2330: case 10:
2331: icr_temp |= IFWD_DMAE;
2332: break;
2333: case 2:
2334: case 9: /* Same as 2 */
2335: break;
2336: case 11:
2337: icr_temp |= IFWD_DMAE;
2338: /*FALLTHROUGH*/
2339: case 3:
2340: irr_temp |= IFWD_IR0;
2341: break;
2342: case 15:
2343: icr_temp |= IFWD_DMAE;
2344: /*FALLTHROUGH*/
2345: case 5:
2346: irr_temp |= IFWD_IR1;
2347: break;
2348: case 4:
2349: icr_temp |= IFWD_DMAE;
2350: /*FALLTHROUGH*/
2351: case 7:
2352: irr_temp |= IFWD_IR0 | IFWD_IR1;
2353: break;
2354: default:
2355: printf("%s%d: wd80xx_get_board_id(): Could not set Interrupt Request Register according to pic(%d).\n",
2356: ns8390_softc[unit].card, unit,
2357: ns8390info[unit]->sysdep1);
2358: break;
2359: }
2360: } else {
2361: switch(ns8390info[unit]->sysdep1) {
2362: /* attempt to set interrupt according to assigned pic */
2363: case 2:
2364: case 9: /* Same as 2 */
2365: break;
2366: case 3:
2367: irr_temp |= IFWD_IR0;
2368: break;
2369: case 4:
2370: irr_temp |= IFWD_IR1;
2371: break;
2372: case 5:
2373: irr_temp |= IFWD_IR1 | IFWD_AINT;
2374: break;
2375: case 7:
2376: irr_temp |= IFWD_IR0 | IFWD_IR1;
2377: break;
2378: default:
2379: printf("%s%d: wd80xx_get_board_id(): Could not set Interrupt Request Register according to pic(%d).\n",
2380: ns8390_softc[unit].card, unit,
2381: ns8390info[unit]->sysdep1);
2382: }
2383: }
2384: outb(hdwbase + IFWD_IRR, irr_temp);
2385: outb(hdwbase + IFWD_ICR, icr_temp);
2386: }
2387: printf("\n");
2388: return (board_id);
2389: }
2390:
2391: wd80xxget_eeprom_info(hdwbase, board_id)
2392: caddr_t hdwbase;
2393: long board_id;
2394: {
2395: unsigned long new_bits = 0;
2396: int reg_temp;
2397:
2398: outb(hdwbase + IFWD_REG_1,
2399: ((inb(hdwbase + IFWD_REG_1) & IFWD_ICR_MASK) | IFWD_OTHER_BIT));
2400: outb(hdwbase + IFWD_REG_3,
2401: ((inb(hdwbase + IFWD_REG_3) & IFWD_EAR_MASK) | IFWD_ENGR_PAGE));
2402: outb(hdwbase + IFWD_REG_1,
2403: ((inb(hdwbase + IFWD_REG_1) & IFWD_ICR_MASK) |
2404: (IFWD_RLA | IFWD_OTHER_BIT)));
2405: while (inb(hdwbase + IFWD_REG_1) & IFWD_RECALL_DONE_MASK)
2406: ;
2407:
2408: reg_temp = inb(hdwbase + IFWD_EEPROM_1);
2409: switch (reg_temp & IFWD_EEPROM_BUS_TYPE_MASK) {
2410: case IFWD_EEPROM_BUS_TYPE_AT:
2411: if (wd_debug & 1) printf("wd: AT bus, ");
2412: break;
2413: case IFWD_EEPROM_BUS_TYPE_MCA:
2414: if (wd_debug & 1) printf("wd: MICROCHANNEL, ");
2415: new_bits |= IFWD_MICROCHANNEL;
2416: break;
2417: default:
2418: break;
2419: }
2420: switch (reg_temp & IFWD_EEPROM_BUS_SIZE_MASK) {
2421: case IFWD_EEPROM_BUS_SIZE_8BIT:
2422: if (wd_debug & 1) printf("8 bit bus size, ");
2423: break;
2424: case IFWD_EEPROM_BUS_SIZE_16BIT:
2425: if (wd_debug & 1) printf("16 bit bus size ");
2426: new_bits |= IFWD_BOARD_16BIT;
2427: if (inb(hdwbase + IFWD_REG_1) & IFWD_16BIT) {
2428: new_bits |= IFWD_SLOT_16BIT;
2429: if (wd_debug & 1)
2430: printf("in 16 bit slot, ");
2431: } else {
2432: if (wd_debug & 1)
2433: printf("in 8 bit slot (why?), ");
2434: }
2435: break;
2436: default:
2437: if (wd_debug & 1) printf("bus size other than 8 or 16 bit, ");
2438: break;
2439: }
2440: reg_temp = inb(hdwbase + IFWD_EEPROM_0);
2441: switch (reg_temp & IFWD_EEPROM_MEDIA_MASK) {
2442: case IFWD_STARLAN_TYPE:
2443: if (wd_debug & 1) printf("Starlan media, ");
2444: new_bits |= IFWD_STARLAN_MEDIA;
2445: break;
2446: case IFWD_TP_TYPE:
2447: if (wd_debug & 1) printf("Twisted pair media, ");
2448: new_bits |= IFWD_TWISTED_PAIR_MEDIA;
2449: break;
2450: case IFWD_EW_TYPE:
2451: if (wd_debug & 1) printf("Ethernet and twisted pair media, ");
2452: new_bits |= IFWD_EW_MEDIA;
2453: break;
2454: case IFWD_ETHERNET_TYPE: /*FALLTHROUGH*/
2455: default:
2456: if (wd_debug & 1) printf("ethernet media, ");
2457: new_bits |= IFWD_ETHERNET_MEDIA;
2458: break;
2459: }
2460: switch (reg_temp & IFWD_EEPROM_IRQ_MASK) {
2461: case IFWD_ALTERNATE_IRQ_1:
2462: if (wd_debug & 1) printf("Alternate irq 1\n");
2463: new_bits |= IFWD_ALTERNATE_IRQ_BIT;
2464: break;
2465: default:
2466: if (wd_debug & 1) printf("\n");
2467: break;
2468: }
2469: switch (reg_temp & IFWD_EEPROM_RAM_SIZE_MASK) {
2470: case IFWD_EEPROM_RAM_SIZE_8K:
2471: new_bits |= IFWD_RAM_SIZE_8K;
2472: break;
2473: case IFWD_EEPROM_RAM_SIZE_16K:
2474: if ((new_bits & IFWD_BOARD_16BIT) && (new_bits & IFWD_SLOT_16BIT))
2475: new_bits |= IFWD_RAM_SIZE_16K;
2476: else
2477: new_bits |= IFWD_RAM_SIZE_8K;
2478: break;
2479: case IFWD_EEPROM_RAM_SIZE_32K:
2480: new_bits |= IFWD_RAM_SIZE_32K;
2481: break;
2482: case IFWD_EEPROM_RAM_SIZE_64K:
2483: if ((new_bits & IFWD_BOARD_16BIT) && (new_bits & IFWD_SLOT_16BIT))
2484: new_bits |= IFWD_RAM_SIZE_64K;
2485: else
2486: new_bits |= IFWD_RAM_SIZE_32K;
2487: break;
2488: default:
2489: new_bits |= IFWD_RAM_SIZE_UNKNOWN;
2490: break;
2491: }
2492: outb(hdwbase + IFWD_REG_1,
2493: ((inb(hdwbase + IFWD_REG_1) & IFWD_ICR_MASK) | IFWD_OTHER_BIT));
2494: outb(hdwbase + IFWD_REG_3,
2495: ((inb(hdwbase + IFWD_REG_3) & IFWD_EAR_MASK) | IFWD_EA6));
2496: outb(hdwbase + IFWD_REG_1,
2497: ((inb(hdwbase + IFWD_REG_1) & IFWD_ICR_MASK) | IFWD_RLA));
2498: return (new_bits);
2499: }
2500:
2501: wdpr(unit)
2502: {
2503: caddr_t nic = ns8390_softc[unit].nic;
2504: spl_t s;
2505: int temp_cr;
2506:
2507: s = SPLNET();
2508: temp_cr = inb(nic+ds_cmd); /* get current CR value */
2509:
2510: printf("CR %x, BNDRY %x, TSR %x, NCR %x, FIFO %x, ISR %x, RSR %x\n",
2511: inb(nic+0x0), inb(nic+0x3), inb(nic+0x4), inb(nic+0x5),
2512: inb(nic+0x6), inb(nic+0x7), inb(nic+0xc));
2513: printf("CLD %x:%x, CRD %x:%x, FR %x, CRC %x, Miss %x\n",
2514: inb(nic+0x1), inb(nic+0x2),
2515: inb(nic+0x8), inb(nic+0x9),
2516: inb(nic+0xd), inb(nic+0xe), inb(nic+0xf));
2517:
2518:
2519: outb(nic, (temp_cr&0x3f)|DSCM_PG1); /* page 1 CR value */
2520: printf("PHYS %x:%x:%x:%x:%x CUR %x\n",
2521: inb(nic+0x1), inb(nic+0x2), inb(nic+0x3),
2522: inb(nic+0x4), inb(nic+0x5), inb(nic+0x6),
2523: inb(nic+0x7));
2524: printf("MAR %x:%x:%x:%x:%x:%x:%x:%x\n",
2525: inb(nic+0x8), inb(nic+0x9), inb(nic+0xa), inb(nic+0xb),
2526: inb(nic+0xc), inb(nic+0xd), inb(nic+0xe), inb(nic+0xf));
2527: outb(nic, temp_cr); /* restore current CR value */
2528: splx(s);
2529: }
2530:
2531:
2532: /*
2533: This sets bit 7 (0 justified) of register offset 0x05. It will enable
2534: the host to access shared RAM 16 bits at a time. It will also maintain
2535: the LAN16BIT bit high in addition, this routine maintains address bit 19
2536: (previous cards assumed this bit high...we must do it manually)
2537:
2538: note 1: this is a write only register
2539: note 2: this routine should be called only after interrupts are disabled
2540: and they should remain disabled until after the routine 'dis_16bit_access'
2541: is called
2542: */
2543:
2544: en_16bit_access (hdwbase, board_id)
2545: caddr_t hdwbase;
2546: long board_id;
2547: {
2548: if (board_id & IFWD_INTERFACE_CHIP)
2549: outb(hdwbase+IFWD_REG_5,
2550: (inb(hdwbase+IFWD_REG_5) & IFWD_REG5_MEM_MASK)
2551: | IFWD_MEM16ENB | IFWD_LAN16ENB);
2552: else
2553: outb(hdwbase+IFWD_REG_5, (IFWD_MEM16ENB | IFWD_LAN16ENB |
2554: IFWD_LA19));
2555: }
2556:
2557: /*
2558: This resets bit 7 (0 justified) of register offset 0x05. It will disable
2559: the host from accessing shared RAM 16 bits at a time. It will maintain the
2560: LAN16BIT bit high in addition, this routine maintains address bit 19
2561: (previous cards assumed this bit high...we must do it manually)
2562:
2563: note: this is a write only register
2564: */
2565:
2566: dis_16bit_access (hdwbase, board_id)
2567: caddr_t hdwbase;
2568: long board_id;
2569: {
2570: if (board_id & IFWD_INTERFACE_CHIP)
2571: outb(hdwbase+IFWD_REG_5,
2572: ((inb(hdwbase+IFWD_REG_5) & IFWD_REG5_MEM_MASK) |
2573: IFWD_LAN16ENB));
2574: else
2575: outb(hdwbase+IFWD_REG_5, (IFWD_LAN16ENB | IFWD_LA19));
2576: }
2577:
2578: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.