![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_we.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / arch / i386 / isa|
Return to if_we.c CVS log | Up to [Net/2] / Net2 / arch / i386 / isa |
1.1 root 1: /*-
2: * Copyright (c) 1990 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * This code is derived from software contributed to Berkeley by
6: * Tim L. Tucker.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. All advertising materials mentioning features or use of this software
17: * must display the following acknowledgement:
18: * This product includes software developed by the University of
19: * California, Berkeley and its contributors.
20: * 4. Neither the name of the University nor the names of its contributors
21: * may be used to endorse or promote products derived from this software
22: * without specific prior written permission.
23: *
24: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34: * SUCH DAMAGE.
35: *
36: * @(#)if_we.c 7.3 (Berkeley) 5/21/91
37: */
38:
39: /*
40: * Modification history
41: *
42: * 8/28/89 - Initial version(if_wd.c), Tim L Tucker
43: */
44:
45: #include "we.h"
46: #if NWE > 0
47: /*
48: * Western Digital 8003 ethernet/starlan adapter
49: *
50: * Supports the following interface cards:
51: * WD8003E, WD8003EBT, WD8003S, WD8003SBT, WD8013EBT
52: *
53: * The Western Digital card is one of many AT/MCA ethernet interfaces
54: * based on the National DS8390 Network Interface chip set.
55: */
56: #include "param.h"
57: #include "mbuf.h"
58: #include "socket.h"
59: #include "ioctl.h"
60: #include "errno.h"
61: #include "syslog.h"
62:
63: #include "net/if.h"
64: #include "net/netisr.h"
65:
66: #ifdef INET
67: #include "netinet/in.h"
68: #include "netinet/in_systm.h"
69: #include "netinet/in_var.h"
70: #include "netinet/ip.h"
71: #include "netinet/if_ether.h"
72: #endif
73:
74: #ifdef NS
75: #include "netns/ns.h"
76: #include "netns/ns_if.h"
77: #endif
78:
79: #include "i386/isa/if_wereg.h"
80: #include "i386/isa/isa_device.h"
81:
82: /*
83: * This constant should really be 60 because the we adds 4 bytes of crc.
84: * However when set to 60 our packets are ignored by deuna's , 3coms are
85: * okay ??????????????????????????????????????????
86: */
87: #define ETHER_MIN_LEN 64
88: #define ETHER_ADDR_LEN 6
89: #define ETHER_HDR_SIZE 14
90:
91: /*
92: * Ethernet software status per interface.
93: *
94: * Each interface is referenced by a network interface structure,
95: * qe_if, which the routing code uses to locate the interface.
96: * This structure contains the output queue for the interface, its address, ...
97: */
98: struct we_softc {
99: struct arpcom we_ac; /* Ethernet common part */
100: #define we_if we_ac.ac_if /* network-visible interface */
101: #define we_addr we_ac.ac_enaddr /* hardware Ethernet address */
102:
103: u_char we_flags; /* software state */
104: #define WDF_RUNNING 0x01
105: #define WDF_TXBUSY 0x02
106:
107: u_char we_type; /* interface type code */
108: u_short we_vector; /* interrupt vector */
109: short we_io_ctl_addr; /* i/o bus address, control */
110: short we_io_nic_addr; /* i/o bus address, DS8390 */
111:
112: caddr_t we_vmem_addr; /* card RAM virtual memory base */
113: u_long we_vmem_size; /* card RAM bytes */
114: caddr_t we_vmem_ring; /* receive ring RAM vaddress */
115: caddr_t we_vmem_end; /* receive ring RAM end */
116: } we_softc[NWE];
117:
118: int weprobe(), weattach(), weintr(), westart();
119: int weinit(), ether_output(), weioctl(), wereset(), wewatchdog();
120:
121: struct isa_driver wedriver = {
122: weprobe, weattach, "we",
123: };
124:
125: /*
126: * Probe the WD8003 to see if it's there
127: */
128: weprobe(is)
129: struct isa_device *is;
130: {
131: register int i;
132: register struct we_softc *sc = &we_softc[is->id_unit];
133: union we_mem_sel wem;
134: u_char sum;
135:
136: /*
137: * Here we check the card ROM, if the checksum passes, and the
138: * type code and ethernet address check out, then we know we have
139: * a wd8003 card.
140: *
141: * Autoconfiguration: No warning message is printed on error.
142: */
143: for (sum = 0, i = 0; i < 8; ++i)
144: sum += inb(is->id_iobase + WD_ROM_OFFSET + i);
145: if (sum != WD_CHECKSUM)
146: return (0);
147: sc->we_type = inb(is->id_iobase + WD_ROM_OFFSET + 6);
148: if ((sc->we_type != WD_ETHER) && (sc->we_type != WD_STARLAN)
149: && (sc->we_type != WD_ETHER2))
150: return (0);
151:
152: /*
153: * Setup card RAM area and i/o addresses
154: * Kernel Virtual to segment C0000-DFFFF?????
155: */
156: sc->we_io_ctl_addr = is->id_iobase;
157: sc->we_io_nic_addr = sc->we_io_ctl_addr + WD_NIC_OFFSET;
158: sc->we_vector = is->id_irq;
159: sc->we_vmem_addr = (caddr_t)is->id_maddr;
160: sc->we_vmem_size = is->id_msize;
161: sc->we_vmem_ring = sc->we_vmem_addr + (WD_PAGE_SIZE * WD_TXBUF_SIZE);
162: sc->we_vmem_end = sc->we_vmem_addr + is->id_msize;
163:
164: /*
165: * Save board ROM station address
166: */
167: for (i = 0; i < ETHER_ADDR_LEN; ++i)
168: sc->we_addr[i] = inb(sc->we_io_ctl_addr + WD_ROM_OFFSET + i);
169:
170: /*
171: * Mapin interface memory, setup memory select register
172: */
173: /* wem.ms_addr = (u_long)sc->we_vmem_addr >> 13; */
174: wem.ms_addr = (u_long)(0xd0000)>> 13;
175: wem.ms_enable = 1;
176: wem.ms_reset = 0;
177: outb(sc->we_io_ctl_addr, wem.ms_byte);
178:
179: /*
180: * clear interface memory, then sum to make sure its valid
181: */
182: for (i = 0; i < sc->we_vmem_size; ++i)
183: sc->we_vmem_addr[i] = 0x0;
184: for (sum = 0, i = 0; i < sc->we_vmem_size; ++i)
185: sum += sc->we_vmem_addr[i];
186: if (sum != 0x0) {
187: printf("we%d: wd8003 dual port RAM address error\n", is->id_unit);
188: return (0);
189: }
190:
191: return (WD_IO_PORTS);
192: }
193:
194: /*
195: * Interface exists: make available by filling in network interface
196: * record. System will initialize the interface when it is ready
197: * to accept packets.
198: */
199: weattach(is)
200: struct isa_device *is;
201: {
202: register struct we_softc *sc = &we_softc[is->id_unit];
203: register struct ifnet *ifp = &sc->we_if;
204: union we_command wecmd;
205:
206: wecmd.cs_byte = inb(sc->we_io_nic_addr + WD_P0_COMMAND);
207: wecmd.cs_stp = 1;
208: wecmd.cs_sta = 0;
209: wecmd.cs_ps = 0;
210: outb(sc->we_io_nic_addr + WD_P0_COMMAND, wecmd.cs_byte);
211: /*
212: * Initialize ifnet structure
213: */
214: ifp->if_unit = is->id_unit;
215: ifp->if_name = "we" ;
216: ifp->if_mtu = ETHERMTU;
217: ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_NOTRAILERS ;
218: ifp->if_init = weinit;
219: ifp->if_output = ether_output;
220: ifp->if_start = westart;
221: ifp->if_ioctl = weioctl;
222: ifp->if_reset = wereset;
223: ifp->if_watchdog = wewatchdog;
224: if_attach(ifp);
225:
226: /*
227: * Banner...
228: */
229: printf(" %s address %s",
230: ((sc->we_type != WD_STARLAN) ? "ethernet" : "starlan"),
231: ether_sprintf(sc->we_addr));
232: }
233:
234: /*
235: * Reset of interface.
236: */
237: wereset(unit, uban)
238: int unit, uban;
239: {
240: if (unit >= NWE)
241: return;
242: printf("we%d: reset\n", unit);
243: /* we_softc[unit].we_flags &= ~WDF_RUNNING; */
244: weinit(unit);
245: }
246:
247: /*
248: * Take interface offline.
249: */
250: westop(unit)
251: int unit;
252: {
253: register struct we_softc *sc = &we_softc[unit];
254: union we_command wecmd;
255: int s;
256:
257: /*
258: * Shutdown DS8390
259: */
260: s = splimp();
261: wecmd.cs_byte = inb(sc->we_io_nic_addr + WD_P0_COMMAND);
262: wecmd.cs_stp = 1;
263: wecmd.cs_sta = 0;
264: wecmd.cs_ps = 0;
265: outb(sc->we_io_nic_addr + WD_P0_COMMAND, wecmd.cs_byte);
266: (void) splx(s);
267: }
268:
269: wewatchdog(unit) {
270:
271: log(LOG_WARNING,"we%d: soft reset\n", unit);
272: westop(unit);
273: weinit(unit);
274: }
275:
276: static Bdry;
277: /*
278: * Initialization of interface (really just DS8390).
279: */
280: weinit(unit)
281: int unit;
282: {
283: register struct we_softc *sc = &we_softc[unit];
284: register struct ifnet *ifp = &sc->we_if;
285: union we_command wecmd;
286: int i, s;
287:
288: /* address not known */
289: if (ifp->if_addrlist == (struct ifaddr *)0)
290: return;
291:
292: /* already running */
293: /*if (ifp->if_flags & IFF_RUNNING) return; */
294:
295: /*
296: * Initialize DS8390 in order given in NSC NIC manual.
297: * this is stock code...please see the National manual for details.
298: */
299: s = splhigh();
300: Bdry = 0;
301: wecmd.cs_byte = inb(sc->we_io_nic_addr + WD_P0_COMMAND);
302: wecmd.cs_stp = 1;
303: wecmd.cs_sta = 0;
304: wecmd.cs_ps = 0;
305: outb(sc->we_io_nic_addr + WD_P0_COMMAND, wecmd.cs_byte);
306: outb(sc->we_io_nic_addr + WD_P0_DCR, WD_D_CONFIG);
307: outb(sc->we_io_nic_addr + WD_P0_RBCR0, 0);
308: outb(sc->we_io_nic_addr + WD_P0_RBCR1, 0);
309: outb(sc->we_io_nic_addr + WD_P0_RCR, WD_R_MON);
310: outb(sc->we_io_nic_addr + WD_P0_TCR, WD_T_CONFIG);
311: outb(sc->we_io_nic_addr + WD_P0_TPSR, 0);
312: outb(sc->we_io_nic_addr + WD_P0_PSTART, WD_TXBUF_SIZE);
313: outb(sc->we_io_nic_addr + WD_P0_PSTOP,
314: sc->we_vmem_size / WD_PAGE_SIZE);
315: outb(sc->we_io_nic_addr + WD_P0_BNRY, WD_TXBUF_SIZE);
316: outb(sc->we_io_nic_addr + WD_P0_ISR, 0xff);
317: outb(sc->we_io_nic_addr + WD_P0_IMR, WD_I_CONFIG);
318: wecmd.cs_ps = 1;
319: outb(sc->we_io_nic_addr + WD_P0_COMMAND, wecmd.cs_byte);
320: for (i = 0; i < ETHER_ADDR_LEN; ++i)
321: outb(sc->we_io_nic_addr + WD_P1_PAR0 + i, sc->we_addr[i]);
322: for (i = 0; i < ETHER_ADDR_LEN; ++i) /* == broadcast addr */
323: outb(sc->we_io_nic_addr + WD_P1_MAR0 + i, 0xff);
324: outb(sc->we_io_nic_addr + WD_P1_CURR, WD_TXBUF_SIZE);
325: wecmd.cs_ps = 0;
326: wecmd.cs_stp = 0;
327: wecmd.cs_sta = 1;
328: wecmd.cs_rd = 0x4;
329: outb(sc->we_io_nic_addr + WD_P1_COMMAND, wecmd.cs_byte);
330: outb(sc->we_io_nic_addr + WD_P0_RCR, WD_R_CONFIG);
331:
332: /*
333: * Take the interface out of reset, program the vector,
334: * enable interrupts, and tell the world we are up.
335: */
336: ifp->if_flags |= IFF_RUNNING;
337: sc->we_flags &= ~WDF_TXBUSY;
338: (void) splx(s);
339: westart(ifp);
340: }
341:
342: /*
343: * Start output on interface.
344: */
345: westart(ifp)
346: struct ifnet *ifp;
347: {
348: register struct we_softc *sc = &we_softc[ifp->if_unit];
349: struct mbuf *m0, *m;
350: register caddr_t buffer;
351: int len, s;
352: union we_command wecmd;
353:
354: /*
355: * The DS8390 has only one transmit buffer, if it is busy we
356: * must wait until the transmit interrupt completes.
357: */
358: s = splhigh();
359: if (sc->we_flags & WDF_TXBUSY) {
360: (void) splx(s);
361: return;
362: }
363: IF_DEQUEUE(&sc->we_if.if_snd, m);
364: if (m == 0) {
365: (void) splx(s);
366: return;
367: }
368: sc->we_flags |= WDF_TXBUSY;
369: (void) splx(s);
370:
371: /*
372: * Copy the mbuf chain into the transmit buffer
373: */
374: buffer = sc->we_vmem_addr;
375: len = 0;
376: for (m0 = m; m != 0; m = m->m_next) {
377: bcopy(mtod(m, caddr_t), buffer, m->m_len);
378: buffer += m->m_len;
379: len += m->m_len;
380: }
381:
382: m_freem(m0);
383:
384: /*
385: * Init transmit length registers, and set transmit start flag.
386: */
387: s = splhigh();
388: len = MAX(len, ETHER_MIN_LEN);
389: wecmd.cs_byte = inb(sc->we_io_nic_addr + WD_P0_COMMAND);
390: wecmd.cs_ps = 0;
391: outb(sc->we_io_nic_addr + WD_P0_COMMAND, wecmd.cs_byte);
392: outb(sc->we_io_nic_addr + WD_P0_TBCR0, len & 0xff);
393: outb(sc->we_io_nic_addr + WD_P0_TBCR1, len >> 8);
394: wecmd.cs_txp = 1;
395: outb(sc->we_io_nic_addr + WD_P0_COMMAND, wecmd.cs_byte);
396: (void) splx(s);
397: }
398:
399: /*
400: * Ethernet interface interrupt processor
401: */
402: weintr(unit)
403: int unit;
404: {
405: register struct we_softc *sc = &we_softc[unit];
406: union we_command wecmd;
407: union we_interrupt weisr;
408:
409: unit =0;
410:
411: /* disable onboard interrupts, then get interrupt status */
412: wecmd.cs_byte = inb(sc->we_io_nic_addr + WD_P0_COMMAND);
413: wecmd.cs_ps = 0;
414: outb(sc->we_io_nic_addr + WD_P0_COMMAND, wecmd.cs_byte);
415: weisr.is_byte = inb(sc->we_io_nic_addr + WD_P0_ISR);
416: loop:
417: outb(sc->we_io_nic_addr + WD_P0_ISR, weisr.is_byte);
418:
419: /* transmit error */
420: if (weisr.is_txe) {
421: /* need to read these registers to clear status */
422: sc->we_if.if_collisions +=
423: inb(sc->we_io_nic_addr + WD_P0_TBCR0);
424: ++sc->we_if.if_oerrors;
425: }
426:
427: /* receiver error */
428: if (weisr.is_rxe) {
429: /* need to read these registers to clear status */
430: (void) inb(sc->we_io_nic_addr + 0xD);
431: (void) inb(sc->we_io_nic_addr + 0xE);
432: (void) inb(sc->we_io_nic_addr + 0xF);
433: ++sc->we_if.if_ierrors;
434: }
435:
436: /* normal transmit complete */
437: if (weisr.is_ptx || weisr.is_txe)
438: wetint (unit);
439:
440: /* normal receive notification */
441: if (weisr.is_prx || weisr.is_rxe)
442: werint (unit);
443:
444: /* try to start transmit */
445: westart(&sc->we_if);
446:
447: /* re-enable onboard interrupts */
448: wecmd.cs_byte = inb(sc->we_io_nic_addr + WD_P0_COMMAND);
449: wecmd.cs_ps = 0;
450: outb(sc->we_io_nic_addr + WD_P0_COMMAND, wecmd.cs_byte);
451: outb(sc->we_io_nic_addr + WD_P0_IMR, 0xff/*WD_I_CONFIG*/);
452: weisr.is_byte = inb(sc->we_io_nic_addr + WD_P0_ISR);
453: if (weisr.is_byte) goto loop;
454: }
455:
456: /*
457: * Ethernet interface transmit interrupt.
458: */
459: wetint(unit)
460: int unit;
461: {
462: register struct we_softc *sc = &we_softc[unit];
463:
464: /*
465: * Do some statistics (assume page zero of NIC mapped in)
466: */
467: sc->we_flags &= ~WDF_TXBUSY;
468: sc->we_if.if_timer = 0;
469: ++sc->we_if.if_opackets;
470: sc->we_if.if_collisions += inb(sc->we_io_nic_addr + WD_P0_TBCR0);
471: }
472:
473: /*
474: * Ethernet interface receiver interrupt.
475: */
476: werint(unit)
477: int unit;
478: {
479: register struct we_softc *sc = &we_softc[unit];
480: u_char bnry, curr;
481: long len;
482: union we_command wecmd;
483: struct we_ring *wer;
484:
485: /*
486: * Traverse the receive ring looking for packets to pass back.
487: * The search is complete when we find a descriptor not in use.
488: */
489: wecmd.cs_byte = inb(sc->we_io_nic_addr + WD_P0_COMMAND);
490: wecmd.cs_ps = 0;
491: outb(sc->we_io_nic_addr + WD_P0_COMMAND, wecmd.cs_byte);
492: bnry = inb(sc->we_io_nic_addr + WD_P0_BNRY);
493: wecmd.cs_ps = 1;
494: outb(sc->we_io_nic_addr + WD_P0_COMMAND, wecmd.cs_byte);
495: curr = inb(sc->we_io_nic_addr + WD_P1_CURR);
496: if(Bdry)
497: bnry =Bdry;
498:
499: while (bnry != curr)
500: {
501: /* get pointer to this buffer header structure */
502: wer = (struct we_ring *)(sc->we_vmem_addr + (bnry << 8));
503:
504: /* count includes CRC */
505: len = wer->we_count - 4;
506: if (len > 30 && len <= ETHERMTU+100
507: /*&& (*(char *)wer == 1 || *(char *) wer == 0x21)*/)
508: weread(sc, (caddr_t)(wer + 1), len);
509: else printf("reject %d", len);
510:
511: outofbufs:
512: wecmd.cs_byte = inb(sc->we_io_nic_addr + WD_P0_COMMAND);
513: wecmd.cs_ps = 0;
514: outb(sc->we_io_nic_addr + WD_P0_COMMAND, wecmd.cs_byte);
515:
516: /* advance on chip Boundry register */
517: if((caddr_t) wer + WD_PAGE_SIZE - 1 > sc->we_vmem_end) {
518: bnry = WD_TXBUF_SIZE;
519: outb(sc->we_io_nic_addr + WD_P0_BNRY,
520: sc->we_vmem_size / WD_PAGE_SIZE-1);
521:
522: } else {
523: if (len > 30 && len <= ETHERMTU+100)
524: bnry = wer->we_next_packet;
525: else bnry = curr;
526:
527: /* watch out for NIC overflow, reset Boundry if invalid */
528: if ((bnry - 1) < WD_TXBUF_SIZE) {
529: outb(sc->we_io_nic_addr + WD_P0_BNRY,
530: (sc->we_vmem_size / WD_PAGE_SIZE) - 1);
531: bnry = WD_TXBUF_SIZE;
532: } else
533: outb(sc->we_io_nic_addr + WD_P0_BNRY, bnry-1);
534: }
535:
536: /* refresh our copy of CURR */
537: wecmd.cs_ps = 1;
538: outb(sc->we_io_nic_addr + WD_P0_COMMAND, wecmd.cs_byte);
539: curr = inb(sc->we_io_nic_addr + WD_P1_CURR);
540: }
541: Bdry = bnry;
542: }
543:
544: #ifdef shit
545: /*
546: * Process an ioctl request.
547: */
548: weioctl(ifp, cmd, data)
549: register struct ifnet *ifp;
550: int cmd;
551: caddr_t data;
552: {
553: struct we_softc *sc = &we_softc[ifp->if_unit];
554: struct ifaddr *ifa = (struct ifaddr *)data;
555: int s = splimp(), error = 0;
556:
557: switch (cmd) {
558:
559: case SIOCSIFADDR:
560: ifp->if_flags |= IFF_UP;
561: weinit(ifp->if_unit);
562: switch(ifa->ifa_addr->sa_family) {
563: #ifdef INET
564: case AF_INET:
565: ((struct arpcom *)ifp)->ac_ipaddr =
566: IA_SIN(ifa)->sin_addr;
567: arpwhohas((struct arpcom *)ifp, &IA_SIN(ifa)->sin_addr);
568: break;
569: #endif
570: #ifdef NS
571: case AF_NS:
572: {
573: register struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr);
574:
575: if (ns_nullhost(*ina))
576: ina->x_host = *(union ns_host *)(sc->we_addr);
577: else
578: wesetaddr(ina->x_host.c_host, ifp->if_unit);
579: break;
580: }
581: #endif
582: }
583: break;
584:
585: case SIOCSIFFLAGS:
586: if (((ifp->if_flags & IFF_UP) == 0) &&
587: (sc->we_flags & WDF_RUNNING)) {
588: westop(ifp->if_unit);
589: } else if (((ifp->if_flags & IFF_UP) == IFF_UP) &&
590: ((sc->we_flags & WDF_RUNNING) == 0))
591: weinit(ifp->if_unit);
592: break;
593:
594: default:
595: error = EINVAL;
596:
597: }
598: (void) splx(s);
599: return (error);
600: }
601: #endif
602:
603: /*
604: * Process an ioctl request.
605: */
606: weioctl(ifp, cmd, data)
607: register struct ifnet *ifp;
608: int cmd;
609: caddr_t data;
610: {
611: register struct ifaddr *ifa = (struct ifaddr *)data;
612: struct we_softc *sc = &we_softc[ifp->if_unit];
613: struct ifreq *ifr = (struct ifreq *)data;
614: int s = splimp(), error = 0;
615:
616:
617: switch (cmd) {
618:
619: case SIOCSIFADDR:
620: ifp->if_flags |= IFF_UP;
621:
622: switch (ifa->ifa_addr->sa_family) {
623: #ifdef INET
624: case AF_INET:
625: weinit(ifp->if_unit); /* before arpwhohas */
626: ((struct arpcom *)ifp)->ac_ipaddr =
627: IA_SIN(ifa)->sin_addr;
628: arpwhohas((struct arpcom *)ifp, &IA_SIN(ifa)->sin_addr);
629: break;
630: #endif
631: #ifdef NS
632: case AF_NS:
633: {
634: register struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr);
635:
636: if (ns_nullhost(*ina))
637: ina->x_host = *(union ns_host *)(sc->ns_addr);
638: else {
639: /*
640: * The manual says we can't change the address
641: * while the receiver is armed,
642: * so reset everything
643: */
644: ifp->if_flags &= ~IFF_RUNNING;
645: bcopy((caddr_t)ina->x_host.c_host,
646: (caddr_t)sc->ns_addr, sizeof(sc->ns_addr));
647: }
648: weinit(ifp->if_unit); /* does ne_setaddr() */
649: break;
650: }
651: #endif
652: default:
653: weinit(ifp->if_unit);
654: break;
655: }
656: break;
657:
658: case SIOCSIFFLAGS:
659: if ((ifp->if_flags & IFF_UP) == 0 &&
660: ifp->if_flags & IFF_RUNNING) {
661: ifp->if_flags &= ~IFF_RUNNING;
662: westop(ifp->if_unit);
663: } else if (ifp->if_flags & IFF_UP &&
664: (ifp->if_flags & IFF_RUNNING) == 0)
665: weinit(ifp->if_unit);
666: break;
667:
668: #ifdef notdef
669: case SIOCGHWADDR:
670: bcopy((caddr_t)sc->sc_addr, (caddr_t) &ifr->ifr_data,
671: sizeof(sc->sc_addr));
672: break;
673: #endif
674:
675: default:
676: error = EINVAL;
677: }
678: splx(s);
679: return (error);
680: }
681: /*
682: * set ethernet address for unit
683: */
684: wesetaddr(physaddr, unit)
685: u_char *physaddr;
686: int unit;
687: {
688: register struct we_softc *sc = &we_softc[unit];
689: register int i;
690:
691: /*
692: * Rewrite ethernet address, and then force restart of NIC
693: */
694: for (i = 0; i < ETHER_ADDR_LEN; i++)
695: sc->we_addr[i] = physaddr[i];
696: sc->we_flags &= ~WDF_RUNNING;
697: weinit(unit);
698: }
699:
700: #define wedataaddr(sc, eh, off, type) \
701: ((type) ((caddr_t)((eh)+1)+(off) >= (sc)->we_vmem_end) ? \
702: (((caddr_t)((eh)+1)+(off))) - (sc)->we_vmem_end \
703: + (sc)->we_vmem_ring: \
704: ((caddr_t)((eh)+1)+(off)))
705: /*
706: * Pass a packet to the higher levels.
707: * We deal with the trailer protocol here.
708: */
709: weread(sc, buf, len)
710: register struct we_softc *sc;
711: char *buf;
712: int len;
713: {
714: register struct ether_header *eh;
715: struct mbuf *m, *weget();
716: int off, resid;
717:
718: /*
719: * Deal with trailer protocol: if type is trailer type
720: * get true type from first 16-bit word past data.
721: * Remember that type was trailer by setting off.
722: */
723: eh = (struct ether_header *)buf;
724: eh->ether_type = ntohs((u_short)eh->ether_type);
725: if (eh->ether_type >= ETHERTYPE_TRAIL &&
726: eh->ether_type < ETHERTYPE_TRAIL+ETHERTYPE_NTRAILER) {
727: off = (eh->ether_type - ETHERTYPE_TRAIL) * 512;
728: if (off >= ETHERMTU) return; /* sanity */
729: eh->ether_type = ntohs(*wedataaddr(sc, eh, off, u_short *));
730: resid = ntohs(*(wedataaddr(sc, eh, off+2, u_short *)));
731: if (off + resid > len) return; /* sanity */
732: len = off + resid;
733: } else off = 0;
734:
735: len -= sizeof(struct ether_header);
736: if (len <= 0) return;
737:
738: /*
739: * Pull packet off interface. Off is nonzero if packet
740: * has trailing header; neget will then force this header
741: * information to be at the front, but we still have to drop
742: * the type and length which are at the front of any trailer data.
743: */
744: m = weget(buf, len, off, &sc->we_if, sc);
745: if (m == 0) return;
746: ether_input(&sc->we_if, eh, m);
747: }
748:
749: /*
750: * Supporting routines
751: */
752:
753: /*
754: * Pull read data off a interface.
755: * Len is length of data, with local net header stripped.
756: * Off is non-zero if a trailer protocol was used, and
757: * gives the offset of the trailer information.
758: * We copy the trailer information and then all the normal
759: * data into mbufs. When full cluster sized units are present
760: * we copy into clusters.
761: */
762: struct mbuf *
763: weget(buf, totlen, off0, ifp, sc)
764: caddr_t buf;
765: int totlen, off0;
766: struct ifnet *ifp;
767: struct we_softc *sc;
768: {
769: struct mbuf *top, **mp, *m, *p;
770: int off = off0, len;
771: register caddr_t cp = buf;
772: char *epkt;
773: int tc =totlen;
774:
775: buf += sizeof(struct ether_header);
776: cp = buf;
777: epkt = cp + totlen;
778:
779: if (off) {
780: cp += off + 2 * sizeof(u_short);
781: totlen -= 2 * sizeof(u_short);
782: }
783:
784: MGETHDR(m, M_DONTWAIT, MT_DATA);
785: if (m == 0)
786: return (0);
787: m->m_pkthdr.rcvif = ifp;
788: m->m_pkthdr.len = totlen;
789: m->m_len = MHLEN;
790:
791: top = 0;
792: mp = ⊤
793: while (totlen > 0) {
794: if (top) {
795: MGET(m, M_DONTWAIT, MT_DATA);
796: if (m == 0) {
797: m_freem(top);
798: return (0);
799: }
800: m->m_len = MLEN;
801: }
802: len = min(totlen, epkt - cp);
803: if (len >= MINCLSIZE) {
804: MCLGET(m, M_DONTWAIT);
805: if (m->m_flags & M_EXT)
806: m->m_len = len = min(len, MCLBYTES);
807: else
808: len = m->m_len;
809: } else {
810: /*
811: * Place initial small packet/header at end of mbuf.
812: */
813: if (len < m->m_len) {
814: if (top == 0 && len + max_linkhdr <= m->m_len)
815: m->m_data += max_linkhdr;
816: m->m_len = len;
817: } else
818: len = m->m_len;
819: }
820:
821: totlen -= len;
822: /* only do up to end of buffer */
823: if (cp+len > sc->we_vmem_end) {
824: unsigned toend = sc->we_vmem_end - cp;
825:
826: bcopy(cp, mtod(m, caddr_t), toend);
827: cp = sc->we_vmem_ring;
828: bcopy(cp, mtod(m, caddr_t)+toend, len - toend);
829: cp += len - toend;
830: epkt = cp + totlen;
831: } else {
832: bcopy(cp, mtod(m, caddr_t), (unsigned)len);
833: cp += len;
834: }
835: *mp = m;
836: mp = &m->m_next;
837: if (cp == epkt) {
838: cp = buf;
839: epkt = cp + tc;
840: }
841: }
842: return (top);
843: }
844: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.