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

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

VxWorks

开发平台：

C/C++

if_bp.c：源码内容
  1. /* if_bp.c - original VxWorks (and SunOS) backplane network interface driver */
  3. /* Copyright 1984 - 1997 Wind River Systems, Inc. */
  4. #ifndef UNIX
  5. #include "copyright_wrs.h"
  6. #else   /* UNIX */
  7. static char *copyright=
  8.      "Copyright 1984 - 1997 Wind River Systems, Inc.";
  9. #endif  /* UNIX */
  11. /*
  12. modification history
  13. --------------------
  14. 01u,09oct97,spm  removed driver initialization from ioctl support (SPR #8831)
  15. 01t,07apr97,spm  code cleanup, corrected statistics, and upgraded to BSD 4.4
  16. 01s,25aug95,hk   use cacheDmaMalloc() for shared memory on SH7600 targets.
  17. 01r,12nov94,tmk  removed some IMPORTed function decs and included unixLib.h
  18. 01q,29mar94,caf  use cacheDmaMalloc() for shared memory on MIPS targets.
  19. 01p,23apr93,caf  ansification: changed cast of free() parameter.
  20. 01o,22feb93,jdi  documentation cleanup.
  21. 01n,18sep92,jcf  clean up of warnings.
  22. 01m,09sep92,gae  documentation tweaks.
  23. 01l,18jul92,smb  Changed errno.h to errnoLib.h.
  24. 01k,11jun92,elh  fixed memory sizing bug - SPR 1481.
  25. 01j,04jun92,ajm  added test and set suport for mips
  26. 01i,26may92,rrr  the tree shuffle
  27.   -changed includes to have absolute path from h/
  28. 01h,26may92,ajm  got rid of HOST_DEC def's (new compiler)
  29. 04g,05may92,wmd  changed LITTLE_ENDIAN to _LITTLE_ENDIAN, removed conditional
  30.  for i960 to pass IPL vec parameter in sysMailboxEnable().
  31. 04f,07apr92,yao  removed duplicated macro ROUND_UP.  removed unneccessary
  32.  ROUND_UP for SPARC.  changed copyright notice.
  33. 04e,14feb92,wmd  added BP_NTOHS, BP_HTONS for BUF_NODE->b_len conversions.
  34.  Fixed ansi warnings.
  35. 04d,27nov91,rfs  fixed bug in bpStart(), which did not handle errors
  36.                  correctly, causing memory depletion. Also fixed ANSI warnings.
  37. 04c,07oct91,rrr  turned off some checking in the r3000
  38. 04b,04oct91,rrr  passed through the ansification filter
  39.                   -changed functions to ansi style
  40.                   -changed functions to ansi style
  41.   -changed includes to have absolute path from h/
  42.   -fixed #else and #endif
  43.   -changed READ, WRITE and UPDATE to O_RDONLY O_WRONLY and O_RDWR
  44.   -changed VOID to void
  45.   -changed copyright notice
  46. 04a,01oct91,ajm  got rid of conditional comp (MIPS) for ItoKval, and KtoIval
  47. 03z,10sep91,wmd  added conditionals for MIPS.
  48. 03y,21aug91,ajm  added macros to allocate and free mips dynamic memory
  49.                  from uncached space
  50.                  cast line 1250 comparison with 0 to struct mbuf * to
  51.  resolve warning in mips land
  52. 03x,15aug91,rrr  added IPL to sysMailboxEnable() for I960_FAMILY
  53. 03w,23jul91,rrr  added hton and ntoh stuff so I960 would work
  54. 03v,12jul91,wmd  minor cleanup of 03u.  Added Al Maillet's fix to bpXmit
  55.  for the case that ringput returns > 1 available slots.
  56. 03u,24may91,hvh  deleted 'short-macros' because they screwed up
  57.    +jwt  and besides, they are not needed since a short on
  58.  the SPARC is 2 bytes (so no aligment problem);
  59.  deleted 'KLUDGES' for SPARC since they make no sence
  60.  and introduce gigantic interrupt-latencys in, what
  61.  is supposed to be, a realtime operating system;
  62.  included ELH 29dec91 bpPollTask check for NULL bp;
  63.  fixed TAS(x) macro for Sun-1E and others - bpTas().
  64. 03t,29apr91,hdn  use SIZEOF_ETHERHEADER instead of sizeof(ether_header).
  65. 03s,10apr91,jdi  documentation cleanup; doc review by dnw.
  66. 03r,29dec91,elh  changed bpPollTask to check if bp is null.
  67. 03q,10aug90,dnw  fixed forward declarations for void functions.
  68.  added include of if_subr.h.
  69. 03p,12aug90,hjb  added bpSlotCheck() to help BOOTP.
  70.  changed bp pseudo-Ethernet addr to be all 00.
  71. 03o,18jul90,hjb  deleted cluster-loan code temporarily; fixed a bug caused
  72.  by the macro ROUND_UP.
  73. 03n,15jul90,dnw  added b_pad to BUF_NODE structure to make it long aligned.
  74.  changed to round up BP_BUFSIZ to be long aligned.
  75.  removed B_COPY, B_ASSIGN, B_FROM macros
  76.  coerced malloc() to (char*) where necessary.
  77. 03m,11jul90,hjb  removed references to ipintr().
  78. 03l,26jun90,hjb  fixes to accommodate SunOS; copy_from_mbufs() & m_freem() fix;
  79.  changed params to build_cluster()
  80. 03k,19apr90,hjb  deleted param.h, added BP_SLOT_NUM, BP_MAX_LOANS,
  81.  DEBUG_OPTION_5, bpRIngFree(), modified bpRead()
  82.  to optimize throughput via cluster-callback-hack.
  83. 03j,18mar90,hjb  isolated out SunOS compatible routines for if_subr.c.
  84. 03i,07aug89,gae  adjusted BUF_NODE definition to work on SPARC; changed
  85.    iv68k.h to iv.h; fixed ether_attach to not append unit.
  86. 03h,14jun89,gae  glitch in 03g: left bpParity on and wrong poll task priority.
  87. 03g,14mar89,gae  used unsigned int's for pointer arithmetic.
  88.  made Ethernet address unique for multiple units.
  89.  slight reorganization of bpPollTask. Added more DEBUG levels.
  90. 03f,28mar89,gae  turned off debugging; fixed bp BUFSIZ to be bigger
  91.    than MTU to allow for ether_header overhead -- bug fix.
  92. 03e,10feb89,gae  taught SunOS to do mailboxes and about bus interrupts;
  93.    +jcf  added testing in bpInit for sufficient memory;
  94.            +dnw  added read mailboxes; fixed mbuf bug in copy_to_mbufs.
  95.  UNIX ver. now compiles under SunOS 4.0 and has SUN3_5 flag.
  96. 03c,10dec88,gae  SunOS version tweaks.
  97. 03b,20nov88,dnw  lint
  98. 03a,13sep88,gae  merged SunOS and VxWorks versions.  Documentation.
  99.    +dnw  debugged SunOS version.
  100.    +ak   wrote SunOS version.
  101. 02l,23jun88,rdc  added IFF_BROADCAST to if_flags.
  102. 02k,06jun88,dnw  changed taskSpawn/taskCreate args.
  103.  changed NCPU from 9 to 32.
  104. 02j,30may88,dnw  changed to v4 names.
  105. 02i,12apr88,gae  added include of ioLib.h for O_RDONLY/O_WRONLY/O_RDWR.
  106. 02h,28jan88,jcf  made kernel independent.
  107. 02g,20feb88,dnw  lint
  108. 02f,05jan88,rdc  added include of systm.h
  109. 02e,20nov87,ecs  lint
  110.     dnw  changed bpattach to take int vec num instead of vec adrs.
  111. 02d,13nov87,dnw  added heartbeat & anchor.
  112. 02c,03nov87,dnw  fixed bug in bpRead of throwing away packets that were
  113.    larger than 1500 bytes.
  114.  make bpPoll be global so that it is legible in i().
  115.  added intConnect() call for bus interrupt connects in
  116.    bpConnect().
  117.  changed bpReboot() into bpReset().
  118. 02b,26oct87,jcf  added bpConnect that does a sysMailboxConnect in the case of
  119.      &    mailbox interrupts or a spawn of bpPoll for non-interrupt
  120.     dnw   driven backplanes
  121.  changed to not probe shared memory unless cpu 0.
  122. 02a,22apr87,dnw  rewritten.
  123. 01b,08apr87,rdc  moved call to bpConnect from bpAttach to bpInit.
  124. 01x,01apr87,jlf  delinted, removed ifdef CLEAN.
  125.  changed calls to tas () to vxTas ().
  126.  added copyright.
  127. */
  129. /*
  130. DESCRIPTION
  131. This module implements the original VxWorks backplane network interface driver.
  133. The backplane driver allows several CPUs to communicate via shared
  134. memory.  Usually, the first CPU to boot in a card cage is considered the
  135. backplane master.  This CPU has either dual-ported memory or an additional
  136. memory board which all other CPUs can access.  Each CPU must be
  137. interruptible by another CPU, as well as be able to interrupt all other
  138. CPUs.  There are three interrupt types: polling, mailboxes, and VMEbus
  139. interrupts.  Polling is used when there are no hardware interrupts; each
  140. CPU spawns a polling task to manage transfers.  Mailbox interrupts are the
  141. preferred method, because they do not require an interrupt level.  VMEbus
  142. interrupts offer better performance than polling; however, they may
  143. require hardware jumpers.
  145. There are three user-callable routines: bpInit(), bpattach(), and bpShow().
  146. The backplane master, usually processor 0, must initialize the backplane
  147. memory and structures by first calling bpInit().  Once the backplane has
  148. been initialized, all processors can be attached via bpattach().  Usually,
  149. bpInit() and bpattach() are called automatically in usrConfig.c when
  150. backplane parameters have been specified in the boot line.
  152. The bpShow() routine is provided as a diagnostic aid
  153. to show all the CPUs configured on a backplane.
  155. For more information about SunOS use of this driver, see the 
  156. .I "Guide to the VxWorks Backplane Driver for SunOS."
  158. This driver has been replaced by if_sm and is included here for backwards
  159. compatibility.
  161. MEMORY LAYOUT
  162. All pointers in shared memory are relative to the start of shared memory,
  163. since dual-ported memory may appear in different places on different CPUs.
  165. .ne 11
  166. .CS
  167.    ---------------------------- low address (anchor)
  168.    |       ready value        |     1234567
  169.    |         heartbeat        |     increments 1/sec
  170.    |   pointer to bp header   |
  171.    |         watchdog         |     for backplane master CPU
  172.     --------------------------
  173.    the backplane header may be contiguous or
  174.    allocated elsewhere on the master CPU
  175. .ne 7 
  176.    ---------------------------- backplane header
  177.    |    backplane header      |     1234567
  178.    |       num CPUs           |     unused
  179.    |    Ethernet address      |     (6 bytes)
  180.    |   pointer to free ring   |
  181.    |--------------------------|
  183. .ne 11
  184.    |--------------------------| cpu descriptor
  185.    |        active            |     true/false
  186.    |   processor number       |     0-NCPU
  187.    |         unit             |     0-NBP
  188.    |   pointer to input ring  |
  189.    |    interrupt type        |     POLL  | MAILBOX    |  BUS
  190.    |    interrupt arg1        |     none  | addr space | level
  191.    |    interrupt arg2        |     none  | address    | vector
  192.    |    interrupt arg3        |     none  | value      | none
  193.    |--------------------------|
  194.               ...               repeated MAXCPU times
  195. .ne 16
  196.    |--------------------------|
  197.    |       free ring          |     contains pointers to buffer nodes
  198.    |--------------------------|
  199.    |       input ring 1       |     contains pointers to buffer nodes
  200.    |--------------------------|
  201.       ...
  202.    |--------------------------|
  203.    |       input ring n       |
  204.    |--------------------------|
  206.    |--------------------------| buffer node 1
  207.    |     address, length      |
  208.    |--------------------------|
  209.    |       data buffer 1      |
  210.    |--------------------------|
  211.       ...
  212. .ne 6
  213.    |--------------------------| buffer node m
  214.    |     address, length      |
  215.    |--------------------------|
  216.    |       data buffer m      |
  217.    ---------------------------- high address
  218. .CE
  220. BOARD LAYOUT
  221. This device is "software only."  A jumpering diagram is not applicable.
  224. INTERNAL
  225.  SOFTWARE ARCHITECTURE
  226. .CS
  227.     bpIoctl   |    bpOutput   bpPoll   bpattach  bpReset  bpInit
  228.       |    __/        |         |         /                |
  229.       |   /           |         |        /                 |
  230.       |  /            |         |       /                  |
  231.      bpIfinit    ether_output   |     bpAlive bpInit*    bpSizeMem
  232.       / |            |         |
  233.  bpAlive|bpIntEnable bpPut      |
  234.      bpConnect        |         | (interrupt level)
  235.        |            bpXmit      /    /
  236.        |                      /    /
  237.      bpPollTask              /    /
  238.      bpPollUnix             /    /
  239.                            /  __/
  240.                          bpintr
  241.                            |
  242.                         bpReadAll
  243.                            |
  244.                          bpRead
  246.  * UNIX only; called directly in VxWorks
  248. .CE
  250. SEE ALSO: ifLib
  251. */
  253. #ifdef UNIX
  255. #ifndef KERNEL
  256. #define KERNEL
  257. #endif /* KERNEL */
  259. #ifdef SUN3_5
  260. #include "h/types.h"
  261. #include "h/systm.h"
  262. #include "h/mbuf.h"
  263. #include "h/buf.h"
  264. #include "h/map.h"
  265. #include "h/socket.h"
  266. #include "h/vmmac.h"
  267. #include "h/errno.h"
  268. #else /* SUN3_5 */
  269. #include "sys/types.h"
  270. #include "sys/systm.h"
  271. #include "sys/mbuf.h"
  272. #include "sys/buf.h"
  273. #include "sys/map.h"
  274. #include "sys/socket.h"
  275. #include "sys/param.h"
  276. #include "sys/vmmac.h"
  277. #include "sys/errno.h"
  278. #endif /* SUN3_5 */
  280. #include "machine/param.h"
  281. #include "machine/pte.h"
  283. #ifdef SUN3_5
  284. #include "h/time.h"
  285. #include "h/kernel.h"
  286. #include "h/ioctl.h"
  287. #else /* SUN3_5 */
  288. #include "sys/time.h"
  289. #include "sys/kernel.h"
  290. #include "sys/ioctl.h"
  291. #endif /* SUN3_5 */
  293. #include "net/if.h"
  294. #include "netinet/in.h"
  295. #include "netinet/if_ether.h"
  297. #include "sundev/mbvar.h"
  299. #ifdef SUN3_5
  300. #include "h/protosw.h"
  301. #else /* SUN3_5 */
  302. #include "sys/protosw.h"
  303. #endif /* SUN3_5 */
  305. #include "net/route.h"
  306. #include "netinet/in_systm.h"
  307. #include "netinet/ip.h"
  308. #include "netinet/ip_var.h"
  310. #ifdef INET /* "vxWorks.h" defines INET */
  311. #undef INET
  312. #endif /* INET */
  314. #include "vxWorks.h"
  315. #include "vme.h" /* vxWorks vme AM's */
  317. #define BP_MASTER       (bp_procnum == 0)
  319. IMPORT int bp_tas;
  320. IMPORT int bp_procnum;
  321. IMPORT int bp_n;
  322. IMPORT int bp_mem_size;
  323. IMPORT char *bp_mem_adrs;
  324. IMPORT int bp_int_type;
  325. IMPORT int bp_int_arg1;
  326. IMPORT int bp_int_arg2;
  327. IMPORT int bp_int_arg3;
  329. IMPORT void wakeup ();
  330. IMPORT struct mbuf *copy_to_mbufs ();
  332. #else /* UNIX */
  334. #include "vxWorks.h"
  336. #include "iv.h"
  337. #include "taskLib.h"
  338. #include "memLib.h"
  339. #include "ioLib.h"
  340. #include "ioctl.h"
  341. #include "etherLib.h"
  342. #include "wdLib.h"
  343. #include "iosLib.h"
  344. #include "intLib.h"
  345. #include "logLib.h"
  346. #include "netLib.h"
  347. #include "net/mbuf.h"
  348. #include "socket.h"
  349. #include "net/protosw.h"
  350. #include "errnoLib.h"
  351. #include "net/systm.h"
  352. #include "net/route.h"
  353. #include "netinet/in.h"
  354. #include "netinet/in_systm.h"
  355. #include "netinet/ip.h"
  356. #include "netinet/ip_var.h"
  357. #include "net/if.h"
  358. #include "net/unixLib.h"
  359. #include "netinet/if_ether.h"
  360. #include "net/if_subr.h"
  361. #include "netinet/in_var.h"
  362. #include "vxLib.h"
  363. #include "stdio.h"
  364. #include "stdlib.h"
  365. #include "sysLib.h"
  366. #if ((CPU_FAMILY==MIPS) || (CPU_FAMILY==SH))
  367. #include "cacheLib.h"
  368. #endif /* CPU_FAMILY==MIPS || CPU_FAMILY==SH */
  370. #endif /* UNIX */
  372. #include "drv/netif/if_ring.h"
  373. #include "if_bp.h"
  375. IMPORT struct ifnet *ifunit ();
  376. #if defined (BSD43_DRIVER) || defined (UNIX)
  377. IMPORT int    ether_output (struct ifnet *ifp, struct mbuf *m0,
  378.      struct sockaddr *dst, FUNCPTR startRtn,
  379.      struct arpcom *pArpcom);
  380. #endif
  381. IMPORT int    set_if_addr (struct ifnet *ifp,char *data,u_char *enaddr);
  382. IMPORT void   m_freem (struct mbuf *m);
  384. #define MAXCPU 32 /* don't change! */
  385. #define NCPU 32 /* number of input rings to init */
  386. #define MINPKTSIZE 60 /* minimum packet size to send */
  387. #define BP_SLOT_NUM 32 /* number of the input ring slots */
  389. #define BP_MTU ((2 * 1024) + 128)
  390. int bp_mtu = BP_MTU; /* patch before calling bpInit */
  392. /* round up bufsiz to be long aligned */
  394. #define BP_BUFSIZ       (ROUND_UP (bp_mtu + SIZEOF_ETHERHEADER, 4))
  396. #ifdef UNIX
  397. #define logMsg          printf
  398. #define WDOG_ID int
  399. #define vir2phys(v) (unsigned)ptob((unsigned)hat_getkpfnum(v))
  400. #define splimp() spl3()
  401. #define NBP 1 /* max # bp interfaces */
  402. #else /* UNIX */
  403. #define hz (sysClkRateGet ())
  404. #define NBP 2 /* max. # bp interfaces */
  405. #define vir2phys(v) (v)
  406. #endif /* UNIX */
  409. typedef struct ring RING;
  411. typedef struct /* buffer node */
  412.     {
  413.     char *b_addr; /* buffer address (as offset) */
  414.     short       b_len; /* buffer length */
  415.     short b_pad; /* padding to make structure long aligned */
  416.     } BUF_NODE;
  418. typedef struct /* CPU descriptor in bp header */
  419.     {
  420.     BOOL cd_active; /* CPU is present */
  421.     int cd_cpuNum; /* processor number */
  422.     int cd_unit; /* unit on own CPU */
  423.     RING *cd_pInputRing;
  424.     int cd_intType; /* interrupt: poll, bus, or mailbox */
  425.     int cd_intArg1;
  426.     int cd_intArg2;
  427.     int cd_intArg3;
  428.     } CPU_DESC;
  430. typedef struct /* bp header */
  431.     {
  432.     int hdr_ready; /* used only as marker for debugging */
  433.     short hdr_ncpu; /* unused */
  434.     u_char hdr_enetAdrs[6];/* "Ethernet address" */
  435.     RING *hdr_pFreeRing;
  436.     CPU_DESC hdr_cpuDesc[MAXCPU];
  437.     } BP_HEADER;
  439. typedef struct /* bp anchor */
  440.     {
  441.     int an_ready; /* special value 1234.... */
  442.     UINT an_heartbeat; /* increments every second */
  443.     BP_HEADER *an_pHdr; /* separate to minimize usage of low memory */
  444.     WDOG_ID an_wdog; /* for VxWorks version only */
  445.     } BP_ANCHOR;
  448. #define BP_READY   0x12345678 /* distinctive ready value */
  449. #define BP_READY_SOFT_TAS 0x12344321 /* ready value with software tas */
  451. #if _BYTE_ORDER==_LITTLE_ENDIAN
  452. #define BP_NTOHL(v) ntohl(v)
  453. #define BP_NTOHS(v) ntohs(v)
  454. #define BP_HTONL(v) htonl(v)
  455. #define BP_HTONS(v) htons(v)
  456. #else
  457. #define BP_NTOHL(v) (v)
  458. #define BP_NTOHS(v) (v)
  459. #define BP_HTONL(v) (v)
  460. #define BP_HTONS(v) (v)
  461. #endif  /* _BYTE_ORDER==_LITTLE_ENDIAN */
  463. #define ItoKval(p,type,base) ((type)(ntohl((u_int)(p)) + (u_int)(base)))
  464. #define KtoIval(p,type,base) ((type)htonl((u_int)(p) - (u_int)(base)))
  466. /*
  467.  * Net software status per interface.
  468.  *
  469.  * Each interface is referenced by a network interface structure,
  470.  * bs_if, which the routing code uses to locate the interface.
  471.  * This structure contains the output queue for the interface, its address, ...
  472.  */
  474. typedef struct
  475.     {
  476.     struct arpcom bs_ac; /* common Ethernet structures */
  477. #define bs_if           bs_ac.ac_if     /* network-visible interface */
  478. #define bs_enaddr       bs_ac.ac_enaddr /* hardware Ethernet address */
  479.     int bs_procNum; /* processor number on this net */
  480.     BP_ANCHOR *bs_pAnchor; /* pointer to bp anchor */
  481.     BP_HEADER *bs_pHdr; /* pointer to bp header */
  482.     volatile RING       *bs_pFreeRing;  /* pointer to free ring */
  483.     volatile RING       *bs_pInputRing; /* pointer to our input ring */
  484.     volatile BOOL       bs_readPending; /* read interrupt is outstanding */
  485.     int bs_intType; /* interrupt type: poll, bus, mailbox */
  486.     int bs_intArg1;
  487.     int bs_intArg2;
  488.     int bs_intArg3;
  489. #ifdef UNIX
  490.     caddr_t  bs_addr;
  491.     u_char  bs_ivec;
  492. #endif /* UNIX */
  493.     } BP_SOFTC;
  495. #ifdef UNIX
  496. extern struct mb_driver bpdriver;
  497. struct mb_device *bpinfo[NBP];
  499. LOCAL BP_SOFTC bp_softc [NBP];
  500. #define BP_SOFTC_P &bp_softc
  501. #define dbgprintf printf
  502. #define sysProcNumGet() (bp_procnum)
  503. FUNCPTR bpProbeType;
  505. LOCAL char *cpudesc_vaddr [MAXCPU];
  506. #else /* UNIX */
  508. /* bpPollTask parameters */
  509. int bpPollTaskId;
  510. int bpPollTaskOptions = VX_SUPERVISOR_MODE | VX_UNBREAKABLE;
  511. int bpPollTaskStackSize = 2000;
  512. int bpPollTaskPriority = 250;
  514. LOCAL BP_SOFTC *bp_softc[NBP];
  515. #define BP_SOFTC_P bp_softc
  516. #define dbgprintf logMsg
  517. int bpProbeType;
  518. #endif /* UNIX */
  520. LOCAL  BOOL vxTasac ();
  522. /*
  523.  * the default TAS, use undef if you dont like it
  524.  */
  525. #define TAS(x)  (bpTasOK ? sysBusTas (x) : vxTasac (x))
  526. #if     (CPU_FAMILY==MIPS)
  527. #define TAS_CLEAR(x)    (bpTasOK ? sysBusClearTas (&(x)) : ((x)=0))
  528. #endif  /* CPU_FAMILY==MIPS */
  530. #if  CPU_FAMILY==SPARC
  531. IMPORT BOOL vxTas ();
  532. IMPORT BOOL sysBusTas ();
  533. FUNCPTR         bpTasRtn = vxTasac;  /* Test-and-Set Routine */
  534. #undef TAS(x)
  535. #define TAS(x)  (*bpTasRtn)(x)
  537. /*******************************************************************************
  538. *
  539. * bpTas - determine backplane test-and-set macro TAS(x)
  540. *
  541. * NOMANUAL
  542. */
  544. void bpTas (bp_tas, bp_off_board, bp_target)
  545.     BOOL bp_tas; /* BP_TAS */
  546.     BOOL bp_off_board; /* BP_OFF_BOARD */
  547.     int  bp_target; /* target id */
  549.     {
  550.     if (!bp_tas)
  551.       bpTasRtn = vxTasac;       /* software TAS */
  552.     else
  553. {
  554. /* hardware TAS */
  555. if (bp_target == 0x1E)
  556.     {
  557.     /* Sun-1E */
  558.     if (bp_off_board)
  559. bpTasRtn = vxTas;
  560.     else
  561. bpTasRtn = sysBusTas;
  562.     }
  563. else
  564.     {
  565.     if (bp_off_board)
  566. bpTasRtn = sysBusTas;
  567.     else
  568. bpTasRtn = vxTas;
  569.     }
  570. }
  571.     }
  573. #endif /* CPU_FAMILY==SPARC */
  575. #ifdef UNIX
  576. #define intLock spl7
  577. #define intUnlock splx
  578. #endif /* UNIX */
  581. #define DELAY_COUNT 5000 /* how high to count when waiting on TAS */
  583. #ifdef UNIX
  584. IMPORT int bpParity;
  585. IMPORT int bpDebug; /* flags: 1-usage, 2-dropped packets */
  586. #else /* UNIX */
  587. int bpParity = FALSE;
  588. int bpDebug; /* flags: 1-usage, 2-dropped packets */
  589. #endif /* UNIX */
  591. #define DEBUG_OPTION_1 (bpDebug & 0x1)
  592. #define DEBUG_OPTION_2 (bpDebug & 0x2)
  593. #define DEBUG_OPTION_3 (bpDebug & 0x4)
  594. #define DEBUG_OPTION_4 (bpDebug & 0x8)
  595. #define DEBUG_OPTION_5 (bpDebug & 0x10)
  597. /*  0, 0, 0, 0, unit, host */
  598. u_char bpEnetAdrs [6] = { 0, 0, 0, 0, 0, 0 };
  600. /* local variables */
  602. LOCAL BOOL bpTasOK; /* whether hardward can do test-and-set */
  603. LOCAL int bpHeartbeatRate;
  604. int bpBitBucket; /* spare change */
  606. /* forward declarations */
  608. void bpPollTask ();
  609. void bpintr ();
  611. /* forward static functions */
  613. static void bpReset (int unit);
  614. static STATUS bpAlive (BP_SOFTC *bs);
  615. static STATUS bpIfInit (int unit);
  616. static void bpReadAll (int unit);
  617. static STATUS bpRead (BP_SOFTC *bs, BUF_NODE *pBufNode, BUF_NODE
  618. *pBufNodeOrig);
  619. #if defined BSD43_DRIVER || defined (UNIX)
  620. static void bpStart (int unit);
  621. static int bpOutput (struct ifnet *ifp, struct mbuf *m0, struct sockaddr
  622. *dst);
  623. #else
  624. static void bpStart (BP_SOFTC *  bs);
  625. #endif
  627. static STATUS bpPut (BP_SOFTC *bs, struct mbuf *m);
  628. static void bpXmit (BP_SOFTC *bs, BUF_NODE *pBufNode, int destProcNum, int
  629. srcProcNum);
  630. static void bpIntAck (BP_SOFTC *bs);
  631. static STATUS bpConnect (BP_SOFTC *bs, int unit);
  632. static STATUS bpIntEnable (BP_SOFTC *bs);
  633. static void bpIntGen (CPU_DESC *pCpu, int srcProcNum);
  634. static void bpHeartbeat (BP_ANCHOR *pAnchor);
  635. static int bpSizeMem (caddr_t memAdrs, int memSize);
  636. static int bpIoctl (struct ifnet *ifp, int cmd, caddr_t data);
  637. static void ringinit (RING *rp, short size);
  638. #if CPU==R3000
  639. static int ringput ();
  640. static int ringget ();
  641. #else
  642. static int ringput (RING *rp, int v);
  643. static int ringget (RING *rp);
  644. #endif
  645. static int ringcount (RING *pRing);
  646. static BOOL vxTasac (char *address);
  648. #ifdef UNIX
  649. LOCAL void bpRead ();
  650. #else /* UNIX */
  651. LOCAL STATUS bpRead ();
  652. #endif /* UNIX */
  654. #ifdef UNIX
  655. /*******************************************************************************
  656. *
  657. * bpattach - attach the `bp' interface to the network
  658. *
  659. * Make the `bp' interface available by filling in the network interface record.
  660. * The system will initialize the interface when it is ready to accept packets.
  661. *
  662. * RETURNS: N/A
  663. *
  664. * NOMANUAL
  665. */
  667. void bpattach (md)
  668.     struct mb_device *md;
  670.     {
  671.     int unit          = md->md_unit;
  672.     FAST BP_SOFTC *bs = BP_SOFTC_P [unit];
  673.     struct ifnet *ifp = &bs->bs_if;
  675.     bs->bs_procNum = bp_procnum;
  677.     bs->bs_intType = bp_int_type;
  678.     bs->bs_intArg1 = bp_int_arg1;
  679.     bs->bs_intArg2 = bp_int_arg2;
  680.     bs->bs_intArg3 = bp_int_arg3;
  682.     bs->bs_addr = md->md_addr;
  683.     bs->bs_ivec = md->md_intr->v_vec;
  685.     ether_attach (ifp, unit, "bp", bpIfInit, bpIoctl, bpOutput,
  686.                   (FUNCPTR)bpReset);
  688.     ifp->if_mtu = bp_mtu;
  690.     bzero ((char*) cpudesc_vaddr, sizeof (cpudesc_vaddr));
  691.     }
  693. /*******************************************************************************
  694. *
  695. * bpPoke - map in physical memory and write value to address
  696. *
  697. * This routine is used to map in CPU boards' mailboxes.
  698. * An array up to MAXCPU is kept so that a mailbox is
  699. * only mapped in once per CPU.
  700. */
  702. LOCAL void bpPoke (addr, type, value, cpuNum)
  703.     char *addr; /* physical address */
  704.     int type; /* mailbox size + read/write */
  705.     int value; /* value to write */
  706.     int cpuNum; /* which CPU */
  708.     {
  709.     char *vaddr; /* virtual address */
  710.     int kmx; /* kernel map index */
  711.     int numClicks;
  712.     /* int numBytes; */
  713.     int addrOffset;
  715.     if (cpuNum < 0 && cpuNum > MAXCPU)
  716. {
  717. printf ("bp: bpPoke invalid cpu #%dn", cpuNum);
  718. return;
  719. }
  721.     if ((vaddr = cpudesc_vaddr [cpuNum]) == 0)
  722. {
  723. numClicks = btoc (sizeof (int));
  724. /* numBytes = ctob (numClicks); */
  725. addrOffset = (int)(addr - ptob (btop (addr)));
  727. /* get some virtual address space */
  729. if ((kmx = rmalloc (kernelmap, numClicks)) == 0)
  730.     {
  731.     printf ("bp: no kernelmap for bp mailboxn");
  732.     panic ("bpPoke");
  733.     }
  735. vaddr = (char *)kmxtob (kmx);
  737. mapin (&Usrptmap [kmx], btop (vaddr), btop (addr) | PGT_VME_D16,
  738. numClicks, PG_V | PG_KW);
  740. cpudesc_vaddr [cpuNum] = vaddr += addrOffset;
  742. if (DEBUG_OPTION_1)
  743.     printf ("nbp: cpu #%d mailbox addr = 0x%x, vaddr = 0x%xn",
  744.     cpuNum, (int)addr, (int)vaddr);
  745. }
  747.     switch (type)
  748. {
  749. case BP_INT_MAILBOX_1: *(char  *) vaddr = value; break;
  750. case BP_INT_MAILBOX_2: *(short *) vaddr = value; break;
  751. case BP_INT_MAILBOX_4: *(long  *) vaddr = value; break;
  752. case BP_INT_MAILBOX_R1: value = *(char  *) vaddr; break;
  753. case BP_INT_MAILBOX_R2: value = *(short *) vaddr; break;
  754. case BP_INT_MAILBOX_R4: value = *(long  *) vaddr; break;
  755. default: printf ("bp: bpPoke - bad mailbox type 0x%xn", type); break;
  756. }
  758. #ifdef MAP_OUT
  759.     /* example of mapping out memory */
  761.     cpudesc_vaddr [cpuNum] = 0;
  762.     mapout (&Usrptmap [kmx], numClicks, kmx);
  763.     rmfree (kernelmap, numClicks, kmx);
  764. #endif /* MAP_OUT */
  765.     }
  766. /*******************************************************************************
  767. *
  768. * bpProbe - probe for backplane memory
  769. *
  770. * RETURNS:
  771. * The amount of memory available, or 0 if error.
  772. *
  773. * NOMANUAL
  774. */
  776. int bpProbe (addr, unit)
  777.     caddr_t addr; /* address of backplane memory */
  778.     int unit; /* device number */
  780.     {
  781.     int memSize = bp_mem_size;
  782.     FAST BP_SOFTC *bs = BP_SOFTC_P [unit];
  783.     extern int peek (), pokec ();
  785.     if (BP_MASTER)
  786. bpProbeType = bpParity ? pokec : peek;
  787.     else
  788. bpProbeType = peek;
  790.     if (DEBUG_OPTION_1)
  791. printf ("bp%d: debugging on (level = 0x%x)n", unit, bpDebug);
  793.     /* anchor is at the start of shared memory */
  795.     bs->bs_pAnchor = (BP_ANCHOR *) addr;
  797.     if ((*bpProbeType) (addr, 0) == -1)
  798. {
  799. printf ("bp%d: shared memory not present at 0x%x (0x%x)n",
  800. unit, (int)bs->bs_pAnchor,(int)vir2phys((char*)bs->bs_pAnchor));
  801. return (0);
  802. }
  804.     if (BP_MASTER &&
  805. bpInit ((char*)bs->bs_pAnchor, addr, memSize, bp_tas) == ERROR)
  806. {
  807. printf ("bp%d: bpProbe cannot initialize anchor!n", unit);
  808. return (0);
  809. }
  811.     if (DEBUG_OPTION_1)
  812. printf ("bp%d: shared memory size is %d bytes, at 0x%x (0x%x)n", unit,
  813.      memSize,(int)bs->bs_pAnchor, (int)vir2phys((char*)bs->bs_pAnchor));
  815.     return (memSize);
  816.     }
  818. #else /* UNIX */
  820. /*******************************************************************************
  821. *
  822. * bpattach - publish the `bp' network interface and initialize the driver and device
  823. *
  824. * This routine attaches a `bp' interface to the network, if the
  825. * interface exists.  This routine makes the interface available by filling in
  826. * the network interface record.  The system will initialize the interface
  827. * when it is ready to accept packets.
  828. *
  829. * RETURN: OK or ERROR.
  830. */
  832. STATUS bpattach
  833.     (
  834.     int unit,           /* backplane unit number */
  835.     char *pAnchor,      /* bus pointer to bp anchor */
  836.     int procNum,        /* processor number in backplane */
  837.     int intType,        /* interrupt type: poll, bus, mailbox */
  838.     int intArg1,        /* as per interrupt type */
  839.     int intArg2,        /* as per interrupt type */
  840.     int intArg3         /* as per interrupt type */
  841.     )
  842.     {
  843.     FAST BP_SOFTC *bs;
  844.     FAST struct ifnet *ifp;
  845.     FAST BP_ANCHOR *pBpAnchor = (BP_ANCHOR *) pAnchor;
  847.     if (procNum == 0)
  848. bpProbeType = bpParity ? O_WRONLY : O_RDONLY;
  849.     else
  850. bpProbeType = O_RDONLY;
  852.     /* allocate bp_softc structure */
  854.     if ((bs = (BP_SOFTC *) malloc (sizeof (BP_SOFTC))) == NULL)
  855. return (ERROR);
  857.     bp_softc [unit] = bs; /* XXX check if non-zero for re-attach? */
  858.     ifp = &bs->bs_if;
  860.     /* initialize the interface structure */
  862.     bzero ((char *) bs, sizeof (BP_SOFTC));
  864.     bs->bs_pAnchor = pBpAnchor;
  865.     bs->bs_procNum = procNum;
  866.     bs->bs_intType = intType;
  867.     bs->bs_intArg1 = intArg1;
  868.     bs->bs_intArg2 = intArg2;
  869.     bs->bs_intArg3 = intArg3;
  871.     /* wait for shared memory to be initialized; master CPU does sanity check */
  873.     if (bpAlive (bs) == ERROR)
  874. {
  875. (void) free ((void *) bs);
  876. return (ERROR);
  877. }
  879.     if (bpDebug != 0)
  880. {
  881. printf ("bp%d: debugging on (level = 0x%x)n", unit, bpDebug);
  882. printf ("bpattach: anchor CPU can%s do real TAS.n",
  883. bpTasOK ? "" : "not");
  884. }
  886. #ifdef BSD43_DRIVER
  887.     ether_attach (ifp, unit, "bp", bpIfInit, bpIoctl, bpOutput,
  888.                   (FUNCPTR)bpReset);
  889. #else
  890.     ether_attach (
  891.                  ifp,
  892.                  unit,
  893.                  "bp",
  894.                  (FUNCPTR) bpIfInit,
  895.                  (FUNCPTR) bpIoctl,
  896.                  (FUNCPTR) ether_output,
  897.                  (FUNCPTR) bpReset
  898.                  );
  899.     ifp->if_start = (FUNCPTR)bpStart;
  900. #endif
  902.     ifp->if_mtu = bp_mtu;
  904.     if (bpIfInit (unit) == ERROR)
  905.         {
  906.         (void) free ((void *) bs);
  907.         return (ERROR);
  908.         }
  910.     return (OK);
  911.     }
  912. #endif /* UNIX */
  914. /*******************************************************************************
  915. *
  916. * bpInit - initialize the backplane anchor
  917. *
  918. * This routine initializes the backplane anchor.  Typically, <pAnchor> and
  919. * <pMem> both point to the same block of shared memory.  If the first
  920. * processor is dual-porting its memory, then, by convention, the anchor is
  921. * at 0x600 (only 16 bytes are required) and the start of memory <pMem> is
  922. * dynamically allocated by using the value NONE (-1).  <memSize> should be at
  923. * least 64 Kbytes.  The <tasOK> parameter is provided for CPUs that do
  924. * not support the test-and-set instruction.  If the system includes any
  925. * test-and-set deficient CPUs, then all CPUs must use the software
  926. * "test-and-set".
  927. *
  928. * RETURNS:
  929. * OK, or ERROR if data structures cannot be set up or memory is insufficient.
  930. */
  932. STATUS bpInit
  933.     (
  934.     FAST char *pAnchor, /* backplane anchor address */
  935.     FAST char *pMem,    /* start of backplane shared memory, NONE = alloc */
  936.     int memSize,        /* no. bytes in bp shared memory, 0 = 0x100000 */
  937.     BOOL tasOK          /* TRUE = hardware can do test-and-set */
  938.     )
  939.     {
  940.     FAST BP_ANCHOR *pBpAnchor = (BP_ANCHOR *) pAnchor;
  941.     FAST RING *pFreeRing;
  942.     FAST int ix;
  943.     FAST char *pMemEnd; /* end of backplane shared memory */
  944.     FAST CPU_DESC *pCpu;
  945.     FAST BP_HEADER *pHdr;
  946.     int npackets = 0;
  948.     memSize = (memSize == 0) ? 0x100000 : memSize;
  949.     bpTasOK = tasOK;
  951.     /* if bp header specified, probe it, otherwise malloc it */
  953.     if (pMem != (char *) NONE)
  954. {
  955. memSize = min (memSize, bpSizeMem (pMem, memSize));
  956. if (memSize == 0)
  957.     {
  958.     printf ("bp: no shared memory at address 0x%xn", (int)pMem);
  959.     return (ERROR);
  960.     }
  962. /* if anchor is at start of shared region, skip over it */
  964. if (pMem == pAnchor)
  965.     {
  966.     pMem    += sizeof (BP_ANCHOR);
  967.     memSize -= sizeof (BP_ANCHOR);
  968.     }
  969. }
  970.     else
  971. {
  972. #ifndef UNIX
  973. #if ((CPU_FAMILY==MIPS) || (CPU_FAMILY==SH))
  974. if ((pMem = (char *) cacheDmaMalloc ((unsigned) memSize)) == NULL)
  975. #else /* CPU_FAMILY==MIPS || CPU_FAMILY==SH */
  976.         if ((pMem = (char *) malloc ((unsigned) memSize)) == NULL)
  977. #endif /* CPU_FAMILY==MIPS || CPU_FAMILY==SH */
  978. #endif /* UNIX */
  979.     {
  980.     printf ("bp: can't allocate shared memoryn");
  981.     return (ERROR);
  982.     }
  983. }
  985.     pMemEnd = pMem + memSize;
  986.     pHdr = (BP_HEADER *) pMem;
  988.     /* initialize bp anchor region */
  990.     pBpAnchor->an_ready     = 0; /* set bp not ready */
  991.     pBpAnchor->an_heartbeat = 0; /* clear heartbeat */
  992.     pBpAnchor->an_pHdr      = KtoIval (pHdr, BP_HEADER *, pAnchor);
  994.     if (pMem + sizeof (BP_HEADER) > pMemEnd)
  995. {
  996. printf ("bp: bpInit out of memory!n");
  997. return (ERROR);
  998. }
  1000.     /* initialize bp header region */
  1002.     pHdr->hdr_ready = 0;                /* set CPU region not ready */
  1003.     pHdr->hdr_ncpu = BP_HTONS(NCPU);    /* set number of CPUs */
  1005.     bcopy ((char *) bpEnetAdrs, (char *) pHdr->hdr_enetAdrs, 6);
  1007.     /* initialize each CPU descriptor */
  1009.     for (ix = 0; ix < MAXCPU; ++ix)
  1010. {
  1011. pCpu = &pHdr->hdr_cpuDesc[ix];
  1013. pCpu->cd_active      = FALSE;
  1014. pCpu->cd_cpuNum      = BP_HTONL(ix);
  1015. pCpu->cd_pInputRing  = NULL;
  1016. }
  1018.     /* initialize free ring */
  1020.     pMem += sizeof (BP_HEADER);
  1022.     if ((pMem + sizeof (struct ring256) + NCPU * sizeof (struct ring32))
  1023. > pMemEnd)
  1024. {
  1025. printf ("bp: bpInit out of memory!n");
  1026. return (ERROR);
  1027. }
  1029.     ringinit ((pFreeRing = (RING *) pMem), 256);
  1030.     pHdr->hdr_pFreeRing =  KtoIval (pFreeRing, RING *, pAnchor);
  1031.     pMem += sizeof (struct ring256);
  1033.     /* initialize each input ring */
  1035.     for (ix = 0; ix < NCPU; ++ix)
  1036. {
  1037. ringinit ((RING *) pMem, 32);
  1038. pHdr->hdr_cpuDesc[ix].cd_pInputRing = KtoIval (pMem, RING *, pAnchor);
  1039. pMem += sizeof (struct ring32);
  1040. }
  1042.     /* initialize as many buffer blocks as will fit in remaining shared memory*/
  1044.     if ((pMem + sizeof (BUF_NODE) + BP_BUFSIZ) > pMemEnd)
  1045. {
  1046. printf ("bp: bpInit out of memory!n");
  1047. return (ERROR);
  1048. }
  1050.     while ((pMem + sizeof (BUF_NODE) + BP_BUFSIZ) <= pMemEnd)
  1051. {
  1052. ((BUF_NODE *)pMem)->b_addr = KtoIval (pMem + sizeof (BUF_NODE),
  1053.       char*, pAnchor);
  1054.         ((BUF_NODE *)pMem)->b_len = BP_BUFSIZ;
  1056. (void) ringput (pFreeRing, KtoIval (pMem, int, pAnchor));
  1057. pMem += sizeof (BUF_NODE) + BP_BUFSIZ;
  1058. npackets++;
  1059. }
  1061.     if (DEBUG_OPTION_1)
  1062. {
  1063. printf ("bp: number of %d byte packets is %dn", BP_BUFSIZ, npackets);
  1064. printf ("bp: %d bytes unused from 0x%x to 0x%xn",
  1065. (int) (pMemEnd - pMem), 
  1066. (int) vir2phys (pMem), 
  1067. (int) vir2phys (pMemEnd));
  1068. }
  1070.     /* mark bp as ready */
  1072.     if (bpTasOK)
  1073. pHdr->hdr_ready = pBpAnchor->an_ready = BP_HTONL(BP_READY);
  1074.     else
  1075. pHdr->hdr_ready = pBpAnchor->an_ready = BP_HTONL(BP_READY_SOFT_TAS);
  1077.     /* start heartbeat */
  1079.     bpHeartbeatRate = hz;
  1080. #ifdef UNIX
  1081.     timeout (bpHeartbeat, (caddr_t) pAnchor, bpHeartbeatRate);
  1082. #else /* UNIX */
  1083.     /* create watchdog timer for heartbeat */
  1085.     if ((pBpAnchor->an_wdog = wdCreate ()) == NULL)
  1086. return (ERROR);
  1087.     wdStart (pBpAnchor->an_wdog, bpHeartbeatRate, (FUNCPTR) bpHeartbeat,
  1088.              (int) pAnchor);
  1089. #endif /* UNIX */
  1091.     return (OK);
  1092.     }
  1093. /*******************************************************************************
  1094. *
  1095. * bpReset - mark a bp inactive
  1096. *
  1097. * called from reboot and panic
  1098. */
  1100. LOCAL void bpReset
  1101.     (
  1102.     FAST int unit
  1103.     )
  1104.     {
  1105.     FAST BP_SOFTC *bs;
  1106.     FAST BUF_NODE *pBufNode;
  1107. #ifdef UNIX
  1108.     FAST struct mb_device *md;
  1110.     if (unit >= NBP || (md = bpinfo[unit]) == 0 || md->md_alive == 0)
  1111. return;
  1112. #endif /* UNIX */
  1114.     bs = BP_SOFTC_P [unit];
  1116.     if (bs != NULL && bs->bs_pHdr != NULL)
  1117. {
  1118. /* turn off active flag in our CPU descriptor in the
  1119.  * shared header, then throw away anything on our input ring */
  1121. bs->bs_pHdr->hdr_cpuDesc[bs->bs_procNum].cd_active = FALSE;
  1123. while ( (pBufNode = (BUF_NODE *)ringget ( (RING *)bs->bs_pInputRing)))
  1124.     (void)ringput ( (RING *)bs->bs_pFreeRing, (int)pBufNode);
  1125. }
  1126.     }
  1127. /*******************************************************************************
  1128. *
  1129. * bpAlive - check for throbbing heartbeat
  1130. *
  1131. * This routine is called for CPU 0 (master) as well as the rest.
  1132. * The timeout is quick if the master can't see its own ticker.
  1133. *
  1134. * RETURNS: OK or ERROR if unable to find anchor after 10 minutes
  1135. */
  1137. LOCAL STATUS bpAlive
  1138.     (
  1139.     BP_SOFTC *bs
  1140.     )
  1141.     {
  1142.     int readyValue;
  1143.     int heartbeat;
  1144.     FAST unsigned int oldBeat = 0;
  1145.     FAST int countdown             = 10 * 60 * hz; /* wait 10 minutes */
  1146.     FAST BP_ANCHOR *pAnchor        = bs->bs_pAnchor;
  1147. #ifdef UNIX
  1148.     int level = spl3 (); /* find out priority level */
  1149.     splx (level);
  1150. #endif /* UNIX */
  1152.     if (bs->bs_procNum == 0)
  1153. countdown = 2 * hz; /* don't wait around for self if master CPU */
  1155.     while (--countdown > 0)
  1156. {
  1157. /* probe test:
  1158.  *  1) anchor must be readable (memory must be visable to us),
  1159.  *  2) anchor ready value must be BP_READY or BP_READY_SOFT_TAS,
  1160.  *  3) anchor heartbeat must be increasing.
  1161.  */
  1163. #ifdef UNIX
  1164. if (peek ((short *) &pAnchor->an_ready)     != -1 &&
  1165.     peek ((short *) &pAnchor->an_heartbeat) != -1)
  1166.     {
  1167.     readyValue = BP_NTOHL(pAnchor->an_ready);
  1168.     heartbeat  = (UINT)BP_NTOHL(pAnchor->an_heartbeat);
  1169. #else /* UNIX */
  1170. if (vxMemProbe ((char *) &pAnchor->an_ready,
  1171.  O_RDONLY, 4, (char *) &readyValue) == OK &&
  1172.     vxMemProbe ((char *) &pAnchor->an_heartbeat,
  1173.  O_RDONLY, 4, (char *) &heartbeat) == OK)
  1174.     {
  1175.     readyValue = BP_NTOHL(readyValue);
  1176.     heartbeat = (UINT)BP_NTOHL(heartbeat);
  1177. #endif /* UNIX */
  1179.     if ((countdown % 10) == 6)
  1180. {
  1181. printf ("nbp: bpAlive ready = 0x%x, heartbeat = %dn",
  1182.     readyValue, heartbeat);
  1183. }
  1185.     if (readyValue == BP_READY || readyValue == BP_READY_SOFT_TAS)
  1186. {
  1187. if (oldBeat == 0 || heartbeat <= oldBeat)
  1188.     oldBeat = heartbeat;
  1189. else
  1190.     {
  1191.     /* heartbeat increased, passed test */
  1192.     bpTasOK = readyValue == BP_READY;
  1193.     return (OK);
  1194.     }
  1195. }
  1196.     }
  1197. else if ((countdown % 10) == 8)
  1198.     printf ("nbp: bpAlive bus errorn");
  1200. #ifdef UNIX
  1201. timeout (wakeup, (caddr_t)bs, 1);
  1202.         sleep (bs, level);
  1203. #else /* UNIX */
  1204. taskDelay (hz);
  1205. #endif /* UNIX */
  1206. }
  1208. #ifndef UNIX
  1209.     (void) errnoSet (S_iosLib_CONTROLLER_NOT_PRESENT);
  1210. #endif /* UNIX */
  1212.     /* give up - didn't get initialized */
  1214.     return (ERROR);
  1215.     }
  1216. /*******************************************************************************
  1217. *
  1218. * bpIfInit - initialize interface
  1219. *
  1220. * RETURNS: OK or ERROR
  1221. */
  1223. LOCAL STATUS bpIfInit
  1224.     (
  1225.     int unit
  1226.     )
  1227.     {
  1228.     FAST CPU_DESC *pCpu;
  1229.     FAST BP_SOFTC *bs = BP_SOFTC_P [unit];
  1230.     FAST BP_HEADER *pHdr;
  1232.     /* find the anchor and CPU descriptor */
  1233.     pHdr = ItoKval (bs->bs_pAnchor->an_pHdr, BP_HEADER *, bs->bs_pAnchor);
  1234.     bs->bs_pHdr = pHdr;
  1236. #ifdef UNIX
  1237.     /* wait for shared memory to be initialized */
  1239.     if (!BP_MASTER && bpAlive (bs) == ERROR)
  1240. return (ERROR);
  1241. #endif /* UNIX */
  1243.     pCpu = &pHdr->hdr_cpuDesc [bs->bs_procNum];
  1245.     bs->bs_pFreeRing = ItoKval (pHdr->hdr_pFreeRing, RING *, bs->bs_pAnchor);
  1247.     bs->bs_pInputRing= ItoKval(pHdr->hdr_cpuDesc[bs->bs_procNum].cd_pInputRing,
  1248.        RING *, bs->bs_pAnchor);
  1250.     /* fill in Ethernet address, which is the backplane Ethernet address with
  1251.      * our processor number as the last byte. */
  1253. #ifdef UNIX
  1254.     bcopy ((char *) pHdr->hdr_enetAdrs,
  1255.     (char *) bs->bs_enaddr.ether_addr_octet, 6);
  1256.     bs->bs_enaddr.ether_addr_octet [4] = unit;
  1257.     bs->bs_enaddr.ether_addr_octet [5] = (char) bs->bs_procNum;
  1258. #else /* UNIX */
  1259.     bcopy ((char *) pHdr->hdr_enetAdrs, (char *) bs->bs_enaddr, 6);
  1260.     bs->bs_enaddr [4] = unit;
  1261.     bs->bs_enaddr [5] = (char) bs->bs_procNum;
  1262. #endif /* UNIX */
  1264.     /* check that our input buffer was established
  1265.      * (in case NCPU < our cpu < MAXCPU) */
  1267.     if (pCpu->cd_pInputRing == NULL)
  1268. return (ERROR);
  1270.     /* fill in our info in the CPU descriptor in shared memory */
  1272.     pCpu->cd_unit = unit; /* set our internal unit num */
  1274.     /* tell others how to interrupt us */
  1276.     pCpu->cd_intType = BP_HTONL(bs->bs_intType);
  1277.     pCpu->cd_intArg1 = BP_HTONL(bs->bs_intArg1);
  1278.     pCpu->cd_intArg2 = BP_HTONL(bs->bs_intArg2);
  1279.     pCpu->cd_intArg3 = BP_HTONL(bs->bs_intArg3);
  1281.     /* connect and enable our interprocessor interrupt */
  1283.     if (DEBUG_OPTION_1)
  1284. printf ("bp%d: connecting...n", unit);
  1286.     if (bpConnect (bs, unit) != OK || bpIntEnable (bs) != OK)
  1287. return (ERROR);
  1289.     /* tell others we're here now */
  1291.     pCpu->cd_active = TRUE;
  1293.     if ((bs->bs_if.if_flags & IFF_RUNNING) == 0)
  1294. bs->bs_if.if_flags |= IFF_UP | IFF_RUNNING;
  1296.     return (OK);
  1297.     }
  1298. /*******************************************************************************
  1299. *
  1300. * bpintr - interrupt handler
  1301. *
  1302. * RETURNS: N/A
  1303. *
  1304. * NOMANUAL
  1305. */
  1307. void bpintr
  1308.     (
  1309.     int unit
  1310.     )
  1311.     {
  1312.     FAST BP_SOFTC *bs = BP_SOFTC_P [unit];
  1314.     if (bs != NULL && bs->bs_pInputRing != NULL) /* input ring exists? */
  1315. {
  1316. #ifndef UNIX
  1317. bpIntAck (bs);
  1318. #endif /* UNIX */
  1320. if (!bs->bs_readPending)
  1321.     {
  1322.     bs->bs_readPending = TRUE;
  1323. #ifdef UNIX
  1324.     bpReadAll (unit);
  1325. #else /* UNIX */
  1326.     (void) netJobAdd ((FUNCPTR)bpReadAll, unit, 0,0,0,0); /* read from input ring */
  1327. #endif /* UNIX */
  1328.     }
  1329. }
  1330.     }
  1332. /*******************************************************************************
  1333. *
  1334. * bpReadAll -
  1335. */
  1337. LOCAL void bpReadAll
  1338.     (
  1339.     int unit
  1340.     )
  1341.     {
  1342.     FAST BP_SOFTC *bs = BP_SOFTC_P [unit];
  1343.     FAST BUF_NODE *pBufNode;
  1345.     bs->bs_readPending = FALSE;
  1347.     while ((pBufNode = (BUF_NODE *) ringget ((RING *) bs->bs_pInputRing)) != 0)
  1348. {
  1349. #ifdef UNIX
  1350. bpRead (bs, ItoKval (pBufNode, BUF_NODE *, bs->bs_pAnchor));
  1351. (void) ringput (bs->bs_pFreeRing, (int) pBufNode);
  1352. #else /* UNIX */
  1353. if (bpRead (bs, ItoKval (pBufNode, BUF_NODE *, bs->bs_pAnchor),
  1354.     pBufNode) == OK)
  1355.     (void) ringput ((RING *) bs->bs_pFreeRing, (int) pBufNode);
  1356. #endif /* UNIX */
  1357. }
  1358.     }
  1360. /*******************************************************************************
  1361. *
  1362. * bpRead -
  1363. *
  1364. * NOMANUAL
  1365. */
  1367. #ifdef UNIX
  1368. LOCAL void bpRead (bs, pBufNode)
  1369.     BP_SOFTC *bs;
  1370.     BUF_NODE *pBufNode;
  1371. #else /* UNIX */
  1372. LOCAL STATUS bpRead
  1373.     (
  1374.     BP_SOFTC *bs,
  1375.     BUF_NODE *pBufNode,
  1376.     BUF_NODE *pBufNodeOrig
  1377.     )
  1378. #endif  /* UNIX */
  1379.     {
  1380.     FAST struct ether_header *eh;
  1381.     FAST struct mbuf  *m;
  1382.     int  len;
  1383.     int  off;
  1384.     FAST unsigned char  *pData;
  1385.     STATUS  retval;
  1386. #ifdef BSD43_DRIVER
  1387.     u_short ether_type;
  1388. #endif
  1390.     retval = OK;
  1392.     bs->bs_if.if_ipackets++; /* count input packets */
  1394.     /* get length and pointer to packet */
  1396.     len = (int) (BP_NTOHS (pBufNode->b_len));
  1397.     eh = ItoKval (pBufNode->b_addr, struct ether_header *, bs->bs_pAnchor);
  1399. #ifndef UNIX
  1400.     /* call input hook if any */
  1402.     if ((etherInputHookRtn != NULL) &&
  1403. (* etherInputHookRtn) (&bs->bs_if, (char *)eh, BP_NTOHS(pBufNode->b_len)))
  1404. return (retval); /* input hook has already processed packet */
  1405. #endif /* UNIX */
  1407.     len -= SIZEOF_ETHERHEADER;
  1408.     pData = ((unsigned char *) eh) + SIZEOF_ETHERHEADER;
  1410. #ifdef UNIX
  1411.     check_trailer (eh, pData, &len, &off);
  1413.     if (len == 0)
  1414. return;
  1416.     m = copy_to_mbufs (pData, len, off);
  1418.     if (m != NULL)
  1419. do_protocol (eh, m, &bs->bs_ac, len);
  1420.     else
  1421.         bs->bs_if.if_ierrors++;     /* bump error count */
  1422. #else /* UNIX */
  1423. #ifdef BSD43_DRIVER
  1424.     check_trailer (eh, pData, &len, &off, &bs->bs_if);
  1426.     if (len == 0)
  1427. return (retval);
  1429.     ether_type = eh->ether_type;
  1430. #endif
  1432.     m = copy_to_mbufs (pData, len, off, &bs->bs_if);
  1434.     if (m != NULL)
  1435. #ifdef BSD43_DRIVER
  1436.         do_protocol_with_type (ether_type, m, &bs->bs_ac, len);
  1437. #else
  1438.         do_protocol (eh, m, &bs->bs_ac, len);
  1439. #endif
  1440.     else
  1441.         bs->bs_if.if_ierrors++;     /* bump error count */
  1442.          
  1443.     return (retval);
  1444. #endif /* UNIX */
  1445.     }
  1447. /*******************************************************************************
  1448. *
  1449. * bpStart -
  1450. *
  1451. * NOMANUAL
  1452. */
  1454. #ifdef UNIX
  1455. LOCAL void bpStart (dev)
  1456.     dev_t dev;
  1457. #else /* UNIX */
  1458. #ifdef BSD43_DRIVER
  1459. LOCAL void bpStart
  1460.     (
  1461.     int unit
  1462.     )
  1463. #else
  1464. LOCAL void bpStart
  1465.     (
  1466.     BP_SOFTC *  bs
  1467.     )
  1468. #endif    /* BSD43_DRIVER */
  1469. #endif  /* UNIX */
  1470.     {
  1471. #ifdef UNIX
  1472.     int unit = minor (dev);
  1473. #endif /* UNIX */
  1475. #if defined (BSD43_DRIVER) || defined (UNIX)
  1476.     FAST BP_SOFTC *bs = BP_SOFTC_P [unit];
  1477. #endif
  1479.     FAST struct mbuf *m;
  1481.     while (bs->bs_if.if_snd.ifq_head)               /* while queue not empty */
  1482.         {
  1483.         IF_DEQUEUE(&bs->bs_if.if_snd, m);           /* get next from queue */
  1484.         if (bpPut (bs, m) == ERROR)                 /* if couldn't send */
  1485.             {
  1486. #if defined (BSD43_DRIVER) || defined (UNIX)    
  1487.              /* vxWorks BSD 4.4 ether_output() doesn't bump statistic. */
  1488.             bs->bs_if.if_opackets--;                /* it wasn't sent! */
  1489. #endif
  1490.             bs->bs_if.if_oerrors++;                 /* it was an error */
  1491.             m_freem (m);                            /* free the mbufs */
  1492.             }
  1493. #if !defined (BSD43_DRIVER) && !defined (UNIX)
  1494.         else
  1495.             /* bump statistic for BSD 4.4 vxWorks driver. */
  1497.             bs->bs_if.if_opackets++;   
  1498. #endif
  1499.         }
  1500.     }
  1502. #if defined (BSD43_DRIVER) || defined (UNIX)
  1503. /*******************************************************************************
  1504. *
  1505. * bpOutput - net output routine
  1506. *
  1507. * Encapsulate a packet of type family for the local net.
  1508. * Use trailer local net encapsulation if enough data in first
  1509. * packet leaves a multiple of 512 bytes of data in remainder.
  1510. *
  1511. * RETURNS: 0 if successful, errno otherwise (as per network requirements)
  1512. */
  1514. LOCAL int bpOutput
  1515.     (
  1516.     struct ifnet *ifp,
  1517.     struct mbuf *m0,
  1518.     struct sockaddr *dst
  1519.     )
  1520.     {
  1521. #ifdef UNIX
  1522.     return (ether_output (ifp, m0, dst, bpStart,
  1523.     &(BP_SOFTC_P [ifp->if_unit])->bs_ac));
  1524. #else /* UNIX */
  1525.     return (ether_output (ifp, m0, dst, (FUNCPTR)bpStart,
  1526.     &BP_SOFTC_P [ifp->if_unit]->bs_ac));
  1527. #endif /* UNIX */
  1528.     }
  1529. #endif
  1531. /*******************************************************************************
  1532. *
  1533. * bpPut - copy from mbuf chain to shared memory buffer
  1534. *
  1535. * RETURNS: OK or ERROR if no room left in free ring
  1536. */
  1538. LOCAL STATUS bpPut
  1539.     (
  1540.     FAST BP_SOFTC       *bs,
  1541.     FAST struct mbuf    *m
  1542.     )
  1543.     {
  1544.     FAST BUF_NODE  *pBufNode;
  1545.     u_char  *bufStart;
  1546.     int len;
  1548.     if ((pBufNode = (BUF_NODE *) ringget ((RING *) bs->bs_pFreeRing)) == NULL)
  1549. return (ERROR);
  1551.     pBufNode = ItoKval (pBufNode, BUF_NODE *, bs->bs_pAnchor);
  1552.     bufStart = ItoKval (pBufNode->b_addr, u_char *, bs->bs_pAnchor);
  1554. #ifdef UNIX
  1555.     len = copy_from_mbufs (bufStart, m, len);
  1556. #else /* UNIX */
  1557.     copy_from_mbufs (bufStart, m, len);
  1558. #endif /* UNIX */
  1560.     len = max (MINPKTSIZE, len);
  1561.     pBufNode->b_len = BP_HTONS (len);
  1563. #ifndef UNIX
  1564.     /* call output hook if any */
  1566.     if ((etherOutputHookRtn != NULL) &&
  1567. (* etherOutputHookRtn) (&bs->bs_if, bufStart, pBufNode->b_len))
  1568. return (OK); /* output hook has already processed packet */
  1569. #endif /* UNIX */
  1571.     /* send to specified processor:
  1572.      * proc number is in last byte of Ethernet address
  1573.      */
  1575.     bpXmit (bs, pBufNode, (int) ((struct ether_header *)
  1576. #ifdef UNIX
  1577.        (bufStart))->ether_dhost.ether_addr_octet[5], bs->bs_procNum);
  1578. #else /* UNIX */
  1579.        (bufStart))->ether_dhost[5], bs->bs_procNum);
  1580. #endif /* UNIX */
  1582.     return (OK);
  1583.     }
  1585. /*******************************************************************************
  1586. *
  1587. * bpXmit - transmit buffer
  1588. */
  1590. LOCAL void bpXmit
  1591.     (
  1592.     FAST BP_SOFTC *bs,
  1593.     BUF_NODE *pBufNode,
  1594.     int destProcNum,    /* destination CPU */
  1595.     int srcProcNum      /* originator */
  1596.     )
  1597.     {
  1598.     BP_ANCHOR *pAnchor = bs->bs_pAnchor;
  1599.     u_char *buf;
  1600.     FAST CPU_DESC *pCpu;
  1601.     FAST BUF_NODE *pBufNode0;
  1603.     if (destProcNum < 0 || destProcNum >= MAXCPU)
  1604. {
  1605. /* broadcast to all CPUs on network */
  1607. buf = ItoKval (pBufNode->b_addr, u_char *, pAnchor);
  1609. for (destProcNum = MAXCPU - 1; destProcNum >= 0; --destProcNum)
  1610.     {
  1611.     pCpu = &bs->bs_pHdr->hdr_cpuDesc[destProcNum];
  1613.     if (DEBUG_OPTION_3)
  1614. dbgprintf ("bp: broadcast packet from %dn", srcProcNum, 0, 0, 0, 0, 0);
  1616.     if (!pCpu->cd_active)
  1617. continue;
  1619.     if ((pBufNode0 = (BUF_NODE *) ringget ((RING *) bs->bs_pFreeRing))
  1620.             == NULL)
  1621. break;
  1623.     pBufNode0 = ItoKval (pBufNode0, BUF_NODE *, pAnchor);
  1625.             pBufNode0->b_len = pBufNode->b_len;
  1626.     bcopy ((caddr_t) buf,
  1627.    (caddr_t) ItoKval (pBufNode0->b_addr, u_char *, pAnchor),
  1628.                    BP_NTOHS (pBufNode->b_len));
  1630.     if (ringput (ItoKval (pCpu->cd_pInputRing, RING *, pAnchor),
  1631.      KtoIval (pBufNode0, int, pAnchor)) == 0)
  1632. {
  1633. /* if input ring was full, then put bufNode back on free ring */
  1635. if (DEBUG_OPTION_2)
  1636.     dbgprintf ("bp: dropped packetn", 0,0,0,0,0,0);
  1637. (void)ringput ((RING *) bs->bs_pFreeRing,
  1638.        KtoIval (pBufNode0, int, pAnchor));
  1639. }
  1640.     else
  1641. {
  1642. /* if input ring was empty, then interrupt destination CPU */
  1644. bpIntGen (pCpu, srcProcNum);
  1645. }
  1646.     }
  1648. (void) ringput ((RING *) bs->bs_pFreeRing,
  1649.                     KtoIval (pBufNode, int, pAnchor));
  1650. }
  1651.     else
  1652. {
  1653. pCpu = &bs->bs_pHdr->hdr_cpuDesc [destProcNum];
  1655. if (DEBUG_OPTION_3)
  1656.     dbgprintf ("bp: packet from %d for %dn", srcProcNum, destProcNum, 0, 0, 0, 0);
  1658. if (!pCpu->cd_active)
  1659.     (void) ringput ((RING *) bs->bs_pFreeRing,
  1660.                         KtoIval (pBufNode, int, pAnchor));
  1661. else if (ringput (ItoKval (pCpu->cd_pInputRing, RING *, pAnchor),
  1662.           KtoIval (pBufNode, int, pAnchor)) == 0)
  1663.     {
  1664.     /* input ring was full, then put bufNode back on free ring */
  1666.     if (DEBUG_OPTION_2)
  1667. dbgprintf ("bp: dropped packetn", 0,0,0,0,0,0);
  1668.     (void) ringput ((RING *) bs->bs_pFreeRing,
  1669.     KtoIval (pBufNode, int, pAnchor));
  1670.     }
  1671. else
  1672.     {
  1673.     /* input ring had room, then interrupt destination CPU */
  1675.     bpIntGen (pCpu, srcProcNum);
  1676.     }
  1677. }
  1678.     }
  1680. #ifdef UNIX
  1681. /*******************************************************************************
  1682. *
  1683. * bpPollUnix - UNIX backplane poll
  1684. *
  1685. * This routine is called by UNIX's timeout routine to poll the
  1686. * backplane input rings for this CPU.
  1687. */
  1689. LOCAL void bpPollUnix ()
  1691.     {
  1692.     FAST int unit;
  1694.     for (unit = 0; unit < NBP; unit++)
  1695. {
  1696. /* if header structure non-zero then unit is initialized */
  1698. if (bp_softc[unit].bs_pHdr)
  1699.     bpintr (unit);
  1700. }
  1702.     /* loop forever, with a delay of 1 */
  1704.     timeout (bpPollUnix, (caddr_t)0, 1);
  1705.     }
  1706. #else /* UNIX */
  1707. /*******************************************************************************
  1708. *
  1709. * bpPollTask - backplane poll task
  1710. *
  1711. * This routine is spawned as task to poll the backplane input rings for
  1712. * this CPU.  It is only used if no backplane interrupt mechanism is
  1713. * used.
  1714. *
  1715. * NOMANUAL
  1716. */
  1718. void bpPollTask (void)
  1719.     {
  1720.     FAST int unit;
  1721.     FAST BP_SOFTC *bs;
  1723.     FOREVER
  1724. {
  1725. for (unit = 0; unit < NBP; unit++)
  1726.     {
  1727.     bs = BP_SOFTC_P [unit];
  1728.     if (bs != NULL && !bs->bs_readPending)
  1729. {
  1730. bs->bs_readPending = TRUE;
  1731. if (bs->bs_pInputRing != NULL)
  1732.     (void) netJobAdd ((FUNCPTR)bpReadAll, unit,0,0,0,0);
  1733. }
  1734.     }
  1735. }
  1736.     }
  1737. /*******************************************************************************
  1738. *
  1739. * bpIntAck - acknowledge our backplane interrupt
  1740. */
  1742. LOCAL void bpIntAck
  1743.     (
  1744.     FAST BP_SOFTC *bs
  1745.     )
  1746.     {
  1747.     switch (bs->bs_intType)
  1748. {
  1749. case BP_INT_NONE:
  1751. case BP_INT_MAILBOX_1:
  1752. case BP_INT_MAILBOX_2:
  1753. case BP_INT_MAILBOX_4:
  1754. case BP_INT_MAILBOX_R1:
  1755. case BP_INT_MAILBOX_R2:
  1756. case BP_INT_MAILBOX_R4:
  1757.     break;
  1759. /* bus interrupt:
  1760.  *   arg1 = level
  1761.  *   arg2 = vector
  1762.  */
  1764. case BP_INT_BUS:
  1765.     sysBusIntAck (bs->bs_intArg1);
  1766.     break;
  1767. }
  1768.     }
  1769. #endif /* UNIX */
  1770. /*******************************************************************************
  1771. *
  1772. * bpConnect - connect to our backplane using the requested interrupt type
  1773. *
  1774. * RETURNS: OK or ERROR if interrupt type not supported
  1775. */
  1777. LOCAL STATUS bpConnect
  1778.     (
  1779.     FAST BP_SOFTC *bs,
  1780.     FAST int unit
  1781.     )
  1782.     {
  1783.     STATUS status;
  1785.     switch (bs->bs_intType)
  1786. {
  1787. case BP_INT_NONE:
  1788. /* no interprocessor interrupt - spawn background polling task */
  1790. #ifdef UNIX
  1791.     {
  1792.     static BOOL bpIsPolling = FALSE;
  1794.     if (!bpIsPolling)
  1795. {
  1796. bpIsPolling = TRUE;
  1797. timeout (bpPollUnix, (caddr_t)0, 1);
  1798. }
  1799.     status = OK;
  1800.     }
  1801. #else /* UNIX */
  1802.     bpPollTaskId = taskSpawn ("bpPollTask", bpPollTaskPriority,
  1803.       bpPollTaskOptions, bpPollTaskStackSize,
  1804.       (FUNCPTR) bpPollTask, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
  1806.     status = bpPollTaskId == ERROR ? ERROR : OK;
  1807. #endif /* UNIX */
  1809.     break;
  1811. case BP_INT_MAILBOX_1:
  1812. case BP_INT_MAILBOX_2:
  1813. case BP_INT_MAILBOX_4:
  1814. case BP_INT_MAILBOX_R1:
  1815. case BP_INT_MAILBOX_R2:
  1816. case BP_INT_MAILBOX_R4:
  1817. /* interrupt by mailbox (write to bus address):
  1818.  *   arg1 = bus address space
  1819.  *   arg2 = address
  1820.  *   arg3 = value
  1821.  */
  1823. #ifdef UNIX
  1824.     printf ("bp%d: bpConnect interrupt type not implementedn", unit);
  1825.     status = ERROR;
  1826. #else /* UNIX */
  1827.     status = sysMailboxConnect ((FUNCPTR)bpintr, unit);
  1828. #endif /* UNIX */
  1829.     break;
  1831. case BP_INT_BUS:
  1832. /* bus interrupt:
  1833.  *   arg1 = level
  1834.  *   arg2 = vector
  1835.  */
  1836. #ifdef UNIX
  1837.     status = OK;  /* nothing to do, done in kernel configuration */
  1838. #else /* UNIX */
  1839.     status = intConnect ((VOIDFUNCPTR *)INUM_TO_IVEC (bs->bs_intArg2), bpintr, unit);
  1840. #endif /* UNIX */
  1841.     break;
  1843. default:
  1844.     printf ("bp%d: bpConnect bad interrupt type: %dn",
  1845.     unit, bs->bs_intType);
  1846.     status = ERROR;
  1847.     break;
  1848. }
  1850.     return (status);
  1851.     }
  1852. /*******************************************************************************
  1853. *
  1854. * bpIntEnable - enable our backplane interrupt
  1855. *
  1856. * RETURNS: OK or ERROR
  1857. */
  1859. LOCAL STATUS bpIntEnable
  1860.     (
  1861.     FAST BP_SOFTC *bs
  1862.     )
  1863.     {
  1864.     STATUS status;
  1865.     int unit = bs->bs_if.if_unit;
  1867.     switch (bs->bs_intType)
  1868. {
  1869. case BP_INT_NONE:
  1870.     status = OK; /* no interrupt (polling) */
  1871.     break;
  1873. case BP_INT_MAILBOX_1:
  1874. case BP_INT_MAILBOX_2:
  1875. case BP_INT_MAILBOX_4:
  1876. case BP_INT_MAILBOX_R1:
  1877. case BP_INT_MAILBOX_R2:
  1878. case BP_INT_MAILBOX_R4:
  1879. /* interrupt by mailbox (write to bus address):
  1880.  *   arg1 = bus address space
  1881.  *   arg2 = address
  1882.  *   arg3 = value
  1883.  */
  1885. #ifdef UNIX
  1886.     status = ERROR;
  1887.     printf ("bp%d: bpIntEnable interrupt type 0x%x not implementedn",
  1888.     unit, bs->bs_intType);
  1889. #else /* UNIX */
  1890.     status = sysMailboxEnable ((char *) bs->bs_intArg2);
  1892.     if (status == ERROR)
  1893. printf ("bp%d: error enabling mailbox interrupt addr 0x%x.n",
  1894.   unit, bs->bs_intArg2);
  1895. #endif /* UNIX */
  1896.     break;
  1898. case BP_INT_BUS:
  1899. /* bus interrupt:
  1900.  *   arg1 = level
  1901.  *   arg2 = vector
  1902.  */
  1904. #ifdef UNIX
  1905.     status = OK;  /* nothing to do */
  1906. #else /* UNIX */
  1907.     status = sysIntEnable (bs->bs_intArg1);
  1908.     if (status == ERROR)
  1909. printf ("bp%d: error enabling bus interrupt level %d.n",
  1910.   unit, bs->bs_intArg1);
  1911. #endif /* UNIX */
  1912.     break;
  1914. default:
  1915.     printf ("bp%d: bpIntEnable bad interrupt type: %dn",
  1916.     unit, bs->bs_intType);
  1917.     status = ERROR;
  1918.     break;
  1919. }
  1921.     return (status);
  1922.     }
  1923. /*******************************************************************************
  1924. *
  1925. * bpIntGen - interrupt another CPU
  1926. */
  1928. LOCAL void bpIntGen
  1929.     (
  1930.     FAST CPU_DESC *pCpu,        /* ptr to descriptor of CPU to interrupt */
  1931.     int srcProcNum              /* our procNum on this network */
  1932.     )
  1933.     {
  1934.     char *pMailbox;
  1935.     int intType;
  1937.     /* if we're trying to interrupt ourself (a bad idea on some CPUs (is20))
  1938.      * simply invoke the interrupt handler */
  1940.     if (BP_NTOHL(pCpu->cd_cpuNum) == srcProcNum)
  1941. {
  1942. /* read input ring */
  1944. #ifdef UNIX
  1945. bpReadAll (pCpu->cd_unit);
  1946. #else /* UNIX */
  1947. (void) netJobAdd ((FUNCPTR)bpReadAll, pCpu->cd_unit, 0,0,0,0);
  1948. #endif /* UNIX */
  1949. return;
  1950. }
  1952.     switch (intType = BP_NTOHL(pCpu->cd_intType))
  1953. {
  1954. case BP_INT_NONE:
  1955.     /* no interrupt (CPU is polling) */
  1956.     break;
  1958. case BP_INT_MAILBOX_1:
  1959. case BP_INT_MAILBOX_R1:
  1960. /* interrupt by mailbox (read/write to bus address):
  1961.  *   arg1 = bus address space
  1962.  *   arg2 = address
  1963.  *   arg3 = value
  1964.  */
  1966.     if (sysBusToLocalAdrs (BP_NTOHL(pCpu->cd_intArg1),
  1967.    (char *) BP_NTOHL(pCpu->cd_intArg2),
  1968.    &pMailbox) == OK)
  1969. {
  1970. #ifdef UNIX
  1971. bpPoke (pMailbox, intType, BP_NTOHL(pCpu->cd_intArg3),
  1972. BP_NTOHL(pCpu->cd_cpuNum));
  1973. #else /* UNIX */
  1974. if (intType == BP_INT_MAILBOX_R1)
  1975.     bpBitBucket = * (char *)pMailbox;
  1976. else
  1977.     *pMailbox = BP_NTOHL(pCpu->cd_intArg3);
  1978. #endif /* UNIX */
  1979. }
  1980.     else
  1981. {
  1982. logMsg ("bp%d: bpIntGen bad mailbox interrupt, addr space = 0x%x, addr = 0x%xn",
  1983.      pCpu->cd_unit, BP_NTOHL(pCpu->cd_intArg1),
  1984.      BP_NTOHL(pCpu->cd_intArg2), 0,0,0);
  1985. }
  1986.     break;
  1988. case BP_INT_MAILBOX_2:
  1989. case BP_INT_MAILBOX_R2:
  1990.     if (sysBusToLocalAdrs (BP_NTOHL(pCpu->cd_intArg1),
  1991.    (char *) BP_NTOHL(pCpu->cd_intArg2),
  1992.    &pMailbox) == OK)
  1993. {
  1994. #ifdef UNIX
  1995. bpPoke (pMailbox, intType, BP_NTOHL(pCpu->cd_intArg3),
  1996. BP_NTOHL(pCpu->cd_cpuNum));
  1997. #else /* UNIX */
  1998. if (intType == BP_INT_MAILBOX_R2)
  1999.     bpBitBucket = * (short *)pMailbox;
  2000. else
  2001.     * (short *) pMailbox = BP_NTOHL(pCpu->cd_intArg3);
  2002. #endif /* UNIX */
  2003. }
  2004.     else
  2005. {
  2006. logMsg (
  2007.     "bp%d: bpIntGen bad mailbox interrupt, addr space = 0x%x, addr = 0x%xn",
  2008.      pCpu->cd_unit, BP_NTOHL(pCpu->cd_intArg1),
  2009.      BP_NTOHL(pCpu->cd_intArg2), 0, 0, 0);
  2010. }
  2011.     break;
  2013. case BP_INT_MAILBOX_4:
  2014. case BP_INT_MAILBOX_R4:
  2015.     if (sysBusToLocalAdrs (BP_NTOHL(pCpu->cd_intArg1),
  2016.    (char *) BP_NTOHL(pCpu->cd_intArg2),
  2017.    &pMailbox) == OK)
  2018. {
  2019. #ifdef UNIX
  2020. bpPoke (pMailbox, intType, BP_NTOHL(pCpu->cd_intArg3),
  2021. BP_NTOHL(pCpu->cd_cpuNum));
  2022. #else /* UNIX */
  2023. if (intType == BP_INT_MAILBOX_R4)
  2024.     bpBitBucket = * (long *)pMailbox;
  2025. else
  2026.     * (long *) pMailbox = BP_NTOHL(pCpu->cd_intArg3);
  2027. #endif /* UNIX */
  2028. }
  2029.     else
  2030. {
  2031. logMsg (
  2032.     "bp%d: bpIntGen bad mailbox interrupt, addr space = 0x%x, addr = 0x%xn",
  2033.      pCpu->cd_unit, BP_NTOHL(pCpu->cd_intArg1),
  2034.      BP_NTOHL(pCpu->cd_intArg2), 0, 0, 0);
  2035. }
  2036.     break;
  2039. case BP_INT_BUS:
  2040. /* bus interrupt:
  2041.  *   arg1 = level
  2042.  *   arg2 = vector
  2043.  */
  2045. #ifndef UNIX
  2046.     if (sysBusIntGen (BP_NTOHL(pCpu->cd_intArg1),
  2047. BP_NTOHL(pCpu->cd_intArg2)) == ERROR)
  2048. {
  2049. logMsg (
  2050. "bp%d: bpIntGen interrupt failed (level=%d vector=0x%x)n",
  2051.      pCpu->cd_unit, BP_NTOHL(pCpu->cd_intArg1),
  2052.      BP_NTOHL(pCpu->cd_intArg2), 0, 0, 0);
  2053. }
  2054.     break;
  2055. #endif /* UNIX */
  2056. /* UNIX drops through */
  2058. default:
  2059.     logMsg ("bp%d: bpIntGen bad interrupt type: proc = %d, type = %dn",
  2060.      pCpu->cd_unit, BP_NTOHL(pCpu->cd_cpuNum),
  2061.      intType, 0, 0, 0);
  2062.     break;
  2063. }
  2064.     }
  2065. #ifdef UNIX
  2066. /********************************************************************************
  2067. * sysBusToLocalAdrs - convert bus address to local address
  2068. *
  2069. * Given a VME memory address, this routine returns the local address
  2070. * that would have to be accessed to get to that byte.
  2071. *
  2072. * RETURNS: OK, or ERROR if the address space is unknown.
  2073. *
  2074. * SEE ALSO: sysLocalToBusAdrs()
  2075. *
  2076. * NOMANUAL
  2077. */
  2079. STATUS sysBusToLocalAdrs (adrsSpace, busAdrs, pLocalAdrs)
  2080.     int adrsSpace;      /* bus address space in which busAdrs resides,     */
  2081.                         /* use address modifier codes as defined in vme.h, */
  2082.                         /* such as VME_AM_STD_SUP_DATA                     */
  2083.     char *busAdrs;      /* bus address to convert                          */
  2084.     char **pLocalAdrs;  /* where to return local address                   */
  2086.     {
  2087.     switch (adrsSpace)
  2088.         {
  2089.         case VME_AM_SUP_SHORT_IO:
  2090.         case VME_AM_USR_SHORT_IO:
  2091.             *pLocalAdrs = (char *) (0xffff0000 | (int) busAdrs);
  2092.             return (OK);
  2094.         case VME_AM_STD_SUP_ASCENDING:
  2095.         case VME_AM_STD_SUP_PGM:
  2096.         case VME_AM_STD_SUP_DATA:
  2097.         case VME_AM_STD_USR_ASCENDING:
  2098.         case VME_AM_STD_USR_PGM:
  2099.         case VME_AM_STD_USR_DATA:
  2100.             *pLocalAdrs = (char *) (0xff000000 | (int) busAdrs);
  2101.             return (OK);
  2103.         case VME_AM_EXT_SUP_ASCENDING:
  2104.         case VME_AM_EXT_SUP_PGM:
  2105.         case VME_AM_EXT_SUP_DATA:
  2106.         case VME_AM_EXT_USR_ASCENDING:
  2107.         case VME_AM_EXT_USR_PGM:
  2108.         case VME_AM_EXT_USR_DATA:
  2109.             *pLocalAdrs = busAdrs; /* XXX check if on board memory? */
  2110.             return (OK);
  2112.         default:
  2113.             return (ERROR);
  2114.         }
  2115.     }
  2116. #endif /* UNIX */
  2117. /*******************************************************************************
  2118. *
  2119. * bpHeartbeat -
  2120. */
  2122. LOCAL void bpHeartbeat
  2123.     (
  2124.     FAST BP_ANCHOR *pAnchor
  2125.     )
  2126.     {
  2127.     pAnchor->an_heartbeat =
  2128. (UINT)BP_HTONL((UINT)BP_NTOHL(pAnchor->an_heartbeat) + 1);
  2130. #ifdef UNIX
  2131.     timeout (bpHeartbeat, (caddr_t) pAnchor, bpHeartbeatRate);
  2132. #else /* UNIX */
  2133.     wdStart (pAnchor->an_wdog, bpHeartbeatRate, (FUNCPTR) bpHeartbeat,
  2134.              (int) pAnchor);
  2135. #endif /* UNIX */
  2136.     }
  2137. /*******************************************************************************
  2138. *
  2139. * bpSizeMem - size shared memory pool
  2140. *
  2141. * RETURNS: amount of available memory
  2142. */
  2144. LOCAL int bpSizeMem
  2145.     (
  2146.     caddr_t memAdrs,    /* address of start of pool to start probing */
  2147.     int memSize         /* max size of memory pool */
  2148.     )
  2149.     {
  2150.     FAST int size;
  2152.     for (size = 0; size < memSize; size += 4096)
  2153. {
  2154. #ifdef UNIX
  2155.         if ((*bpProbeType) ((char *)(memAdrs + size), 0) == -1)
  2156. #else /* UNIX */
  2157. char bitBucket;
  2159. if (vxMemProbe (memAdrs + size, bpProbeType, 1, &bitBucket) != OK)
  2160. #endif /* UNIX */
  2161.     break;
  2162. }
  2164.     if (bpParity)
  2165. bzero (memAdrs, memSize);
  2167.     /* return the amount of memory found */
  2169.     return (size);
  2170.     }
  2171. /*******************************************************************************
  2172. *
  2173. * bpIoctl - process an ioctl request
  2174. *
  2175. * RETURNS: 0 if successful, errno otherwise (as per network requirements)
  2176. */
  2178. LOCAL int bpIoctl
  2179.     (
  2180.     FAST struct ifnet *pIf,
  2181.     int cmd,
  2182.     caddr_t data
  2183.     )
  2184.     {
  2185.     int error = 0;
  2186.     int unit  = pIf->if_unit;
  2187.     FAST BP_SOFTC *bs = BP_SOFTC_P [unit];
  2188.     int level = splimp ();
  2190.     switch (cmd)
  2191. {
  2192. case SIOCSIFADDR:
  2193. #ifdef UNIX
  2194.             error = set_if_addr (pIf, data, &bs->bs_enaddr);
  2195. #else /* UNIX */
  2196.             ((struct arpcom *)pIf)->ac_ipaddr = IA_SIN (data)->sin_addr;
  2197.             arpwhohas (pIf, &IA_SIN (data)->sin_addr);
  2198. #endif /* UNIX */
  2199.     break;
  2201. case SIOCGIFADDR:
  2202. #ifdef UNIX
  2203.     bcopy ((caddr_t) &bs->bs_enaddr,
  2204.   (caddr_t) &((struct ifreq *)data)->ifr_addr.sa_data[0],
  2205.   sizeof (struct ether_addr));
  2206. #else /* UNIX */
  2207.     bcopy ((caddr_t) bs->bs_enaddr,
  2208.   (caddr_t) &((struct ifreq *)data)->ifr_addr.sa_data[0],
  2209.   6);
  2210. #endif /* UNIX */
  2211.     break;
  2213.         case SIOCGIFFLAGS:
  2214.             *(short *)data = pIf->if_flags;
  2215.             break;
  2217.         case SIOCSIFFLAGS:
  2218.             {
  2219.             short flags = *(short *)data;
  2221.             /* Sanity check - make sure IFF_RUNNING and IFF_UP flags match. */
  2222.               
  2223.             if (pIf->if_flags & IFF_UP)
  2224.                 flags |= (IFF_UP|IFF_RUNNING);
  2225.             else
  2226.                 flags &= ~(IFF_UP|IFF_RUNNING);
  2228.             pIf->if_flags = flags;
  2229.     }
  2230. break;
  2232. default:
  2233.     printf ("bp%d: ioctl 0x%x not implementedn", unit, cmd);
  2234.     error = EINVAL;
  2235.     break;
  2236. }
  2238.     (void) splx (level);
  2239.     return (error);
  2240.     }
  2242. /*******************************************************************************
  2243. *
  2244. * ringinit -
  2245. *
  2246. * Initialize the ring pointed to by "rp" to contain "size" slots.
  2247. * The ring is set up to be empty and unlocked.
  2248. * Size had better be a power of 2!
  2249. */
  2251. LOCAL void ringinit
  2252.     (
  2253.     FAST RING *rp,
  2254.     short size
  2255.     )
  2256.     {
  2257.     rp->r_tas = rp->r_rdidx = rp->r_wrtidx = 0;
  2258.     rp->r_size = BP_HTONS(size);
  2259.     }
  2260. /*******************************************************************************
  2261. *
  2262. * ringput -
  2263. *
  2264. * Add a new entry "v" to the ring "rp".
  2265. * Returns 0 if ring was full, else the new number of entries in the ring.
  2266. * Uses test-and-set routine, allowing multi-processor interlocked access
  2267. * to the ring IF the ring is in VME memory.
  2268. * Masks all interrupts, in order to prevent reentrancy and to
  2269. * minimize ring lockout.
  2270. *
  2271. * RETURNS: new number of entries, or 0 if ring was full
  2272. */
  2274. LOCAL int ringput
  2275.     (
  2276.     FAST RING *rp,
  2277.     int v
  2278.     )
  2279.     {
  2280.     FAST int x = DELAY_COUNT; /* don't wait forever for lock */
  2281.     FAST int s;
  2283.     for (;;)
  2284. {
  2285. /* disable interrupts, then lock the ring */
  2286. s = intLock ();
  2287. if (TAS(&rp->r_tas))
  2288.     break;
  2289. intUnlock (s);
  2291. if (--x == 0)
  2292.     return (0); /* ring is stuck! */
  2293. }
  2295.     if ((x = (BP_NTOHS(rp->r_wrtidx) + 1) &
  2296.     (BP_NTOHS(rp->r_size) - 1)) != BP_NTOHS(rp->r_rdidx))
  2297. {
  2298. rp->r_slot[BP_NTOHS(rp->r_wrtidx)] = v;
  2299. rp->r_wrtidx = BP_HTONS(x);
  2300. } /* if x == rdidx then ring is full */
  2302.     if ((x -= BP_NTOHS(rp->r_rdidx)) < 0)
  2303. x += BP_NTOHS(rp->r_size);
  2305. #if     (CPU_FAMILY==MIPS)
  2306.     TAS_CLEAR(rp->r_tas);               /* unlock ring */
  2307. #else   /* CPU_FAMILY==MIPS */
  2308.     rp->r_tas = 0;                      /* unlock ring */
  2309. #endif  /* CPU_FAMILY==MIPS */
  2312.     intUnlock (s);
  2314.     return (x);
  2315.     }
  2316. /*******************************************************************************
  2317. *
  2318. * ringget -
  2319. *
  2320. * Extract next entry from the ring "rp".
  2321. * Uses test-and-set routine, allowing multi-processor interlocked access
  2322. * to the ring IF the ring is in VME memory.
  2323. * Masks all interrupts, in order to prevent reentrancy and to
  2324. * minimize ring lockout.
  2325. *
  2326. * RETURNS: 0 if ring is empty, else the extracted entry
  2327. */
  2329. LOCAL int ringget
  2330.     (
  2331.     FAST RING *rp
  2332.     )
  2333.     {
  2334.     FAST int x = DELAY_COUNT; /* don't wait forever for lock */
  2335.     FAST int s;
  2337.     for (;;)
  2338. {
  2339. /* disable interrupts, then lock the ring */
  2340. s = intLock ();
  2341. if (TAS(&rp->r_tas))
  2342.     break;
  2343. intUnlock (s);
  2345. if (--x == 0)
  2346.     return (0); /* ring is stuck! */
  2347. }
  2349.     if (rp->r_rdidx != rp->r_wrtidx)
  2350. {
  2351. x = rp->r_slot[BP_NTOHS(rp->r_rdidx)];
  2352. rp->r_rdidx = BP_HTONS(
  2353. (BP_NTOHS(rp->r_rdidx) + 1) & (BP_NTOHS(rp->r_size) - 1));
  2354. }
  2355.     else
  2356. x = 0;
  2358. #if     (CPU_FAMILY==MIPS)
  2359.     TAS_CLEAR(rp->r_tas);               /* unlock ring */
  2360. #else   /* CPU_FAMILY==MIPS */
  2361.     rp->r_tas = 0;                      /* unlock ring */
  2362. #endif  /* CPU_FAMILY==MIPS */
  2365.     intUnlock (s);
  2367.     return (x);
  2368.     }
  2369. /******************************************************************************
  2370. *
  2371. * ringcount - get number of entries in ring
  2372. */
  2374. LOCAL int ringcount
  2375.     (
  2376.     FAST RING *pRing
  2377.     )
  2378.     {
  2379.     int n = BP_NTOHS(pRing->r_wrtidx) - BP_NTOHS(pRing->r_rdidx);
  2381.     if (n < 0)
  2382. n += BP_NTOHS(pRing->r_size);
  2384.     return (n);
  2385.     }
  2386. /********************************************************************************
  2387. * vxTasac - test-and-set-and-check
  2388. *
  2389. * This routine provides quick and dirty test and set when hardware isn't up to
  2390. * the tas.
  2391. *
  2392. * RETURNS:
  2393. *   TRUE if value had been not set (but now is),
  2394. *   FALSE if value was already set.
  2395. */
  2397. LOCAL BOOL vxTasac
  2398.     (
  2399.     FAST char *address          /* address to be tested */
  2400.     )
  2401.     {
  2402.     FAST int tasWait = 10;
  2403.     FAST int count;
  2404.     FAST int value = 0x80 + sysProcNumGet ();
  2405.     int oldLevel = intLock ();
  2407.     /* check for lock available */
  2409.     if (*address != 0)
  2410.         {
  2411.         intUnlock (oldLevel);
  2412.         return (FALSE);
  2413.         }
  2415.     /* lock available - take it */
  2417.     *address = value;
  2419.     /* check that we got it and nobody stepped on it, several times */
  2421.     for (count = 0; count < tasWait; count++)
  2422.         {
  2423.         if (* (unsigned char *) address != value)
  2424.             {
  2425.             intUnlock (oldLevel);
  2426.             return (FALSE);
  2427.             }
  2428.         }
  2430.     intUnlock (oldLevel);
  2431.     return (TRUE);
  2432.     }
  2433. /*******************************************************************************
  2434. *
  2435. * bpShow - display information about the backplane network
  2436. *
  2437. * This routine shows information about the different CPUs configured
  2438. * in the backplane network.
  2439. *
  2440. * EXAMPLE
  2441. * .CS
  2442. *     -> bpShow
  2443. *     Anchor at 0x800000
  2444. *     heartbeat = 705, header at 0x800010, free pkts = 237.
  2445. *
  2446. *     cpu int type    arg1       arg2       arg3    queued pkts rd index
  2447. *     --- -------- ---------- ---------- ---------- ----------- --------
  2448. *      0  poll            0x0        0x0        0x0       0        27
  2449. *      1  poll            0x0        0x0        0x0       0        11
  2450. *      2  bus-int         0x3       0xc9        0x0       0        9
  2451. *      3  mbox-2         0x2d     0x8000        0x0       0        1
  2452. *
  2453. *     input packets = 192     output packets = 164
  2454. *     output errors = 0       collisions = 0
  2455. *     value = 1 = 0x1
  2456. * .CE
  2457. *
  2458. * RETURNS: N/A
  2459. */
  2461. void bpShow
  2462.     (
  2463.     char *bpName,       /* backplane interface name (NULL == "bp0") */
  2464.     BOOL zero           /* TRUE = zap totals */
  2465.     )
  2466.     {
  2467.     FAST BP_SOFTC *bs;
  2468.     FAST BP_ANCHOR *pAnchor;
  2469.     FAST BP_HEADER *pHdr;
  2470.     FAST CPU_DESC *pCpu;
  2471.     RING *pRing;
  2472.     FAST int cpuNum;
  2474.     /* use "bp0" if no interface name specified */
  2476.     if (bpName == NULL)
  2477. bpName = "bp0";
  2479.     /* get pointer to interface descriptor */
  2481.     if ((bs = (BP_SOFTC *) ifunit (bpName)) == NULL)
  2482. {
  2483. printf ("interface %s not attached.n", bpName);
  2484. return;
  2485. }
  2487.     /* check validity of anchor */
  2489.     pAnchor = bs->bs_pAnchor;
  2491.     printf ("Anchor at 0x%x", (int)pAnchor);
  2492. #ifdef UNIX
  2493.     if (peek ((short *)pAnchor) == -1)
  2494. #else /* UNIX */
  2495.     if (vxMemProbe ((char *) pAnchor, O_RDONLY, 4, (char *) &bpBitBucket) != OK)
  2496. #endif /* UNIX */
  2497. {
  2498. printf (", UNREADABLEn");
  2499. return;
  2500. }
  2502.     if (BP_NTOHL(pAnchor->an_ready) != BP_READY)
  2503. {
  2504. if (BP_NTOHL(pAnchor->an_ready) == BP_READY_SOFT_TAS)
  2505.     printf (", SOFT TASn");
  2506. else
  2507.     {
  2508.     printf (", UNINITIALIZEDn");
  2509.     return;
  2510.     }
  2511. }
  2513.     if (bpAlive (bs) == ERROR)
  2514. {
  2515. printf (", NO HEARTBEATn");
  2516. return;
  2517. }
  2520.     /* anchor valid - print out anchor and header info */
  2522.     pHdr = ItoKval (((BP_ANCHOR *)pAnchor)->an_pHdr, BP_HEADER *, pAnchor);
  2524.     printf (" heartbeat = %d, header at 0x%x, free pkts = %d.nn",
  2525.     (int)BP_NTOHL(pAnchor->an_heartbeat),
  2526.     (int)pHdr, ringcount ((RING *)(bs->bs_pFreeRing)));
  2529.     /* print out info for each CPU */
  2531.     printf (
  2532. "cpu int type    arg1       arg2       arg3    queued pkts rd indexn");
  2533.     printf (
  2534. "--- -------- ---------- ---------- ---------- ----------- --------n");
  2536.     for (cpuNum = 0; cpuNum < MAXCPU; ++cpuNum)
  2537. {
  2538. pCpu = &pHdr->hdr_cpuDesc[cpuNum];
  2540. if (pCpu->cd_active)
  2541.     {
  2542.     printf ("%2d  ", cpuNum);
  2544.     switch (BP_NTOHL(pCpu->cd_intType))
  2545. {
  2546. case BP_INT_NONE: printf ("poll    "); break;
  2547. case BP_INT_MAILBOX_1: printf ("mbox-1  "); break;
  2548. case BP_INT_MAILBOX_2: printf ("mbox-2  "); break;
  2549. case BP_INT_MAILBOX_4: printf ("mbox-4  "); break;
  2550. case BP_INT_MAILBOX_R1: printf ("mbox-1r "); break;
  2551. case BP_INT_MAILBOX_R2: printf ("mbox-2r "); break;
  2552. case BP_INT_MAILBOX_R4: printf ("mbox-4r "); break;
  2553. case BP_INT_BUS: printf ("bus-int "); break;
  2554. default:
  2555. printf ("%#8x",BP_NTOHL(pCpu->cd_intType));
  2556. break;
  2557. }
  2559.     printf (" %#10x %#10x %#10x",
  2560.     BP_NTOHL(pCpu->cd_intArg1),
  2561.     BP_NTOHL(pCpu->cd_intArg2),
  2562.     BP_NTOHL(pCpu->cd_intArg3));
  2564.     pRing = ItoKval (pCpu->cd_pInputRing, RING *, pAnchor);
  2565.     printf ("     %3d       %3dn", ringcount (pRing), BP_NTOHS(pRing->r_rdidx));
  2566.     }
  2567. }
  2569.     printf ("ninput packets = %3ld  ", bs->bs_if.if_ipackets);
  2570.     if (zero)
  2571. bs->bs_if.if_ipackets = 0;
  2573.     printf ("output packets = %3ldn", bs->bs_if.if_opackets);
  2574.     if (zero)
  2575. bs->bs_if.if_opackets = 0;
  2577.     printf ("output errors = %3ld  ", bs->bs_if.if_oerrors);
  2578.     if (zero)
  2579. bs->bs_if.if_oerrors = 0;
  2581.     printf ("collisions     = %3ldn", bs->bs_if.if_collisions);
  2582.     if (zero)
  2583. bs->bs_if.if_collisions = 0;
  2584.     }
  2585. #ifndef UNIX
  2586. /******************************************************************************
  2587. *
  2588. * bpSlotCheck - check if a CPU is being serviced by a backplane unit
  2589. *
  2590. * This routine can be used on a backplane master CPU to find out
  2591. * if a particular slave CPU is being serviced by a particular
  2592. * backplane device unit.
  2593. *
  2594. * NOMANUAL
  2595. */
  2597. BOOL bpSlotCheck
  2598.     (
  2599.     int unit,                   /* backplane device unit */
  2600.     int slot                    /* CPU number  */
  2601.     )
  2602.     {
  2603.     FAST BP_SOFTC  *bs;
  2604.     FAST BP_ANCHOR *pAnchor;
  2605.     FAST BP_HEADER *pHdr;
  2606.     FAST CPU_DESC  *pCpu;
  2607.     char    devName [10];
  2609.     sprintf (devName, "bp%d", unit);
  2611.     bs = (BP_SOFTC *) ifunit (devName);
  2613.     if (bs == NULL)
  2614.         return (FALSE);
  2616.     pAnchor = bs->bs_pAnchor;
  2618.     if (vxMemProbe ((char *) pAnchor, O_RDONLY, 4, (char *) &bpBitBucket) != OK)
  2619.         return (FALSE);
  2621.     if (BP_NTOHL(pAnchor->an_ready) != BP_READY &&
  2622. BP_NTOHL(pAnchor->an_ready) != BP_READY_SOFT_TAS)
  2623.         return (FALSE);
  2625.     pHdr = ItoKval (((BP_ANCHOR *)pAnchor)->an_pHdr, BP_HEADER *, pAnchor);
  2626.     pCpu = &pHdr->hdr_cpuDesc [slot];
  2628.     if (pCpu->cd_active)
  2629.         return (TRUE);
  2631.     return (FALSE);
  2632.     }
  2633. #endif