开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
if_pn.c
资源名称：ixp425BSP.rar　[点击查看]
上传用户：luoyougen
上传日期：2008-05-12
资源大小：23136k
文件大小：35k
源码类别：

VxWorks

开发平台：

C/C++

if_pn.c：源码内容
  1. /* if_pn.c - proNET-80 network interface driver */
  3. /* Copyright 1984,1985,1986,1987,1988,1989 Wind River Systems, Inc. */
  4. extern char copyright_wind_river[]; static char *copyright=copyright_wind_river;
  6. static char sccsid[] = "@(#)if_pn.c 2.1 11/4/86 (c) 1986 Proteon, Inc.";
  8. /*
  9. modification history
  10. --------------------
  11. 01k,07aug89,gae  changed iv68k.h to iv.h.
  12. 01j,05sep88,gae  got rid of non-functional code.
  13. 01i,03sep88,gae  fixed bug with >2 pronets in ring.
  14. 01h,20aug88,gae  fixed wire-center/bootrom hang problem by disabling
  15.  interrupts in pnreset().  ifdef'd out DMA stuff.
  16.  got rid of gratuitous taskDelay() in pnoutput.
  17.  called pnprobe() in pnattach().
  18. 01g,12jul88,gae  merged in Carl Reed's fixes.  Lint.  Cleanup.
  19.  fixed pn_softc definition thanks to Phil Wiborg.
  20. 01f,07jul88,jcf  lint.
  21. 01e,30may88,dnw  changed to v4 names.
  22. 01d,10may88,llk  include ioLib.h for READ constants.
  23.  changed vxTdelay to taskDelay.
  24. 01c,08feb88,rdc  fixed several races and bugs.
  25. 01b,17nov87,dnw  changed pnattach to take int vec num instead of vec adrs.
  26. 01a,06nov87,rdc  written.
  27. */
  29. /*
  30. DESCRIPTION
  31. ProNET device driver for proNET VMEbus interfaces (p1500 and p1580).
  33. The only user callable routine is:
  35.    pnattach (unit, addr, ivec, ilevel)
  37. BUGS
  38. Only one 'unit' allowed; proNet-80 (not proNet-10) is hard-coded.
  39. */
  41. #include "vxWorks.h"
  42. #include "iv.h"
  43. #include "ioLib.h"
  44. #include "ioctl.h"
  45. #include "memLib.h"
  46. #include "etherLib.h"
  48. #include "param.h"
  49. #include "mbuf.h"
  50. #include "protosw.h"
  51. #include "socket.h"
  52. #include "errno.h"
  53. #include "if.h"
  54. #include "route.h"
  56. #ifdef INET
  57. #include "in.h"
  58. #include "in_systm.h"
  59. #include "in_var.h"
  60. #include "ip.h"
  61. #endif INET
  63. #include "if_pn.h"
  64. #include "if_ether.h"
  66. IMPORT VOID ipintr ();
  68. #define NPN 1 /* maximum number of proNET boards */
  69. #define IS_80 TRUE /* TRUE=proNET-80, FALSE=proNET-10 */
  72. /**************************************************************************/
  73. /*    maximum transmission unit defined --                                */
  74. /*        you can set PNMTU at anything from 576 on up, so long as you    */
  75. /*        recongnize the weaknesses of 4.2BSD in assumuing too much about */
  76. /*        the MTU of other TCP/IP implementations. Thus 576 is the most   */
  77. /*        "compatible" value. 1536 is a popular "large" value, because    */
  78. /*        it is a multiple of 512, which the trailer scheme liked.        */
  79. /*        The absolute maximum size is 4096, which is enforced.           */
  80. /**************************************************************************/
  82. /* Adjust the next line for desired MTU (576 <= PNMTU).
  83.  * Acceptable values are 576, 1024, 1536, 2048, 2560, 3072, 3584, 4096
  84.  */
  85. #define PNMTU 4096
  87. /* Do not to touch the next group of lines.
  88.  * They check the value and set other constants based on it.
  89.  */
  90. #if PNMTU>4096
  91. #undef PNMTU
  92. #define PNMTU 4096
  93. #endif PNMTU>4096
  95. #define PNMRU (PNMTU + 16)
  96. #define PNBUFSIZE (PNMRU + sizeof(struct pn_header))
  97. #define PNCMDSIZE 4096
  99. /* end of don't touch */
  102. /**************************************************************************/
  103. /*   debugging and tracing stuff                                          */
  104. /**************************************************************************/
  105. int pn_tracehdr  = FALSE; /* TRUE => trace headers (slowly!!) */
  106. int pn_logerrors = FALSE; /* TRUE => log all I/O errors */
  108. #define pntracehdr  if (pn_tracehdr) pnprt_hdr
  109. #define pnprintf    if (pn_logerrors) logMsg
  111. BOOL pn_copy = FALSE;
  112. /* XXX most boards won't allow long word transfers on 'just' even boundaries */
  113. #define pncopy(x,y,l) (pn_copy ? bcopy(x,y,l) : bcopyBytes(x,y,l))
  115. LOCAL u_short pn_modes[] = /* three operating modes */
  116.     {
  117.     PN_RST, /* digital loopback */
  118.     PN_MEN, /* analog loopback */
  119.     PN_JNR|PN_MEN /* network mode */
  120.     };
  122. /**************************************************************************/
  123. /* Software status of each interface.                                     */
  124. /*                                                                        */
  125. /* Each interface is referenced by a network interface structure,         */
  126. /* vs_if, which the routing code uses to locate the interface.            */
  127. /* Structure contains the output queue for the interface, its address, ...*/
  128. /**************************************************************************/
  129. struct pn_softc
  130.     {
  131.     struct arpcom vs_ac; /* common Ethernet structures */
  133. #define vs_if vs_ac.ac_if /* network-visible interface */
  134. #define vs_enaddr vs_ac.ac_enaddr /* hardware ethernet address */
  136.     short vs_oactive; /* is output active */
  137.     short vs_olen; /* output length */
  138.     u_short vs_ostrt; /* output start, for retransmission */
  139.     short vs_tries; /* transmit current retry count */
  140.     short vs_init; /* number of ring inits */
  141.     short vs_refused; /* number of packets refused */
  142.     short vs_timeouts; /* number of transmit timeouts */
  143.     short vs_otimeout; /* number of output timeouts */
  144.     short vs_ibadf; /* number of input bad formats */
  145.     short vs_parity; /* number of parity errors */
  146.     u_short rcvhd; /* beginning of the rcv blk, for RBUFDMAPTR */
  147.     caddr_t vs_tbuf; /* xmt buffer */
  149.     int pnIntLevel;           /* VME interrupt level */
  150.     struct pn_regs *pn_regs;
  151.     } pn_softc[NPN];
  154. /* forward declarations */
  156. LOCAL int pnprobe ();
  157. LOCAL VOID pnreset ();
  158. LOCAL VOID pninit ();
  159. LOCAL int pnidentify ();
  160. LOCAL VOID pnstart ();
  161. LOCAL VOID pnxint ();
  162. LOCAL VOID pnwatchdog ();
  163. LOCAL VOID pnrint ();
  164. LOCAL VOID pnoutput ();
  165. LOCAL VOID pnioctl ();
  166. LOCAL VOID pnsetaddr ();
  167. LOCAL VOID pnrcsrintr ();
  168. LOCAL VOID pntcsrintr ();
  169. LOCAL struct mbuf *emptyrbuf ();
  172. /*******************************************************************************
  173. *
  174. * pnattach -
  175. *
  176. * Interface exists: make available by filling in network interface record.
  177. * System will initialize the interface when it is ready to accept packets.
  178. *
  179. * RETURNS: OK or ERROR
  180. */
  182. STATUS pnattach (unit, addr, ivec, ilevel)
  183.     int unit; 
  184.     FAST struct pn_regs *addr;
  185.     int ivec;
  186.     int ilevel;
  188.     {
  189.     FAST struct pn_softc *vs = &pn_softc[unit];
  191.     if (pnprobe (addr) == 0)
  192. return (ERROR);
  194.     vs->pnIntLevel = ilevel;
  195.     vs->pn_regs    = addr;
  197.     addr->pn_ctl.rdmaint     = (unsigned short) ((ivec+0) & 0xff);
  198.     addr->pn_ctl.tdmaint_nxm = (unsigned short) ((ivec+1) & 0xff);
  199.     addr->pn_ctl.rcsrint     = (unsigned short) ((ivec+2) & 0xff);
  200.     addr->pn_ctl.tcsrint     = (unsigned short) ((ivec+3) & 0xff);
  201.     addr->pn_ctl.dma_int     = (unsigned short) 0;
  203.     (void) intConnect (INUM_TO_IVEC (ivec+2), pnrcsrintr, unit);
  204.     (void) intConnect (INUM_TO_IVEC (ivec+3), pntcsrintr, unit);
  206.     sysIntEnable (ilevel);
  208.     vs->vs_if.if_unit     = unit;
  209.     vs->vs_if.if_name     = "pn";
  210.     vs->vs_if.if_mtu      = PNMTU;
  211.     vs->vs_if.if_init     = pninit;
  212.     vs->vs_if.if_ioctl    = pnioctl;
  213.     vs->vs_if.if_output   = pnoutput;
  214.     vs->vs_if.if_reset    = pnreset;
  215.     vs->vs_if.if_timer    = 0;
  216.     vs->vs_if.if_watchdog = pnwatchdog; 
  217.     vs->vs_if.if_flags    = IFF_BROADCAST;
  219.     if_attach (&vs->vs_if);
  221.     return (OK);
  222.     }
  223. /*******************************************************************************
  224. *
  225. * pnprobe - probe for presence of hardware
  226. *
  227. * RETURNS: 0 if no device, otherwise non-zero
  228. */
  230. LOCAL int pnprobe (reg)
  231.     caddr_t reg;
  233.     {
  234.     int dummy;
  235.     FAST struct pn_regs *addr = (struct pn_regs *)reg;
  236.     int rcsrLen = sizeof (addr->pn_ctl.rcsr);
  237.     int tcsrLen = sizeof (addr->pn_ctl.tcsr);
  239.     if (vxMemProbe ((char *)&addr->pn_ctl.rcsr, READ, rcsrLen, (char *)&dummy)
  240. == ERROR ||
  241. vxMemProbe ((char *)&addr->pn_ctl.tcsr, READ, tcsrLen, (char *)&dummy)
  242.  == ERROR)
  243.       {
  244.       return (0);
  245.       }
  247.     /* reset interface, enable, and wait till dust settles */
  248.     /* should try to stay in ring */
  249.     if (addr->pn_ctl.rcsr & PN_JNR)
  250. addr->pn_ctl.rcsr = PN_RST | PN_JNR;
  251.     else
  252. addr->pn_ctl.rcsr = PN_RST;
  254.     addr->pn_ctl.tcsr = PN_RST;
  256.     taskDelay (10);
  258.     return (sizeof (struct pn_regs));
  259.     }
  260. /*******************************************************************************
  261. *
  262. * pnreset - reset of interface
  263. */
  265. LOCAL VOID pnreset (unit)
  266.     int unit;
  268.     {
  269.     FAST struct pn_softc *vs = &pn_softc[unit];
  270.     FAST struct pn_regs *addr = vs->pn_regs; 
  272.     pninit (unit);
  274.     /* XXX need to?
  275.     vs->vs_if.if_flags &= ~IFF_RUNNING;
  276.     */
  278.     /* disable interrupts */
  280.     sysIntDisable (vs->pnIntLevel);
  282.     /* set interface to known state (not interrupting) */
  284.     /* should try to stay in ring */
  285.     if (addr->pn_ctl.rcsr & PN_JNR)
  286. addr->pn_ctl.rcsr = PN_RST | PN_JNR;
  287.     else
  288. addr->pn_ctl.rcsr = PN_RST;
  290.     addr->pn_ctl.tcsr = PN_RST;
  292.     taskDelay (10);
  293.     }
  294. /*******************************************************************************
  295. *
  296. * pninit -
  297. *
  298. * Initialization of interface; clear recorded pending
  299. * operations, and start any pending writes.
  300. */
  302. LOCAL VOID pninit (unit)
  303.     int unit;
  305.     {
  306.     FAST int s;
  307.     FAST struct pn_softc *vs = &pn_softc[unit];
  308.     FAST struct pn_regs *addr = vs->pn_regs; 
  310.     if (vs->vs_tbuf == (caddr_t) 0 &&
  311. (vs->vs_tbuf = (caddr_t) malloc ((unsigned) PNBUFSIZE)) == (caddr_t) 0)
  312. {
  313. logMsg ("pninit: out of memory!");
  314. return;
  315. }
  317.     /* Now that the buffers and mapping are set,
  318.      * figure out our address and complete out host address;
  319.      * pnidentify () will do a self-test.
  320.      */
  322.     if (pnidentify (unit, 1) == 0)
  323. {
  324. vs->vs_if.if_flags &= ~IFF_UP;
  325. free((char *)vs->vs_tbuf);
  326. vs->vs_tbuf = (caddr_t) 0;
  327. return;
  328. }
  329.     
  331.     /* Reset the interface, and stay in the ring */
  332.     addr->pn_ctl.tcsr = PN_RST; /* reset xmt */
  333.     addr->pn_ctl.rcsr = PN_RST | PN_JNR | PN_MEN; /* reset rcv */
  335.     taskDelay (60);
  337.     vs->vs_init     = 0; /* clear counters */
  338.     vs->vs_refused  = 0;
  339.     vs->vs_timeouts = 0;
  340.     vs->vs_otimeout = 0;
  341.     vs->vs_ibadf    = 0;
  342.     vs->vs_parity   = 0;
  344.     /* hang receive, start any pending writes by faking a transmit complete */
  346.     s = splimp ();
  348.     vs->rcvhd            = 0; /* RCOUNTER starts at 0 */
  349.     addr->pn_ctl.rcsr    = PN_IEN | PN_JNR | PN_MEN | PN_CEN;
  351.     vs->vs_oactive       = 1;
  352.     vs->vs_if.if_flags  |= IFF_UP | IFF_RUNNING;
  354.     pnxint (unit);
  356.     splx (s);
  357.     }
  358. /*******************************************************************************
  359. *
  360. * pnidentify -
  361. *
  362. * Do a moderately thorough self-test in all three modes.
  363. * Mostly to keep defective nodes off the ring than to be especially thorough.
  364. *
  365. * RETURNS: host address, or 0 if error
  366. */
  368. LOCAL int pnidentify (unit, flg)
  369.     int unit;
  370.     int flg;
  372.     {
  373.     FAST struct pn_header *v;
  374.     FAST int ix;
  375.     FAST int successes;
  376.     FAST int failures;
  377.     u_short shost = 0;
  378.     u_short t_strt;    /* t_strt is start of TBUFAD, and refers to lwords */
  379.     u_short *msg;
  380.     u_short *msgStart;
  381.     u_short pktsz;
  382.     int test;
  383.     BOOL ignorexmt            = TRUE;
  384.     FAST struct pn_softc *vs  = &pn_softc[unit];
  385.     FAST struct pn_regs *addr = vs->pn_regs; 
  387.     t_strt = (TBUFSIZE - ((sizeof(struct pn_header) + 3) >> 2)) & 0x3ff;
  389.     if ((msgStart = (u_short *) malloc (PNBUFSIZE)) == NULL)
  390. {
  391. logMsg ("pnidentify: out of memory!n");
  392. return (0);
  393. }
  395.     /* Build a multicast address to identify our address.
  396.      * We need do this only once, since nobody else is about to use
  397.      * the intermediate transmit buffer (vs->vs_tbuf) that
  398.      * we snagged in pninit().
  399.      */
  401.     addr->pn_ctl.tbufad = t_strt; /* reset tbufad to 0? */
  403.     v = (struct pn_header *)(vs->vs_tbuf);
  404.     v->vh_dhost   = PN_BROADCAST; /* multicast destination address */
  405.     v->vh_shost   = 0; /* will be overwritten with ours */
  406.     v->vh_version = RING_VERSION;
  407.     v->vh_type    = RING_DIAGNOSTICS;
  408.     v->vh_info    = 0;
  410.     vs->vs_olen = (sizeof(struct pn_header) + 1) >> 1;
  412.     /* For each of the modes (digital, analog, network), go through
  413.      * a self-test that requires me to send PNIDENTSUCC good packets
  414.      * in PNIDENTRETRY attempts. Use broadcast destination to find out
  415.      * who I am, then use this as my address to check my address match
  416.      * logic. Only data checked is the vh_type field.
  417.      */
  419.     ix = (addr->pn_ctl.rcsr & PN_JNR) == PN_JNR ? 2 : 0;
  421.     for (; ix < 4; ix++)
  422. {
  423. successes = 0; /* clear successes for this mode */
  424. failures  = 0; /* and clear failures, too */
  426. /* take over device, and leave ring */
  427. addr->pn_ctl.tcsr = PN_RST;
  429. test = (ix < 2) ? ix : 2;
  430. addr->pn_ctl.rcsr = pn_modes[test]; /* test mode */
  432. /* retry loop */
  433. while (successes < PNIDENTSUCC && failures < PNIDENTRETRY)
  434.     {
  435.     /* cancel any previous unfinished operations */
  437.     addr->pn_ctl.rcsr = PN_RST|pn_modes[test];
  438.     addr->pn_ctl.tcsr = PN_RST;
  440.     taskDelay (1); /* let's give it a little more time */
  442.     /* start a receive */
  444.     addr->pn_ctl.rcounter   = 0; /* RCNTR after rcv is pkt size */
  445.     addr->pn_ctl.rcsr       = pn_modes[test]|PN_CEN; /* do it */
  447.     /* send our output packet:
  448.      *   set up TCSR, TBUFAD, and TBUFDA's
  449.      */
  450.     addr->pn_ctl.tbufad = t_strt;
  451.     msg = (u_short *)vs->vs_tbuf;
  453.     while ((addr->pn_ctl.tbufad & 0x7ff) != TBUFSIZE)
  454. {
  455. addr->pn_ctl.tbufda = *msg++;
  456. addr->pn_ctl.tbufda = *msg++;
  457. }
  459.     addr->pn_ctl.tbufad = t_strt;
  460.     addr->pn_ctl.tcsr   = PN_INI|PN_ORI;
  462.     taskDelay (1); /* wait to receive message */
  464.     if ((addr->pn_ctl.rcsr & PN_RDY) == 0 ||
  465. (addr->pn_ctl.tcsr & PN_RDY) == 0)
  466. {
  467. failures++;
  468. continue;
  469. }
  471.     /* check csr status on this packet */
  473.     if ((addr->pn_ctl.rstatr & PNRERR) ||
  474. (addr->pn_ctl.tcsr   & PNTERR))
  475. {
  476. failures++;
  477. continue;
  478. }
  480.     if (ignorexmt && test == 0)
  481. {
  482. /* Ignore the first xmit message.
  483.  * There is a problem with Proteon's software address
  484.  * override so the address returned from the first
  485.  * broadcast message after powerup may be wrong.
  486.  */
  488. ignorexmt = FALSE;
  489. continue;
  490. }
  492.     /* copy out the rcv pkt from RBUFFER to rbuf */
  493.     msg = msgStart;
  495.     for (pktsz = 0;
  496.  pktsz < PNBUFSIZE && pktsz < (addr->pn_ctl.rcntr >> 1);
  497.  pktsz++)
  498. {
  499. *msg++ = addr->pn_rbuffer [pktsz];
  500. }
  502.     addr->pn_ctl.rstcntr = 0; /* clear CNTR */
  503.     v = (struct pn_header *) msgStart;
  505.     /* proper message type */
  506.     if ((v->vh_type & 0xff) == RING_DIAGNOSTICS)
  507. {
  508. if (shost == 0)
  509.     {
  510.     shost = v->vh_shost & 0xff;
  511.     ((struct pn_header *)(vs->vs_tbuf))->vh_dhost = shost;
  512.     }
  513.   successes++;
  514. }
  515.     else
  516.       failures++;
  517.     v->vh_type = 0; /* zap it out so we can check again */
  518.     }
  520. if (failures >= PNIDENTRETRY)
  521.     {
  522.     if (flg)
  523. {
  524. printf("pn%d: failed self-test after %d tries in %s moden",
  525. unit, PNIDENTRETRY, ix == 0 ? "digital loopback" :
  526. (ix == 1 ? "analog loopback" : "network"));
  528. printf("pn%d: rstatr = %#x, rcsr = %#x, tcsr = %#xn",
  529. unit, 0x7 & addr->pn_ctl.rstatr, /*PN_SBITS,*/
  530. 0xffff & addr->pn_ctl.rcsr/*, PN_RBITS*/,
  531. 0xffff & addr->pn_ctl.tcsr/*, PN_TBITS*/);
  532. }
  534.     addr->pn_ctl.rcsr = PN_RST; /* kill the sick board */
  535.     addr->pn_ctl.tcsr = PN_RST;
  537.     free ((char *) msgStart);
  538.     return (0);
  539.     }
  540. }
  542.     free ((char *) msgStart);
  543.     return (shost);
  544.     }
  545. /*******************************************************************************
  546. *
  547. * pnstart - start or restart output on interface
  548. *
  549. * If interface active, then a retransmit, just restuff registers and go.
  550. * If interface not already active, get another datagram off the interface
  551. * queue, copy to buffer and send it.
  552. */
  554. LOCAL VOID pnstart (unit)
  555.     int unit;
  557.     {
  558.     int s;
  559.     FAST struct mbuf *m;
  560.     FAST struct pn_softc *vs  = &pn_softc[unit];
  561.     FAST struct pn_regs *addr = vs->pn_regs; 
  563.     /* active? */
  564.     if (vs->vs_oactive)
  565. {
  566. addr->pn_ctl.tbufad = vs->vs_ostrt; /* retransmit */
  567. goto restart;
  568. }
  570.     /* not active, try dequeueing a new message */
  572.     s = splimp();
  573.     IF_DEQUEUE(&vs->vs_if.if_snd, m);
  574.     splx (s);
  576.     /* any message? */
  577.     if (m == NULL) 
  578. {
  579. vs->vs_oactive = 0;
  580. return;
  581. }
  583.     /* prepare to send */
  585.     vs->vs_olen = filltbuf (unit, vs->vs_tbuf, m);
  586.     m_freem (m);
  588. restart :
  590.     /* make sure this packet will fit in the interface */
  592.     if (vs->vs_olen > PNBUFSIZE)
  593. {
  594. printf ("pn%d: vs_olen: %d > PNBUFSIZEn", unit, vs->vs_olen);
  595. panic ("pnstart: vs_olen botch");
  596. }
  598.     vs->vs_if.if_timer = PNTIMEOUT;
  599.     vs->vs_oactive = 1;
  601.     /* supposed to setup for 82258 transmit dma here */
  603.     if (addr->pn_ctl.tcsr & PN_NOK) 
  604. vs->vs_init++; /* count ring inits */
  606.     addr->pn_ctl.tcsr = PN_IEN | PN_INI | PN_ORI;
  607.     }
  608. /*******************************************************************************
  609. *
  610. * pnwatchdog -
  611. *
  612. * Transmit watchdog timer routine. This routine gets called when we lose
  613. * a transmit interrupt. The best we can do is try to restart output.
  614. */
  616. LOCAL VOID pnwatchdog (unit)
  617.     int unit;
  619.     {
  620.     FAST int s;
  621.     FAST struct pn_softc *vs = &pn_softc[unit];
  623.     pnprintf("pn%d: lost a transmit interrupt.n", unit);
  625.     vs->vs_timeouts++;
  627.     s = splimp ();
  628.     pnstart (unit);
  629.     splx (s);
  630.     }
  631. /*******************************************************************************
  632. *
  633. * pnxint - transmit interrupt
  634. *
  635. * Start new output if more data available.
  636. */
  638. LOCAL VOID pnxint (unit)
  639.     int unit;
  641.     {
  642.     FAST struct pn_softc *vs  = &pn_softc[unit];
  643.     FAST struct pn_regs *addr = vs->pn_regs; 
  644.     FAST int tcsr             = addr->pn_ctl.tcsr & 0xffff;
  646.     vs->vs_if.if_timer = 0;
  648.     addr->pn_ctl.tcsr = PN_RTI; /* clear/reset the interrupt */
  650.     if (vs->vs_oactive == 0) 
  651. {
  652. pnprintf("pn%d: stray interrupt tcsr = %#xn", unit, tcsr/*,PN_TBITS*/);
  653. return;
  654. }
  656.     /* retransmit on soft error.
  657.      * TODO: sort retransmits to end of queue if possible
  658.      */
  659.     if (tcsr & (PN_TMO | PN_REF))
  660. {
  661. if (vs->vs_tries++ < PNRETRY) 
  662.     {
  663.     if (tcsr & PN_TMO)
  664. vs->vs_otimeout++;
  666.     if (tcsr & PN_REF)
  667. {
  668. vs->vs_if.if_collisions++;
  669. vs->vs_refused++;
  670. }
  672.     pnstart (unit); /* restart this message */
  673.     return;
  674.     }
  675. }
  677.     vs->vs_if.if_opackets++;
  678.     vs->vs_oactive = 0;
  679.     vs->vs_tries   = 0;
  681.     if (tcsr & PNTERR)
  682. {
  683. vs->vs_if.if_oerrors++;
  684. pnprintf ("pn%d: error tcsr = %#xn", unit, tcsr/*, PN_TBITS*/);
  685. }
  687.     pnstart (unit);
  688.     }
  689. /*******************************************************************************
  690. *
  691. * pnrint - receive interrupt
  692. *
  693. * First, stash data on packet just received. Then
  694. * swap receive buffers and start a new receive. Now! Then check error
  695. * status of packet. Then undo trailers, examine the packet, and pass it
  696. * on the the appropriate higher protocol.
  697. */
  699. LOCAL VOID pnrint (unit, rcsr, rstatr, rcntr)
  700.     int unit;
  701.     FAST int rcsr; /* this is the current input CSR */
  702.     FAST int rstatr; /* ditto here as status register */
  703.     int rcntr;
  705.     {
  706.     FAST struct pn_header *pn;
  707.     FAST struct mbuf *m;
  708.     struct ifqueue *inq;
  709.     int len;
  710.     int s;
  711.     FAST int off;
  712.     int type;
  713.     short resid; /* this is the current residual */
  714.     int index;
  715.     FAST struct pn_softc *vs  = &pn_softc[unit];
  716.     FAST struct pn_regs *addr = vs->pn_regs; 
  718.     vs->vs_if.if_ipackets++;
  720.     /* save device registers, as we are restarting
  721.      * (note rcsr saved it initial interrupt time)
  722.      */
  724.     if (rcntr < vs->rcvhd)
  725. len = RBUFSIZE - vs->rcvhd + rcntr;
  726.     else
  727.         len = rcntr  - vs->rcvhd; /* only 14 addr bits */
  728.     len -= sizeof (struct pn_header); /* but remove local net hdr len */
  731.     /* get a pointer to packet in RBUFFER */
  732.     index = vs->rcvhd;
  733.     pn = (struct pn_header *)&(addr->pn_rbuffer[index >> 1]);
  735.     pntracehdr ("rint", pn, 1);
  737.     vs->rcvhd = (rcntr + 3) & 0x3ffc;   /* blk addr of next pkt */
  739.     if (! (vs->vs_if.if_flags & IFF_UP))
  740.       {
  741.       pnprintf ("pn%d: not up!n", unit);
  742.       return;
  743.       }
  745.     /* Now that a new receive has been started, do the processing
  746.      * on the old packet (bufno)
  747.      */
  749.     if (rstatr & PNRERR) 
  750. {
  751. pnprintf("pn%d: receive error, rcsr = %#x, rstatr = %#xn",
  752.                   unit, rcsr, rstatr);
  753. if (rstatr & RBDF)
  754.     vs->vs_ibadf++;
  755. goto dropit;
  756. }
  758.     if (rcsr & PN_PER)
  759. {
  760. /* don't have to clear it because the recieve command
  761.  * above wrote 0 to the parity bit
  762.  */
  763. vs->vs_parity++;
  765. /* Only on 10 megabit proNET is PN_PER an end-to-end parity
  766.  * bit. On 80 megabit, it returns to the intended use of
  767.  * node-to-node parity. End-to-end parity errors on 80 megabit
  768.  * give PN_BDF.
  769.  */
  771. if (!IS_80)
  772.     goto dropit;
  773. }
  776.     /* fundamental length check */
  778.     if ((rstatr & ROVR) || (len > PNMRU) || (len <= 0))
  779. {
  780. pnprintf(
  781. "pn%d: len too long or short, len = %d, rcsr = %#x, rstatr = %#xn",
  782.     unit, len, rcsr, /*PN_RBITS,*/ rstatr/*, PN_SBITS*/);
  783. goto dropit;
  784. }
  786.     /* check the protocol header version */
  787.     if (pn->vh_version != RING_VERSION)
  788. {
  789. pnprintf("pn%d: bad protocol header version %dn",
  790.  unit, pn->vh_version & 0xff);
  791. goto dropit;
  792. }
  794.     /* untested trailer handling -- taken straight from VAX code */
  796.     off = 0;
  798. #define pndataaddr(pn, off, type) ((type)(((caddr_t)((pn)+1)+(off))))
  800.     if (pn->vh_type >= RING_IPTrailer &&
  801. pn->vh_type < RING_IPTrailer+RING_IPNTrailer) 
  802. {
  803. off = (pn->vh_type - RING_IPTrailer) * 512;
  804. if (off > PNMTU) 
  805. {
  806.     pnprintf("pn%d: off > PNMTU, off = %d, rcsr = %#xn",
  807. unit, off, rcsr/*, PN_RBITS*/);
  808.     goto dropit;
  809. }
  810. pn->vh_type = ntohs(*pndataaddr(pn, off, u_short *));
  812. resid = ntohs(*pndataaddr(pn, 2+off, u_short *));
  813.     /* 2+off -> better code */
  815. if (off + resid > len) 
  816.     {
  817.     pnprintf ("pn%d: trailer packet too shortn", unit);
  818.     pnprintf ("pn%d: len=%d, off=%d, resid=%d, rcsr=%#x, rstatr=%#xn",
  819. unit, len, off, resid,
  820. rcsr/*, PN_RBITS*/, rstatr/*, PN_SBITS*/);
  821.     goto dropit;
  822.     }
  823. len = off + resid;
  824. }
  826.     if (len == 0) 
  827. {
  828. pnprintf("pn%d: len is zero, rcsr = %#x, rstatr = %#xn",
  829.                   unit, rcsr/*, PN_RBITS*/, rstatr/*, PN_SBITS*/);
  830. goto dropit;
  831. }
  834.     /* save packet type for later demux */
  835.     type = pn->vh_type & 0xff;
  837.     /* Copy buffer into mbuf chain, without net header.
  838.      * Could wait until type is o.k., but almost certainly is so why wait
  839.      * Note that this part of the code runs SLOW, which is why the
  840.      * multiple receive buffers are used. It still must be reckoned
  841.      * that the keyboard is still locked out...
  842.      */
  843.     m = emptyrbuf (unit, addr, index, len, off, sizeof(struct pn_header), 
  844.   &vs->vs_if);
  846.     if (m == 0) /* success? */
  847. goto dropit;
  849.     /* remove trailer header length header */
  850.     if (off)
  851. {
  852.      struct ifnet *ifp;
  854.      ifp = *(mtod (m, struct ifnet **));
  855.      m->m_off += 2 * sizeof (u_short);
  856.      m->m_len -= 2 * sizeof (u_short);
  857.      *(mtod (m, struct ifnet **)) = ifp;
  858. }
  860.     /* demultiplex on packet type */
  862.     switch (type)
  863. {
  864. #ifdef INET
  865. case RING_IP:
  866.     inq = &ipintrq;
  868.     s = splimp ();
  869.     if (IF_QFULL(inq)) 
  870. {
  871. IF_DROP(inq);
  872. m_freem (m);
  873. }
  874.     else
  875. IF_ENQUEUE(inq, m);
  876.     splx (s);
  878.     netJobAdd (ipintr, 0);
  879.     break;
  880. #endif
  882. default:
  883.     pnprintf ("pn%d: unknown pkt type %#xn", unit, type);
  884.     m_freem (m);
  885. }
  887.     return; /* next packet receive is already started */
  889. dropit : /* drop packet on floor -- count them!! */
  891.     pnprintf ("pn%d: dropped it!n", unit);
  892.     vs->vs_if.if_ierrors++;
  893.     }
  894. /*******************************************************************************
  895. *
  896. * pnoutput -
  897. *
  898. * RETURNS: 0 if OK, otherwise UNIX errno
  899. */
  901. LOCAL VOID pnoutput (ifp, m0, dst)
  902.     struct ifnet *ifp;
  903.     struct mbuf *m0;
  904.     struct sockaddr *dst;
  906.     {
  907.     FAST struct pn_header *pn;
  908.     FAST int s;
  909.     int type;
  910.     int dest;
  911.     int error;
  912.     u_short info              = 0;
  913.     FAST struct mbuf *m       = m0;
  914.     FAST int unit             = ifp->if_unit;
  915.     FAST struct pn_softc *vs  = &pn_softc[unit];
  916.     FAST struct pn_regs *addr = vs->pn_regs; 
  918.     switch (dst->sa_family) 
  919. {
  920. #ifdef INET
  921. case AF_INET:
  922.     dest = ((struct sockaddr_in *)dst)->sin_addr.s_addr;
  923.     /*
  924.      * Take the local net address part of the address,
  925.      * and use it as node number. This is not exactly
  926.      * kosher under some circumstances, but I'll let it fly.
  927.      */
  929.     if ((dest = in_lnaof(*((struct in_addr *)&dest))) >= 0x100) 
  930. {
  931. pnprintf("pn%d: can't do af%dn", unit, dst->sa_family);
  932. error = EPERM;
  933. goto bad;
  934. }
  936.     type = RING_IP; /* NO TRAILERS OUTBOUND */
  937.     break;
  939. #endif
  940. default:
  941.     pnprintf("pn%d: can't handle af%dn", unit, dst->sa_family);
  942.     error = EAFNOSUPPORT;
  943.     goto bad;
  944. }
  946.     /* add local net header.  If no space in first mbuf, allocate another */
  948.     if (m->m_off > MMAXOFF || MMINOFF + sizeof (struct pn_header) > m->m_off) 
  949. {
  950. m = m_get(M_DONTWAIT, MT_HEADER);
  951. if (m == (struct mbuf *)0) 
  952.     {
  953.     error = ENOBUFS;
  954.     goto bad;
  955.     }
  956. m->m_next = m0;
  957. m->m_off = MMINOFF;
  958. m->m_len = sizeof (struct pn_header);
  959. }
  960.     else 
  961. {
  962. m->m_off -= sizeof (struct pn_header);
  963. m->m_len += sizeof (struct pn_header);
  964. }
  966.     pn = mtod (m, struct pn_header *);
  968.     pn->vh_shost = in_lnaof ( ((struct arpcom *)ifp)->ac_ipaddr); 
  969.     if (pn->vh_shost == 0)
  970. {
  971. panic ("pnoutput: interface not found in in_ifaddrn");
  972. error = EPERM;
  973. goto bad;
  974. }
  976.     /* map the destination address if it's a broadcast */
  978.     if ((pn->vh_dhost = dest) == INADDR_ANY)
  979. pn->vh_dhost = PN_BROADCAST;
  981.     pn->vh_version = RING_VERSION;
  982.     pn->vh_type    = type;
  983.     pn->vh_info    = htons (info); /* this gets changed if testing packets */
  985.     /* queue packet, and if interface not active, send */
  987.     s = splimp ();
  989.     if (IF_QFULL(&ifp->if_snd)) 
  990. {
  991. IF_DROP(&ifp->if_snd);
  992. error = ENOBUFS;
  993. goto qfull;
  994. }
  996.     IF_ENQUEUE(&ifp->if_snd, m);
  998.     if (vs->vs_oactive == 0)
  999. pnstart (unit);
  1001.     splx (s);
  1003.     return (0);
  1005. qfull :
  1006.     m0 = m;
  1007.     splx (s);
  1009. bad :
  1010.     m_freem (m0);
  1012.     return (error);
  1013.     }
  1014. /*******************************************************************************
  1015. *
  1016. * pnioctl -
  1017. */
  1019. LOCAL VOID pnioctl (ifp, cmd, data)
  1020.     FAST struct ifnet *ifp;
  1021.     int cmd;
  1022.     caddr_t data;
  1023.     {
  1024.     FAST struct sockaddr *sin;
  1025.     FAST struct ifaddr *ifa = (struct ifaddr *)data;
  1026.     int error               = 0;
  1027.     FAST int s              = splimp();
  1029.     switch (cmd) 
  1030. {
  1031. case SIOCSIFADDR:
  1032.     sin = (struct sockaddr *)data;
  1033.     if (sin->sa_family != AF_INET)
  1034. {
  1035. error = EINVAL;
  1036. break;
  1037. }
  1039.     pnsetaddr(ifp, (struct sockaddr_in *)sin);
  1041.     /* store the internet address in arpcom */
  1042.     ((struct arpcom *)ifp)->ac_ipaddr = IA_SIN(ifa)->sin_addr;
  1044.     if (!(ifp->if_flags & IFF_RUNNING))
  1045. {
  1046. pninit (ifp->if_unit);
  1047. if ((ifp->if_flags & IFF_UP) == 0)
  1048.     error = ENETDOWN; /* self test failed, give error */
  1049. }
  1050.     break;
  1052. case SIOCSIFFLAGS:
  1053.     /* not implemented (set interface up/down) */
  1054. default:
  1055.     error = EINVAL;
  1056.     break;
  1057. }
  1059.     splx (s);
  1061.     return (error);
  1062.     }
  1063. /*******************************************************************************
  1064. *
  1065. * pnsetaddr - set pronet address
  1066. *
  1067. * set up the address for this interface.  Uses the network number
  1068. * from the passed address and an invalid host number.
  1069. * pnidentify figures out and inserts real host address later.
  1070. */
  1072. LOCAL VOID pnsetaddr (ifp, sin)
  1073.     FAST struct ifnet *ifp;
  1074.     FAST struct sockaddr_in *sin;
  1076.     {
  1077.     FAST struct pn_softc *vs  = &pn_softc[ifp->if_unit];
  1078.     FAST struct pn_regs *addr = vs->pn_regs; 
  1079.     int lna = in_lnaof (((struct sockaddr_in *)sin)->sin_addr);
  1081.     /* set the board's host number, overriding the hardware address */
  1083.     if (IS_80)
  1084. addr->pn_ctl.rbufdmaptr = 0xc000 | lna;
  1085.     }
  1086. /*******************************************************************************
  1087. *
  1088. * pnrcsrintr - rcv csr intr handler
  1089. */
  1091. LOCAL VOID pnrcsrintr (unit)
  1092.     int unit;
  1094.     {
  1095.     int csr;
  1096.     int rstatr;
  1097.     int rcntr;
  1098.     FAST struct pn_regs *addr = pn_softc[unit].pn_regs;
  1100.     if ((addr->pn_ctl.rcsr & (PN_IRQ|PN_RDY)) != (PN_IRQ|PN_RDY))
  1101. logMsg ("proNET: rcv csr vector number clash!n");
  1102.     else
  1103. {
  1104. csr    = addr->pn_ctl.rcsr & 0xffff;
  1105. rstatr = addr->pn_ctl.rstatr & 0x7;
  1106. rcntr  = addr->pn_ctl.rcntr & 0x3fff; 
  1107. netJobAdd (pnrint, unit, csr, rstatr, rcntr);
  1108. }
  1110.     addr->pn_ctl.rcsr =  PN_IEN | PN_MEN | PN_JNR | PN_RTI | PN_CEN;
  1111.     addr->pn_ctl.rstcntr = 0; /* get ready for next pkt */
  1112.     }
  1113. /*******************************************************************************
  1114. *
  1115. * pntcsrintr - xmt csr intr handler
  1116. */
  1118. LOCAL VOID pntcsrintr (unit)
  1119.     FAST int unit;
  1121.     {
  1122.     FAST struct pn_softc *vs  = &pn_softc[unit];
  1123.     FAST struct pn_regs *addr = vs->pn_regs;
  1124.     FAST int tcsr             = addr->pn_ctl.tcsr & 0xffff;
  1125.     FAST int rfsreg           = addr->pn_ctl.rfsreg & 0xffff;
  1127.     sysBusIntAck (vs->pnIntLevel);
  1129.     if ((tcsr & (PN_IRQ|PN_RDY)) != (PN_IRQ|PN_RDY))
  1130. {
  1131. pnprintf("proNET: xmt csr vector number clash!n");
  1132. logMsg ("tcsr = %#xn", addr->pn_ctl.tcsr );
  1134. if ((addr->pn_ctl.tcsr & (PN_IRQ)) != (PN_IRQ))
  1135.     logMsg ("PN_IRQ not onn");
  1137. if ((addr->pn_ctl.tcsr & (PN_RDY)) != (PN_RDY))
  1138.     logMsg ("PN_RDY not onn");
  1140. addr->pn_ctl.tcsr = PN_RTI; /* clear/reset the interrupt */
  1141. }
  1142.     else
  1143. {
  1144. /* should call pnxint() here, but duplicated here for speed */
  1146. vs->vs_if.if_timer = 0;
  1148. addr->pn_ctl.tcsr = PN_RTI; /* clear/reset the interrupt */
  1150. if (vs->vs_oactive == 0) 
  1151.     {
  1152.     pnprintf("pn%d: stray interrupt tcsr = %#xn",
  1153.      unit, tcsr/*, PN_TBITS*/);
  1154.     return;
  1155.     }
  1157. /* retransmit on soft error
  1158.  * TODO: sort retransmits to end of queue if possible
  1159.  */
  1161. if (tcsr & PNTERR)
  1162.     {
  1163.     if (vs->vs_tries++ < PNRETRY) 
  1164. {
  1165. /* re-order refused bits and cancel the "any":
  1166.  *  what's wrong here?
  1167.  *
  1168.  * rfsreg = ((rfsreg >> 9) & 0x7f) | ((rfsreg & 0xff) << 7);
  1169.  */
  1171. if (tcsr & PN_TMO)
  1172.     {
  1173.     vs->vs_otimeout++;
  1174.     pnprintf ("pntcsrintr: RESTART (TIMEOUT) %#xn", rfsreg);
  1175.     }
  1176. if (tcsr & PN_REF)
  1177.     {
  1178.     vs->vs_if.if_collisions++;
  1179.     vs->vs_refused++;
  1180.     pnprintf ("pntcsrintr: RESTART (refused) %#xn", rfsreg);
  1181.     }
  1182. if (tcsr & PN_BDF)
  1183.     {
  1184.     pnprintf ("pntcsrintr: RESTART (bad form) %#xn", rfsreg);
  1185.     }
  1187. /* doesn't need to be at task level, 'cuz we're restarting */
  1188. pnstart (unit);
  1189. return;
  1190. }
  1191.     }
  1193. vs->vs_if.if_opackets++;
  1194. vs->vs_oactive = 0;
  1195. vs->vs_tries   = 0;
  1197. if (tcsr & PNTERR)
  1198.     {
  1199.     vs->vs_if.if_oerrors++;
  1200.     pnprintf("pn%d: error tcsr = %#xn", unit, tcsr/*, PN_TBITS*/);
  1201.     }
  1203. /* let's only call pnstart if there are messages in the output queue */
  1205. if (vs->vs_if.if_snd.ifq_len > 0)  
  1206.     netJobAdd (pnstart, unit);
  1207. }
  1208.     }
  1209. /*******************************************************************************
  1210. *
  1211. * filltbuf -
  1212. *
  1213. * takes a chain of mbufs and copies the chain into a buffer.
  1214. * returns the number of bytes put into the buffer.  if board is
  1215. * not swabbing it also swabs the bytes. does not free mbuf chain.
  1216. *
  1217. * RETURNS: number of bytes filled
  1218. */
  1220. LOCAL int filltbuf (unit, buf, mchain)
  1221.     int unit;
  1222.     caddr_t buf;
  1223.     struct mbuf *mchain;
  1225.     {
  1226.     FAST u_long *tbufda;
  1227.     FAST struct mbuf *m;
  1228.     BOOL odd             = FALSE;
  1229.     int len              = 0;
  1230.     struct pn_softc *vs  = &pn_softc[unit];
  1231.     struct pn_regs *addr = vs->pn_regs; 
  1233.     /* sum mbuf chain, and check for odd length mbuf's */
  1235.     for (m = mchain; m != NULL; m = m->m_next)
  1236. {
  1237. if (m->m_len & 0x1 || m->m_off & 0x1)
  1238.     odd = TRUE;
  1239. len += m->m_len;
  1240. }
  1242.     tbufda = (u_long*)&addr->pn_ctl.tbufda;
  1243.     vs->vs_ostrt = (TBUFSIZE - ((len + 3) >> 2)) & 0x3ff;
  1244.     addr->pn_ctl.tbufad = vs->vs_ostrt;
  1246.     m = mchain;
  1248.     if (odd)
  1249. {
  1250. caddr_t bpend;
  1251. FAST caddr_t bp = buf;
  1253. /* double buffering! however this code probably never runs */
  1255. for (; m != NULL; m = m->m_next)
  1256.     {
  1257.     pncopy (mtod (m, caddr_t), bp, m->m_len);
  1258.     bp += m->m_len;
  1259.     }
  1260. bpend = bp;
  1261. for (bp = buf; bp < bpend; bp += 4)
  1262.     *tbufda = *(u_long *)bp;
  1263. }
  1264.     else
  1265. {
  1266. int flag = 0;
  1268. for (; m != NULL; m = m->m_next)
  1269.     flag = movep (mtod (m, u_long *), tbufda, m->m_len, flag);
  1270. }
  1272.     addr->pn_ctl.tbufad = vs->vs_ostrt;
  1274.     return (len);
  1275.     }
  1276. /*******************************************************************************
  1277. *
  1278. * emptyrbuf - empty a buffer into a chain of mbufs
  1279. *
  1280. * This routine is admitted to be hard to understand.  It is doing three
  1281. * things at once: copying the buffer, moving IP trailers to the front of
  1282. * the packet and skipping the ring header.
  1283. *
  1284. * NOTE:
  1285. * IP trailers part is not tested.
  1286. *
  1287. * RETURNS: the start of the chain, or 0 if error
  1288. *
  1289. * ARGSUSED
  1290. */
  1292. LOCAL struct mbuf *emptyrbuf (unit, addr, pktad, totlen, off0, skip, ifp)
  1293.     int unit; /* unit number */
  1294.     struct pn_regs *addr; /* device address */
  1295.     int pktad; /* index of pkt in RBUFFER */
  1296.     FAST int totlen; /* bytes to copy */
  1297.     int off0; /* trailer offset */
  1298.     int skip; /* header length */
  1299.     struct ifnet *ifp;
  1301.     {
  1302.     FAST int len;
  1303.     FAST struct mbuf *m;
  1304.     struct mbuf *top = (struct mbuf *) 0;
  1305.     FAST struct mbuf **mp = &top;
  1306.     int off          = off0; /* assuming off = 0, ie. no trailers */
  1307.     int index        = ((pktad + skip) >> 1) & 0x1fff; /* word array index */
  1308.     FAST caddr_t bp  = (caddr_t)&addr->pn_rbuffer[index];
  1311.     pntracehdr ("input", (struct pn_header *)&(addr->pn_rbuffer[pktad>>1]), 1);
  1313.     while (totlen > 0)
  1314. {
  1315. MGET(m,M_DONTWAIT,MT_DATA);
  1316. if (m == (struct mbuf *)0)
  1317.     {
  1318.     if (top != (struct mbuf *)0)
  1319.       m_freem (top);
  1321.     return ((struct mbuf *)0);
  1322.     }
  1324. if (off)
  1325.     {
  1326.     len = totlen - off;
  1327.     index = ((pktad + off + skip) >> 1) & 0x1fff;
  1328.     bp = (caddr_t)&(addr->pn_rbuffer[index]);
  1329.     }
  1330. else
  1331.     len = totlen;
  1333. m->m_off = MMINOFF;
  1334. if (ifp)
  1335.     {
  1336.     /* Leave room for ifp */
  1337.     m->m_len = MIN(MLEN - sizeof(ifp), len);
  1338.     m->m_off += sizeof(ifp);
  1339.     }
  1340. else 
  1341.     m->m_len = MIN(MLEN, len);
  1343. m->m_next = (struct mbuf *)0; 
  1345. if ((index << 1) + m->m_len >= RBUFSIZE)
  1346.     {
  1347.     caddr_t tp = mtod (m, caddr_t);
  1348.     int cut = RBUFSIZE - (index << 1);
  1350.     pncopy(bp,tp,cut);
  1351.     pncopy((caddr_t)addr->pn_rbuffer,tp+cut,m->m_len-cut);
  1352.     index = (m->m_len - cut) >> 1;
  1353.     bp = (caddr_t)&(addr->pn_rbuffer[index]);
  1354.     }
  1355. else
  1356.     {
  1357.     pncopy(bp, mtod (m,caddr_t), m->m_len);
  1358.     index += (m->m_len >> 1);
  1359.     bp += m->m_len;
  1360.     }
  1362. *mp = m;
  1363. mp = &m->m_next;
  1365. if (off)
  1366.     {
  1367.     off += m->m_len;
  1368.     if (off == totlen)
  1369. {
  1370. index = ((pktad + skip) >> 1) & 0x1fff;
  1371. bp = (caddr_t)&(addr->pn_rbuffer[index]);
  1372. off = 0;
  1373. totlen = off0;
  1374. }
  1375.     }
  1376. else
  1377.     totlen -= m->m_len;
  1379. if (ifp) 
  1380.     {
  1381.     /* prepend interface pointer to first mbuf */
  1383.     m->m_len += sizeof(ifp);
  1384.     m->m_off -= sizeof(ifp);
  1385.     *(mtod (m, struct ifnet **)) = ifp;
  1386.     ifp = (struct ifnet *)0;
  1387.     }
  1388.       }
  1390.     return (top);
  1391.     }
  1393. /* debugging aid printout routines */
  1395. /*******************************************************************************
  1396. *
  1397. * pnprt_hdr - print the local net header in "v" with title "s"
  1398. */
  1400. LOCAL VOID pnprt_hdr (s, v, nl)
  1401.     char *s;
  1402.     FAST struct pn_header *v;
  1403.     int nl;
  1405.     {
  1406.     printf ("%10s @ %#10x: d=%#x s=%#x v=%#x t=%#x i=%#x",
  1407. s, v,
  1408. 0xff & (int)(v->vh_dhost), 0xff & (int)(v->vh_shost),
  1409. 0xff & (int)(v->vh_version), 0xff & (int)(v->vh_type),
  1410. 0xffff & (int)(v->vh_info));
  1412.     if (nl)
  1413. printf("n");
  1414.     }
  1415. /*******************************************************************************
  1416. *
  1417. * pn_errors - print error statistics and zero
  1418. */
  1420. VOID pn_errors (unit)
  1422.     {
  1423.     FAST struct pn_softc *vs = &pn_softc[unit];
  1425.     printf ("oerrors = %d", vs->vs_if.if_oerrors);
  1426.     vs->vs_if.if_oerrors = 0;
  1428.     printf ("otimeout = %d", vs->vs_otimeout);
  1429.     vs->vs_otimeout = 0;
  1431.     printf ("collisions = %d", vs->vs_if.if_collisions);
  1432.     vs->vs_if.if_collisions = 0;
  1434.     printf ("refused = %d", vs->vs_refused);
  1435.     vs->vs_refused = 0;
  1436.     }
  1438. BOOL xmovep (from, to, len)
  1439.     short *from;
  1440.     short *to;
  1441.     int len;
  1442.     {
  1443.     while (len -= 2)
  1444. *to = *from++;
  1445.     }