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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
sysLib.c
资源名称：bcm4702.rar　[点击查看]
上传用户：yuanda199
上传日期：2022-06-26
资源大小：412k
文件大小：50k
源码类别：

VxWorks

开发平台：

C/C++

sysLib.c：源码内容
  1. /*
  2.     Copyright 2001, Broadcom Corporation
  3.     All Rights Reserved.
  4.     
  5.     This is UNPUBLISHED PROPRIETARY SOURCE CODE of Broadcom Corporation;
  6.     the contents of this file may not be disclosed to third parties, copied or
  7.     duplicated in any form, in whole or in part, without the prior written
  8.     permission of Broadcom Corporation.
  9. */
  10.  
  11. /* sysLib.c - BCM 4702 system-dependent routines */
  13. /*
  14. modification history
  15. --------------------
  16. 01e,24sep02,jmb   send XON to serial port.  
  17. 01d,06sep02,jmb   remove single PCI interrupt hack.  Use VxWorks shared PCI
  18.                   interrupt handler.  Scan for secondary PCI bridges.
  19. 01c,15aug02,jmb   pciIntConnect for single PCI interrupt
  20. 01b,14aug02,jmb   stubbed out sysBusTas for vxMemProbe
  21. 01a,30jul02,jmb   created from sysLib.c,v 1.33 for HNBU 4710 eval board.  Merged
  22.                   in code from Strata idtrp334 BSP.
  23. */
  25. /*
  26. DESCRIPTION
  27. This library provides board-specific routines.
  30. INCLUDE FILES: sysLib.h
  32. SEE ALSO:
  33. .pG "Configuration"
  34. */
  36. /* includes */
  38. #include "vxWorks.h"
  39. #include "vxLib.h"
  40. #include "config.h"
  41. #include "version.h"
  42. #include "ioLib.h"
  43. #include "tyLib.h"
  44. #include "sysLib.h"
  45. #include "dosFsLib.h"
  46. #include "string.h"
  47. #include "intLib.h"
  48. #include "muxLib.h"
  49. #include "ipProto.h"
  50. #include "ifLib.h"
  51. #include "tickLib.h"
  52. #include "cacheLib.h"
  53. #include "symLib.h"
  54. #include "rebootLib.h"
  55. #include "stdio.h"
  56. #include "hnbutypedefs.h"
  57. #include "sbconfig.h"
  58. #include "bcmenet47xx.h"
  59. #include "vxbsp.h"
  60. #include "sb2pci.h"
  61. #include "drv/pci/pciConfigLib.h"
  62. #include "vx_osl.h"
  63. #include "vxbsp.h"
  64. #include "sbextif.h"
  65. #include "m48t59y.h"
  66. #include "ds1743.h"
  67. #include "netinet/in.h"         /* for sysBindFix() */
  68. #include "sockLib.h"            /* for sysBindFix() */
  69. #include "mem/byteNvRam.c"
  70.  
  71. static bcmenetregs_t *timerregs = NULL;
  73. IMPORT void     sysWbFlush ();
  74. IMPORT ULONG    taskSRInit();
  75. IMPORT int      sysSetCompare ();
  76. IMPORT int      sysGetCompare ();
  77. IMPORT int      sysGetPrid ();
  78. IMPORT int      sysGetCount ();
  79. IMPORT int      sysSetCount ();
  80. IMPORT int      printf (const char *, ...);
  81. IMPORT int      isprint (char);
  83. IMPORT UCHAR    sysinbyte(ULONG address);
  84. IMPORT USHORT   sysinword(ULONG address);
  85. IMPORT ULONG    sysinlong( ULONG address);
  86. IMPORT void     sysoutlong(ULONG address, ULONG datavalue);
  87. IMPORT void     sysoutword(ULONG address, USHORT datavalue);
  88. IMPORT void     sysoutbyte(ULONG address, UCHAR data);
  90. IMPORT void     platform_init();
  91. IMPORT uint32   get_sb_extif_tpsflag();
  93. IMPORT UINT8    ffsMsbTbl[];            /* Msb high interrupt hash table */
  94. IMPORT UINT8    ffsLsbTbl[];            /* Lsb high interrupt hash table */
  96. IMPORT int              consoleFd;              /* klmod: fd of initial console device */
  97. IMPORT int     pciMaxBus;
  99. IMPORT STATUS usrBootLineCrack(char * bootString,BOOT_PARAMS *pParams);
  101. /* globals */
  102. int   sysCpu      = CPU;                /* system CPU type (MIPS_RC32364) */
  103. char *sysMemTopAdr= NULL;               /* top of memory */
  104. char *sysBootLine = BOOT_LINE_ADRS;     /* address of boot line */
  105. char *sysExcMsg   = EXC_MSG_ADRS;       /* catastrophic message area */
  106. int   sysProcNum;                       /* processor number of this CPU */
  107. int   sysFlags;                         /* boot flags */
  108. char  sysBootHost [BOOT_FIELD_LEN];     /* name of host from which we booted */
  109. char  sysBootFile [BOOT_FIELD_LEN];     /* name of file from which we booted */
  110. int   sysVectorIRQ0 =IV_IORQ0_VEC;      /* used by SAL for pci int connect */
  111. int   sysMemTopDebug = 0;
  112. ULONG sysSoftCompare = 0;               /* last target compare reg value */
  114. /*
  115. *  Since tying interrupt lines to the processor is board dependent sysHashOrder
  116. *  is provided to select the prioritization of interrupt lines.  Setting the
  117. *  #define INT_PRIO_MSB to TRUE prioritizes interrupts from 7-0, 7 being
  118. *  highest priority, 0 being lowest.  Setting it to FALSE prioritizes
  119. *  interrupts from 0-7.  See idts134.h for the definition of INT_PRIO_MSB.
  120. */
  122. #if INT_PRIO_MSB == TRUE
  123. UINT8 * sysHashOrder = ffsMsbTbl;       /* interrupt prio., 7 = high 0 = low */
  124. #else   /* INT_PRIO_MSB == TRUE */
  125. UINT8 * sysHashOrder = ffsLsbTbl;       /* interrupt prio., 0 = high 7 = low */
  126. #endif  /* INT_PRIO_MSB == TRUE */
  128. /* forward declarations */
  129. STATUS sysEnetAddrGet (char *dev, int unit, unsigned char *pMac);
  131. LOCAL void      sysClkInt ();
  132. LOCAL int       sysSw0Ack ();
  133. LOCAL int       sysSw1Ack ();
  135. typedef struct 
  136.     {
  137.     ULONG       intCause;               /* cause of interrupt   */
  138.     ULONG       bsrTableOffset;         /* index to BSR table   */
  139.     ULONG       statusReg;              /* interrupt level      */
  140.     ULONG       pad;                    /* pad for ease of use  */
  141.     } PRIO_TABLE;
  143. /*
  144. *       intPrioTable is a board dependant structure that aids in the
  145. *       processing of the 8 Rc32364 interrupt conditions.
  146. *       It is used by excLib to determine the pending interrupt and
  147. *       to call the user attached handler.  The present search algorithm
  148. *       relies on a one to one mapping of Rc32364 interrupt lines and
  149. *       table entries.
  150. *
  151. *       Each entry has 4 fields, the first (intCause) is the interrupt ID, 
  152. *       second (bsrTableOffset) is the vector number, third is unused
  153. *       last (pad) is the multiplex field.  When an interrupt is received
  154. *       the handler maps the pending Rc32364 line to  its' corresponding
  155. *       table entry (ie. Software interrupt 0 would map to the first entry
  156. *       in the table).  At this point interrupts that are not pending are
  157. *       enabled.  Next the multiplex field is read, if it is zero, field 
  158. *       two is taken as the interrupt vector number in the BSR table, 
  159. *       otherwise it is interpreted as a demultiplex function and called
  160. *       with field 4 passed as it's parameter.  The job of the demultiplex
  161. *       routine is to calculate the correct interrupt vector number and pass
  162. *       it back to the handler.  The handler can then call the routine the
  163. *       user has installed in the BSR table with intVecSet, or intConnect.
  164. *
  165. *       This table is critical to interrupt processing.  Do not alter
  166. *       it's contents until you understand the consequences.  The routine
  167. *       sysPrioUpdate can aid modification during runtime.
  168. */
  170. PRIO_TABLE intPrioTable[8] =
  171.     {
  172.     {CAUSE_SW1,(ULONG) IV_SWTRAP0_VEC, 0x0100, 0},      /* sw trap 0      */
  173.     {CAUSE_SW2,(ULONG) IV_SWTRAP1_VEC, 0x0200, 0},      /* sw trap 1      */
  174.     {CAUSE_IP3,(ULONG) INT_VEC_IORQ0 , 0x0400, 0},              
  175.     {CAUSE_IP4,(ULONG) INT_VEC_IORQ1 , 0x0800, 0},      
  176.     {CAUSE_IP5,(ULONG) INT_VEC_IORQ2 , 0x1000, 0},      
  177.     {CAUSE_IP6,(ULONG) INT_VEC_IORQ3 , 0x2000, 0},      
  178.     {CAUSE_IP7,(ULONG) INT_VEC_IORQ4 , 0x4000, 0},      
  179.     {CAUSE_IP8,(ULONG) INT_VEC_IORQ5 , 0x8000, 0}       
  180.     };
  183. typedef struct _systodfunctions
  184.     {
  185.     FUNCPTR init;
  186.     FUNCPTR get;
  187.     FUNCPTR set;
  188.     FUNCPTR getSecond;
  189.     FUNCPTR watchdogArm;
  190.     } SYSTODFUNCTIONS;
  192. SYSTODFUNCTIONS sysTodFuncs;
  194. int sysRevId;
  195. VOIDFUNCPTR bringupPrintRtn = NULL;
  197. /* select cache library */
  199. IMPORT STATUS cacheBcm47xxLibInit(CACHE_MODE,CACHE_MODE);
  200. FUNCPTR sysCacheLibInit = (FUNCPTR)cacheBcm47xxLibInit; 
  202. /* locals */
  203. LOCAL int   sysClkTicksPerSecond    = 100;      /* default sys timer rate    */
  204. LOCAL int   sysClkArg               = 0;        /* clock int routine arg     */
  205. LOCAL BOOL  sysClkConnected         = FALSE;    /* sys clock connect flag    */
  206. LOCAL BOOL  sysClkRunning           = FALSE;    /* sys clock enabled flag    */
  207. LOCAL int   sysClkProcessorTicks;               /* MIPS32 clock ticks        */
  208. LOCAL FUNCPTR   sysClkRoutine       = NULL ;    /* clock interrupt routine   */
  209. LOCAL char sysModelStr[200];
  211. /* Commenting out sysAuxClkRoutines and defines as its not supported. However
  212.    the auxiliary clock can be generated by using one of the three general 
  213.    purpose timers of Rc32134 */                                           
  214. LOCAL BOOL  sysAuxClkRunning        = FALSE;     /*sys aux clock enabled flag */
  215. LOCAL BOOL  sysAuxClkConnected      = FALSE;     /*sys aux clock connect flag */
  216. LOCAL int   sysAuxClkTicksPerSecond = 200;       /* default aux timer rate    */
  217. LOCAL int   sysAuxClkArg            = 0 ;        /*aux clock int routine arg  */
  218. LOCAL FUNCPTR   sysAuxClkRoutine    = NULL ;     /*aux clock interpt routine  */
  220. #ifdef INCLUDE_TIMESTAMP
  221. LOCAL BOOL  sysTimestampRunning     = FALSE;   /* timestamp running flag */
  222. #endif  /* INCLUDE_TIMESTAMP */
  224. #ifdef INCLUDE_NETWORK
  225. #ifdef INCLUDE_END
  226. #if (defined(INCLUDE_ET0_END) || defined(INCLUDE_ET1_END))
  227. #include "sysEtEnd.c"
  228. #endif /* INCLUDE_ET_END */
  229. #endif /* INCLUDE_END */
  230. #endif  /* INCLUDE_NETWORK */
  233. /*
  234.  * Tell if a buffer contains a valid ansiTime time zone specification
  235.  */
  236. int sysTimeZoneGood(char *tz)
  237. {
  238.     int                 i, colons = 0;
  240.     for (i = 0; i < 64; i++) {
  241.         if (tz[i] == 0 || tz[i] == 10 || tz[i] == 13) {
  242.             tz[i] = 0;
  243.             break;
  244.         }
  245.         if (tz[i] < 32 || (tz[i] & 0x80))
  246.             return 0;
  247.         if (tz[i] == ':')
  248.             colons++;
  249.     }
  251.     return (i < 64 && colons == 4);
  252. }
  255. /*******************************************************************************
  256. *
  257. * sysModel - return the model name of the CPU board
  258. *
  259. * This routine returns the model name of the CPU board.
  260. *
  261. * RETURNS: A pointer to the string "IDT S134".
  262. */
  264. char *sysModel (void)
  265.     {
  266.     strcpy (sysModelStr, "BCM4702 (MIPS32)n");
  267.     strcat (sysModelStr, "Board:  MBZn");
  268.     return (sysModelStr);
  269.     }
  272. /******************************************************************************
  273. *
  274. * sysBspRev - return the bsp version with the revision eg 1.1/<x>
  275. *
  276. * This function returns a pointer to a bsp version with the revision.
  277. * for eg. 1.1/<x>. BSP_REV is concatanated to BSP_VERSION to form the
  278. * BSP identification string.
  279. *
  280. * RETURNS: A pointer to the BSP version/revision string.
  281. */
  283. char * sysBspRev (void)
  284.     {
  285.     return (BSP_VERSION BSP_REV);
  286.     }
  288. /*****************************************************************************
  289. *
  290. * Each time VxWorks is rebooted, it starts assigning system-assigned
  291. * port numbers beginning at 1024.  Thus, if vxWorks is rebooted two or
  292. * more times in succession, the same port number will be re-used.
  293. *
  294. * This behavior causes problems when vxWorks is being booted from a
  295. * remote FTP server (particularly one running Solaris), because port
  296. * 1024 goes into a TIME_WAIT state on the server and cannot be reused
  297. * until it times out, typically in 2-4 minutes.
  298. *
  299. * This hack reduces the likelihood of this happening by "wasting"
  300. * a different number of system-assigned port numbers for each boot.
  301. */
  303. void sysBindFix(void)
  304. {
  305.     UINT8               N;
  307.     BPRINT("BFIX");
  308.     sysNvRamGet((char *) &N, 1, NV_OFF_BINDFIX);
  309.     N -= 16;
  310.     sysNvRamSet((char *) &N, 1, NV_OFF_BINDFIX);
  312.     /* This is quite fast even when N=255 */
  314.     while (N--) {
  315.         int s;
  316.         struct sockaddr_in saddr;
  317.         saddr.sin_addr.s_addr = htonl(INADDR_ANY);
  318.         saddr.sin_port = 0;
  319.         saddr.sin_family = AF_INET;
  320.         s = socket(AF_INET, SOCK_STREAM, 0);
  321.         bind(s, (struct sockaddr *) &saddr, sizeof(saddr));
  322.         close(s);
  323.     }
  324. }
  326. /*******************************************************************************
  327. *
  328. * sysHwInit - initialize the CPU board hardware
  329. *
  330. * This routine initializes various features of the IDT S364.
  331. * It is called from usrInit() in usrConfig.c.
  332. *
  333. * This routine initializes and turns off the timers.
  334. *
  335. * NOTE:
  336. * This routine should not be called directly by the user.
  337. * 
  338. * RETURNS: N/A
  339. */
  341. void sysHwInit (void)
  342.     {
  343.     int prid;
  344.     int sr;
  345.     char xonString[3];
  347.     prid = sysGetPrid ();       /* get the BCM47xx processor ID register */
  348.     
  349.     /* set default task status register for BCM47xx */
  350.     sr = BCM47XX_SR;
  352.     sysRevId = SYS_REVID_GET();
  354.     /* Initialize TOD functions */
  356.     switch(sysRevId) {
  357.         case BOARD_ID_MBZ_1:
  358.             sysTodFuncs.init = (FUNCPTR) m48_tod_init;
  359.             sysTodFuncs.get = (FUNCPTR) m48_tod_get;
  360.             sysTodFuncs.set = (FUNCPTR) m48_tod_set;
  361.             sysTodFuncs.getSecond =  (FUNCPTR) m48_tod_get_second;
  362.             sysTodFuncs.watchdogArm = (FUNCPTR) m48_watchdog_arm;
  363.             break;
  364.         /* case BOARD_ID_LM_1_32MB:*/
  365.         case BOARD_ID_MBZ_32MB:
  366.         case BOARD_ID_LM_1:
  367.         case BOARD_ID_MBZ_2:
  368.         case BOARD_ID_MBZ_5645_REF:
  369.         default:
  370.             sysTodFuncs.init = (FUNCPTR) ds1743_tod_init;
  371.             sysTodFuncs.get = (FUNCPTR) ds1743_tod_get;
  372.             sysTodFuncs.set = (FUNCPTR) ds1743_tod_set;
  373.             sysTodFuncs.getSecond = (FUNCPTR) ds1743_tod_get_second;
  374.             sysTodFuncs.watchdogArm = (FUNCPTR) NULL;
  375.             break;
  376.     }
  378.     /* init status register but leave interrupts disabled */
  379.     taskSRInit (sr);
  380.     intSRSet (sr & ~SR_IE);
  382.     BPRINT ("HWOK");
  383.     }
  385. /*******************************************************************************
  386. *
  387. * sharedInt0: checks to see which interrupts are connected to 0 and calls each
  388. * in turn.
  389. *
  390. *******************************************************************************/
  392. LOCAL void sharedInt0 (void)
  393. {
  394.     unsigned long index=0x40;
  395.     unsigned long intNum = IV_IORQ0_BIT6_VEC; 
  396.     FUNCPTR  intVec;
  397.     
  398.     if (!DEF_SBINTVEC) 
  399. return;
  401.     while(index) {       
  402. /* is interrupt enabled*/
  403. if(index & DEF_SBINTVEC) {
  404.     /* Get the interrupt vector */
  405.     intVec = intVecGet((FUNCPTR*)INUM_TO_IVEC(intNum--));
  406.     
  407.     /* if non null then call the interrupt handler */
  408.     if(intVec) (intVec)();
  410.     /* If ext/if interrupt then call an additional two possible handlers */
  411.     if(index & (1 << get_sb_extif_tpsflag())) {
  412.      intVec = intVecGet((FUNCPTR*)INUM_TO_IVEC(IV_EXT_ALT1_VEC));
  413.      if(intVec) (intVec)();
  414.      intVec = intVecGet((FUNCPTR*)INUM_TO_IVEC(IV_EXT_ALT2_VEC));
  415.      if(intVec) (intVec)();
  416. #ifdef INCLUDE_PCMCIA
  417. intVec = intVecGet((FUNCPTR*)INUM_TO_IVEC(IV_EXT_ALT3_VEC));
  418.      if(intVec) (intVec)();
  419.      intVec = intVecGet((FUNCPTR*)INUM_TO_IVEC(IV_EXT_ALT4_VEC));
  420.      if(intVec) (intVec)();
  421. #endif
  422.     }                
  423. }
  425. /* check next interrupt */ 
  426. index = index >> 1; 
  427.     }
  429. }
  431. /******************************************************************************
  432. *
  433. * sysHwInit2 - additional system configuration and initialization
  434. *
  435. * This routine connects system interrupts and does any additional
  436. * configuration necessary.
  437. *
  438. * RETURNS: N/A
  439. *
  440. * NOMANUAL
  441. */
  443. static void dummyISR(void) {
  444.     /* do nothing */
  445.     return;
  446. }
  448. void sysHwInit2 (void)
  449. {
  450.     int sr,i;
  451.     char xonString[3];
  453.     sr = intSRGet();
  454.     BPRINT ("PCI ");
  456. #ifdef INCLUDE_PCI
  457.     /* this routine is also responsible for resetting any devices that may
  458.        currently be in an active state and sets up the interrupt mappings */
  460.     pciConfigLibInit(0,0,0,0);
  462.     /*
  463.     * Probe for secondary bridge devices.  The 4702 supports 2 PCI devices
  464.     * connected directly to the host PCI bus.
  465.     * One or both of these devices may be PCI bridges to other buses.
  466.     * Bridges on secondary buses is not supported.
  467.     *
  468.     * Args to the bridge probe function are:
  469.     * (instance, primary busNo, secondary busNo, subordinate busNo)
  470.     * For 4702, the bus numbering is non-standard.  HNBU software has
  471.     * coopted bus number 0 for the silicon backplane, so PCI bus numbering
  472.     * starts at 1.
  473.     *
  474.     */
  476. #endif
  478.     BPRINT ("TOD ");
  479.     /* Start the Time of Day device */
  480.     sysTodInit ((void *) MBZ_NVRAM_ADDR);
  482.     BPRINT ("SER ");
  483.     /* Setup the serial device descriptors. */
  484.     sysSerialHwInit();
  486.     /*
  487.     *  Send XON character in case power-off noise from UART has
  488.     *  sent an XOFF
  489.     */
  490.     xonString[0] = (char) 0x11;
  491.     xonString[1] = 'n';
  492.     xonString[2] = '';
  494.     sysSerialPrintString(xonString);
  496.     /* Perform anything specific to this platform design */
  497.     platform_init(); 
  499.     pciMaxBus = 1;
  501.     /* 
  502.     * Look for a secondary PCI bridge.  If we find one, look for
  503.     * another.  This BSP only supports up to 2 secondary bridges
  504.     * on the host bridge.
  505.     */
  506.     if (sysPCIBridgeProbe (0, 1, 2, 2) == OK)
  507.         sysPCIBridgeProbe (1, 1, 3, 3);
  509.     /* Initialize PCI shared interrupt handler */
  511.     pciIntLibInit();
  512.     /*
  513.     **  External UART interrupt init.
  514.     **  BOARD_ID_MBZ_5645_REF uses internal UART.
  515.     */
  516.     if (SYS_REVID_GET() != BOARD_ID_MBZ_5645_REF) {
  517.         gpioIntInit();
  518.     }
  520.     /* connect dummy isr's to shared int vectors */
  521.     for(i=IV_IORQ0_VEC; i<IV_LAST_VEC; i++)
  522.   intConnect (INUM_TO_IVEC(i), dummyISR, i);
  524.     /* connect and enable timer int */
  525.     (void) intConnect (INUM_TO_IVEC(IV_RTIME_VEC), sysClkInt, 0);
  526.     sr |= INT_LVL_TIMER;   
  528.     /* Connect and enable "shared" mips int 0 handler */
  529.     (void) intConnect (INUM_TO_IVEC(IV_IORQ0_VEC), sharedInt0, 0);
  530.     sr |= INT_LVL_IORQ0;   
  532.     /* connect serial channel interrupts */
  534.     sysSerialHwInit2();         
  535.     
  536.     intSRSet(sr);    
  538. }
  540. /*******************************************************************************
  541. *
  542. * sysPhysMemTop - get the address of the top of memory
  543. *
  544. * This routine returns the address of the first missing byte of memory, which
  545. * indicates the top of memory.
  546. *
  547. * NOTE: Do not adjust LOCAL_MEM_SIZE to reserve memory for application
  548. * use.  See sysMemTop() for more information on reserving memory.
  549. *
  550. * RETURNS: The address of the top of memory.
  551. */
  553. char *sysPhysMemTop (void)
  554.     {
  555.   
  556.   static char * memTop = NULL;
  558.     if (memTop == NULL)
  559. {
  560. memTop = (char *)(LOCAL_MEM_LOCAL_ADRS +
  561.                 (((SYS_REVID_GET() != BOARD_ID_LM_1_32MB) &&
  562.                  (SYS_REVID_GET() != BOARD_ID_MBZ_32MB)) ?
  563.                     LOCAL_MEM_SIZE:LOCAL_MEM_SIZE_LM));
  564. }
  565.     return memTop;
  566.     }
  568. /*******************************************************************************
  569. *
  570. * sysMemTop - get the address of the top of logical memory
  571. *
  572. * This routine returns the address of the first unusable byte of memory.
  573. * VxWorks will not use any memory at or above this address.
  574. *
  575. * The user can reserve local memory from the board by declaring the
  576. * macro USER_RESERVED_MEM with the amount of memory to reserve. This
  577. * routine will return a pointer to the first byte of the reserved memory
  578. * area.
  579. *
  580. * RETURNS: The address of the top of usable memory.
  581. */
  582. char *sysMemTop (void)
  583. {
  584.     static char * memTop = NULL;
  586.     if (memTop == NULL)
  587. memTop = sysPhysMemTop () - USER_RESERVED_MEM;
  589.     return memTop;
  590. }
  592. #ifdef BROADCOM_BSP
  593. /******************************************************************************
  594. *
  595. * sysBacktraceMips - perform a stack trace of the caller with symbols
  596. *               by Curt McDowell - csm@broadcom.com 03-20-01
  597. *
  598. * NOTE:
  599. *
  600. * This routine is specific to MIPS and GCC stack frame generation.
  601. * Each function generated by the compiler must begin with a decrement
  602. * of the stack pointer, then in the next few instructions, must save
  603. * the return address on the stack.
  604. *
  605. *   27bdffd0    addiu       $sp,$sp,-48
  606. *               ...
  607. *   afbf0028    sw          $ra,40($sp)
  608. *               ...
  609. */
  611. /* Hack; some day fix to locate function start using symFindByValue */
  612. #define SYSBT_MAX_FUNC_WORDS    4096
  614. LOCAL void sysbt_addr2sym(char *symName, UINT addr)
  615. {
  616.     extern SYMTAB_ID sysSymTbl;
  617.     UINT symVal;
  618.     SYM_TYPE symType;
  619.     int                 rc;
  621. #if VX_VERSION==55
  622.     char                **psymName;
  623.     
  624.     rc = symByValueFind(sysSymTbl,
  625.        (UINT) addr,
  626.        psymName, &symVal, &symType);
  627.     if (rc != ERROR)
  628.         strcpy(symName, *psymName);        
  629. #else
  630.     rc = symFindByValue(sysSymTbl,
  631.        (UINT) addr,
  632.        symName, &symVal, &symType);
  633. #endif
  634.     if (rc == ERROR)
  635.         sprintf(symName, "0x%x", addr);
  636.     else if (symVal < addr)
  637. sprintf(symName + strlen(symName),
  638. " + 0x%x", addr - symVal);
  639.     else if (symVal > addr)
  640. sprintf(symName + strlen(symName),
  641. " - 0x%x", symVal - addr);
  642. }
  644. #define VALID_K0(addr) 
  645.         (IS_KSEG0(addr) && K0_TO_PHYS(addr) < K0_TO_PHYS(sysPhysMemTop()))
  646. #define VALID_K1(addr) 
  647.         (IS_KSEG1(addr) && K1_TO_PHYS(addr) < K0_TO_PHYS(sysPhysMemTop()))
  648. #define VALID_ADDR(addr) 
  649.         (VALID_K0(addr) || VALID_K1(addr))
  650. #define VALID_TEXT_ADDR(addr) 
  651.         VALID_ADDR(addr)        /* some day fix for text range */
  652. #define VALID_STACK_ADDR(addr) 
  653.         VALID_ADDR(addr)        /* some day fix for stack range */
  655. void sysBacktraceMips(char *pfx, char *sfx, int direct)
  656. {
  657.     UINT                *sp, *pc, *fn_start, *caller_sp, *ra;
  658.     extern UINT         *vxSpGet(), *vxPcGet();         /* sysALib.s */
  659.     int                 limit, first = 1;
  660.     char                buf[2048], symName[128], *s;
  661.     int                 ra_off, sp_off;
  662.     extern void         sysSerialPrintString(char *s);
  664.     sp = vxSpGet();
  665.     pc = vxPcGet();
  667.     s = buf;
  669.     strcpy(s, pfx);
  670.     while (*s) s++;
  672.     while (s < &buf[sizeof (buf) - 128]) {
  673.         fn_start = pc;
  674.         for (limit = 0; limit < SYSBT_MAX_FUNC_WORDS; limit++) {
  675.             /* sw $ra,x($sp); x>=0 */
  676.             if ((*--fn_start & 0xffff8000) == 0xafbf0000)
  677.                 break;
  678.         }
  679.         if (limit == SYSBT_MAX_FUNC_WORDS)
  680.             break;
  681.         ra_off = (*fn_start & 0x7fff);
  682.         for (limit = 0; limit < SYSBT_MAX_FUNC_WORDS; limit++) {
  683.             /* addiu $sp,$sp,-x; x<0 */
  684.             if ((*--fn_start & 0xffff8000) == 0x27bd8000)
  685.                 break;
  686.         }
  687.         if (limit == SYSBT_MAX_FUNC_WORDS)
  688.             break;
  689.         sp_off = (int) (*fn_start | 0xffff0000);
  690.         ra = (UINT *) sp[ra_off / 4];
  691.         caller_sp = sp - (sp_off / 4);
  692.         sysbt_addr2sym(symName, (UINT) pc);
  693.         if (! first)
  694.             sprintf(s,
  695.                     "FUNC = 0x%x, PC = 0x%x (%s), SP = 0x%xn",
  696.                     (UINT) fn_start, (UINT) pc, symName, (UINT) sp);
  697.         while (*s) s++;
  698.         if (! VALID_TEXT_ADDR(ra)) {
  699.             sprintf(s, "RA 0x%x out of rangen", (UINT) ra);
  700.             while (*s) s++;
  701.             break;
  702.         }
  703.         if (! VALID_STACK_ADDR(caller_sp)) {
  704.             sprintf(s, "Caller SP 0x%x out of rangen", (UINT) caller_sp);
  705.             while (*s) s++;
  706.             break;
  707.         }
  708.         pc = ra;
  709.         sp = caller_sp;
  710.         first = 0;
  711.     }
  713.     strcpy(s, sfx);
  715.     if (direct)
  716.         sysSerialPrintString(buf);      /* Atomically print giant string */
  717.     else {
  718.         fputs(buf, stdout);             /* Regular print giant string */
  719.         fflush(stdout);
  720.     }
  721. }
  723. #endif /* BROADCOM_BSP */
  726. /*******************************************************************************
  727. *
  728. * sysToMonitor - transfer control to the ROM monitor
  729. *
  730. * This routine transfers control to the ROM monitor.  Normally, it is called
  731. * only by reboot()--which services ^X--and bus errors at interrupt level.
  732. * However, in some circumstances, the user may wish to introduce a
  733. * <startType> to enable special boot ROM facilities.
  734. *
  735. * RETURNS: Does not return.
  736. */
  738. int sysToMonitorExcMessage = 0;
  739. int sysToMonitorBacktrace = 1;
  740. int sysToMonitorReboot = 1;
  741. void (*sysToMonitorHook)(void);
  743. STATUS sysToMonitor
  744.     (
  745.     int startType    /* parameter passed to ROM to tell it how to boot */
  746.     )
  747.     {
  748.     if (sysToMonitorHook)
  749.         (*sysToMonitorHook)();
  751.     if (sysToMonitorBacktrace)
  752.         sysBacktraceMips("n--- Stack Trace ---n", "", 1);
  754.     if (sysToMonitorReboot) {
  755.         FUNCPTR pRom = (FUNCPTR) (ROM_TEXT_ADRS + 8);
  756.         intLock();
  757.         /* no addition work necessary for the PRO100B */
  758.         (*pRom) (startType);
  759.     }
  761.     return (OK);    /* in case we ever continue from rom monitor */
  762.     }
  764. /******************************************************************************
  765. *
  766. * sysProcNumGet - get the processor number
  767. *
  768. * This routine returns the processor number for the CPU board, which is
  769. * set with sysProcNumSet().
  770. *
  771. * RETURNS: The processor number for the CPU board.
  772. *
  773. * SEE ALSO: sysProcNumSet()
  774. */
  776. int sysProcNumGet (void)
  777.     {
  778.     return (sysProcNum);
  779.     }
  781. /*******************************************************************************
  782. *
  783. * sysProcNumSet - set the processor number
  784. *
  785. * This routine sets the processor number for this board.  Processor numbers
  786. * should be unique on a single backplane.
  787. *
  788. * RETURNS: N/A
  789. *
  790. * SEE ALSO: sysProcNumGet()
  791. */
  793. void sysProcNumSet
  794.     (
  795.     int procNum
  796.     )
  797.     {
  798.     sysProcNum = procNum;
  799.     }
  801. /*
  802.  * Write characters to LCD display.
  803.  * Note that the bytes for the first character is the last address.
  804.  */
  805. void
  806. sysLedDsply(const char* msg)
  807. {
  808.     LED_REG(0) = msg[3];
  809.     LED_REG(1) = msg[2];
  810.     LED_REG(2) = msg[1];
  811.     LED_REG(3) = msg[0];
  812. }
  814. /*******************************************************************************
  815. *
  816. * sysBusEid - get the value of the error ID register
  817. *
  818. * This routine returns the contents of the bus error status register
  819. * (if one existed).
  820. *
  821. * NOTE:
  822. * This routine must be provided on all Rc32364 board support packages.
  823. *
  824. * RETURNS: 0, always.
  825. */
  827. USHORT sysBusEid (void)
  828.     {
  829.     return (0);
  830.     }
  832. /*******************************************************************************
  833. *
  834. * sysBusEar - get the access address of a bus error
  835. *
  836. * This routine returns the address of a bus error.
  837. *
  838. * NOTE:
  839. * This routine must be provided on all Rc32364 board support packages.
  840. * The IDT S134 cannot determine the address that caused
  841. * a bus error.  It is possible to determine the source of a read bus error
  842. * by interpreting the instruction stream that caused the bus error.
  843. *
  844. * RETURNS: -1, always.
  845. */
  847. ULONG sysBusEar (void)
  848.     {
  849.     return (-1);
  850.     }
  852. /*******************************************************************************
  853. *
  854. * sysAutoAck - acknowledge the RC32364 interrupt condition 
  855. *
  856. * This routine acknowledges an RC32364 interrupt for a specified interrupt
  857. * vector.
  858. *
  859. * NOTE:
  860. * This routine must be provided on all RC32364 board support packages.
  861. * Most interrupts are automatically acknowledged in the interrupt service
  862. * routine.
  863. *
  864. * RETURNS: The result of the interrupt acknowledge cycle.
  865. */
  867. int sysAutoAck
  868.     (
  869.     int vecNum          /* vector num of interrupt that bugs us */
  870.     )
  871.     {
  872.     int result;
  873.     result = 0;
  874.     switch (vecNum)
  875. {
  876. case IV_RTIME_VEC:
  877.     sysSetCompare (0);
  878.     break;
  879. case IV_SWTRAP0_VEC:            /* software trap 0 */
  880.     return(result = sysSw0Ack ());
  881.     break;
  882. case IV_SWTRAP1_VEC:            /* software trap 1 */
  883.     return(result = sysSw1Ack ());
  884.     break;
  885. default:
  886.     return (-1);
  887.     break;
  888. }
  889.     return (result);
  890.     }
  892. /*******************************************************************************
  893. *
  894. * sysSw0Gen - generate software interrupt 0
  895. *
  896. * This routine writes the RC32364 cause register to generate a software
  897. * interrupt.
  898. *
  899. * RETURNS: N/A
  900. */
  902. void sysSw0Gen (void)
  903.     {
  904.     unsigned causeReg;
  906.     causeReg = intCRGet ();
  907.     causeReg |= CAUSE_SW1;
  908.     intCRSet (causeReg);
  909.     }
  911. /*******************************************************************************
  912. *
  913. * sysSw1Gen - generate software interrupt 1
  914. *
  915. * This routine writes the RC32364 cause register to generate a software
  916. * interrupt.
  917. *
  918. * RETURNS: N/A
  919. */
  921. void sysSw1Gen (void)
  922.     {
  923.     unsigned causeReg;
  925.     causeReg = intCRGet ();
  926.     causeReg |= CAUSE_SW2;
  927.     intCRSet (causeReg);
  928.     }
  930. /*******************************************************************************
  931. *
  932. * sysSw0Ack - acknowledge software interrupt 0
  933. *
  934. * This routine writes the RC32364 cause register to acknowledge a software
  935. * interrupt.
  936. *
  937. * NOTE:
  938. * This routine is provided as a default interrupt service routine.
  939. *
  940. * RETURNS: N/A
  941. */
  943. LOCAL int sysSw0Ack (void)
  944.     {
  945.     unsigned causeReg;
  947.     causeReg = intCRGet ();
  948.     causeReg &= ~CAUSE_SW1;
  949.     intCRSet (causeReg);
  951.     return(OK);
  952.     }
  954. /*******************************************************************************
  955. *
  956. * sysSw1Ack - acknowledge software interrupt 1 
  957. *
  958. * This routine writes the RC32364 cause register to acknowledge a software
  959. * interrupt.
  960. *
  961. * NOTE:
  962. * This routine is provided as a default interrupt service routine.
  963. *
  964. * RETURNS: N/A
  965. */
  967. LOCAL int sysSw1Ack (void)
  968.     {
  969.     unsigned causeReg;
  971.     causeReg = intCRGet ();
  972.     causeReg &= ~CAUSE_SW2;
  973.     intCRSet (causeReg);
  975.     return(OK);
  976.     }
  979. /*****************************************************************************
  980. *
  981. * sysClkEnable - turn on system clock interrupts
  982. *
  983. * This routine enables system clock interrupts.
  984. *
  985. * RETURNS: N/A
  986. *
  987. * SEE ALSO: sysClkDisable(), sysClkRateSet()
  988. */
  990. void sysClkEnable (void)
  991.     {
  992.     /* start the timer */
  993.     int key;
  994.     
  995.     sysClkProcessorTicks = (get_sb_clock()/sysClkTicksPerSecond)/2;
  997.     key = intLock ();
  998.     sysSetCompare (0);
  999.     sysSetCount (1);
  1000.     sysSetCompare (sysClkProcessorTicks);
  1001.     sysSoftCompare = sysClkProcessorTicks;
  1002.     sysClkRunning = TRUE;
  1003.     intUnlock (key);
  1005.     }
  1008. /*****************************************************************************
  1009. *
  1010. * sysClkRateGet - get the system clock rate
  1011. *
  1012. * This routine returns the interrupt rate of the system clock.
  1013. *
  1014. * RETURNS: The number of ticks per second of the system clock.
  1015. *
  1016. * SEE ALSO: sysClkRateSet()
  1017. */
  1019. int sysClkRateGet (void)
  1020.     {
  1021.     return (sysClkTicksPerSecond);
  1022.     }
  1024. /*****************************************************************************
  1025. *
  1026. * sysClkRateSet - set the system clock rate
  1027. *
  1028. * This routine sets the interrupt rate of the system clock.  It does not
  1029. * enable system clock interrupts.  Normally, it is called by usrRoot() in
  1030. * usrConfig.c.
  1031. *
  1032. * NOTE
  1033. * The RC32364 internal timer is used to provide the system clock.
  1034. *
  1035. * RETURNS: OK, or ERROR if the tick rate is invalid or the timer cannot be
  1036. * set.
  1037. *
  1038. * SEE ALSO: sysClkDisable(), sysClkEnable(), sysClkRateGet()
  1039. */
  1041. STATUS sysClkRateSet
  1042.     (
  1043.     int ticksPerSecond  /* number of clock interrupts per second */
  1044.     )
  1045.     {
  1046.     if (ticksPerSecond < SYS_CLK_RATE_MIN || ticksPerSecond > SYS_CLK_RATE_MAX)
  1047. return (ERROR);
  1049.     sysClkTicksPerSecond = ticksPerSecond;
  1051.     if (sysClkRunning)
  1052. {
  1053. sysClkDisable ();
  1054. sysClkEnable ();
  1055. }
  1057.     return (OK);
  1058.     }
  1060. /*****************************************************************************
  1061. *
  1062. * sysClkInt - handle a system clock interrupt
  1063. *
  1064. * This routine handles a system clock interrupt.  
  1065. *
  1066. * RETURNS: N/A
  1067. */
  1069. LOCAL void sysClkInt (void)
  1070.     {
  1071.     int key;
  1072.     ULONG delta;        /* time to when next interrupt should be */
  1073.  
  1074.     /* see sysClkDisable(). Clear interrupt and return. */
  1075.     if (!sysClkRunning)
  1076. {
  1077. sysSetCompare (sysSoftCompare);
  1078. return;
  1079. }
  1080.     key = intLock();
  1081.     /* use unsigned arithmetic to compensate for wrap-around */
  1083.     /* delta is how long ago the interrupt occured. */
  1084.     delta = sysGetCount() - sysSoftCompare;
  1085.     if (delta < (sysClkProcessorTicks - 200))
  1086. {
  1087.      /*
  1088.       * case 1 (normal): we haven't missed the next interrupt.
  1089.       *  The 200 above is an estimate of how far count will advance
  1090.       *  between reading it above and setting the compare register
  1091.       *  below (count should not pass the new compare value before
  1092.       *  we've set the register).  sysClkProcessorTicks is on
  1093.       *  the order of 500,000.
  1094.       */
  1095.      sysSoftCompare += sysClkProcessorTicks;
  1096.      sysSetCompare (sysSoftCompare);
  1097. }
  1098.     else if (delta < (16 * sysClkProcessorTicks))
  1099. {
  1100.      /*
  1101.       * case 2 (missed a couple): we've missed some interrupts,
  1102.       *   don't set the compare register (so we'll take another
  1103.       *   interrupt as soon as we return).
  1104.       */
  1105.      sysSoftCompare += sysClkProcessorTicks;
  1106. }
  1107.     else
  1108. {
  1109.      /*
  1110.       * case 3 (missed a lot): set the next interrupt at
  1111.       *   sysClkProcessorTicks past the current time.
  1112.       */
  1113.      sysSoftCompare = sysGetCount() + sysClkProcessorTicks;
  1114.      sysSetCompare (sysSoftCompare);
  1115. }
  1117.     intUnlock (key);
  1119.     if (sysClkRoutine != NULL)
  1120. (*sysClkRoutine) (sysClkArg);
  1121.     }
  1124. /*****************************************************************************
  1125. *
  1126. * sysClkConnect - connect a routine to the system clock interrupt
  1127. *
  1128. * This routine specifies the interrupt handler to be called at each system
  1129. * clock interrupt.  It does not enable system clock interrupts.  Normally,
  1130. * it is called from usrRoot() in usrConfig.c to connect usrClock() to the
  1131. * system clock interrupt.  Other standard interrupt handlers are also set up
  1132. * at this time.
  1133. *
  1134. * RETURN: OK, or ERROR if the routine cannot be connected to the interrupt.
  1135. *
  1136. * SEE ALSO: intConnect(), usrClock()
  1137. */
  1139. STATUS sysClkConnect
  1140.     (
  1141.     FUNCPTR routine,    /* routine called at each system clock interrupt */
  1142.     int arg             /* argument with which to call routine           */
  1143.     )
  1144.     {
  1145.     if (sysClkConnected == FALSE)
  1146. {
  1147. sysHwInit2 ();
  1148. sysClkConnected = TRUE;
  1149. }
  1151.     sysClkRoutine   = routine;
  1152.     sysClkArg       = arg;
  1154.     return (OK);
  1155.     }
  1157. /*****************************************************************************
  1158. *
  1159. * sysClkDisable - turn off system clock interrupts
  1160. *
  1161. * This routine disables system clock interrupts.
  1162. *
  1163. * RETURNS: N/A
  1164. *
  1165. * SEE ALSO: sysClkEnable(), sysClkRateSet()
  1166. */
  1168. void sysClkDisable (void)
  1169.     {
  1170.     int key;
  1171.     
  1172.     /* we cannot disable interrupts so we do this instead... */
  1174.     key = intLock ();
  1175.     sysSetCompare (0);
  1176.     sysSetCount (1);
  1177.     sysClkProcessorTicks = 0xffffff00;
  1178.     sysSetCompare (sysClkProcessorTicks);
  1179.     sysSoftCompare = sysClkProcessorTicks;
  1180.     sysClkRunning = FALSE;
  1181.     intUnlock (key);
  1182.     }
  1185. /*******************************************************************************
  1186. *
  1187. * sysAuxClkInt - interrupt level processing for auxiliary clock
  1188. *
  1189. * This routine handles the auxiliary clock interrupt.  It is attached to the
  1190. * clock interrupt vector by the routine sysAuxClkConnect().
  1191. * The appropriate routine is called and the interrupt is acknowleged.
  1192. */
  1194. LOCAL void sysAuxClkInt (void)
  1195. {
  1196. uint32 intstatus;
  1198. intstatus = R_REG(&timerregs->intstatus) & I_TO;
  1200.     if (intstatus) {
  1201.         /* clear the timer interrupt */
  1202.      W_REG(&timerregs->intstatus, intstatus);
  1203.         
  1204.         if (sysAuxClkRoutine != NULL)
  1205.      (*sysAuxClkRoutine) (sysAuxClkArg);     
  1206.     }
  1207. }
  1209. /*******************************************************************************
  1210. *
  1211. * sysAuxClkConnect - connect a routine to the auxiliary clock interrupt
  1212. *
  1213. * This routine specifies the interrupt service routine to be called at each
  1214. * auxiliary clock interrupt.  It does not enable auxiliary clock
  1215. * interrupts.
  1216. *
  1217. * RETURNS: OK, or ERROR if the routine cannot be connected to the interrupt.
  1218. *
  1219. * SEE ALSO: intConnect(), sysAuxClkEnable()
  1220. */
  1222. STATUS sysAuxClkConnect
  1223.     (
  1224.     FUNCPTR routine,    /*routine called at each aux clock interrupt   */    
  1225.     int arg             /*argument to auxiliary clock interrupt routine*/ 
  1226.     )
  1227.     {
  1228.     if (!sysAuxClkConnected)
  1229. {
  1230. sysAuxClkConnected = TRUE;
  1231.     (void) intConnect (INUM_TO_IVEC(INT_VEC_IORQ3), sysAuxClkInt, 0);
  1232. }
  1234.     sysAuxClkRoutine = routine;
  1235.     sysAuxClkArg = arg;
  1237.     return (OK);
  1238.     }
  1240. /*******************************************************************************
  1241. *
  1242. * sysAuxClkDisable - turn off auxiliary clock interrupts
  1243. *
  1244. * This routine disables auxiliary clock interrupts.
  1245. *
  1246. * RETURNS: N/A
  1247. *
  1248. * SEE ALSO: sysAuxClkEnable()
  1249. */
  1251. void sysAuxClkDisable (void)
  1252.     {
  1253.         /* write a zero to disable the timer */
  1254.       W_REG( &timerregs->gptimer, 0);
  1256.       /* disable interrupts */
  1257.       W_REG( &timerregs->intmask, 0);
  1258.       
  1259.       sysAuxClkRunning = FALSE ;
  1260.     }
  1262. /*******************************************************************************
  1263. *
  1264. * sysAuxClkEnable - turn on auxiliary clock interrupts
  1265. *
  1266. * This routine enables auxiliary clock interrupts.
  1267. *
  1268. * RETURNS: N/A
  1269. *
  1270. * SEE ALSO: sysAuxClkConnect(), sysAuxClkDisable(), sysAuxClkRateSet()
  1271. */
  1273. void sysAuxClkEnable (void)
  1274.     {
  1275.     uint32 clock,core;
  1276.     sbconfig_t *sbregs;
  1278.     if (timerregs == NULL) {
  1279.         printf("No core was selected to provide a timern");
  1280.         printf("Use set_auxtimer(base_addr) to select a core.n");
  1281.         sysAuxClkRunning = FALSE ;
  1282.         return;
  1283.     }
  1285.     sbregs = (sbconfig_t*)((uint32)timerregs + SBCONFIGOFF);
  1286.     core = (sbregs->sbidhigh & SBIDH_CC_MASK) >> SBIDH_CC_SHIFT;
  1288.     /* check if the core selected is the iLine core and set clock appropriately */
  1289.     if (core == SB_ILINE20) 
  1290.         clock = 64000000;
  1291.     else
  1292.         clock = get_sb_clock();
  1294.     /* write to the timer */
  1295.     W_REG( &timerregs->gptimer, get_sb_clock()/sysAuxClkTicksPerSecond);
  1296.     /* enable timer interrupt */
  1297.     W_REG( &timerregs->intmask, I_TO);
  1299.     sysAuxClkRunning = TRUE ;
  1300.     }
  1302. void set_auxtimer( uint32 base_addr )
  1303. {
  1304.     timerregs = (bcmenetregs_t *)base_addr;
  1305. }
  1307. void show_auxtimer( void ) {
  1308.     printf("Aux timer core base address is 0x%xn", (uint32)timerregs); 
  1309. }
  1311. /*******************************************************************************
  1312. *
  1313. * sysAuxClkRateGet - get the auxiliary clock rate
  1314. *
  1315. * This routine returns the interrupt rate of the auxiliary clock.
  1316. *
  1317. * RETURNS: The number of ticks per second of the auxiliary clock.
  1318. *
  1319. * SEE ALSO: sysAuxClkEnable(), sysAuxClkRateSet()
  1320. */
  1322. int sysAuxClkRateGet (void)
  1323.     {
  1324.     return (sysAuxClkTicksPerSecond);
  1325.     }
  1327. /*******************************************************************************
  1328. *
  1329. * sysAuxClkRateSet - set the auxiliary clock rate
  1330. *
  1331. * This routine sets the interrupt rate of the auxiliary clock.
  1332. * It does not enable auxiliary clock interrupts.
  1333. *
  1334. * RETURNS: OK, or ERROR if the tick rate is invalid or the timer cannot be set.
  1335. *
  1336. * SEE ALSO: sysAuxClkEnable(), sysAuxClkRateGet()
  1337. */
  1339. STATUS sysAuxClkRateSet
  1340.     (
  1341.     int ticksPerSecond     /* number of clock interrupts per second*/ 
  1342.     )
  1343.     {
  1344.      if( ticksPerSecond < AUX_CLK_RATE_MIN || ticksPerSecond > AUX_CLK_RATE_MAX)
  1345.        {
  1346. return (ERROR);
  1347.        }
  1348.      sysAuxClkTicksPerSecond = ticksPerSecond ;
  1349.      
  1350.      if ( sysAuxClkRunning )
  1351. {
  1352.   sysAuxClkDisable();
  1353.   sysAuxClkEnable();
  1354. }
  1356.       return (OK);
  1357.     }
  1359. /*
  1360.  * Reboot system.
  1361.  */
  1363. void sysReboot(void)
  1364. {
  1365.     SYS_HARD_RESET();
  1366. }
  1369. #ifdef INCLUDE_TIMESTAMP
  1370.      /* Timestamp routines derived from srcdrvtimermipsR4kTimer.c */
  1372. /*******************************************************************************
  1373. *
  1374. * sysTimestampConnect - connect a user routine to a timestamp timer interrupt
  1375. *
  1376. * This routine specifies the user interrupt routine to be called at each
  1377. * timestamp timer interrupt.
  1378. *
  1379. * RETURNS: ERROR, always.
  1380. */
  1382. STATUS sysTimestampConnect
  1383.     (
  1384.     FUNCPTR routine,    /* routine called at each timestamp timer interrupt */
  1385.     int arg             /* argument with which to call routine */
  1386.     )
  1387.     {
  1388.     return (ERROR);
  1389.     }
  1391. /*******************************************************************************
  1392. *
  1393. * sysTimestampEnable - enable a timestamp timer interrupt
  1394. *
  1395. * This routine enables timestamp timer interrupts and resets the counter.
  1396. *
  1397. * RETURNS: OK, always.
  1398. *
  1399. * SEE ALSO: sysTimestampDisable()
  1400. */
  1402. STATUS sysTimestampEnable (void)
  1403.    {
  1404.    if (sysTimestampRunning)
  1405.       {
  1406.       return (OK);
  1407.       }
  1409.    if (!sysClkRunning)
  1410.       return (ERROR);
  1412.    sysTimestampRunning = TRUE;
  1414.    return (OK);
  1415.    }
  1417. /*******************************************************************************
  1418. *
  1419. * sysTimestampDisable - disable a timestamp timer interrupt
  1420. *
  1421. * This routine disables timestamp timer interrupts.
  1422. *
  1423. * RETURNS: OK, always.
  1424. *
  1425. * SEE ALSO: sysTimestampEnable()
  1426. */
  1428. STATUS sysTimestampDisable (void)
  1429.     {
  1430.     if (sysTimestampRunning)
  1431.         sysTimestampRunning = FALSE;
  1433.     return (OK);
  1434.     }
  1436. /*******************************************************************************
  1437. *
  1438. * sysTimestampPeriod - get the period of a timestamp timer
  1439. *
  1440. * This routine gets the period of the timestamp timer, in ticks.  The
  1441. * period, or terminal count, is the number of ticks to which the timestamp
  1442. * timer counts before rolling over and restarting the counting process.
  1443. *
  1444. * RETURNS: The period of the timestamp timer in counter ticks.
  1445. */
  1447. UINT32 sysTimestampPeriod (void)
  1448.     {
  1449.     /*
  1450.      * The period of the timestamp depends on the clock rate of the on-chip
  1451.      * timer.
  1452.      */
  1454.     return (get_sb_clock()/sysClkTicksPerSecond)/2;
  1455.     }
  1457. /*******************************************************************************
  1458. *
  1459. * sysTimestampFreq - get a timestamp timer clock frequency
  1460. *
  1461. * This routine gets the frequency of the timer clock, in ticks per
  1462. * second.  The rate of the timestamp timer is set explicitly by the
  1463. * hardware and typically cannot be altered.
  1464. *
  1465. * RETURNS: The timestamp timer clock frequency, in ticks per second.
  1466. */
  1468. UINT32 sysTimestampFreq (void)
  1469.     {
  1470.     return (get_sb_clock()/2);
  1471.     }
  1473. /*******************************************************************************
  1474. *
  1475. * sysTimestamp - get a timestamp timer tick count
  1476. *
  1477. * This routine returns the current value of the timestamp timer tick counter.
  1478. * The tick count can be converted to seconds by dividing it by the return of
  1479. * sysTimestampFreq().
  1480. *
  1481. * This routine should be called with interrupts locked.  If interrupts are
  1482. * not locked, sysTimestampLock() should be used instead.
  1483. *
  1484. * RETURNS: The current timestamp timer tick count.
  1485. *
  1486. * SEE ALSO: sysTimestampFreq(), sysTimestampLock()
  1487. */
  1489. UINT32 sysTimestamp (void)
  1490.     {
  1491.     return (sysGetCount() - (sysSoftCompare - sysClkProcessorTicks) + 1);
  1492.     }
  1494. /*******************************************************************************
  1495. *
  1496. * sysTimestampLock - lock interrupts and get the timestamp timer tick count
  1497. *
  1498. * This routine locks interrupts when the tick counter must be stopped
  1499. * in order to read it or when two independent counters must be read.
  1500. * It then returns the current value of the timestamp timer tick
  1501. * counter.
  1502. *
  1503. * The tick count can be converted to seconds by dividing it by the return of
  1504. * sysTimestampFreq().
  1505. *
  1506. * If interrupts are already locked, sysTimestamp() should be
  1507. * used instead.
  1508. *
  1509. * RETURNS: The current timestamp timer tick count.
  1510. *
  1511. * SEE ALSO: sysTimestampFreq(), sysTimestamp()
  1512. */
  1514. UINT32 sysTimestampLock (void)
  1515.     {
  1516.     return(sysGetCount() - (sysSoftCompare - sysClkProcessorTicks)+ 1);
  1517.     }
  1519. #endif  /* INCLUDE_TIMESTAMP */
  1521. /*******************************************************************************
  1522. *
  1523. * sysMaskVmeErr - mask the VMEbus error interrupt
  1524. *
  1525. * This routine is required for all RC32364 BSPs.  It has no effect on the
  1526. * S134.
  1527. *
  1528. * RETURNS: 0.
  1529. *
  1530. * NOMANUAL
  1531. */
  1533. UINT8 sysMaskVmeErr (void)
  1534.     {
  1535.     return (0);
  1536.     }
  1538. /*******************************************************************************
  1539. *
  1540. * sysUnmaskVmeErr - unmask the VMEbus error interrupt
  1541. *
  1542. * This routine is required for all RC32364 BSPs.  It has no effect on the
  1543. * S134.
  1544. *
  1545. * RETURNS: 0.
  1546. *
  1547. * NOMANUAL
  1548. */
  1550. UINT8 sysUnmaskVmeErr (void)
  1551.     {
  1552.     return (0);
  1553.     }
  1556. /******************************************************************************
  1557. *
  1558. * sysEnetAddrGet - read the ethernet address from NVRAM
  1559. *
  1560. * This routine returns the system ethernet address from flash.
  1561. * If more than one ethernet driver is installed, the ethernet address
  1562. * will be the unit number added to the system ethernet address (unit 0).
  1563. *
  1564. * RETURNS: OK if flash read successful and enet addr isn't garbage
  1565. *          ERROR if flash read fails or enet addr is all 0's or all f's
  1566. *
  1567. */
  1568. STATUS sysEnetAddrGet
  1569.     (
  1570.     char *dev,          /* name of device, e.g. "bc" */
  1571.     int unit,           /* unit number */
  1572.     unsigned char *pMac         /* where to write the mac address */
  1573.     )
  1574.     {
  1575.     int i;
  1576.     int allzeros;
  1577.     int allfs;
  1579.     if (dev == NULL)
  1580.         return (ERROR);
  1582.     if (strcmp ("phy", dev) == 0)
  1583.         {
  1584.         if (unit != 0 && unit != 1)
  1585.             return (ERROR);
  1586.         if (unit == 0) 
  1587.            * (int *) pMac = (sysIsLM() ? ET1_PHYADDR:ET0_PHYADDR);
  1588.         else
  1589.            * (int *) pMac = (sysIsLM() ? ET0_PHYADDR:ET1_PHYADDR);
  1590.         return (OK);
  1591.         }
  1593.     if (strcmp ("mdc", dev) == 0)
  1594.         {
  1595.         if (unit != 0 && unit != 1)
  1596.             return (ERROR);
  1597.         if (unit == 0)
  1598.            * (int *) pMac = ET0_MDCPORT;
  1599.         else
  1600.            * (int *) pMac = ET1_MDCPORT;
  1601.         return (OK);
  1602.         }
  1604.     if (sysNvRamGet(pMac, 6, NV_OFF_MACADDR) == ERROR)
  1605.         return (ERROR);
  1607.     /*
  1608.      * Check what we got from NVRAM.  If it looks fishy, return ERROR
  1609.      */
  1611.     allzeros = 1;
  1612.     allfs = 1;
  1614.     for (i = 0; i < 6; i++)
  1615.         {
  1616.         if (pMac[i] == '')
  1617.             {
  1618.             if (allzeros)
  1619.                 continue;
  1620.             else
  1621.                 goto goodmac;
  1622.             }
  1623.         else if (pMac[i] == (unsigned char) 0xff)
  1624.             {
  1625.             if (allfs)
  1626.                 continue;
  1627.             else
  1628.                 goto goodmac;
  1629.             }
  1630.         else
  1631.             goto goodmac;
  1632.         }
  1634.     return (ERROR);
  1636. goodmac:
  1638.     pMac[5] = pMac[5] + unit;
  1639.     return (OK);
  1640.     }
  1642. #ifndef INCLUDE_FLASH
  1643. /*
  1644. *  This call is here because the xmodem code calls flashFsSync().
  1645. *  flashFsSync() is normally defined in flashFsLib, but MBZ uses
  1646. *  the DOC, not a flash array.
  1647. */
  1648. STATUS flashFsSync(void)
  1649.     {
  1650.     return (OK);
  1651.     }
  1653. #endif /* INCLUDE_FLASH */
  1655. /* Detect HHB4 / DC21150 PCI-PCI bridge chips, and configure bus if
  1656.  * found. Note that this code should be run whenever we find a PCI
  1657.  * class code of type bridge. After we have run this procedure for the
  1658.  * first bridge, we then need to traverse any sub-bridges. This code
  1659.  * deals with only one PCI-PCI bridge and it's IO space for
  1660.  * sub-devices. See mousse.h for more details as well as the PCI-PCI
  1661.  * bridge specification.
  1662.  */
  1663. int sysPCIBridgeProbe(int instance,
  1664.                       int primary,
  1665.                       int secondary,
  1666.                       int subordinate)
  1667. {
  1668.     int BusNo, DevNo, FuncNo;
  1669.     unsigned int buses = 0;
  1670.     /* Find DC21150 PCI-PCI bridge or
  1671.      * HINTCORP HB4 PCI-PCI Bridge
  1672.      */
  1673.     if ( (pciFindDevice(DC21150_VENDOR_ID,
  1674.                         DC21150_DEVICE_ID,
  1675.                         instance,
  1676.                         &BusNo, &DevNo, &FuncNo) != ERROR) ||
  1677.          (pciFindDevice(PERICOM_VENDOR_ID,
  1678.                         PERICOM_8150_DEV_ID,
  1679.                         instance,
  1680.                         &BusNo, &DevNo, &FuncNo) != ERROR) ||
  1681.          (pciFindDevice(HINT_HB4_VENDOR_ID,
  1682.                         HINT_HB4_DEVICE_ID,
  1683.                         instance,
  1684.                         &BusNo, &DevNo, &FuncNo) != ERROR)) {
  1686.         pciMaxBus++;
  1688.         /* Disable device */
  1689.         pciConfigOutWord(BusNo,DevNo,FuncNo, PCI_CFG_COMMAND, 0x0000);
  1690.         pciConfigOutWord(BusNo,DevNo,FuncNo, PCI_CFG_STATUS, 0xffff);
  1692.         /* Reset secondary bus */
  1693.         pciConfigOutWord(BusNo,DevNo,FuncNo,
  1694.                          PCI_CFG_BRIDGE_CONTROL,
  1695.                          0x0040);
  1697.         /* Setup topology info */
  1698.         buses = (buses & 0xff000000)
  1699.             | ((unsigned int)(primary)     <<  0)
  1700.             | ((unsigned int)(secondary)   <<  8)
  1701.             | ((unsigned int)(subordinate) << 16);
  1702.         /*
  1703.          * We need to blast all three values with a single write.
  1704.          */
  1705.         pciConfigOutLong(BusNo, DevNo, FuncNo,
  1706.                          PCI_CFG_PRIMARY_BUS, buses);
  1708.         /* Clear secondary status */
  1709.         pciConfigOutWord(BusNo,DevNo,FuncNo,
  1710.                          PCI_CFG_SEC_STATUS, 0xffff);
  1712.         /* Setup memory address space mapping */
  1713.         pciConfigOutWord(BusNo,DevNo,FuncNo,
  1714.                          PCI_CFG_MEM_BASE,
  1715.                          ((P2P_NONPREF_MEM_BASE & 0xFFF00000) >> 16));
  1717.         pciConfigOutWord(BusNo,DevNo,FuncNo,
  1718.                          PCI_CFG_MEM_LIMIT,
  1719.                          ((P2P_NONPREF_MEM_BASE +
  1720.                            P2P_NONPREF_MEM_SIZE - 1) & 0xFFF00000) >> 16);
  1722.         /* Clear bridge control */
  1723.         pciConfigOutWord(BusNo,DevNo,FuncNo,
  1724.                          PCI_CFG_BRIDGE_CONTROL,0x0000);
  1726.         /* Enable PCI clocks on remote end */
  1727.         pciConfigOutWord(BusNo,DevNo,FuncNo,
  1728.                          PCI_CFG_DEC21150_SEC_CLK,
  1729.                          P2P_CLK_ENABLE);
  1731.         /* Clear status */
  1732.         pciConfigOutByte(BusNo,DevNo,FuncNo,
  1733.                          PCI_CFG_DEC21150_SERR_STAT, 0xff);
  1735.         /* Clear status */
  1736.         pciConfigOutWord(BusNo,DevNo,FuncNo,
  1737.                          PCI_CFG_STATUS, 0xffff);
  1739.         /* Re-enable config space */
  1740.         pciConfigOutWord(BusNo,DevNo,FuncNo, PCI_CFG_COMMAND,
  1741.                          P2P_PMC_ENABLE);
  1742.         return OK;
  1743.     }
  1744.     return ERROR;
  1745. }
  1747. /*
  1748. *  Stub required because we're using vxMemProbe
  1749. */
  1750. BOOL sysBusTas(char * address)
  1751.     {
  1752.     return(TRUE);
  1753.     }
  1755. UINT8 sysBoardRev()
  1756. {
  1757.     return (SYS_REVID_GET());
  1758. }
  1760. int sysTodGetSecond (void)
  1761.     {
  1762.     if (sysTodFuncs.getSecond == NULL)
  1763.         return -1;
  1764.     else
  1765.         return (sysTodFuncs.getSecond ());
  1766.     }
  1768. STATUS sysTodGet
  1769.     (
  1770.     int *pYear,
  1771.     int *pMonth,
  1772.     int *pDay,
  1773.     int *pHour,
  1774.     int *pMin,
  1775.     int *pSec 
  1776.     )
  1777.     {
  1778.     if (sysTodFuncs.get == NULL)
  1779.         return (ERROR);
  1780.     else
  1781.         return (sysTodFuncs.get (pYear, pMonth, pDay, pHour, pMin, pSec));
  1782.     }
  1784. STATUS sysTodSet
  1785.     (
  1786.     int year,
  1787.     int month,
  1788.     int day,
  1789.     int hour,
  1790.     int min,
  1791.     int sec 
  1792.     )
  1793.     {
  1794.     if (sysTodFuncs.set == NULL)
  1795.         return (ERROR);
  1796.     else
  1797.         return (sysTodFuncs.set (year, month, day, hour, min, sec));
  1798.     }
  1800. STATUS sysTodInit (UINT8 *addr)
  1801.     {
  1802.     if (sysTodFuncs.init == NULL)
  1803.         return (ERROR);
  1804.     else
  1805.         return (sysTodFuncs.init (addr));
  1806.     }
  1808. STATUS sysTodWatchdogArm
  1809.     (
  1810.     int usec
  1811.     )
  1812.     {
  1813.     if (sysTodFuncs.watchdogArm == NULL)
  1814.         return (ERROR);
  1815.     else
  1816.         return (sysTodFuncs.watchdogArm (usec));
  1817.     }
  1819. /*****************************************************************************
  1820. *
  1821. * sysSerialPrintStringNL - print string and add newline
  1822. *
  1823. * This routine should only be used as alternative to sysLedDsply, as
  1824. * part of the BPRINT() mechanism for debugging bootroms or board bringup.
  1825. *
  1826. * Returns:  N/A
  1827. */
  1829. void sysSerialPrintStringNL
  1830.     (
  1831.     char *s
  1832.     )
  1833.     {
  1834.     sysSerialPrintString (s);
  1835.     sysSerialPrintString ("nr");
  1836.     }
  1838. void sys47xxClocks(int *core, int *sb, int *pci)
  1839. {
  1840.     volatile int *p;
  1842.     p = (volatile int *)(KSEG1ADDR((BCM4710_REG_EXTIF + 0x44)));
  1843.     switch(*p) {
  1844.         case (CC_125_N) :   *core = 125; break;
  1845.         case (CC_DEF_N) :   *core = 100; break;
  1846.         default:            *core = 0; break;
  1847.     }
  1849.     p = (volatile int *)(KSEG1ADDR((BCM4710_REG_EXTIF + 0x48)));
  1850.     switch(*p) {
  1851.         case (CC_125_M) :   *sb = 125; break;
  1852.         case (CC_DEF_100) : *sb = 100; break;
  1853.         default:            *sb = 0; break;
  1854.     }
  1856.     p = (volatile int *)(KSEG1ADDR((BCM4710_REG_EXTIF + 0x4c)));
  1857.     switch(*p) {
  1858.         case (CC_DEF_33) :   *pci = 33; break;
  1859.         case (CC_125_M33) :   *pci = 33; break;
  1860.         case (CC_DEF_25) :   *pci = 25; break;
  1861.         case (CC_125_M25) :   *pci = 25; break;
  1862.         default:            *pci = 0; break;
  1863.     }
  1864. }
  1866. /* Line module specific */
  1867. int sysSlotIdGet();
  1868. int sysIsLM();
  1870. int
  1871. sysSlotIdGet()
  1872. {
  1873.     if (sysIsLM()) {
  1874.         return (SYS_SLOTID_GET() + 2);
  1875.     } else {
  1876.         return(2);
  1877.     }
  1878. }
  1880. int
  1881. sysIsLM()
  1882. {
  1883.     unsigned int id;
  1885.     id = SYS_REVID_GET();
  1887.     return(id == BOARD_ID_LM_1_32MB);
  1888. }