![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_pc586.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_pc586.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: /*
27: * Olivetti PC586 Mach Ethernet driver v1.0
28: * Copyright Ing. C. Olivetti & C. S.p.A. 1988, 1989
29: * All rights reserved.
30: *
31: */
32:
33: /*
34: Copyright 1988, 1989 by Olivetti Advanced Technology Center, Inc.,
35: Cupertino, California.
36:
37: All Rights Reserved
38:
39: Permission to use, copy, modify, and distribute this software and
40: its documentation for any purpose and without fee is hereby
41: granted, provided that the above copyright notice appears in all
42: copies and that both the copyright notice and this permission notice
43: appear in supporting documentation, and that the name of Olivetti
44: not be used in advertising or publicity pertaining to distribution
45: of the software without specific, written prior permission.
46:
47: OLIVETTI DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
48: INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
49: IN NO EVENT SHALL OLIVETTI BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
50: CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
51: LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
52: NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUR OF OR IN CONNECTION
53: WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
54: */
55:
56: /*
57: Copyright 1988, 1989 by Intel Corporation, Santa Clara, California.
58:
59: All Rights Reserved
60:
61: Permission to use, copy, modify, and distribute this software and
62: its documentation for any purpose and without fee is hereby
63: granted, provided that the above copyright notice appears in all
64: copies and that both the copyright notice and this permission notice
65: appear in supporting documentation, and that the name of Intel
66: not be used in advertising or publicity pertaining to distribution
67: of the software without specific, written prior permission.
68:
69: INTEL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
70: INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
71: IN NO EVENT SHALL INTEL BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
72: CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
73: LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
74: NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
75: WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
76: */
77:
78: /*
79: * NOTE:
80: * by rvb:
81: * 1. The best book on the 82586 is:
82: * LAN Components User's Manual by Intel
83: * The copy I found was dated 1984. This really tells you
84: * what the state machines are doing
85: * 2. In the current design, we only do one write at a time,
86: * though the hardware is capable of chaining and possibly
87: * even batching. The problem is that we only make one
88: * transmit buffer available in sram space.
89: * 3.
90: * n. Board Memory Map
91: RFA/FD 0 - 227 0x228 bytes
92: 226 = 0x19 * 0x16 bytes
93: RBD 228 - 3813 0x35ec bytes
94: 35e8 = 0x19 * 0x228 bytes
95: == 0x0a bytes (bd) + 2 bytes + 21c bytes
96: CU 3814 - 3913 0x100 bytes
97: TBD 3914 - 39a3 0x90 bytes
98: 90 = No 18 * 0x08 bytes
99: TBUF 39a4 - 3fdd 0x63a bytes (= 1594(10))
100: SCB 3fde - 3fed 0x10 bytes
101: ISCP 3fee - 3ff5 0x08 bytes
102: SCP 3ff6 - 3fff 0x0a bytes
103: *
104: */
105:
106: /*
107: * NOTE:
108: *
109: * Currently this driver doesn't support trailer protocols for
110: * packets. Once that is added, please remove this comment.
111: *
112: * Also, some lacking material includes the DLI code. If you
113: * are compiling this driver with DLI set, lookout, that code
114: * has not been looked at.
115: *
116: */
117:
118: #define DEBUG
119: #define IF_CNTRS MACH
120: #define NDLI 0
121:
122: #include <pc586.h>
123:
124: #ifdef MACH_KERNEL
125: #include <kern/time_out.h>
126: #include <device/device_types.h>
127: #include <device/errno.h>
128: #include <device/io_req.h>
129: #include <device/if_hdr.h>
130: #include <device/if_ether.h>
131: #include <device/net_status.h>
132: #include <device/net_io.h>
133: #else MACH_KERNEL
134: #include <sys/param.h>
135: #include <mach/machine/vm_param.h>
136: #include <sys/systm.h>
137: #include <sys/mbuf.h>
138: #include <sys/buf.h>
139: #include <sys/protosw.h>
140: #include <sys/socket.h>
141: #include <sys/vmmac.h>
142: #include <sys/ioctl.h>
143: #include <sys/errno.h>
144: #include <sys/syslog.h>
145:
146: #include <net/if.h>
147: #include <net/netisr.h>
148: #include <net/route.h>
149:
150: #ifdef INET
151: #include <netinet/in.h>
152: #include <netinet/in_systm.h>
153: #include <netinet/in_var.h>
154: #include <netinet/ip.h>
155: #include <netinet/if_ether.h>
156: #endif
157:
158: #ifdef NS
159: #include <netns/ns.h>
160: #include <netns/ns_if.h>
161: #endif
162:
163: #if DLI
164: #include <net/dli_var.h>
165: struct dli_var de_dlv[NDE];
166: #endif DLI
167: #endif MACH_KERNEL
168:
169: #include <i386/ipl.h>
170: #include <mach/vm_param.h>
171: #include <vm/vm_kern.h>
172: #include <chips/busses.h>
173: #include <i386at/if_pc586.h>
174:
175: #define SPLNET spl6
176: #if __STDC__
177: #define CMD(x, y, unit) *(u_short *)(pc_softc[unit].prom + OFFSET_ ## x) = (u_short) (y)
178: #else __STDC__
179: #define CMD(x, y, unit) *(u_short *)(pc_softc[unit].prom + OFFSET_/**/x) = (u_short) (y)
180: #endif __STDC__
181:
182: #define pc586chatt(unit) CMD(CHANATT, 0x0001, unit)
183: #define pc586inton(unit) CMD(INTENAB, CMD_1, unit)
184: #define pc586intoff(unit) CMD(INTENAB, CMD_0, unit)
185:
186: int pc586probe();
187: void pc586attach();
188: int pc586intr(), pc586init(), pc586output(), pc586ioctl(), pc586reset();
189: int pc586watch(), pc586rcv(), pc586xmt(), pc586bldcu();
190: int pc586diag(), pc586config();
191: char *pc586bldru();
192: char *ram_to_ptr();
193: u_short ptr_to_ram();
194:
195: static vm_offset_t pc586_std[NPC586] = { 0 };
196: static struct bus_device *pc586_info[NPC586];
197: struct bus_driver pcdriver =
198: {pc586probe, 0, pc586attach, 0, pc586_std, "pc", pc586_info, 0, 0, 0};
199:
200: char t_packet[ETHERMTU + sizeof(struct ether_header) + sizeof(long)];
201: int xmt_watch = 0;
202:
203: typedef struct {
204: #ifdef MACH_KERNEL
205: struct ifnet ds_if; /* generic interface header */
206: u_char ds_addr[6]; /* Ethernet hardware address */
207: #else MACH_KERNEL
208: struct arpcom pc586_ac;
209: #define ds_if pc586_ac.ac_if
210: #define ds_addr pc586_ac.ac_enaddr
211: #endif MACH_KERNEL
212: int flags;
213: int seated;
214: int timer;
215: int open;
216: fd_t *begin_fd;
217: fd_t *end_fd;
218: rbd_t *end_rbd;
219: char *prom;
220: char *sram;
221: int tbusy;
222: short mode;
223: } pc_softc_t;
224: pc_softc_t pc_softc[NPC586];
225:
226: struct pc586_cntrs {
227: struct {
228: u_int xmt, xmti;
229: u_int defer;
230: u_int busy;
231: u_int sleaze, intrinsic, intrinsic_count;
232: u_int chain;
233: } xmt;
234: struct {
235: u_int rcv;
236: u_int ovw;
237: u_int crc;
238: u_int frame;
239: u_int rscerrs, ovrnerrs;
240: u_int partial, bad_chain, fill;
241: } rcv;
242: u_int watch;
243: } pc586_cntrs[NPC586];
244:
245:
246: #ifdef IF_CNTRS
247: int pc586_narp = 1, pc586_arp = 0;
248: int pc586_ein[32], pc586_eout[32];
249: int pc586_lin[128/8], pc586_lout[128/8];
250: static
251: log_2(no)
252: unsigned long no;
253: {
254: return ({ unsigned long _temp__;
255: asm("bsr %1, %0; jne 0f; xorl %0, %0; 0:" :
256: "=r" (_temp__) : "a" (no));
257: _temp__;});
258: }
259: #endif IF_CNTRS
260:
261: /*
262: * pc586probe:
263: *
264: * This function "probes" or checks for the pc586 board on the bus to see
265: * if it is there. As far as I can tell, the best break between this
266: * routine and the attach code is to simply determine whether the board
267: * is configured in properly. Currently my approach to this is to write
268: * and read a word from the SRAM on the board being probed. If the word
269: * comes back properly then we assume the board is there. The config
270: * code expects to see a successful return from the probe routine before
271: * attach will be called.
272: *
273: * input : address device is mapped to, and unit # being checked
274: * output : a '1' is returned if the board exists, and a 0 otherwise
275: *
276: */
277: pc586probe(port, dev)
278: struct bus_device *dev;
279: {
280: caddr_t addr = (caddr_t)dev->address;
281: int unit = dev->unit;
282: int len = round_page(0x4000);
283: int sram_len = round_page(0x4000);
284: extern vm_offset_t phys_last_addr;
285: int i;
286: volatile char *b_prom;
287: volatile char *b_sram;
288: volatile u_short*t_ps;
289:
290: if ((unit < 0) || (unit > NPC586)) {
291: printf("pc%d: board out of range [0..%d]\n",
292: unit, NPC586);
293: return(0);
294: }
295: if ((addr > (caddr_t)0x100000) && (addr < (caddr_t)phys_last_addr))
296: return 0;
297:
298: if (kmem_alloc_pageable(kernel_map, (vm_offset_t *) &b_prom, len)
299: != KERN_SUCCESS) {
300: printf("pc%d: can not allocate memory for prom.\n", unit);
301: return 0;
302: }
303: if (kmem_alloc_pageable(kernel_map, (vm_offset_t *) &b_sram, sram_len)
304: != KERN_SUCCESS) {
305: printf("pc%d: can not allocate memory for sram.\n", unit);
306: return 0;
307: }
308: (void)pmap_map(b_prom, (vm_offset_t)addr,
309: (vm_offset_t)addr+len,
310: VM_PROT_READ | VM_PROT_WRITE);
311: if ((int)addr > 0x100000) /* stupid hardware */
312: addr += EXTENDED_ADDR;
313: addr += 0x4000; /* sram space */
314: (void)pmap_map(b_sram, (vm_offset_t)addr,
315: (vm_offset_t)addr+sram_len,
316: VM_PROT_READ | VM_PROT_WRITE);
317:
318: *(b_prom + OFFSET_RESET) = 1;
319: { int i; for (i = 0; i < 1000; i++); /* 4 clocks at 6Mhz */}
320: *(b_prom + OFFSET_RESET) = 0;
321: t_ps = (u_short *)(b_sram + OFFSET_SCB);
322: *(t_ps) = (u_short)0x5a5a;
323: if (*(t_ps) != (u_short)0x5a5a) {
324: kmem_free(kernel_map, b_prom, len);
325: kmem_free(kernel_map, b_sram, sram_len);
326: return(0);
327: }
328: t_ps = (u_short *)(b_prom + + OFFSET_PROM);
329: #define ETHER0 0x00
330: #define ETHER1 0xaa
331: #define ETHER2 0x00
332: if ((t_ps[0]&0xff) == ETHER0 &&
333: (t_ps[1]&0xff) == ETHER1 &&
334: (t_ps[2]&0xff) == ETHER2)
335: pc_softc[unit].seated = TRUE;
336: #undef ETHER0
337: #undef ETHER1
338: #undef ETHER2
339: #define ETHER0 0x00
340: #define ETHER1 0x00
341: #define ETHER2 0x1c
342: if ((t_ps[0]&0xff) == ETHER0 ||
343: (t_ps[1]&0xff) == ETHER1 ||
344: (t_ps[2]&0xff) == ETHER2)
345: pc_softc[unit].seated = TRUE;
346: #undef ETHER0
347: #undef ETHER1
348: #undef ETHER2
349: if (pc_softc[unit].seated != TRUE) {
350: kmem_free(kernel_map, b_prom, len);
351: kmem_free(kernel_map, b_sram, sram_len);
352: return(0);
353: }
354: (volatile char *)pc_softc[unit].prom = (volatile char *)b_prom;
355: (volatile char *)pc_softc[unit].sram = (volatile char *)b_sram;
356: return(1);
357: }
358:
359: /*
360: * pc586attach:
361: *
362: * This function attaches a PC586 board to the "system". The rest of
363: * runtime structures are initialized here (this routine is called after
364: * a successful probe of the board). Once the ethernet address is read
365: * and stored, the board's ifnet structure is attached and readied.
366: *
367: * input : bus_device structure setup in autoconfig
368: * output : board structs and ifnet is setup
369: *
370: */
371: void pc586attach(dev)
372: struct bus_device *dev;
373: {
374: struct ifnet *ifp;
375: u_char *addr_p;
376: u_short *b_addr;
377: u_char unit = (u_char)dev->unit;
378: pc_softc_t *sp = &pc_softc[unit];
379: volatile scb_t *scb_p;
380:
381: take_dev_irq(dev);
382: printf(", port = %x, spl = %d, pic = %d. ",
383: dev->address, dev->sysdep, dev->sysdep1);
384:
385: sp->timer = -1;
386: sp->flags = 0;
387: sp->mode = 0;
388: sp->open = 0;
389: CMD(RESET, CMD_1, unit);
390: { int i; for (i = 0; i < 1000; i++); /* 4 clocks at 6Mhz */}
391: CMD(RESET, CMD_0, unit);
392: b_addr = (u_short *)(sp->prom + OFFSET_PROM);
393: addr_p = (u_char *)sp->ds_addr;
394: addr_p[0] = b_addr[0];
395: addr_p[1] = b_addr[1];
396: addr_p[2] = b_addr[2];
397: addr_p[3] = b_addr[3];
398: addr_p[4] = b_addr[4];
399: addr_p[5] = b_addr[5];
400: printf("ethernet id [%x:%x:%x:%x:%x:%x]",
401: addr_p[0], addr_p[1], addr_p[2],
402: addr_p[3], addr_p[4], addr_p[5]);
403:
404: scb_p = (volatile scb_t *)(sp->sram + OFFSET_SCB);
405: scb_p->scb_crcerrs = 0; /* initialize counters */
406: scb_p->scb_alnerrs = 0;
407: scb_p->scb_rscerrs = 0;
408: scb_p->scb_ovrnerrs = 0;
409:
410: ifp = &(sp->ds_if);
411: ifp->if_unit = unit;
412: ifp->if_mtu = ETHERMTU;
413: ifp->if_flags = IFF_BROADCAST;
414: #ifdef MACH_KERNEL
415: ifp->if_header_size = sizeof(struct ether_header);
416: ifp->if_header_format = HDR_ETHERNET;
417: ifp->if_address_size = 6;
418: ifp->if_address = (char *)&sp->ds_addr[0];
419: if_init_queues(ifp);
420: #else MACH_KERNEL
421: ifp->if_name = "pc";
422: ifp->if_init = pc586init;
423: ifp->if_output = pc586output;
424: ifp->if_ioctl = pc586ioctl;
425: ifp->if_reset = pc586reset;
426: ifp->if_next = NULL;
427: if_attach(ifp);
428: #endif MACH_KERNEL
429: }
430:
431: /*
432: * pc586reset:
433: *
434: * This routine is in part an entry point for the "if" code. Since most
435: * of the actual initialization has already (we hope already) been done
436: * by calling pc586attach().
437: *
438: * input : unit number or board number to reset
439: * output : board is reset
440: *
441: */
442: pc586reset(unit)
443: int unit;
444: {
445: pc_softc[unit].ds_if.if_flags &= ~IFF_RUNNING;
446: pc_softc[unit].flags &= ~(DSF_LOCK|DSF_RUNNING);
447: return(pc586init(unit));
448:
449: }
450:
451: /*
452: * pc586init:
453: *
454: * Another routine that interfaces the "if" layer to this driver.
455: * Simply resets the structures that are used by "upper layers".
456: * As well as calling pc586hwrst that does reset the pc586 board.
457: *
458: * input : board number
459: * output : structures (if structs) and board are reset
460: *
461: */
462: pc586init(unit)
463: int unit;
464: {
465: struct ifnet *ifp;
466: int stat;
467: spl_t oldpri;
468:
469: ifp = &(pc_softc[unit].ds_if);
470: #ifdef MACH_KERNEL
471: #else MACH_KERNEL
472: if (ifp->if_addrlist == (struct ifaddr *)0) {
473: return;
474: }
475: #endif MACH_KERNEL
476: oldpri = SPLNET();
477: if ((stat = pc586hwrst(unit)) == TRUE) {
478: #ifdef MACH_KERNEL
479: #undef HZ
480: #define HZ hz
481: #endif MACH_KERNEL
482: timeout(pc586watch, &(ifp->if_unit), 5*HZ);
483: pc_softc[unit].timer = 5;
484:
485: pc_softc[unit].ds_if.if_flags |= IFF_RUNNING;
486: pc_softc[unit].flags |= DSF_RUNNING;
487: pc_softc[unit].tbusy = 0;
488: pc586start(unit);
489: #if DLI
490: dli_init();
491: #endif DLI
492: } else
493: printf("pc%d init(): trouble resetting board.\n", unit);
494: splx(oldpri);
495: return(stat);
496: }
497:
498: #ifdef MACH_KERNEL
499: /*ARGSUSED*/
500: pc586open(dev, flag)
501: dev_t dev;
502: int flag;
503: {
504: register int unit;
505: pc_softc_t *sp;
506:
507: unit = minor(dev); /* XXX */
508: if (unit < 0 || unit >= NPC586 || !pc_softc[unit].seated)
509: return (ENXIO);
510:
511: pc_softc[unit].ds_if.if_flags |= IFF_UP;
512: pc586init(unit);
513: return (0);
514: }
515: #endif MACH_KERNEL
516:
517: /*
518: * pc586start:
519: *
520: * This is yet another interface routine that simply tries to output a
521: * in an mbuf after a reset.
522: *
523: * input : board number
524: * output : stuff sent to board if any there
525: *
526: */
527: pc586start(unit)
528: int unit;
529: {
530: #ifdef MACH_KERNEL
531: io_req_t m;
532: #else MACH_KERNEL
533: struct mbuf *m;
534: #endif MACH_KERNEL
535: struct ifnet *ifp;
536: register pc_softc_t *is = &pc_softc[unit];
537: volatile scb_t *scb_p = (volatile scb_t *)(pc_softc[unit].sram + OFFSET_SCB);
538:
539: if (is->tbusy) {
540: if (!(scb_p->scb_status & 0x0700)) { /* ! IDLE */
541: is->tbusy = 0;
542: pc586_cntrs[unit].xmt.busy++;
543: /*
544: * This is probably just a race. The xmt'r is just
545: * became idle but WE have masked interrupts so ...
546: */
547: if (xmt_watch) printf("!!");
548: } else
549: return;
550: }
551:
552: ifp = &(pc_softc[unit].ds_if);
553: IF_DEQUEUE(&ifp->if_snd, m);
554: #ifdef MACH_KERNEL
555: if (m != 0)
556: #else MACH_KERNEL
557: if (m != (struct mbuf *)0)
558: #endif MACH_KERNEL
559: {
560: is->tbusy++;
561: pc586_cntrs[unit].xmt.xmt++;
562: pc586xmt(unit, m);
563: }
564: return;
565: }
566:
567: /*
568: * pc586read:
569: *
570: * This routine does the actual copy of data (including ethernet header
571: * structure) from the pc586 to an mbuf chain that will be passed up
572: * to the "if" (network interface) layer. NOTE: we currently
573: * don't handle trailer protocols, so if that is needed, it will
574: * (at least in part) be added here. For simplicities sake, this
575: * routine copies the receive buffers from the board into a local (stack)
576: * buffer until the frame has been copied from the board. Once in
577: * the local buffer, the contents are copied to an mbuf chain that
578: * is then enqueued onto the appropriate "if" queue.
579: *
580: * input : board number, and an frame descriptor pointer
581: * output : the packet is put into an mbuf chain, and passed up
582: * assumes : if any errors occur, packet is "dropped on the floor"
583: *
584: */
585: pc586read(unit, fd_p)
586: int unit;
587: fd_t *fd_p;
588: {
589: register pc_softc_t *is = &pc_softc[unit];
590: register struct ifnet *ifp = &is->ds_if;
591: struct ether_header eh;
592: #ifdef MACH_KERNEL
593: ipc_kmsg_t new_kmsg;
594: struct ether_header *ehp;
595: struct packet_header *pkt;
596: char *dp;
597: #else MACH_KERNEL
598: struct mbuf *m, *tm;
599: #endif MACH_KERNEL
600: rbd_t *rbd_p;
601: u_char *buffer_p;
602: u_char *mb_p;
603: u_short mlen, len, clen;
604: u_short bytes_in_msg, bytes_in_mbuf, bytes;
605:
606:
607: if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
608: printf("pc%d read(): board is not running.\n", ifp->if_unit);
609: pc586intoff(ifp->if_unit);
610: }
611: pc586_cntrs[unit].rcv.rcv++;
612: #ifdef MACH_KERNEL
613: new_kmsg = net_kmsg_get();
614: if (new_kmsg == IKM_NULL) {
615: /*
616: * Drop the received packet.
617: */
618: is->ds_if.if_rcvdrops++;
619:
620: /*
621: * not only do we want to return, we need to drop the packet on
622: * the floor to clear the interrupt.
623: */
624: return 1;
625: }
626: ehp = (struct ether_header *) (&net_kmsg(new_kmsg)->header[0]);
627: pkt = (struct packet_header *)(&net_kmsg(new_kmsg)->packet[0]);
628:
629: /*
630: * Get ether header.
631: */
632: ehp->ether_type = fd_p->length;
633: len = sizeof(struct ether_header);
634: bcopy16(fd_p->source, ehp->ether_shost, ETHER_ADD_SIZE);
635: bcopy16(fd_p->destination, ehp->ether_dhost, ETHER_ADD_SIZE);
636:
637: /*
638: * Get packet body.
639: */
640: dp = (char *)(pkt + 1);
641:
642: rbd_p = (rbd_t *)ram_to_ptr(fd_p->rbd_offset, unit);
643: if (rbd_p == 0) {
644: printf("pc%d read(): Invalid buffer\n", unit);
645: if (pc586hwrst(unit) != TRUE) {
646: printf("pc%d read(): hwrst trouble.\n", unit);
647: }
648: net_kmsg_put(new_kmsg);
649: return 0;
650: }
651:
652: do {
653: buffer_p = (u_char *)(pc_softc[unit].sram + rbd_p->buffer_addr);
654: bytes_in_msg = rbd_p->status & RBD_SW_COUNT;
655: bcopy16((u_short *)buffer_p,
656: (u_short *)dp,
657: (bytes_in_msg + 1) & ~1); /* but we know it's even */
658: len += bytes_in_msg;
659: dp += bytes_in_msg;
660: if (rbd_p->status & RBD_SW_EOF)
661: break;
662: rbd_p = (rbd_t *)ram_to_ptr(rbd_p->next_rbd_offset, unit);
663: } while ((int) rbd_p);
664:
665: pkt->type = ehp->ether_type;
666: pkt->length =
667: len - sizeof(struct ether_header)
668: + sizeof(struct packet_header);
669:
670: /*
671: * Send the packet to the network module.
672: */
673: net_packet(ifp, new_kmsg, pkt->length, ethernet_priority(new_kmsg));
674: return 1;
675: #else MACH_KERNEL
676: eh.ether_type = ntohs(fd_p->length);
677: bcopy16(fd_p->source, eh.ether_shost, ETHER_ADD_SIZE);
678: bcopy16(fd_p->destination, eh.ether_dhost, ETHER_ADD_SIZE);
679:
680: if ((rbd_p =(rbd_t *)ram_to_ptr(fd_p->rbd_offset, unit))== (rbd_t *)NULL) {
681: printf("pc%d read(): Invalid buffer\n", unit);
682: if (pc586hwrst(unit) != TRUE) {
683: printf("pc%d read(): hwrst trouble.\n", unit);
684: }
685: return 0;
686: }
687:
688: bytes_in_msg = rbd_p->status & RBD_SW_COUNT;
689: buffer_p = (u_char *)(pc_softc[unit].sram + rbd_p->buffer_addr);
690: MGET(m, M_DONTWAIT, MT_DATA);
691: tm = m;
692: if (m == (struct mbuf *)0) {
693: /*
694: * not only do we want to return, we need to drop the packet on
695: * the floor to clear the interrupt.
696: *
697: */
698: printf("pc%d read(): No mbuf 1st\n", unit);
699: if (pc586hwrst(unit) != TRUE) {
700: pc586intoff(unit);
701: printf("pc%d read(): hwrst trouble.\n", unit);
702: pc_softc[unit].timer = 0;
703: }
704: return 0;
705: }
706: m->m_next = (struct mbuf *) 0;
707: m->m_len = MLEN;
708: if (bytes_in_msg > 2 * MLEN - sizeof (struct ifnet **)) {
709: MCLGET(m);
710: }
711: /*
712: * first mbuf in the packet must contain a pointer to the
713: * ifnet structure. other mbufs that follow and make up
714: * the packet do not need this pointer in the mbuf.
715: *
716: */
717: *(mtod(tm, struct ifnet **)) = ifp;
718: mlen = sizeof (struct ifnet **);
719: clen = mlen;
720: bytes_in_mbuf = m->m_len - sizeof(struct ifnet **);
721: mb_p = mtod(tm, u_char *) + sizeof (struct ifnet **);
722: bytes = min(bytes_in_mbuf, bytes_in_msg);
723: do {
724: if (bytes & 1)
725: len = bytes + 1;
726: else
727: len = bytes;
728: bcopy16(buffer_p, mb_p, len);
729: clen += bytes;
730: mlen += bytes;
731:
732: if (!(bytes_in_mbuf -= bytes)) {
733: MGET(tm->m_next, M_DONTWAIT, MT_DATA);
734: tm = tm->m_next;
735: if (tm == (struct mbuf *)0) {
736: m_freem(m);
737: printf("pc%d read(): No mbuf nth\n", unit);
738: if (pc586hwrst(unit) != TRUE) {
739: pc586intoff(unit);
740: printf("pc%d read(): hwrst trouble.\n", unit);
741: pc_softc[unit].timer = 0;
742: }
743: return 0;
744: }
745: mlen = 0;
746: tm->m_len = MLEN;
747: bytes_in_mbuf = MLEN;
748: mb_p = mtod(tm, u_char *);
749: } else
750: mb_p += bytes;
751:
752: if (!(bytes_in_msg -= bytes)) {
753: if (rbd_p->status & RBD_SW_EOF ||
754: (rbd_p = (rbd_t *)ram_to_ptr(rbd_p->next_rbd_offset, unit)) ==
755: NULL) {
756: tm->m_len = mlen;
757: break;
758: } else {
759: bytes_in_msg = rbd_p->status & RBD_SW_COUNT;
760: buffer_p = (u_char *)(pc_softc[unit].sram + rbd_p->buffer_addr);
761: }
762: } else
763: buffer_p += bytes;
764:
765: bytes = min(bytes_in_mbuf, bytes_in_msg);
766: } while(1);
767: #ifdef IF_CNTRS
768: /* clen -= (sizeof (struct ifnet **)
769: clen += 4 /* crc */;
770: clen += sizeof (struct ether_header);
771: pc586_ein[log_2(clen)]++;
772: if (clen < 128) pc586_lin[clen>>3]++;
773:
774: if (eh.ether_type == ETHERTYPE_ARP) {
775: pc586_arp++;
776: if (pc586_narp) {
777: pc586_ein[log_2(clen)]--;
778: if (clen < 128) pc586_lin[clen>>3]--;
779: }
780: }
781: #endif IF_CNTRS
782: /*
783: * received packet is now in a chain of mbuf's. next step is
784: * to pass the packet upwards.
785: *
786: */
787: pc586send_packet_up(m, &eh, is);
788: return 1;
789: #endif MACH_KERNEL
790: }
791:
792: /*
793: * Send a packet composed of an mbuf chain to the higher levels
794: *
795: */
796: #ifndef MACH_KERNEL
797: pc586send_packet_up(m, eh, is)
798: struct mbuf *m;
799: struct ether_header *eh;
800: pc_softc_t *is;
801: {
802: register struct ifqueue *inq;
803: spl_t opri;
804:
805: switch (eh->ether_type) {
806: #ifdef INET
807: case ETHERTYPE_IP:
808: schednetisr(NETISR_IP);
809: inq = &ipintrq;
810: break;
811: case ETHERTYPE_ARP:
812: arpinput(&is->pc586_ac, m);
813: return;
814: #endif
815: #ifdef NS
816: case ETHERTYPE_NS:
817: schednetisr(NETISR_NS);
818: inq = &nsintrq;
819: break;
820: #endif
821: default:
822: #if DLI
823: {
824: eh.ether_type = htons(eh.ether_type);
825: dli_input(m,eh.ether_type,&eh.ether_shost[0],
826: &de_dlv[ds->ds_if.if_unit], &eh);
827: }
828: #else DLI
829: m_freem(m);
830: #endif DLI
831: return;
832: }
833: opri = SPLNET();
834: if (IF_QFULL(inq)) {
835: IF_DROP(inq);
836: splx(opri);
837: m_freem(m);
838: return;
839: }
840: IF_ENQUEUE(inq, m);
841: splx(opri);
842: return;
843: }
844: #endif MACH_KERNEL
845:
846: #ifdef MACH_KERNEL
847: pc586output(dev, ior)
848: dev_t dev;
849: io_req_t ior;
850: {
851: register int unit;
852:
853: unit = minor(dev); /* XXX */
854: if (unit < 0 || unit >= NPC586 || !pc_softc[unit].seated)
855: return (ENXIO);
856:
857: return (net_write(&pc_softc[unit].ds_if, pc586start, ior));
858: }
859:
860: pc586setinput(dev, receive_port, priority, filter, filter_count)
861: dev_t dev;
862: mach_port_t receive_port;
863: int priority;
864: filter_t filter[];
865: unsigned int filter_count;
866: {
867: register int unit = minor(dev);
868: if (unit < 0 || unit >= NPC586 || !pc_softc[unit].seated)
869: return (ENXIO);
870:
871: return (net_set_filter(&pc_softc[unit].ds_if,
872: receive_port, priority,
873: filter, filter_count));
874: }
875: #else MACH_KERNEL
876: /*
877: * pc586output:
878: *
879: * This routine is called by the "if" layer to output a packet to
880: * the network. This code resolves the local ethernet address, and
881: * puts it into the mbuf if there is room. If not, then a new mbuf
882: * is allocated with the header information and precedes the data
883: * to be transmitted. The routines that actually transmit the
884: * data (pc586xmt()) expect the ethernet structure to precede
885: * the data in the mbuf. This information is required by the
886: * 82586's transfer command segment, and thus mbuf's cannot
887: * be simply "slammed" out onto the network.
888: *
889: * input: ifnet structure pointer, an mbuf with data, and address
890: * to be resolved
891: * output: mbuf is updated to hold enet address, or a new mbuf
892: * with the address is added
893: *
894: */
895: pc586output(ifp, m0, dst)
896: struct ifnet *ifp;
897: struct mbuf *m0;
898: struct sockaddr *dst;
899: {
900: register pc_softc_t *is = &pc_softc[ifp->if_unit];
901: register struct mbuf *m = m0;
902: int type, error;
903: spl_t opri;
904: u_char edst[6];
905: struct in_addr idst;
906: register struct ether_header *eh;
907: register int off;
908: int usetrailers;
909:
910: if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
911: printf("pc%d output(): board is not running.\n", ifp->if_unit);
912: pc586intoff(ifp->if_unit);
913: error = ENETDOWN;
914: goto bad;
915: }
916: switch (dst->sa_family) {
917:
918: #ifdef INET
919: case AF_INET:
920: idst = ((struct sockaddr_in *)dst)->sin_addr;
921: if (!arpresolve(&is->pc586_ac, m, &idst, edst, &usetrailers)){
922: return (0); /* if not yet resolved */
923: }
924: off = ntohs((u_short)mtod(m, struct ip *)->ip_len) - m->m_len;
925:
926: if (usetrailers && off > 0 && (off & 0x1ff) == 0 &&
927: m->m_off >= MMINOFF + 2 * sizeof (u_short)) {
928: type = ETHERTYPE_TRAIL + (off>>9);
929: m->m_off -= 2 * sizeof (u_short);
930: m->m_len += 2 * sizeof (u_short);
931: *mtod(m, u_short *) = htons((u_short)ETHERTYPE_IP);
932: *(mtod(m, u_short *) + 1) = htons((u_short)m->m_len);
933: goto gottrailertype;
934: }
935: type = ETHERTYPE_IP;
936: off = 0;
937: goto gottype;
938: #endif
939: #ifdef NS
940: case AF_NS:
941: type = ETHERTYPE_NS;
942: bcopy((caddr_t)&(((struct sockaddr_ns *)dst)->sns_addr.x_host),
943: (caddr_t)edst, sizeof (edst));
944: off = 0;
945: goto gottype;
946: #endif
947:
948: #if DLI
949: case AF_DLI:
950: if (m->m_len < sizeof(struct ether_header))
951: {
952: error = EMSGSIZE;
953: goto bad;
954: }
955: eh = mtod(m, struct ether_header *);
956: bcopy(dst->sa_data, (caddr_t)eh->ether_dhost,
957: sizeof (eh->ether_dhost));
958: goto gotheader;
959: #endif DLI
960:
961: case AF_UNSPEC:
962: eh = (struct ether_header *)dst->sa_data;
963: bcopy((caddr_t)eh->ether_dhost, (caddr_t)edst, sizeof (edst));
964: type = eh->ether_type;
965: goto gottype;
966:
967: default:
968: printf("pc%d output(): can't handle af%d\n",
969: ifp->if_unit, dst->sa_family);
970: error = EAFNOSUPPORT;
971: goto bad;
972: }
973:
974: gottrailertype:
975: /*
976: * Packet to be sent as trailer: move first packet
977: * (control information) to end of chain.
978: */
979: while (m->m_next)
980: m = m->m_next;
981: m->m_next = m0;
982: m = m0->m_next;
983: m0->m_next = 0;
984: m0 = m;
985:
986: gottype:
987: /*
988: * Add local net header. If no space in first mbuf,
989: * allocate another.
990: */
991: if (m->m_off > MMAXOFF ||
992: MMINOFF + sizeof (struct ether_header) > m->m_off) {
993: m = m_get(M_DONTWAIT, MT_HEADER);
994: if (m == 0) {
995: error = ENOBUFS;
996: goto bad;
997: }
998: m->m_next = m0;
999: m->m_off = MMINOFF;
1000: m->m_len = sizeof (struct ether_header);
1001: } else {
1002: m->m_off -= sizeof (struct ether_header);
1003: m->m_len += sizeof (struct ether_header);
1004: }
1005: eh = mtod(m, struct ether_header *);
1006: eh->ether_type = htons((u_short)type);
1007: bcopy((caddr_t)edst, (caddr_t)eh->ether_dhost, sizeof (edst));
1008: bcopy((caddr_t)is->ds_addr,(caddr_t)eh->ether_shost, sizeof(edst));
1009: #if DLI
1010: gotheader:
1011: #endif DLI
1012:
1013: /*
1014: * Queue message on interface, and start output if interface
1015: * not yet active.
1016: */
1017: opri = SPLNET();
1018: if (IF_QFULL(&ifp->if_snd)) {
1019: IF_DROP(&ifp->if_snd);
1020: splx(opri);
1021: m_freem(m);
1022: return (ENOBUFS);
1023: }
1024: IF_ENQUEUE(&ifp->if_snd, m);
1025: /*
1026: * Some action needs to be added here for checking whether the
1027: * board is already transmitting. If it is, we don't want to
1028: * start it up (ie call pc586start()). We will attempt to send
1029: * packets that are queued up after an interrupt occurs. Some
1030: * flag checking action has to happen here and/or in the start
1031: * routine. This note is here to remind me that some thought
1032: * is needed and there is a potential problem here.
1033: *
1034: */
1035: pc586start(ifp->if_unit);
1036: splx(opri);
1037: return (0);
1038: bad:
1039: m_freem(m0);
1040: return (error);
1041: }
1042: #endif MACH_KERNEL
1043:
1044: #ifdef MACH_KERNEL
1045: pc586getstat(dev, flavor, status, count)
1046: dev_t dev;
1047: int flavor;
1048: dev_status_t status; /* pointer to OUT array */
1049: unsigned int *count; /* out */
1050: {
1051: register int unit = minor(dev);
1052: register pc_softc_t *sp;
1053:
1054: if (unit < 0 || unit >= NPC586 || !pc_softc[unit].seated)
1055: return (ENXIO);
1056:
1057: sp = &pc_softc[unit];
1058: return (net_getstat(&sp->ds_if, flavor, status, count));
1059: }
1060:
1061: pc586setstat(dev, flavor, status, count)
1062: dev_t dev;
1063: int flavor;
1064: dev_status_t status;
1065: unsigned int count;
1066: {
1067: register int unit = minor(dev);
1068: register pc_softc_t *sp;
1069:
1070: if (unit < 0 || unit >= NPC586 || !pc_softc[unit].seated)
1071: return (ENXIO);
1072:
1073: sp = &pc_softc[unit];
1074:
1075: switch (flavor) {
1076: case NET_STATUS:
1077: {
1078: /*
1079: * All we can change are flags, and not many of those.
1080: */
1081: register struct net_status *ns = (struct net_status *)status;
1082: int mode = 0;
1083:
1084: if (count < NET_STATUS_COUNT)
1085: return (D_INVALID_OPERATION);
1086:
1087: if (ns->flags & IFF_ALLMULTI)
1088: mode |= MOD_ENAL;
1089: if (ns->flags & IFF_PROMISC)
1090: mode |= MOD_PROM;
1091:
1092: /*
1093: * Force a complete reset if the receive mode changes
1094: * so that these take effect immediately.
1095: */
1096: if (sp->mode != mode) {
1097: sp->mode = mode;
1098: if (sp->flags & DSF_RUNNING) {
1099: sp->flags &= ~(DSF_LOCK|DSF_RUNNING);
1100: pc586init(unit);
1101: }
1102: }
1103: break;
1104: }
1105:
1106: default:
1107: return (D_INVALID_OPERATION);
1108: }
1109: return (D_SUCCESS);
1110:
1111: }
1112: #else MACH_KERNEL
1113: /*
1114: * pc586ioctl:
1115: *
1116: * This routine processes an ioctl request from the "if" layer
1117: * above.
1118: *
1119: * input : pointer the appropriate "if" struct, command, and data
1120: * output : based on command appropriate action is taken on the
1121: * pc586 board(s) or related structures
1122: * return : error is returned containing exit conditions
1123: *
1124: */
1125: pc586ioctl(ifp, cmd, data)
1126: struct ifnet *ifp;
1127: int cmd;
1128: caddr_t data;
1129: {
1130: register struct ifaddr *ifa = (struct ifaddr *)data;
1131: int unit = ifp->if_unit;
1132: register pc_softc_t *is = &pc_softc[unit];
1133: short mode = 0;
1134: int error = 0;
1135: spl_t opri;
1136:
1137: opri = SPLNET();
1138: switch (cmd) {
1139: case SIOCSIFADDR:
1140: ifp->if_flags |= IFF_UP;
1141: pc586init(unit);
1142: switch (ifa->ifa_addr.sa_family) {
1143: #ifdef INET
1144: case AF_INET:
1145: ((struct arpcom *)ifp)->ac_ipaddr = IA_SIN(ifa)->sin_addr;
1146: arpwhohas((struct arpcom *)ifp, &IA_SIN(ifa)->sin_addr);
1147: break;
1148: #endif
1149: #ifdef NS
1150: case AF_NS:
1151: {
1152: register struct ns_addr *ina =
1153: &(IA_SNS(ifa)->sns_addr);
1154: if (ns_nullhost(*ina))
1155: ina->x_host = *(union ns_host *)(ds->ds_addr);
1156: else
1157: pc586setaddr(ina->x_host.c_host, unit);
1158: break;
1159: }
1160: #endif
1161: }
1162: break;
1163: case SIOCSIFFLAGS:
1164: if (ifp->if_flags & IFF_ALLMULTI)
1165: mode |= MOD_ENAL;
1166: if (ifp->if_flags & IFF_PROMISC)
1167: mode |= MOD_PROM;
1168: /*
1169: * force a complete reset if the receive multicast/
1170: * promiscuous mode changes so that these take
1171: * effect immediately.
1172: *
1173: */
1174: if (is->mode != mode) {
1175: is->mode = mode;
1176: if (is->flags & DSF_RUNNING) {
1177: is->flags &= ~(DSF_LOCK|DSF_RUNNING);
1178: pc586init(unit);
1179: }
1180: }
1181: if ((ifp->if_flags & IFF_UP) == 0 && is->flags & DSF_RUNNING) {
1182: printf("pc%d ioctl(): board is not running\n", unit);
1183: is->flags &= ~(DSF_LOCK | DSF_RUNNING);
1184: is->timer = -1;
1185: pc586intoff(unit);
1186: } else if (ifp->if_flags & IFF_UP && (is->flags & DSF_RUNNING) == 0) {
1187: pc586init(unit);
1188: }
1189: break;
1190: #ifdef IF_CNTRS
1191: case SIOCCIFCNTRS:
1192: if (!suser()) {
1193: error = EPERM;
1194: break;
1195: }
1196: bzero((caddr_t)pc586_ein, sizeof (pc586_ein));
1197: bzero((caddr_t)pc586_eout, sizeof (pc586_eout));
1198: bzero((caddr_t)pc586_lin, sizeof (pc586_lin));
1199: bzero((caddr_t)pc586_lout, sizeof (pc586_lout));
1200: bzero((caddr_t)&pc586_arp, sizeof (int));
1201: bzero((caddr_t)&pc586_cntrs, sizeof (pc586_cntrs));
1202: break;
1203: #endif IF_CNTRS
1204: default:
1205: error = EINVAL;
1206: }
1207: splx(opri);
1208: return (error);
1209: }
1210: #endif MACH_KERNEL
1211:
1212: /*
1213: * pc586hwrst:
1214: *
1215: * This routine resets the pc586 board that corresponds to the
1216: * board number passed in.
1217: *
1218: * input : board number to do a hardware reset
1219: * output : board is reset
1220: *
1221: */
1222: pc586hwrst(unit)
1223: int unit;
1224: {
1225: CMD(CHANATT, CMD_0, unit);
1226: CMD(RESET, CMD_1, unit);
1227: { int i; for (i = 0; i < 1000; i++); /* 4 clocks at 6Mhz */}
1228: CMD(RESET,CMD_0, unit);
1229:
1230: /*
1231: * for (i = 0; i < 1000000; i++);
1232: * with this loop above and with the reset toggle also looping to
1233: * 1000000. We don't see the reset behaving as advertised. DOES
1234: * IT HAPPEN AT ALL. In particular, NORMODE, ENABLE, and XFER
1235: * should all be zero and they have not changed at all.
1236: */
1237: CMD(INTENAB, CMD_0, unit);
1238: CMD(NORMMODE, CMD_0, unit);
1239: CMD(XFERMODE, CMD_1, unit);
1240:
1241: pc586bldcu(unit);
1242:
1243: if (pc586diag(unit) == FALSE)
1244: return(FALSE);
1245:
1246: if (pc586config(unit) == FALSE)
1247: return(FALSE);
1248: /*
1249: * insert code for loopback test here
1250: *
1251: */
1252: pc586rustrt(unit);
1253:
1254: pc586inton(unit);
1255: CMD(NORMMODE, CMD_1, unit);
1256: return(TRUE);
1257: }
1258:
1259: /*
1260: * pc586watch():
1261: *
1262: * This routine is the watchdog timer routine for the pc586 chip. If
1263: * chip wedges, this routine will fire and cause a board reset and
1264: * begin again.
1265: *
1266: * input : which board is timing out
1267: * output : potential board reset if wedged
1268: *
1269: */
1270: int watch_dead = 0;
1271: pc586watch(b_ptr)
1272: caddr_t b_ptr;
1273: {
1274: spl_t opri;
1275: int unit = *b_ptr;
1276:
1277: if ((pc_softc[unit].ds_if.if_flags & IFF_UP) == 0) {
1278: return;
1279: }
1280: if (pc_softc[unit].timer == -1) {
1281: timeout(pc586watch, b_ptr, 5*HZ);
1282: return;
1283: }
1284: if (--pc_softc[unit].timer != -1) {
1285: timeout(pc586watch, b_ptr, 1*HZ);
1286: return;
1287: }
1288:
1289: opri = SPLNET();
1290: #ifdef notdef
1291: printf("pc%d watch(): 6sec timeout no %d\n", unit, ++watch_dead);
1292: #endif notdef
1293: pc586_cntrs[unit].watch++;
1294: if (pc586hwrst(unit) != TRUE) {
1295: printf("pc%d watch(): hwrst trouble.\n", unit);
1296: pc_softc[unit].timer = 0;
1297: } else {
1298: timeout(pc586watch, b_ptr, 1*HZ);
1299: pc_softc[unit].timer = 5;
1300: }
1301: splx(opri);
1302: }
1303:
1304: /*
1305: * pc586intr:
1306: *
1307: * This function is the interrupt handler for the pc586 ethernet
1308: * board. This routine will be called whenever either a packet
1309: * is received, or a packet has successfully been transfered and
1310: * the unit is ready to transmit another packet.
1311: *
1312: * input : board number that interrupted
1313: * output : either a packet is received, or a packet is transfered
1314: *
1315: */
1316: pc586intr(unit)
1317: int unit;
1318: {
1319: volatile scb_t *scb_p = (volatile scb_t *)(pc_softc[unit].sram + OFFSET_SCB);
1320: volatile ac_t *cb_p = (volatile ac_t *)(pc_softc[unit].sram + OFFSET_CU);
1321: int next, x;
1322: int i;
1323: u_short int_type;
1324:
1325: if (pc_softc[unit].seated == FALSE) {
1326: printf("pc%d intr(): board not seated\n", unit);
1327: return(-1);
1328: }
1329:
1330: while ((int_type = (scb_p->scb_status & SCB_SW_INT)) != 0) {
1331: pc586ack(unit);
1332: if (int_type & SCB_SW_FR) {
1333: pc586rcv(unit);
1334: watch_dead=0;
1335: }
1336: if (int_type & SCB_SW_RNR) {
1337: pc586_cntrs[unit].rcv.ovw++;
1338: #ifdef notdef
1339: printf("pc%d intr(): receiver overrun! begin_fd = %x\n",
1340: unit, pc_softc[unit].begin_fd);
1341: #endif notdef
1342: pc586rustrt(unit);
1343: }
1344: if (int_type & SCB_SW_CNA) {
1345: /*
1346: * At present, we don't care about CNA's. We
1347: * believe they are a side effect of XMT.
1348: */
1349: }
1350: if (int_type & SCB_SW_CX) {
1351: /*
1352: * At present, we only request Interrupt for
1353: * XMT.
1354: */
1355: if ((!(cb_p->ac_status & AC_SW_OK)) ||
1356: (cb_p->ac_status & (0xfff^TC_SQE))) {
1357: if (cb_p->ac_status & TC_DEFER) {
1358: if (xmt_watch) printf("DF");
1359: pc586_cntrs[unit].xmt.defer++;
1360: } else if (cb_p->ac_status & (TC_COLLISION|0xf)) {
1361: if (xmt_watch) printf("%x",cb_p->ac_status & 0xf);
1362: } else if (xmt_watch)
1363: printf("pc%d XMT: %x %x\n",
1364: unit, cb_p->ac_status, cb_p->ac_command);
1365: }
1366: pc586_cntrs[unit].xmt.xmti++;
1367: pc_softc[unit].tbusy = 0;
1368: pc586start(unit);
1369: }
1370: pc_softc[unit].timer = 5;
1371: }
1372: return(0);
1373: }
1374:
1375: /*
1376: * pc586rcv:
1377: *
1378: * This routine is called by the interrupt handler to initiate a
1379: * packet transfer from the board to the "if" layer above this
1380: * driver. This routine checks if a buffer has been successfully
1381: * received by the pc586. If so, the routine pc586read is called
1382: * to do the actual transfer of the board data (including the
1383: * ethernet header) into a packet (consisting of an mbuf chain).
1384: *
1385: * input : number of the board to check
1386: * output : if a packet is available, it is "sent up"
1387: *
1388: */
1389: pc586rcv(unit)
1390: int unit;
1391: {
1392: fd_t *fd_p;
1393:
1394: for (fd_p = pc_softc[unit].begin_fd; fd_p != (fd_t *)NULL;
1395: fd_p = pc_softc[unit].begin_fd) {
1396: if (fd_p->status == 0xffff || fd_p->rbd_offset == 0xffff) {
1397: if (pc586hwrst(unit) != TRUE)
1398: printf("pc%d rcv(): hwrst ffff trouble.\n",
1399: unit);
1400: return;
1401: } else if (fd_p->status & AC_SW_C) {
1402: fd_t *bfd = (fd_t *)ram_to_ptr(fd_p->link_offset, unit);
1403:
1404: if (fd_p->status == (RFD_DONE|RFD_RSC)) {
1405: /* lost one */;
1406: #ifdef notdef
1407: printf("pc%d RCV: RSC %x\n",
1408: unit, fd_p->status);
1409: #endif notdef
1410: pc586_cntrs[unit].rcv.partial++;
1411: } else if (!(fd_p->status & RFD_OK))
1412: printf("pc%d RCV: !OK %x\n",
1413: unit, fd_p->status);
1414: else if (fd_p->status & 0xfff)
1415: printf("pc%d RCV: ERRs %x\n",
1416: unit, fd_p->status);
1417: else
1418: if (!pc586read(unit, fd_p))
1419: return;
1420: if (!pc586requeue(unit, fd_p)) { /* abort on chain error */
1421: if (pc586hwrst(unit) != TRUE)
1422: printf("pc%d rcv(): hwrst trouble.\n", unit);
1423: return;
1424: }
1425: pc_softc[unit].begin_fd = bfd;
1426: } else
1427: break;
1428: }
1429: return;
1430: }
1431:
1432: /*
1433: * pc586requeue:
1434: *
1435: * This routine puts rbd's used in the last receive back onto the
1436: * free list for the next receive.
1437: *
1438: */
1439: pc586requeue(unit, fd_p)
1440: int unit;
1441: fd_t *fd_p;
1442: {
1443: rbd_t *l_rbdp;
1444: rbd_t *f_rbdp;
1445:
1446: #ifndef REQUEUE_DBG
1447: if (bad_rbd_chain(fd_p->rbd_offset, unit))
1448: return 0;
1449: #endif REQUEUE_DBG
1450: f_rbdp = (rbd_t *)ram_to_ptr(fd_p->rbd_offset, unit);
1451: if (f_rbdp != NULL) {
1452: l_rbdp = f_rbdp;
1453: while ( (!(l_rbdp->status & RBD_SW_EOF)) &&
1454: (l_rbdp->next_rbd_offset != 0xffff))
1455: {
1456: l_rbdp->status = 0;
1457: l_rbdp = (rbd_t *)ram_to_ptr(l_rbdp->next_rbd_offset,
1458: unit);
1459: }
1460: l_rbdp->next_rbd_offset = PC586NULL;
1461: l_rbdp->status = 0;
1462: l_rbdp->size |= AC_CW_EL;
1463: pc_softc[unit].end_rbd->next_rbd_offset =
1464: ptr_to_ram((char *)f_rbdp, unit);
1465: pc_softc[unit].end_rbd->size &= ~AC_CW_EL;
1466: pc_softc[unit].end_rbd= l_rbdp;
1467: }
1468:
1469: fd_p->status = 0;
1470: fd_p->command = AC_CW_EL;
1471: fd_p->link_offset = PC586NULL;
1472: fd_p->rbd_offset = PC586NULL;
1473:
1474: pc_softc[unit].end_fd->link_offset = ptr_to_ram((char *)fd_p, unit);
1475: pc_softc[unit].end_fd->command = 0;
1476: pc_softc[unit].end_fd = fd_p;
1477:
1478: return 1;
1479: }
1480:
1481: /*
1482: * pc586xmt:
1483: *
1484: * This routine fills in the appropriate registers and memory
1485: * locations on the PC586 board and starts the board off on
1486: * the transmit.
1487: *
1488: * input : board number of interest, and a pointer to the mbuf
1489: * output : board memory and registers are set for xfer and attention
1490: *
1491: */
1492: #ifdef DEBUG
1493: int xmt_debug = 0;
1494: #endif DEBUG
1495: pc586xmt(unit, m)
1496: int unit;
1497: #ifdef MACH_KERNEL
1498: io_req_t m;
1499: #else MACH_KERNEL
1500: struct mbuf *m;
1501: #endif MACH_KERNEL
1502: {
1503: pc_softc_t *is = &pc_softc[unit];
1504: register u_char *xmtdata_p = (u_char *)(is->sram + OFFSET_TBUF);
1505: register u_short *xmtshort_p;
1506: #ifdef MACH_KERNEL
1507: register struct ether_header *eh_p = (struct ether_header *)m->io_data;
1508: #else MACH_KERNEL
1509: struct mbuf *tm_p = m;
1510: register struct ether_header *eh_p = mtod(m, struct ether_header *);
1511: u_char *mb_p = mtod(m, u_char *) + sizeof(struct ether_header);
1512: u_short count = m->m_len - sizeof(struct ether_header);
1513: #endif MACH_KERNEL
1514: volatile scb_t *scb_p = (volatile scb_t *)(is->sram + OFFSET_SCB);
1515: volatile ac_t *cb_p = (volatile ac_t *)(is->sram + OFFSET_CU);
1516: tbd_t *tbd_p = (tbd_t *)(is->sram + OFFSET_TBD);
1517: u_short tbd = OFFSET_TBD;
1518: u_short len, clen = 0;
1519:
1520: cb_p->ac_status = 0;
1521: cb_p->ac_command = (AC_CW_EL|AC_TRANSMIT|AC_CW_I);
1522: cb_p->ac_link_offset = PC586NULL;
1523: cb_p->cmd.transmit.tbd_offset = OFFSET_TBD;
1524:
1525: bcopy16(eh_p->ether_dhost, cb_p->cmd.transmit.dest_addr, ETHER_ADD_SIZE);
1526: cb_p->cmd.transmit.length = (u_short)(eh_p->ether_type);
1527:
1528: #ifndef MACH_KERNEL
1529: #ifdef DEBUG
1530: if (xmt_debug)
1531: printf("XMT mbuf: L%d @%x ", count, mb_p);
1532: #endif DEBUG
1533: #endif MACH_KERNEL
1534: tbd_p->act_count = 0;
1535: tbd_p->buffer_base = 0;
1536: tbd_p->buffer_addr = ptr_to_ram(xmtdata_p, unit);
1537: #ifdef MACH_KERNEL
1538: { int Rlen, Llen;
1539: clen = m->io_count - sizeof(struct ether_header);
1540: Llen = clen & 1;
1541: Rlen = ((int)(m->io_data + sizeof(struct ether_header))) & 1;
1542:
1543: bcopy16(m->io_data + sizeof(struct ether_header) - Rlen,
1544: xmtdata_p,
1545: clen + (Rlen + Llen) );
1546: xmtdata_p += clen + Llen;
1547: tbd_p->act_count = clen;
1548: tbd_p->buffer_addr += Rlen;
1549: }
1550: #else MACH_KERNEL
1551: do {
1552: if (count) {
1553: if (clen + count > ETHERMTU)
1554: break;
1555: if (count & 1)
1556: len = count + 1;
1557: else
1558: len = count;
1559: bcopy16(mb_p, xmtdata_p, len);
1560: clen += count;
1561: tbd_p->act_count += count;
1562: xmtdata_p += len;
1563: if ((tm_p = tm_p->m_next) == (struct mbuf *)0)
1564: break;
1565: if (count & 1) {
1566: /* go to the next descriptor */
1567: tbd_p++->next_tbd_offset = (tbd += sizeof (tbd_t));
1568: tbd_p->act_count = 0;
1569: tbd_p->buffer_base = 0;
1570: tbd_p->buffer_addr = ptr_to_ram(xmtdata_p, unit);
1571: /* at the end -> coallesce remaining mbufs */
1572: if (tbd == OFFSET_TBD + (N_TBD-1) * sizeof (tbd_t)) {
1573: pc586sftwsleaze(&count, &mb_p, &tm_p, unit);
1574: continue;
1575: }
1576: /* next mbuf short -> coallesce as needed */
1577: if ( (tm_p->m_next == (struct mbuf *) 0) ||
1578: #define HDW_THRESHOLD 55
1579: tm_p->m_len > HDW_THRESHOLD)
1580: /* ok */;
1581: else {
1582: pc586hdwsleaze(&count, &mb_p, &tm_p, unit);
1583: continue;
1584: }
1585: }
1586: } else if ((tm_p = tm_p->m_next) == (struct mbuf *)0)
1587: break;
1588: count = tm_p->m_len;
1589: mb_p = mtod(tm_p, u_char *);
1590: #ifdef DEBUG
1591: if (xmt_debug)
1592: printf("mbuf+ L%d @%x ", count, mb_p);
1593: #endif DEBUG
1594: } while (1);
1595: #endif MACH_KERNEL
1596: #ifdef DEBUG
1597: if (xmt_debug)
1598: printf("CLEN = %d\n", clen);
1599: #endif DEBUG
1600: if (clen < ETHERMIN) {
1601: tbd_p->act_count += ETHERMIN - clen;
1602: for (xmtshort_p = (u_short *)xmtdata_p;
1603: clen < ETHERMIN;
1604: clen += 2) *xmtshort_p++ = 0;
1605: }
1606: tbd_p->act_count |= TBD_SW_EOF;
1607: tbd_p->next_tbd_offset = PC586NULL;
1608: #ifdef IF_CNTRS
1609: clen += sizeof (struct ether_header) + 4 /* crc */;
1610: pc586_eout[log_2(clen)]++;
1611: if (clen < 128) pc586_lout[clen>>3]++;
1612: #endif IF_CNTRS
1613: #ifdef DEBUG
1614: if (xmt_debug) {
1615: pc586tbd(unit);
1616: printf("\n");
1617: }
1618: #endif DEBUG
1619:
1620: while (scb_p->scb_command) ;
1621: scb_p->scb_command = SCB_CU_STRT;
1622: pc586chatt(unit);
1623:
1624: #ifdef MACH_KERNEL
1625: iodone(m);
1626: #else MACH_KERNEL
1627: for (count=0; ((count < 6) && (eh_p->ether_dhost[count] == 0xff)); count++) ;
1628: if (count == 6) {
1629: pc586send_packet_up(m, eh_p, is);
1630: } else
1631: m_freem(m);
1632: #endif MACH_KERNEL
1633: return;
1634: }
1635:
1636: /*
1637: * pc586bldcu:
1638: *
1639: * This function builds up the command unit structures. It inits
1640: * the scp, iscp, scb, cb, tbd, and tbuf.
1641: *
1642: */
1643: pc586bldcu(unit)
1644: {
1645: char *sram = pc_softc[unit].sram;
1646: scp_t *scp_p = (scp_t *)(sram + OFFSET_SCP);
1647: iscp_t *iscp_p = (iscp_t *)(sram + OFFSET_ISCP);
1648: volatile scb_t *scb_p = (volatile scb_t *)(sram + OFFSET_SCB);
1649: volatile ac_t *cb_p = (volatile ac_t *)(sram + OFFSET_CU);
1650: tbd_t *tbd_p = (tbd_t *)(sram + OFFSET_TBD);
1651: int i;
1652:
1653: scp_p->scp_sysbus = 0;
1654: scp_p->scp_iscp = OFFSET_ISCP;
1655: scp_p->scp_iscp_base = 0;
1656:
1657: iscp_p->iscp_busy = 1;
1658: iscp_p->iscp_scb_offset = OFFSET_SCB;
1659: iscp_p->iscp_scb = 0;
1660: iscp_p->iscp_scb_base = 0;
1661:
1662: pc586_cntrs[unit].rcv.crc += scb_p->scb_crcerrs;
1663: pc586_cntrs[unit].rcv.frame += scb_p->scb_alnerrs;
1664: pc586_cntrs[unit].rcv.rscerrs += scb_p->scb_rscerrs;
1665: pc586_cntrs[unit].rcv.ovrnerrs += scb_p->scb_ovrnerrs;
1666: scb_p->scb_status = 0;
1667: scb_p->scb_command = 0;
1668: scb_p->scb_cbl_offset = OFFSET_CU;
1669: scb_p->scb_rfa_offset = OFFSET_RU;
1670: scb_p->scb_crcerrs = 0;
1671: scb_p->scb_alnerrs = 0;
1672: scb_p->scb_rscerrs = 0;
1673: scb_p->scb_ovrnerrs = 0;
1674:
1675: scb_p->scb_command = SCB_RESET;
1676: pc586chatt(unit);
1677: for (i = 1000000; iscp_p->iscp_busy && (i-- > 0); );
1678: if (!i) printf("pc%d bldcu(): iscp_busy timeout.\n", unit);
1679: for (i = STATUS_TRIES; i-- > 0; ) {
1680: if (scb_p->scb_status == (SCB_SW_CX|SCB_SW_CNA))
1681: break;
1682: }
1683: if (!i)
1684: printf("pc%d bldcu(): not ready after reset.\n", unit);
1685: pc586ack(unit);
1686:
1687: cb_p->ac_status = 0;
1688: cb_p->ac_command = AC_CW_EL;
1689: cb_p->ac_link_offset = OFFSET_CU;
1690:
1691: tbd_p->act_count = 0;
1692: tbd_p->next_tbd_offset = PC586NULL;
1693: tbd_p->buffer_addr = 0;
1694: tbd_p->buffer_base = 0;
1695: return;
1696: }
1697:
1698: /*
1699: * pc586bldru:
1700: *
1701: * This function builds the linear linked lists of fd's and
1702: * rbd's. Based on page 4-32 of 1986 Intel microcom handbook.
1703: *
1704: */
1705: char *
1706: pc586bldru(unit)
1707: int unit;
1708: {
1709: fd_t *fd_p = (fd_t *)(pc_softc[unit].sram + OFFSET_RU);
1710: ru_t *rbd_p = (ru_t *)(pc_softc[unit].sram + OFFSET_RBD);
1711: int i;
1712:
1713: pc_softc[unit].begin_fd = fd_p;
1714: for(i = 0; i < N_FD; i++, fd_p++) {
1715: fd_p->status = 0;
1716: fd_p->command = 0;
1717: fd_p->link_offset = ptr_to_ram((char *)(fd_p + 1), unit);
1718: fd_p->rbd_offset = PC586NULL;
1719: }
1720: pc_softc[unit].end_fd = --fd_p;
1721: fd_p->link_offset = PC586NULL;
1722: fd_p->command = AC_CW_EL;
1723: fd_p = (fd_t *)(pc_softc[unit].sram + OFFSET_RU);
1724:
1725: fd_p->rbd_offset = ptr_to_ram((char *)rbd_p, unit);
1726: for(i = 0; i < N_RBD; i++, rbd_p = (ru_t *) &(rbd_p->rbuffer[RCVBUFSIZE])) {
1727: rbd_p->r.status = 0;
1728: rbd_p->r.buffer_addr = ptr_to_ram((char *)(rbd_p->rbuffer),
1729: unit);
1730: rbd_p->r.buffer_base = 0;
1731: rbd_p->r.size = RCVBUFSIZE;
1732: if (i != N_RBD-1) {
1733: rbd_p->r.next_rbd_offset=ptr_to_ram(&(rbd_p->rbuffer[RCVBUFSIZE]),
1734: unit);
1735: } else {
1736: rbd_p->r.next_rbd_offset = PC586NULL;
1737: rbd_p->r.size |= AC_CW_EL;
1738: pc_softc[unit].end_rbd = (rbd_t *)rbd_p;
1739: }
1740: }
1741: return (char *)pc_softc[unit].begin_fd;
1742: }
1743:
1744: /*
1745: * pc586rustrt:
1746: *
1747: * This routine starts the receive unit running. First checks if the
1748: * board is actually ready, then the board is instructed to receive
1749: * packets again.
1750: *
1751: */
1752: pc586rustrt(unit)
1753: int unit;
1754: {
1755: volatile scb_t *scb_p = (volatile scb_t *)(pc_softc[unit].sram + OFFSET_SCB);
1756: char *strt;
1757:
1758: if ((scb_p->scb_status & SCB_RUS_READY) == SCB_RUS_READY)
1759: return;
1760:
1761: strt = pc586bldru(unit);
1762: scb_p->scb_command = SCB_RU_STRT;
1763: scb_p->scb_rfa_offset = ptr_to_ram(strt, unit);
1764: pc586chatt(unit);
1765: return;
1766: }
1767:
1768: /*
1769: * pc586diag:
1770: *
1771: * This routine does a 586 op-code number 7, and obtains the
1772: * diagnose status for the pc586.
1773: *
1774: */
1775: pc586diag(unit)
1776: int unit;
1777: {
1778: volatile scb_t *scb_p = (volatile scb_t *)(pc_softc[unit].sram + OFFSET_SCB);
1779: volatile ac_t *cb_p = (volatile ac_t *)(pc_softc[unit].sram + OFFSET_CU);
1780: int i;
1781:
1782: if (scb_p->scb_status & SCB_SW_INT) {
1783: printf("pc%d diag(): bad initial state %\n",
1784: unit, scb_p->scb_status);
1785: pc586ack(unit);
1786: }
1787: cb_p->ac_status = 0;
1788: cb_p->ac_command = (AC_DIAGNOSE|AC_CW_EL);
1789: scb_p->scb_command = SCB_CU_STRT;
1790: pc586chatt(unit);
1791:
1792: for(i = 0; i < 0xffff; i++)
1793: if ((cb_p->ac_status & AC_SW_C))
1794: break;
1795: if (i == 0xffff || !(cb_p->ac_status & AC_SW_OK)) {
1796: printf("pc%d: diag failed; status = %x\n",
1797: unit, cb_p->ac_status);
1798: return(FALSE);
1799: }
1800:
1801: if ( (scb_p->scb_status & SCB_SW_INT) && (scb_p->scb_status != SCB_SW_CNA) ) {
1802: printf("pc%d diag(): bad final state %x\n",
1803: unit, scb_p->scb_status);
1804: pc586ack(unit);
1805: }
1806: return(TRUE);
1807: }
1808:
1809: /*
1810: * pc586config:
1811: *
1812: * This routine does a standard config of the pc586 board.
1813: *
1814: */
1815: pc586config(unit)
1816: int unit;
1817: {
1818: volatile scb_t *scb_p = (volatile scb_t *)(pc_softc[unit].sram + OFFSET_SCB);
1819: volatile ac_t *cb_p = (volatile ac_t *)(pc_softc[unit].sram + OFFSET_CU);
1820: int i;
1821:
1822:
1823: /*
1824: if ((scb_p->scb_status != SCB_SW_CNA) && (scb_p->scb_status & SCB_SW_INT) ) {
1825: printf("pc%d config(): unexpected initial state %x\n",
1826: unit, scb_p->scb_status);
1827: }
1828: */
1829: pc586ack(unit);
1830:
1831: cb_p->ac_status = 0;
1832: cb_p->ac_command = (AC_CONFIGURE|AC_CW_EL);
1833:
1834: /*
1835: * below is the default board configuration from p2-28 from 586 book
1836: */
1837: cb_p->cmd.configure.fifolim_bytecnt = 0x080c;
1838: cb_p->cmd.configure.addrlen_mode = 0x2600;
1839: cb_p->cmd.configure.linprio_interframe = 0x6000;
1840: cb_p->cmd.configure.slot_time = 0xf200;
1841: cb_p->cmd.configure.hardware = 0x0000;
1842: cb_p->cmd.configure.min_frame_len = 0x0040;
1843:
1844: scb_p->scb_command = SCB_CU_STRT;
1845: pc586chatt(unit);
1846:
1847: for(i = 0; i < 0xffff; i++)
1848: if ((cb_p->ac_status & AC_SW_C))
1849: break;
1850: if (i == 0xffff || !(cb_p->ac_status & AC_SW_OK)) {
1851: printf("pc%d: config-configure failed; status = %x\n",
1852: unit, cb_p->ac_status);
1853: return(FALSE);
1854: }
1855: /*
1856: if (scb_p->scb_status & SCB_SW_INT) {
1857: printf("pc%d configure(): bad configure state %x\n",
1858: unit, scb_p->scb_status);
1859: pc586ack(unit);
1860: }
1861: */
1862: cb_p->ac_status = 0;
1863: cb_p->ac_command = (AC_IASETUP|AC_CW_EL);
1864:
1865: bcopy16(pc_softc[unit].ds_addr, cb_p->cmd.iasetup, ETHER_ADD_SIZE);
1866:
1867: scb_p->scb_command = SCB_CU_STRT;
1868: pc586chatt(unit);
1869:
1870: for (i = 0; i < 0xffff; i++)
1871: if ((cb_p->ac_status & AC_SW_C))
1872: break;
1873: if (i == 0xffff || !(cb_p->ac_status & AC_SW_OK)) {
1874: printf("pc%d: config-address failed; status = %x\n",
1875: unit, cb_p->ac_status);
1876: return(FALSE);
1877: }
1878: /*
1879: if ((scb_p->scb_status & SCB_SW_INT) != SCB_SW_CNA) {
1880: printf("pc%d configure(): unexpected final state %x\n",
1881: unit, scb_p->scb_status);
1882: }
1883: */
1884: pc586ack(unit);
1885:
1886: return(TRUE);
1887: }
1888:
1889: /*
1890: * pc586ack:
1891: */
1892: pc586ack(unit)
1893: {
1894: volatile scb_t *scb_p = (volatile scb_t *)(pc_softc[unit].sram + OFFSET_SCB);
1895: int i;
1896:
1897: if (!(scb_p->scb_command = scb_p->scb_status & SCB_SW_INT))
1898: return;
1899: CMD(CHANATT, 0x0001, unit);
1900: for (i = 1000000; scb_p->scb_command && (i-- > 0); );
1901: if (!i)
1902: printf("pc%d pc586ack(): board not accepting command.\n", unit);
1903: }
1904:
1905: char *
1906: ram_to_ptr(offset, unit)
1907: int unit;
1908: u_short offset;
1909: {
1910: if (offset == PC586NULL)
1911: return(NULL);
1912: if (offset > 0x3fff) {
1913: printf("ram_to_ptr(%x, %d)\n", offset, unit);
1914: panic("range");
1915: return(NULL);
1916: }
1917: return(pc_softc[unit].sram + offset);
1918: }
1919:
1920: #ifndef REQUEUE_DBG
1921: bad_rbd_chain(offset, unit)
1922: {
1923: rbd_t *rbdp;
1924: char *sram = pc_softc[unit].sram;
1925:
1926: for (;;) {
1927: if (offset == PC586NULL)
1928: return 0;
1929: if (offset > 0x3fff) {
1930: printf("pc%d: bad_rbd_chain offset = %x\n",
1931: unit, offset);
1932: pc586_cntrs[unit].rcv.bad_chain++;
1933: return 1;
1934: }
1935:
1936: rbdp = (rbd_t *)(sram + offset);
1937: offset = rbdp->next_rbd_offset;
1938: }
1939: }
1940: #endif REQUEUE_DBG
1941:
1942: u_short
1943: ptr_to_ram(k_va, unit)
1944: char *k_va;
1945: int unit;
1946: {
1947: return((u_short)(k_va - pc_softc[unit].sram));
1948: }
1949:
1950: pc586scb(unit)
1951: {
1952: volatile scb_t *scb = (volatile scb_t *)(pc_softc[unit].sram + OFFSET_SCB);
1953: volatile u_short*cmd = (volatile u_short *)(pc_softc[unit].prom + OFFSET_NORMMODE);
1954: u_short i;
1955:
1956: i = scb->scb_status;
1957: printf("stat: stat %x, cus %x, rus %x //",
1958: (i&0xf000)>>12, (i&0x0700)>>8, (i&0x0070)>>4);
1959: i = scb->scb_command;
1960: printf(" cmd: ack %x, cuc %x, ruc %x\n",
1961: (i&0xf000)>>12, (i&0x0700)>>8, (i&0x0070)>>4);
1962:
1963: printf("crc %d[%d], align %d[%d], rsc %d[%d], ovr %d[%d]\n",
1964: scb->scb_crcerrs, pc586_cntrs[unit].rcv.crc,
1965: scb->scb_alnerrs, pc586_cntrs[unit].rcv.frame,
1966: scb->scb_rscerrs, pc586_cntrs[unit].rcv.rscerrs,
1967: scb->scb_ovrnerrs, pc586_cntrs[unit].rcv.ovrnerrs);
1968:
1969: printf("cbl %x, rfa %x //", scb->scb_cbl_offset, scb->scb_rfa_offset);
1970: printf(" norm %x, ena %x, xfer %x //",
1971: cmd[0] & 1, cmd[3] & 1, cmd[4] & 1);
1972: printf(" atn %x, reset %x, type %x, stat %x\n",
1973: cmd[1] & 1, cmd[2] & 1, cmd[5] & 1, cmd[6] & 1);
1974: }
1975:
1976: pc586tbd(unit)
1977: {
1978: pc_softc_t *is = &pc_softc[unit];
1979: tbd_t *tbd_p = (tbd_t *)(is->sram + OFFSET_TBD);
1980: int i = 0;
1981: int sum = 0;
1982:
1983: do {
1984: sum += (tbd_p->act_count & ~TBD_SW_EOF);
1985: printf("%d: addr %x, count %d (%d), next %x, base %x\n",
1986: i++, tbd_p->buffer_addr,
1987: (tbd_p->act_count & ~TBD_SW_EOF), sum,
1988: tbd_p->next_tbd_offset,
1989: tbd_p->buffer_base);
1990: if (tbd_p->act_count & TBD_SW_EOF)
1991: break;
1992: tbd_p = (tbd_t *)(is->sram + tbd_p->next_tbd_offset);
1993: } while (1);
1994: }
1995:
1996: #ifndef MACH_KERNEL
1997: pc586hdwsleaze(countp, mb_pp, tm_pp, unit)
1998: struct mbuf **tm_pp;
1999: u_char **mb_pp;
2000: u_short *countp;
2001: {
2002: struct mbuf *tm_p = *tm_pp;
2003: u_char *mb_p = *mb_pp;
2004: u_short count = 0;
2005: u_char *cp;
2006: int len;
2007:
2008: pc586_cntrs[unit].xmt.sleaze++;
2009: /*
2010: * can we get a run that will be coallesced or
2011: * that terminates before breaking
2012: */
2013: do {
2014: count += tm_p->m_len;
2015: if (tm_p->m_len & 1)
2016: break;
2017: } while ((tm_p = tm_p->m_next) != (struct mbuf *)0);
2018: if ( (tm_p == (struct mbuf *)0) ||
2019: count > HDW_THRESHOLD) {
2020: *countp = (*tm_pp)->m_len;
2021: *mb_pp = mtod((*tm_pp), u_char *);
2022: printf("\n");
2023: return;
2024: }
2025:
2026: /* we need to copy */
2027: pc586_cntrs[unit].xmt.intrinsic++;
2028: tm_p = *tm_pp;
2029: mb_p = *mb_pp;
2030: count = 0;
2031: cp = (u_char *) t_packet;
2032: do {
2033: bcopy(mtod(tm_p, u_char *), cp, len = tm_p->m_len);
2034: count += len;
2035: if (count > HDW_THRESHOLD)
2036: break;
2037: cp += len;
2038: if (tm_p->m_next == (struct mbuf *)0)
2039: break;
2040: tm_p = tm_p->m_next;
2041: } while (1);
2042: pc586_cntrs[unit].xmt.intrinsic_count += count;
2043: *countp = count;
2044: *mb_pp = (u_char *) t_packet;
2045: *tm_pp = tm_p;
2046: return;
2047: }
2048:
2049: pc586sftwsleaze(countp, mb_pp, tm_pp, unit)
2050: struct mbuf **tm_pp;
2051: u_char **mb_pp;
2052: u_short *countp;
2053: {
2054: struct mbuf *tm_p = *tm_pp;
2055: u_char *mb_p = *mb_pp;
2056: u_short count = 0;
2057: u_char *cp = (u_char *) t_packet;
2058: int len;
2059:
2060: pc586_cntrs[unit].xmt.chain++;
2061: /* we need to copy */
2062: do {
2063: bcopy(mtod(tm_p, u_char *), cp, len = tm_p->m_len);
2064: count += len;
2065: cp += len;
2066: if (tm_p->m_next == (struct mbuf *)0)
2067: break;
2068: tm_p = tm_p->m_next;
2069: } while (1);
2070:
2071: *countp = count;
2072: *mb_pp = (u_char *) t_packet;
2073: *tm_pp = tm_p;
2074: return;
2075: }
2076: #endif MACH_KERNEL
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.